YUV_Space.h

Go to the documentation of this file.

#ifndef   colors_YUV_Space_H__
#define   colors_YUV_Space_H__

#include "Color3_Space.h"
#include "../geo/Vectors.h"

#include "RGB_Space.h"
#include "../math/utility.h"

#include <cstdlib>

namespace meow {

class YUVf_Space: public Color3_Space<double> {
public:
  YUVf_Space(): Color3_Space<double>(Vector3D<double>(0.0, 0.0, 0.0),
                                     Vector3D<double>(1.0, 1.0, 1.0),
                                     Vector3D<double>(0.0, 0.0, 0.0)) {
  }
  YUVf_Space(double c): Color3_Space<double>(Vector3D<double>(0.0, 0.0, 0.0),
                                             Vector3D<double>(1.0, 1.0, 1.0),
                                             Vector3D<double>(  c,   c,   c)) {
  }
  YUVf_Space(Vector3D<double> const& v):
  Color3_Space<double>(Vector3D<double>(0.0, 0.0, 0.0),
                       Vector3D<double>(1.0, 1.0, 1.0),
                       Vector3D<double>(v)) {
  }
  YUVf_Space(YUV_Space const& b): Color3_Space<double>(b) {
  }
  ~YUVf_Space() {
  }
  double const& yuvMin(size_t i) const { return min(i); }
  double const&   yMin(        ) const { return min(0); }
  double const&   uMin(        ) const { return min(1); }
  double const&   vMin(        ) const { return min(2); }
  double const& yuvMax(size_t i) const { return max(i); }
  double const&   yMax(        ) const { return max(0); }
  double const&   uMax(        ) const { return max(1); }
  double const&   vMax(        ) const { return max(2); }
  double const& yuv(size_t i) const { return val(i); }
  double const&   y(        ) const { return yuv(0); }
  double const&   u(        ) const { return yuv(1); }
  double const&   v(        ) const { return yuv(2); }
  double const& yuv(size_t i, double c) { return val(i, c); }
  double const&   y(          double c) { return yuv(0, c); }
  double const&   u(          double c) { return yuv(1, c); }
  double const&   v(          double c) { return yuv(2, c); }
  double& yuvGet(size_t i) { return valGet(i); }
  double&   yGet(        ) { return yuvGet(0); }
  double&   uGet(        ) { return yuvGet(1); }
  double&   vGet(        ) { return yuvGet(2); }
  YUVf_Space& operator=(YUVf_Space const& b) {
    copyFrom(b);
    return *this;
  }
  YUVf_Space operator+(YUVf_Space const& b) const {
    return YUVf_Space(val_ + b.val_);
  }
  YUVf_Space operator-(YUVf_Space const& b) const {
    return YUVf_Space(val_ - b.val_);
  }
  YUVf_Space operator*(double const& c) const {
    return YUVf_Space(val_ * c);
  }
  YUVf_Space operator/(double const& c) const {
    return YUVf_Space(val_ / c);
  }
  double operator*(YUVf_Space const& b) const {
    return val_ * b.val_;
  }
};

inline void colorTransformate(RGBf_Space const& rgb, YUVf_Space* yuv) {
  double r = normalize(rgb.rMin(), rgb.rMax(), rgb.r());
  double g = normalize(rgb.gMin(), rgb.gMax(), rgb.g());
  double b = normalize(rgb.bMin(), rgb.bMax(), rgb.b());
  double y =  0.299 * r + 0.587 * g + 0.114 * b;
  double u = -0.169 * r - 0.331 * g + 0.500 * b + 0.5;
  double v =  0.500 * r - 0.419 * g - 0.081 * b + 0.5;
  yuv->y(denormalize(yuv->yMin(), yuv->yMax(), y));
  yuv->u(denormalize(yuv->uMin(), yuv->uMax(), u));
  yuv->v(denormalize(yuv->vMin(), yuv->vMax(), v));
}

inline void colorTransformate(YUVf_Space const& yuv, RGBf_Space* rgb) {
  double y = normalize(yuv.yMin(),yuv.yMax(),yuv.y());
  double u = normalize(yuv.uMin(),yuv.uMax(),yuv.u());
  double v = normalize(yuv.vMin(),yuv.vMax(),yuv.v());
  double r = y - 0.00093 * (u - 0.5) + 1.401687 * (v - 0.5);
  double g = y - 0.34370 * (u - 0.5) - 0.714170 * (v - 0.5);
  double b = y + 1.77216 * (u - 0.5) - 0.000990 * (v - 0.5);
  rgb->r(denormalize(rgb->rMin(), rgb->rMax(), r));
  rgb->g(denormalize(rgb->gMin(), rgb->gMax(), g));
  rgb->b(denormalize(rgb->bMin(), rgb->bMax(), b));
}

inline void colorTransformate(RGBi_Space const& rgb, YUVf_Space* yuv) {
  RGBf_Space tmp;
  tmp.copyFrom(rgb);
  colorTransformate(tmp, yuv);
}

inline void colorTransformate(YUVf_Space const& yuv, RGBi_Space* rgb) {
  RGBf_Space tmp;
  colorTransformate(yuv, &tmp);
  rgb->copyFrom(tmp);
}

} // meow

#endif // colors_YUV_H__