Image.hh

Go to the documentation of this file.

/*
 * class Image
 *
 * $Date$
 * $Revision$
 *
 */

#ifndef IMAGE_HH__
#define IMAGE_HH__

#include "WImage/ColumnVector.hh"
#include "WImage/RowVector.hh"
#include "WImage/FullVector.hh"
#ifndef _WIN32_WCE
#include "WImage/GreymapReader.hh"
#include "WImage/GreymapWriter.hh"
#endif
#include "WImage/FileName.hh"

class Image;

/* abstract */
class ResizeFillFunc {
public:
  virtual ~ResizeFillFunc (void) {}
  virtual coeff operator() (const Image &scaled, double factor, int y, int x,
                            int newY, int newX, int yOffset, int xOffset) = 0;
};

enum ExtendFunc { ef_mirror, ef_outerBorder };

/*abstract*/
class
Image
{
public:

  Image (void);
  virtual ~Image (void) {}

  inline int rows (void) const { return m_ysize; }
  inline int cols (void) const { return m_xsize; }
  inline int size (void) const { return m_xysize; }

  inline ColumnVector &col (int x = 0) { m_acol->go (x); return *m_acol; }
  inline RowVector &row (int y = 0) { m_arow->go (y); return *m_arow; }

  inline FullVector &full (int xy = 0) { m_afull->go (xy); return *m_afull; }

  virtual coeff at (int y, int x) const = 0;
  virtual coeff at (int abs) const = 0;
  virtual void to (int y, int x, coeff val) = 0;
  virtual void to (int abs, coeff val) = 0;

  virtual int abs (int y, int x) const = 0;

  virtual bool epsilons (Image &img, coeff epsilon) const = 0;
  bool epsilonsAt (int y, int x, coeff value, coeff epsilon) const;
  bool epsilonsAt (int abs, coeff value, coeff epsilon) const;
  virtual bool equals (Image &img) const = 0;

  virtual double iproduct (Image &img) const;

  virtual void normalize (coeff factor);

  virtual void unnormalize (coeff factor);

  virtual void gammaCorrection (double factor, int yoffs = 0, int xoffs = 0,
                                int ysize = -1, int xsize = -1,
                                int norm = 255);

  double gammaCorrectionAuto (int rows, int columns, int yoffs = 0,
                              int xoffs = 0, int ysize = -1,int xsize = -1,
                              int norm = 255);

  virtual void histEqualization (int yoffs = 0, int xoffs = 0,
                                 int ysize = -1, int xsize = -1,
                                 int startH = 0, int endH = 255);

  virtual void beautify (int yoffs = 0, int xoffs = 0,
                         int ysize = 0, int xsize = 0);

  virtual void truncate (coeff min = 0, coeff max = 255);

  virtual void pixelize (void);

  void valadjust (void);

#ifndef _WIN32_WCE

  virtual void read (char const *fname, int rawy = 0, int rawx = 0) = 0;
  virtual void read (char const *fname, filetype ftype,
                     int rawy = 0, int rawx = 0) = 0;

  virtual void write (char const *fname, bool beautify = false) = 0;
  virtual void write (char const *fname, filetype ftype,
                      bool beautify = false) = 0;
#endif

  virtual void importCoeffs (int rows, int cols, coeff *buf);

  virtual coeff * exportCoeffs (void);

  virtual void importPixels (int rows, int cols, pixel *buf);

  virtual pixel * exportPixels (void) const;

  virtual Image *clone (void) const = 0;
  virtual void copy (Image &img);

  Image *crop (int yoffs, int xoffs, int ysize, int xsize) const;
  virtual void paste (int yoffs, int xoffs, Image &img);
  virtual void shift (int yoffs, int xoffs);

  int anasteps (void) const { return m_asteps; }
  int synsteps (void)  const { return m_ssteps; }
  void anasteps (int steps) { m_asteps = steps; }
  void synsteps (int steps) { m_ssteps = steps; }

  void fill (coeff value, int fromY = 0, int fromX = 0,
             int toY = -1, int toX = -1);

  virtual coeff smax (int fromY = 0, int fromX = 0,
                      int toY = -1, int toX = -1) const = 0;
  virtual coeff smin (int fromY = 0, int fromX = 0,
                      int toY = -1, int toX = -1) const = 0;
  virtual coeff amax (int fromY = 0, int fromX = 0,
                      int toY = -1, int toX = -1) const = 0;
  virtual coeff amin (int fromY = 0, int fromX = 0,
                      int toY = -1, int toX = -1) const = 0;
  virtual coeff saverage (int fromY = 0, int fromX = 0,
                          int toY = -1, int toX = -1) const = 0;

  virtual coeff aaverage (int fromY = 0, int fromX = 0,
                          int toY = -1, int toX = -1) const = 0;

  virtual coeff sqvariance (int fromY = 0, int fromX = 0,
                            int toY = -1, int toX = -1) const;

  virtual coeff variance (int fromY, int fromX, int toY, int toX,
                          coeff avg, bool abs) const;

  virtual coeff variance (int fromY = 0, int fromX = 0, int toY = -1,
                          int toX = -1, bool abs = false) const;

  virtual coeff sdeviation (int fromY = 0, int fromX = 0, int toY = -1,
                            int toX = -1, bool abs = false) const;

  virtual void resize (int rows, int cols) = 0;

  virtual Image *fitInto (int rows, int cols,
                          int fill = -1, int function = 0) const;

  virtual Image *fitInto (int rows, int cols, bool mirrorExtend,
                          int function = 0) const;

  virtual Image *fitInto (int rows, int cols, ExtendFunc extend,
                          int function = 0) const;

  virtual Image *fitInto (int rows, int cols, ResizeFillFunc *fillFunc,
                          int function = 0) const;

  virtual Image *scale (double factor, int function = 0) const;

  virtual Image *scale (double yFactor, double xFactor, int function = 0) const;

#ifdef USE_DEPRECATED_API

  inline bool epsilons (Image *img, coeff epsilon) const
  { return this->epsilons (*img, epsilon); }
  inline bool equals (Image *img) const { return this->equals (*img); }
#endif
protected:
  ColumnVector *m_acol;
  RowVector *m_arow;
  FullVector *m_afull;
  int m_ysize;
  int m_xsize;
  int m_xysize;
  int m_asteps;
  int m_ssteps;
  void dimcheck (const Image &img) const;
  virtual Image *mkImage (int rows = 0, int cols = 0) const = 0;

}; /* class Image */

#endif /* IMAGE_HH__ */