image.h

Go to the documentation of this file.

#ifndef IIS_IMAGE_H
#define IIS_IMAGE_H
#include "value.h"
#include "point.h"

class DirectPoint
{
 public:
  int x;
  int y;

  DirectPoint()
    {
      x = 0;
      y = 0;
    };

  DirectPoint(int a, int b)
    {
      x = a;
      y = b;
    }

  DirectPoint(Token data)
    {
      x = (Signed4)data["x"];
      y = (Signed4)data["y"];
    }

  Data getSaveDescription() 
    {
      Token r;
      r["type"]=Symbol("directpoint");
      r["x"]=Signed4(x);
      r["y"]=Signed4(y);
      return r;
    };

  void copyFrom(const PointValue & other)
    {
      x = (int)other.x;
      y = (int)other.y;
    }

  operator PointValue()
    {
      PointValue result;
      result.x = x;
      result.y = y;
      return result;
    }

  DirectPoint & operator +=(const DirectPoint & other)
    {
      x+=other.x;
      y+=other.y;
      return * this;
    }

  DirectPoint operator -(const DirectPoint & other) const
    {
      DirectPoint result;
      result.x = x - other.x;
      result.y = y - other.y;
      return result;
    }

  bool operator ==(const DirectPoint & other) const
    {
      return x==other.x && y==other.y;
    }
};

class ImageValue: public Value
{
  typedef Array<3,float> Image;
  typedef Array<2,float> Plane;
  typedef Array<2,float> ColorLine;
  Image data;
  static const int channels = 0;
  static const int imagex = 1;
  static const int imagey = 2;
  static const int colorlinex = 1;
 protected:
  void loadImage(QString str);
  void loadImage(QImage & i);
 public:
  DirectPoint center;

  PointValue scale;

  virtual Data getSaveDescription(QString );

  ImageValue(int xs, int ys, int c);

  ImageValue(PointValue topleft, PointValue bottomright, PointValue resolution, int channels);

  ImageValue(QImage &i);

  ImageValue(QString str);

  ImageValue(Token data);

  ImageValue * deepCopy();

  virtual QString toString() {return "<image>";};
  virtual bool equals_same_type(Value * other);
  // accessors
  void   set_direct(int x, int y, int c, double v)
    {
      data[Position<3>(c,x,y)]=v;
    };
  void   inc_direct(int x, int y, int c)
    {
      data[Position<3>(c,x,y)]+=1.0; 
    };
  double get_direct(int x, int y, int c)
    { 
      return data[Position<3>(c,x,y)]; 
    };

  int    width_direct() 
    {
      return data.size(imagex); 
    };
  
  int    height_direct() 
    {
      return data.size(imagey); 
    };

  bool outside(DirectPoint & dp)
    {
      return dp.x < 0 ||
        dp.y < 0 ||
        dp.x>=width_direct() ||
        dp.y>=height_direct();
    }
  
  int channelcount() 
    {
      return data.size(channels); 
    };

  double horiz()
    {
      return 1.0/scale.x;
    }

  double vertic()
    {
      return 1.0/scale.y;
    }

  double left()
    {
      return (0-center.x)/scale.x;
    }

  double right()
    {
      return ((width_direct()-1)-center.x)/scale.x;
    }

  double top()
    {
      return (0-center.y)/scale.y;
    }

  double bottom()
    {
      return ((height_direct()-1)-center.y)/scale.y;
    }
  
  PointValue topleft()
    {
      return PointValue(left(),top());
    }

  PointValue bottomright()
    {
      return PointValue(right(),bottom());
    }
  
  double maxz();
  
  double minz();

  double medianz();
  
  void   clear(double v)
    { 
      data=v;
    };

  void addFrom(ImageValue * i);

  void negate();

  QImage getQImage(bool draw_axes);

  void drawAxes(QImage * onto);

  void drawLegend(QPainter * painter, int as, int bs);

  DirectPoint ocsToDcs(const PointValue& in);
  
  void ocsToDcs(const PointValue& in, double &x, double &y)
    {
      DirectPoint r = ocsToDcs(in);
      x = r.x;
      y = r.y;
    }
  
  PointValue dcsToOcs(const DirectPoint& in);
};

#endif

---