ValuesField.h

#pragma once
enum FieldClamp {
    fcWrap = 0,
    fcClamp=1,
    fcZero=2
};
 
class APICALL ValuesField {
    int Lx, Ly, Depth;
    cList<float> values;
    FieldClamp clamp;
    cList<ValuesField*> mips;
public:
    ValuesField();
    ~ValuesField();
 
    ValuesField(const ValuesField& vf, int x = 0, int y = 0, int w = 0, int h = 0);
 
    void  create(int SizeX, int SiezY, int depth = 1, FieldClamp clampmode = fcWrap);
 
    void createMips();
 
    void  setClampMode(FieldClamp cl);
 
    int   width() const ;
 
    int   height() const ;
 
    int   depth() const ;
 
    void  createFromImage(const comms::cImage& im);
 
    void  createFromImageMono(const comms::cImage& im, Vector3D mask = Vector3D::Zero);
 
    void  toImage(comms::cImage& im);
 
    void  loadImage(const char* name);
 
    void  saveImage(const char* name);
 
    void  clear();
 
    bool  torange(int& x, int& y) const;
 
    void  set(float value, int x, int y, int channel = 0);
 
    void  add(float value, int x, int y, int channel = 0);
 
    float get(int x, int y, int channel = 0) const ;
 
    float& value(int x, int y, int channel = 0);
 
    Vector3D& getV3(int x, int y);
    Vector3D getV3(int x, int y) const;
 
    Vector4D& getV4(int x, int y);
    Vector4D getV4(int x, int y) const;
 
    cVec2& getV2(int x, int y);
    cVec2 getV2(int x, int y) const;
 
    float get_linear(float x, float y, int channel = 0) const ;
 
    float get_linear_mip(float x, float y, int channel, float mip_level) const;
 
    cVec2 get_linearV2(float x, float y) const;
 
    cVec2 get_linearV2_mip(float x, float y, float mip_level) const;
 
    cVec3 get_linearV3(float x, float y) const;
 
    cVec3 get_linearV3_mip(float x, float y, float mip_level) const;
 
    cVec4 get_linearV4(float x, float y) const;
 
    cVec4 get_linearV4_mip(float x, float y, float mip_level) const;
 
    float get_bicubic(float x, float y, int channel = 0) const ;
 
    float get_bicubic_mip(float x, float y, int channel, float mip_level) const;
 
    cVec2 get_bicubicV2(float x, float y) const;
 
    cVec2 get_bicubicV2_mip(float x, float y, float mip_level) const;
 
    cVec3 get_bicubicV3(float x, float y) const;
 
    cVec3 get_bicubicV3_mip(float x, float y, float mip_level) const;
 
    cVec4 get_bicubicV4(float x, float y) const;
 
    cVec4 get_bicubicV4_mip(float x, float y, float mip_level) const;
 
    void  resizeTo(ValuesField& dest);
 
    void  sharp2X(ValuesField& dest);
 
    void  sharpEdges2X(ValuesField& dest);
 
    void  sharpEdges2X1(ValuesField& dest);
 
    void  sharpResize(ValuesField& dest, float scale);
 
    void  relax(ValuesField& destination, float degree, float radius);
    void  relax(ValuesField& destination, float degree, float radius, int x0, int y0, int x1, int y1);
 
 
    void sharpen(ValuesField& destination, float degree, float radius);
 
    void  monoTo(ValuesField& dest);
 
    void  curvature(ValuesField& dest);
 
    void  curvatureDir(ValuesField& dest);
 
    void  normalmap(ValuesField& dest, int byChannel = 0);
 
    void  normalmap3(ValuesField& dest, float heightmod = 1.0, int channel = 0);
 
    void  gradientValue(ValuesField& dest);
 
    //experimental functions...
    void  perlinMap(ValuesField& dest);
    void  detectAnisotropy(ValuesField& dest);
    float detectPerlin(int x, int y, int channel);
 
    void operator -= (const ValuesField& field);
 
    void operator += (const ValuesField& field);
 
    void operator += (float value);
 
    void operator -= (float value);
 
    void operator *= (float value);
 
    void operator /= (float value);
 
    void operate(const std::function<void(int, int) >& f, bool multithread = true);
 
    void max(ValuesField& other);
 
    void swap(ValuesField& dest);
 
    void LaplacianInterpolate(const cList<Vector3D>& lines);
 
    void LaplacianInterpolate(const UnlimitedBitset& fixed);
 
    void NormalizeColors(bool monochromatic = false, int mipsize = 64);
 
    comms::cVec3 averageColor(int x = 0, int y = 0, int w = 0, int h = 0, float alpha_threshold = 200) const;
 
    void Decrease2X(ValuesField& dest);
 
    void toPower2(ValuesField& dest);
 
    void recoverBump(ValuesField& dest);
 
    comms::cBounds blendImage(const ValuesField& other, const cMat3& transform, const cVec4& modulator = cVec4::One);
 
    comms::cBounds blendImageM4(const ValuesField& other, const comms::cMat4& transform, const cVec4& modulator = cVec4::One);
 
    void rect(int x0, int y0, int x1, int y1, const cVec4& color);
 
    void calc_featuremap(ValuesField& dest, int radius);
 
    void local_normalisation(ValuesField& dest, int size);
 
    void find_local_minmax(std::vector<comms::cVec2>& minmax);
 
    void getEllipse(int x, int y, cVec2& center, cVec2& longer_axis, float& relation);
};
 
inline int   ValuesField::width() const {
    return Lx;
}
 
inline int   ValuesField::height() const {
    return Ly;
}
 
inline int   ValuesField::depth() const {
    return Depth;   
}