include/refinery/image.h

#ifndef _REFINERY_IMAGE_H
#define _REFINERY_IMAGE_H

#include <refinery/camera.h>

#include <vector>

namespace refinery {

class CameraData;

struct Point {
  int row; 
  int col; 
  Point() : row(0), col(0) {}
  Point(int row, int col) : row(row), col(col) {}
  Point(const Point& rhs) : row(rhs.row), col(rhs.col) {}

  Point operator+(const Point& point) const {
    return Point(row + point.row, col + point.col);
  }

  Point operator-(const Point& point) const {
    return Point(row - point.row, col - point.col);
  }

  bool operator==(const Point& rhs) const {
    return this->row == rhs.row && this->col == rhs.col;
  }

  bool operator!=(const Point& rhs) const {
    return !(this->operator==(rhs));
  }
};

template<typename T, unsigned int N>
struct Pixel {
  typedef unsigned int ColorType; 
  static const ColorType NColors = N; 
  typedef T ValueType; 
  typedef T ArrayType[NColors]; 
  ArrayType colors; 
  Pixel() {
    for (ColorType c = 0; c < N; c++) {
      colors[c] = 0;
    }
  }
  template<typename U> Pixel(const U (&rhs)[N]) {
    for (ColorType c = 0; c < N; c++) {
      colors[c] = rhs[c];
    }
  }
  template<typename U> Pixel(const Pixel<U, N>& rhs) {
    for (ColorType c = 0; c < N; c++) {
      colors[c] = rhs.colors[c];
    }
  }
  inline ArrayType& array() { return colors; }
  inline const ArrayType& constArray() const { return colors; }
  inline T& operator[](const ColorType& index) { return colors[index]; }
  inline const T& at(const ColorType& index) const { return colors[index]; }
};

template<typename T>
struct RGBPixel : public Pixel<T, 3>
{
  RGBPixel() : Pixel<T, 3>() {}
  template<typename U> RGBPixel(const U (&rhs)[3]) : Pixel<T, 3>(rhs) {}
  template<typename U> RGBPixel(const RGBPixel<U>& rhs) : Pixel<T, 3>(rhs) {}
  inline const T& r() const { return this->at(0); }
  inline const T& g() const { return this->at(1); }
  inline const T& b() const { return this->at(2); }
  inline T& r() { return this->operator[](0); }
  inline T& g() { return this->operator[](1); }
  inline T& b() { return this->operator[](2); }
};

template<typename T>
struct LABPixel : public Pixel<T, 3>
{
  LABPixel() : Pixel<T, 3>() {}
  template<typename U> LABPixel(const U (&rhs)[3]) : Pixel<T, 3>(rhs) {}
  template<typename U> LABPixel(const LABPixel<U>& rhs) : Pixel<T, 3>(rhs) {}
  inline const T& l() const { return this->at(0); }
  inline const T& a() const { return this->at(1); }
  inline const T& b() const { return this->at(2); }
  inline T& l() { return this->operator[](0); }
  inline T& a() { return this->operator[](1); }
  inline T& b() { return this->operator[](2); }
};

template<typename T>
struct GrayPixel : public Pixel<T, 1> {
  GrayPixel() : Pixel<T, 1>() {}
  template<typename U> GrayPixel(const U (&rhs)[1]) : Pixel<T, 1>(rhs) {}
  GrayPixel(const T& value) : Pixel<T, 1>() { this[0] = value; }
  template<typename U> GrayPixel(const GrayPixel<U>& rhs) : Pixel<T, 3>(rhs) {}

  T& value() { return this->operator[](0); }
  const T& value() const { return this->at(0); }

  template<typename U> GrayPixel& operator*(const U& rhs) {
    return GrayPixel(value() * rhs);
  }
};

template<typename T>
class Image {
public:
  typedef T PixelType; 
  typedef typename T::ValueType ValueType; 
  typedef typename T::ColorType ColorType; 
private:
  typedef std::vector<PixelType> PixelsType;
  CameraData mCameraData;
  int mWidth;
  int mHeight;
  int mFilters;
  PixelsType mPixels;

  void allocate()
  {
    mPixels.assign(mWidth * mHeight, PixelType());
  }

public:
  Image(const CameraData& cameraData, int width, int height)
    : mCameraData(cameraData), mWidth(width), mHeight(height),
    mFilters(mCameraData.filters())
  {
    this->allocate();
  }

  const CameraData& cameraData() const { return mCameraData; }
  unsigned int width() const { return mWidth; }
  unsigned int height() const { return mHeight; }
  unsigned int nPixels() const { return mWidth * mHeight; }
  unsigned int filters() const { return mFilters; }
  void setFilters(unsigned int filters) { mFilters = filters; }

  ColorType colorAtPoint(const Point& point) const {
    int row = point.row;
    int col = point.col;
    return (mFilters >> (((row << 1 & 14) | (col & 1)) << 1)) & 3;
  }
  ColorType colorAtPoint(unsigned int row, unsigned int col) const {
    return colorAtPoint(Point(row, col));
  }

  PixelType* pixels() { return &mPixels[0]; }
  PixelType* pixelsEnd() { return &mPixels[mWidth * mHeight]; }

  const PixelType* constPixels() const { return &mPixels[0]; }
  const PixelType* constPixelsEnd() const { return &mPixels[mWidth * mHeight]; }

  const PixelType* constPixelsAtRow(int row) const {
    return &mPixels[row * mWidth];
  }
  PixelType* pixelsAtRow(int row) {
    return &mPixels[row * mWidth];
  }

  PixelType* pixelsAtPoint(const Point& point) {
    int row = point.row;
    int col = point.col;
    return &mPixels[row * mWidth + col];
  }
  PixelType* pixelsAtPoint(unsigned int row, unsigned int col) {
    return pixelsAtPoint(Point(row, col));
  }
  const PixelType* constPixelsAtPoint(const Point& point) const {
    int row = point.row;
    int col = point.col;
    return &mPixels[row * mWidth + col];
  }
  const PixelType* constPixelsAtPoint(
      unsigned int row, unsigned int col) const {
    return constPixelsAtPoint(Point(row, col));
  }

  PixelType& pixelAtPoint(const Point& point) {
    return *pixelsAtPoint(point);
  }
  PixelType& pixelAtPoint(unsigned int row, unsigned int col) {
    return *pixelsAtPoint(row, col);
  }
  const PixelType& constPixelAtPoint(const Point& point) const {
    return *constPixelsAtPoint(point);
  }
  const PixelType& constPixelAtPoint(unsigned int row, unsigned int col) const {
    return *constPixelsAtPoint(row, col);
  }
};

typedef RGBPixel<unsigned short> u16RGBPixel;
typedef LABPixel<short> s16LABPixel;
typedef GrayPixel<unsigned short> u16GrayPixel;

typedef Image<u16RGBPixel> RGBImage;
typedef Image<s16LABPixel> LABImage;
typedef Image<u16GrayPixel> GrayImage;

}; /* namespace refinery */

#endif /* REFINERY_IMAGE_H */