Color.cpp

// This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
//
// Copyright @ 2013 ImageMagick Studio LLC, a non-profit organization
// dedicated to making software imaging solutions freely available.
//
// Color Implementation
//
 
#define MAGICKCORE_IMPLEMENTATION
#define MAGICK_PLUSPLUS_IMPLEMENTATION 1
 
#include "Magick++/Include.h"
#include <string>
 
#include "Magick++/Color.h"
#include "Magick++/Exception.h"
 
using namespace std;
 
MagickPPExport int Magick::operator == (const Magick::Color &left_,
  const Magick::Color &right_)
{
#if defined(MAGICKCORE_HDRI_SUPPORT)
  return((left_.isValid() == right_.isValid()) &&
    (fabs((double) left_.quantumRed()-(double) right_.quantumRed()) < MagickEpsilon) &&
    (fabs((double) left_.quantumGreen()-(double) right_.quantumGreen()) < MagickEpsilon) &&
    (fabs((double) left_.quantumBlue()-(double) right_.quantumBlue()) < MagickEpsilon));
#else
  return((left_.isValid() == right_.isValid()) &&
    (left_.quantumRed() == right_.quantumRed()) &&
    (left_.quantumGreen() == right_.quantumGreen()) &&
    (left_.quantumBlue() == right_.quantumBlue()));
#endif
}
 
MagickPPExport int Magick::operator != (const Magick::Color &left_,
  const Magick::Color &right_)
{
  return(!(left_ == right_));
}
 
MagickPPExport int Magick::operator > (const Magick::Color &left_,
  const Magick::Color &right_)
{
  return(!(left_ < right_ ) && (left_ != right_ ));
}
 
MagickPPExport int Magick::operator < ( const Magick::Color &left_,
  const Magick::Color &right_)
{
  if(left_.quantumRed() < right_.quantumRed())
    return(true);
  if(left_.quantumRed() > right_.quantumRed())
    return(false);
  if(left_.quantumGreen() < right_.quantumGreen())
    return(true);
  if(left_.quantumGreen() > right_.quantumGreen())
    return(false);
  if(left_.quantumBlue() < right_.quantumBlue())
    return(true);
  return(false);
}
 
MagickPPExport int Magick::operator >= (const Magick::Color &left_,
  const Magick::Color &right_)
{
  return((left_ > right_) || (left_ == right_));
}
 
MagickPPExport int Magick::operator <= ( const Magick::Color &left_,
  const Magick::Color &right_)
{
  return((left_ < right_) || (left_ == right_));
}
 
Magick::Color::Color(void)
  : _pixel(new PixelInfo),
    _isValid(false),
    _pixelOwn(true),
    _pixelType(RGBAPixel)
{
  initPixel();
 
  setAlpha(TransparentAlpha);
}
 
Magick::Color::Color(const Magick::Quantum red_,const Magick::Quantum green_,
  const Quantum blue_)
  : _pixel(new PixelInfo),
    _isValid(true),
    _pixelOwn(true),
    _pixelType(RGBPixel)
{
  initPixel();
 
  quantumAlpha(OpaqueAlpha);
  quantumBlack(0);
  quantumBlue(blue_);
  quantumGreen(green_);
  quantumRed(red_);
}
 
Magick::Color::Color(const Magick::Quantum red_,const Magick::Quantum green_,
  const Magick::Quantum blue_, const Magick::Quantum alpha_)
  : _pixel(new PixelInfo),
    _isValid(true),
    _pixelOwn(true),
    _pixelType(RGBPixel)
{
  initPixel();
 
  quantumAlpha(alpha_);
  quantumBlack(0);
  quantumBlue(blue_);
  quantumGreen(green_);
  quantumRed(red_);
  if (alpha_ != OpaqueAlpha)
    _pixelType=RGBAPixel;
}
 
Magick::Color::Color(const Magick::Quantum cyan_,const Magick::Quantum magenta_,
  const Magick::Quantum yellow_,const Magick::Quantum black_,
  const Magick::Quantum alpha_)
  : _pixel(new PixelInfo),
    _isValid(true),
    _pixelOwn(true),
    _pixelType(CMYKPixel)
{
  initPixel();
 
  quantumAlpha(alpha_);
  quantumBlack(black_);
  quantumBlue(yellow_);
  quantumGreen(magenta_);
  quantumRed(cyan_);
  if (alpha_ != OpaqueAlpha)
    _pixelType=CMYKAPixel;
}
 
Magick::Color::Color(const char *color_)
  : _pixel(new PixelInfo),
    _isValid(true),
    _pixelOwn(true),
    _pixelType(RGBPixel)
{
  initPixel();
 
  // Use operator = implementation
  try
  {
    *this=color_;
  }
  catch (...)
  {
    if (_pixelOwn)
      delete _pixel;
    _pixel=(PixelInfo *)NULL;
    throw;
  }
}
 
Magick::Color::Color(const Magick::Color &color_)
  : _pixel(new PixelInfo),
    _isValid(color_._isValid),
    _pixelOwn(true),
    _pixelType(color_._pixelType)
{
  *_pixel=*color_._pixel;
}
 
Magick::Color::Color(const PixelInfo &color_)
  : _pixel(new PixelInfo),
    _isValid(true),
    _pixelOwn(true)
{
  *_pixel=color_;
  setPixelType(color_);
}
 
Magick::Color::Color(const std::string &color_)
  : _pixel(new PixelInfo),
    _isValid(true),
    _pixelOwn(true),
    _pixelType(RGBPixel)
{
  initPixel();
 
  // Use operator = implementation
  try
  {
    *this=color_;
  }
  catch (...)
  {
    if (_pixelOwn)
      delete _pixel;
    _pixel=(PixelInfo *)NULL;
    throw;
  }
}
 
Magick::Color::~Color(void)
{
  if (_pixelOwn)
    delete _pixel;
 
  _pixel=(PixelInfo *)NULL;
}
 
Magick::Color& Magick::Color::operator=(const Magick::Color& color_)
{
  // If not being set to ourself
  if (this != &color_)
    {
      // Copy pixel value
      *_pixel=*color_._pixel;
 
      // Validity
      _isValid=color_._isValid;
 
      // Copy pixel type
      _pixelType=color_._pixelType;
    }
  return(*this);
}
 
const Magick::Color& Magick::Color::operator=(const char *color_)
{
  *this=std::string(color_);
  return(*this);
}
 
const Magick::Color& Magick::Color::operator=(const MagickCore::PixelInfo &color_)
{
  *_pixel=color_;
  setPixelType(color_);
 
  return(*this);
}
 
const Magick::Color& Magick::Color::operator=(const std::string &color_)
{
  PixelInfo
    target_color;
 
  initPixel();
  GetPPException;
  if (QueryColorCompliance(color_.c_str(),AllCompliance,&target_color,
      exceptionInfo))
    {
      quantumAlpha((Magick::Quantum ) target_color.alpha);
      quantumBlack((Magick::Quantum ) target_color.black);
      quantumBlue((Magick::Quantum ) target_color.blue);
      quantumGreen((Magick::Quantum ) target_color.green);
      quantumRed((Magick::Quantum ) target_color.red);
 
      setPixelType(target_color);
    }
  else
    {
      _isValid = false;
      _pixelOwn = false;
      delete _pixel;
      _pixel = (PixelInfo *)NULL;
    }
  ThrowPPException(true);
 
  return(*this);
}
 
Magick::Color::operator MagickCore::PixelInfo() const
{
  return *_pixel;
}
 
Magick::Color::operator std::string() const
{
  char
    colorbuf[MagickPathExtent];
 
  PixelInfo
    pixel;
 
  if (!isValid())
    return std::string("none");
 
  pixel.colorspace=(_pixelType == RGBPixel || _pixelType == RGBAPixel) ?
    sRGBColorspace : CMYKColorspace;
  pixel.depth=MAGICKCORE_QUANTUM_DEPTH;
  pixel.alpha=_pixel->alpha;
  pixel.alpha_trait=_pixel->alpha_trait;
  pixel.black=_pixel->black;
  pixel.blue=_pixel->blue;
  pixel.green=_pixel->green;
  pixel.red=_pixel->red;
  GetColorTuple(&pixel,MagickTrue,colorbuf);
 
  return(std::string(colorbuf));
}
 
bool Magick::Color::isFuzzyEquivalent(const Color &color_, const double fuzz_) const
{
  PixelInfo
    p,
    q;
 
  p=*_pixel;
  p.fuzz=fuzz_;
  q=*color_._pixel;
  q.fuzz=fuzz_;
  return (IsFuzzyEquivalencePixelInfo(&p, &q) != MagickFalse);
}
 
bool Magick::Color::isValid(void) const
{
  return(_isValid);
}
 
Magick::Color::PixelType Magick::Color::pixelType() const
{
  return(_pixelType);
}
 
void Magick::Color::isValid(bool valid_)
{
  if (bool(valid_) == bool(isValid()))
    return;
 
  if (!_pixelOwn)
    {
      _pixel=new PixelInfo;
      _pixelOwn=true;
    }
 
  _isValid=valid_;
 
  initPixel();
}
 
void Magick::Color::quantumAlpha(const Magick::Quantum alpha_)
{
  setAlpha(alpha_);
  _isValid=true;
}
 
Magick::Quantum Magick::Color::quantumAlpha(void) const
{
  return((Magick::Quantum) _pixel->alpha);
}
 
void Magick::Color::quantumBlack(const Magick::Quantum black_)
{
  _pixel->black=black_;
  _isValid=true;
}
 
Magick::Quantum Magick::Color::quantumBlack(void) const
{
  return((Magick::Quantum) _pixel->black);
}
 
void Magick::Color::quantumBlue(const Magick::Quantum blue_)
{
  _pixel->blue=blue_;
  _isValid=true;
}
 
Magick::Quantum Magick::Color::quantumBlue(void) const
{
  return((Magick::Quantum) _pixel->blue);
}
 
void Magick::Color::quantumGreen(const Magick::Quantum green_)
{
  _pixel->green=green_;
  _isValid=true;
}
 
Magick::Quantum Magick::Color::quantumGreen(void) const
{
  return((Magick::Quantum) _pixel->green);
}
 
void Magick::Color::quantumRed(const Magick::Quantum red_)
{
  _pixel->red=red_;
  _isValid=true;
}
 
Magick::Quantum Magick::Color::quantumRed(void) const
{
  return((Magick::Quantum) _pixel->red);
}
 
Magick::Color::Color(PixelType pixelType_)
  : _pixel(new PixelInfo),
    _isValid(false),
    _pixelOwn(true),
    _pixelType(pixelType_)
{
  initPixel();
}
 
Magick::Color::Color(PixelInfo* rep_,PixelType pixelType_)
  : _pixel(rep_),
    _isValid(true),
    _pixelOwn(false),
    _pixelType(pixelType_)
{
}
 
void Magick::Color::pixel(PixelInfo *rep_,PixelType pixelType_)
{
  if (_pixelOwn)
    delete _pixel;
 
  _pixel=rep_;
  _pixelOwn=false;
  _isValid=true;
  _pixelType=pixelType_;
}
 
Magick::Quantum Magick::Color::scaleDoubleToQuantum(const double double_)
{
  return(static_cast<Magick::Quantum>(double_*(double) QuantumRange));
}
 
double Magick::Color::scaleQuantumToDouble(const Magick::Quantum quantum_)
{
#if (MAGICKCORE_QUANTUM_DEPTH < 32) && (MAGICKCORE_SIZEOF_FLOAT_T != MAGICKCORE_SIZEOF_DOUBLE || !defined(MAGICKCORE_HDRI_SUPPORT))
  return(static_cast<double>(QuantumScale*(double) quantum_));
#else
  return(QuantumScale*quantum_);
#endif
}
 
void Magick::Color::initPixel()
{
  MagickCore::GetPixelInfo((MagickCore::Image *) NULL, _pixel);
  if (_pixelType == CMYKPixel || _pixelType == CMYKAPixel)
    _pixel->colorspace=CMYKColorspace;
}
 
void Magick::Color::setAlpha(const Magick::Quantum alpha_)
{
  _pixel->alpha=alpha_;
  if (alpha_ == OpaqueAlpha)
    {
      _pixel->alpha_trait=UndefinedPixelTrait;
      if (_pixelType == RGBAPixel)
        _pixelType=RGBPixel;
      else if (_pixelType == CMYKAPixel)
        _pixelType=CMYKPixel;
    }
  else
    {
      _pixel->alpha_trait=BlendPixelTrait;
      if (_pixelType == RGBPixel)
        _pixelType=RGBAPixel;
      else if (_pixelType == CMYKPixel)
        _pixelType=CMYKAPixel;
    }
}
 
void Magick::Color::setPixelType(const PixelInfo &color_)
{
  if (color_.colorspace == CMYKColorspace)
    _pixelType=color_.alpha_trait != UndefinedPixelTrait ? CMYKAPixel :
      CMYKPixel;
  else
    _pixelType=color_.alpha_trait != UndefinedPixelTrait ? RGBAPixel :
      RGBPixel;
}
 
Magick::ColorCMYK::ColorCMYK(void)
  : Color(CMYKPixel)
{
}
 
Magick::ColorCMYK::ColorCMYK(const Magick::Color &color_)
  : Color(color_)
{
}
 
Magick::ColorCMYK::ColorCMYK(const double cyan_,const double magenta_,
  const double yellow_,const double black_)
  : Color(CMYKPixel)
{
  cyan(cyan_);
  magenta(magenta_);
  yellow(yellow_);
  black(black_);
}
 
Magick::ColorCMYK::ColorCMYK(const double cyan_,const double magenta_,
  const double yellow_,const double black_,const double alpha_)
  : Color(CMYKAPixel)
{
  cyan(cyan_);
  magenta(magenta_);
  yellow(yellow_);
  black(black_);
  alpha(alpha_);
}
 
Magick::ColorCMYK::~ColorCMYK(void)
{
}
 
Magick::ColorCMYK& Magick::ColorCMYK::operator=(const Magick::Color& color_)
{
  *static_cast<Magick::Color*>(this)=color_;
  return(*this);
}
 
void Magick::ColorCMYK::alpha(const double alpha_)
{
  quantumAlpha(scaleDoubleToQuantum(alpha_));
}
 
double Magick::ColorCMYK::alpha(void) const
{
  return(scaleQuantumToDouble(quantumAlpha()));
}
 
void Magick::ColorCMYK::black(const double black_)
{
  quantumBlack(scaleDoubleToQuantum(black_));
}
 
double Magick::ColorCMYK::black(void) const
{
  return(scaleQuantumToDouble(quantumBlack()));
}
 
void Magick::ColorCMYK::cyan(const double cyan_)
{
  quantumRed(scaleDoubleToQuantum(cyan_));
}
 
double Magick::ColorCMYK::cyan(void) const
{
  return(scaleQuantumToDouble(quantumRed()));
}
 
void Magick::ColorCMYK::magenta(const double magenta_)
{
  quantumGreen(scaleDoubleToQuantum(magenta_));
}
 
double Magick::ColorCMYK::magenta(void) const
{
  return(scaleQuantumToDouble(quantumGreen()));
}
 
void Magick::ColorCMYK::yellow(const double yellow_)
{
  quantumBlue(scaleDoubleToQuantum(yellow_));
}
 
double Magick::ColorCMYK::yellow(void) const
{
  return(scaleQuantumToDouble(quantumBlue()));
}
 
Magick::ColorCMYK::ColorCMYK(PixelInfo *rep_,PixelType pixelType_)
  : Color(rep_,pixelType_)
{
}
 
Magick::ColorGray::ColorGray(void)
  : Color(RGBPixel)
{
}
 
Magick::ColorGray::ColorGray(const Magick::Color & color_)
  : Color(color_)
{
}
 
Magick::ColorGray::ColorGray(double shade_)
  : Color(scaleDoubleToQuantum(shade_),scaleDoubleToQuantum(shade_),
          scaleDoubleToQuantum(shade_))
{
}
 
Magick::ColorGray::~ColorGray()
{
}
 
void Magick::ColorGray::shade(double shade_)
{
  Quantum gray=scaleDoubleToQuantum(shade_);
  quantumRed(gray);
  quantumGreen(gray);
  quantumBlue(gray);
}
 
double Magick::ColorGray::shade(void) const
{
  return(scaleQuantumToDouble(quantumGreen()));
}
 
Magick::ColorGray& Magick::ColorGray::operator=(const Magick::Color& color_)
{
  *static_cast<Magick::Color*>(this)=color_;
  return(*this);
}
 
Magick::ColorGray::ColorGray(PixelInfo *rep_,PixelType pixelType_)
: Color(rep_,pixelType_)
{
}
 
Magick::ColorHSL::ColorHSL(void)
  : Color(RGBPixel)
{
}
 
Magick::ColorHSL::ColorHSL(const Magick::Color &color_)
  : Color(color_)
{
}
 
Magick::ColorHSL::ColorHSL(const double hue_,const double saturation_,
  const double lightness_)
  : Color(RGBPixel)
{
  double
    blue,
    green,
    red;
 
  ConvertHSLToRGB(hue_,saturation_,lightness_,&red,&green,&blue);
 
  quantumRed((Magick::Quantum) red);
  quantumGreen((Magick::Quantum) green);
  quantumBlue((Magick::Quantum) blue);
}
 
Magick::ColorHSL::~ColorHSL()
{
}
 
Magick::ColorHSL& Magick::ColorHSL::operator=(const Magick::Color& color_)
{
  *static_cast<Magick::Color*>(this) = color_;
  return(*this);
}
 
void Magick::ColorHSL::hue(const double hue_)
{
  double
    hue,
    lightness,
    saturation;
 
  double
    blue,
    green,
    red;
 
  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
    &lightness);
 
  hue=hue_;
 
  ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
 
  quantumRed(ClampToQuantum(red));
  quantumGreen(ClampToQuantum(green));
  quantumBlue(ClampToQuantum(blue));
}
 
double Magick::ColorHSL::hue(void) const
{
  double
    hue,
    lightness,
    saturation;
 
  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
    &lightness);
 
  return(hue);
}
 
void Magick::ColorHSL::lightness (const double lightness_)
{
  double
    hue,
    lightness,
    saturation;
 
  double
    blue,
    green,
    red;
 
  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
    &lightness);
 
  lightness=lightness_;
 
  ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
 
  quantumRed(ClampToQuantum(red));
  quantumGreen(ClampToQuantum(green));
  quantumBlue(ClampToQuantum(blue));
}
 
double Magick::ColorHSL::lightness (void) const
{
  double
    hue,
    lightness,
    saturation;
 
  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
    &lightness);
 
  return(lightness);
}
 
void Magick::ColorHSL::saturation(const double saturation_)
{
  double
    hue,
    lightness,
    saturation;
 
  double
    blue,
    green,
    red;
 
  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
    &lightness);
 
  saturation=saturation_;
 
  ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
 
  quantumRed(ClampToQuantum(red));
  quantumGreen(ClampToQuantum(green));
  quantumBlue(ClampToQuantum(blue));
}
 
double Magick::ColorHSL::saturation(void) const
{
  double
    hue,
    lightness,
    saturation;
 
  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
    &lightness);
 
  return(saturation);
}
 
Magick::ColorMono::ColorMono(void)
  : Color(RGBPixel)
{
}
 
Magick::ColorMono::ColorMono(const bool mono_)
  : Color((mono_ ? QuantumRange : 0),(mono_ ? QuantumRange : 0),
          (mono_ ? QuantumRange : 0))
{
}
 
Magick::ColorMono::ColorMono(const Magick::Color &color_)
  : Color(color_)
{
}
 
Magick::ColorMono::~ColorMono()
{
}
 
Magick::ColorMono& Magick::ColorMono::operator=(const Magick::Color& color_)
{
  *static_cast<Magick::Color*>(this)=color_;
  return(*this);
}
 
void Magick::ColorMono::mono(bool mono_)
{
  quantumRed(mono_ ? QuantumRange : 0);
  quantumGreen(mono_ ? QuantumRange : 0);
  quantumBlue(mono_ ? QuantumRange : 0);
}
 
bool Magick::ColorMono::mono(void) const
{
  return(quantumGreen() == 0);
}
 
Magick::ColorMono::ColorMono(PixelInfo *rep_,PixelType pixelType_)
  : Color(rep_,pixelType_)
{
}
 
Magick::ColorRGB::ColorRGB(void)
  : Color(RGBPixel)
{
}
 
Magick::ColorRGB::ColorRGB(const Magick::Color &color_)
  : Color(color_)
{
}
 
Magick::ColorRGB::ColorRGB(const double red_,const double green_,
  const double blue_)
  : Color(scaleDoubleToQuantum(red_),scaleDoubleToQuantum(green_),
          scaleDoubleToQuantum(blue_))
{
}
 
Magick::ColorRGB::ColorRGB(const double red_,const double green_,
  const double blue_,const double alpha_)
  : Color(scaleDoubleToQuantum(red_),scaleDoubleToQuantum(green_),
          scaleDoubleToQuantum(blue_),scaleDoubleToQuantum(alpha_))
{
}
 
Magick::ColorRGB::~ColorRGB(void)
{
}
 
Magick::ColorRGB& Magick::ColorRGB::operator=(const Magick::Color& color_)
{
  *static_cast<Magick::Color*>(this)=color_;
  return(*this);
}
 
void Magick::ColorRGB::alpha(const double alpha_)
{
  quantumAlpha(scaleDoubleToQuantum(alpha_));
}
 
double Magick::ColorRGB::alpha(void) const
{
  return(scaleQuantumToDouble(quantumAlpha()));
}
 
void Magick::ColorRGB::blue(const double blue_)
{
  quantumBlue(scaleDoubleToQuantum(blue_));
}
 
double Magick::ColorRGB::blue(void) const
{
  return(scaleQuantumToDouble(quantumBlue()));
}
 
void Magick::ColorRGB::green(const double green_)
{
  quantumGreen(scaleDoubleToQuantum(green_));
}
 
double Magick::ColorRGB::green(void) const
{
  return(scaleQuantumToDouble(quantumGreen()));
}
 
void Magick::ColorRGB::red(const double red_)
{
  quantumRed(scaleDoubleToQuantum(red_));
}
 
double Magick::ColorRGB::red(void) const
{
  return(scaleQuantumToDouble(quantumRed()));
}
 
Magick::ColorRGB::ColorRGB(PixelInfo *rep_,PixelType pixelType_)
  : Color(rep_,pixelType_)
{
}
 
Magick::ColorYUV::ColorYUV(void)
  : Color(RGBPixel)
{
}
 
Magick::ColorYUV::ColorYUV(const Magick::Color &color_)
  : Color(color_)
{
}
 
Magick::ColorYUV::ColorYUV(const double y_,const double u_,const double v_)
  : Color(RGBPixel)
{
  convert(y_, u_, v_);
}
 
Magick::ColorYUV::~ColorYUV(void)
{
}
 
Magick::ColorYUV& Magick::ColorYUV::operator=(const Magick::Color &color_)
{
  *static_cast<Magick::Color*>(this)=color_;
  return(*this);
}
 
void Magick::ColorYUV::u(const double u_)
{
  convert(y(), u_, v());
}
 
double Magick::ColorYUV::u(void) const
{
  return(scaleQuantumToDouble((Magick::Quantum) ((-0.14740 *
    (double) quantumRed()) - (0.28950 * (double) quantumGreen()) + (0.43690 *
    (double) quantumBlue()))));
}
 
void Magick::ColorYUV::v(const double v_)
{
  convert(y(), u(), v_);
}
 
double Magick::ColorYUV::v(void) const
{
  return(scaleQuantumToDouble((Magick::Quantum) ((0.61500 *
    (double) quantumRed()) - (0.51500 * (double) quantumGreen()) - (0.10000 *
    (double) quantumBlue()))));
}
 
void Magick::ColorYUV::y(const double y_)
{
  convert(y_, u(), v());
}
 
double Magick::ColorYUV::y ( void ) const
{
  return(scaleQuantumToDouble((Magick::Quantum) ((0.29900 *
    (double) quantumRed()) + (0.58700 * (double) quantumGreen()) + (0.11400 *
    (double) quantumBlue()))));
}
 
void Magick::ColorYUV::convert(const double y_,const double u_,const double v_)
{
  quantumRed(scaleDoubleToQuantum(y_ + 1.13980 * v_));
  quantumGreen(scaleDoubleToQuantum(y_ - (0.39380 * u_) - (0.58050 * v_)));
  quantumBlue(scaleDoubleToQuantum(y_ + 2.02790 * u_));
}
 
Magick::ColorYUV::ColorYUV(PixelInfo *rep_,PixelType pixelType_)
  : Color(rep_,pixelType_)
{
}