EIC code displayed by LXR master/​include/​ImageMagick-7/​Magick++/​Color.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:01:17

 // This may look like C code, but it is really -*- C++ -*-
 //
 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003, 2008
 //
 // Copyright @ 2013 ImageMagick Studio LLC, a non-profit organization
 // dedicated to making software imaging solutions freely available.
 //
 // Color Implementation
 //
 #if !defined (Magick_Color_header)
 #define Magick_Color_header
 
 #include "Magick++/Include.h"
 #include <string>
 
 namespace Magick
 {
   class MagickPPExport Color;
 
   // Compare two Color objects regardless of LHS/RHS
   MagickPPExport int operator ==
     (const Magick::Color& left_,const Magick::Color& right_);
   MagickPPExport int operator !=
     (const Magick::Color& left_,const Magick::Color& right_);
   MagickPPExport int operator >
     (const Magick::Color& left_,const Magick::Color& right_);
   MagickPPExport int operator <
     (const Magick::Color& left_,const Magick::Color& right_);
   MagickPPExport int operator >=
     (const Magick::Color& left_,const Magick::Color& right_);
   MagickPPExport int operator <=
     (const Magick::Color& left_,const Magick::Color& right_);
 
   // Base color class stores RGBA components scaled to fit Quantum
   // All double arguments have a valid range of 0.0 - 1.0.
   class MagickPPExport Color
   {
   public:
 
     // PixelType specifies the interpretation of PixelInfo members
     // CMYKPixel:
     //   Cyan     = red
     //   Magenta  = green
     //   Yellow   = blue
     //   Black(K) = black
     // CMYKPixel:
     //   Cyan     = red
     //   Magenta  = green
     //   Yellow   = blue
     //   Black(K) = black
     //   Alpha    = alpha
     // RGBPixel:
     //   Red      = red;
     //   Green    = green;
     //   Blue     = blue;
     // RGBAPixel:
     //   Red      = red;
     //   Green    = green;
     //   Blue     = blue;
     //   Alpha    = alpha;
     enum PixelType
     {
       CMYKPixel,
       CMYKAPixel,
       RGBPixel,
       RGBAPixel
     };
 
     // Default constructor
     Color(void);
 
     // Construct Color using the specified RGB values
     Color(const Magick::Quantum red_,const Magick::Quantum green_,
       const Magick::Quantum blue_);
 
     // Construct Color using the specified RGBA values
     Color(const Magick::Quantum red_,const Magick::Quantum green_,
       const Magick::Quantum blue_,const Magick::Quantum alpha_);
 
     // Construct Color using the specified CMYKA values
     Color(const Magick::Quantum cyan_,const Magick::Quantum magenta_,
       const Magick::Quantum yellow_,const Magick::Quantum black_,
       const Magick::Quantum alpha_);
 
     // Construct Color using the specified color string
     Color(const char *color_);
 
     // Copy constructor
     Color(const Color &color_);
 
     // Construct color via ImageMagick PixelInfo
     Color(const PixelInfo &color_);
 
     // Constructor Color using the specified color string
     Color(const std::string &color_);
 
     // Destructor
     virtual ~Color(void);
 
     // Assignment operator
     Color& operator=(const Color &color_);
 
     // Set color via X11 color specification string
     const Color& operator=(const char *color);
 
     // Set color via ImageMagick PixelInfo
     const Color& operator=(const PixelInfo &color_);
 
     // Set color via color specification string
     const Color& operator=(const std::string &color);
 
     // Return ImageMagick PixelInfo
     operator PixelInfo() const;
 
     // Return color specification string
     operator std::string() const;
 
     // Returns true if the distance between the other color is less than the
     // specified distance in a linear three(or four) % dimensional color space.
     bool isFuzzyEquivalent(const Color &color_,const double fuzz_) const;
 
     // Does object contain valid color?
     void isValid(const bool valid_);
     bool isValid(void) const;
 
     // Returns pixel type of the color
     Magick::Color::PixelType pixelType(void) const;
 
     // Alpha level (range OpaqueAlpha=0 to TransparentAlpha=QuantumRange)
     void quantumAlpha(const Quantum alpha_);
     Quantum quantumAlpha(void) const;
 
     // Black color (range 0 to QuantumRange)
     void quantumBlack(const Quantum black_);
     Quantum quantumBlack(void) const;
 
     // Blue/Yellow color (range 0 to QuantumRange)
     void quantumBlue(const Quantum blue_);
     Quantum quantumBlue(void) const;
 
     // Green/Magenta color (range 0 to QuantumRange)
     void quantumGreen(const Quantum green_);
     Quantum quantumGreen(void) const;
 
     // Red/Cyan color (range 0 to QuantumRange)
     void quantumRed(const Quantum red_);
     Quantum quantumRed(void) const;
 
   protected:
 
     // Constructor to construct with PixelInfo*
     // Used to point Color at a pixel in an image
     Color(PixelInfo *rep_,PixelType pixelType_);
 
     // Constructor to construct with PixelType
     Color(PixelType pixelType_);
 
     // Set pixel
     // Used to point Color at a pixel in an image
     void pixel(PixelInfo *rep_,PixelType pixelType_);
 
     // Scale a value expressed as a double (0-1) to Quantum range (0-QuantumRange)
     static Quantum scaleDoubleToQuantum(const double double_);
 
     // Scale a value expressed as a Quantum (0-QuantumRange) to double range (0-1)
     static double scaleQuantumToDouble(const Quantum quantum_);
 
     // PixelInfo represents a color pixel:
     //  red     = red   (range 0 to QuantumRange)
     //  green   = green (range 0 to QuantumRange)
     //  blue    = blue  (range 0 to QuantumRange)
     //  alpha   = alpha (range OpaqueAlpha=0 to TransparentAlpha=QuantumRange)
     //  index   = PseudoColor colormap index
     PixelInfo *_pixel;
 
   private:
 
     bool _isValid; // Set true if pixel is "valid"
     bool _pixelOwn; // Set true if we allocated pixel
     PixelType _pixelType; // Color type supported by _pixel
 
     // Common initializer for PixelInfo representation
     void initPixel();
 
     void setAlpha(const Magick::Quantum alpha_);
 
     // Sets the pixel type using the specified PixelInfo.
     void setPixelType(const PixelInfo &color_);
   };
 
   class MagickPPExport ColorCMYK: public Color
   {
   public:
 
     // Default constructor
     ColorCMYK(void);
 
     // Copy constructor
     ColorCMYK(const Color &color_);
 
     // Construct ColorCMYK using the specified CMYK values
     ColorCMYK(const double cyan_,const double magenta_,const double yellow_,
       const double black_);
 
     // Construct ColorCMYK using the specified CMYKA values
     ColorCMYK(const double cyan_,const double magenta_,const double yellow_,
       const double black_,const double alpha_);
 
     // Destructor
     ~ColorCMYK(void);
 
     // Assignment operator from base class
     ColorCMYK& operator=(const Color& color_);
 
     // Alpha level (range 0 to 1.0)
     void alpha(const double alpha_);
     double alpha(void) const;
 
     // Black/Key color (range 0 to 1.0)
     void black(const double black_);
     double black(void) const;
 
     // Black/Key color (range 0.0 to 1.0)
     void cyan(const double cyan_);
     double cyan(void) const;
 
     // Magenta color (range 0 to 1.0)
     void magenta(const double magenta_);
     double magenta(void) const;
 
     // Yellow color (range 0 to 1.0)
     void yellow(const double yellow_);
     double yellow(void) const;
 
   protected:
 
     // Constructor to construct with PixelInfo*
     ColorCMYK(PixelInfo *rep_,PixelType pixelType_);
   };
 
   //
   // Grayscale RGB color
   //
   // Grayscale is simply RGB with equal parts of red, green, and blue
   // All double arguments have a valid range of 0.0 - 1.0.
   class MagickPPExport ColorGray: public Color
   {
   public:
 
     // Default constructor
     ColorGray(void);
 
     // Copy constructor
     ColorGray(const Color &color_);
 
     // Construct ColorGray using the specified shade
     ColorGray(const double shade_);
 
     // Destructor
     ~ColorGray();
 
     // Shade
     void shade(const double shade_);
     double shade(void) const;
 
     // Assignment operator from base class
     ColorGray& operator=(const Color& color_);
 
   protected:
 
     // Constructor to construct with PixelInfo*
     ColorGray(PixelInfo *rep_,PixelType pixelType_);
   };
 
   //
   // HSL Colorspace colors
   //
   // All double arguments have a valid range of 0.0 - 1.0.
   class MagickPPExport ColorHSL: public Color
   {
   public:
 
     // Default constructor
     ColorHSL(void);
 
     // Copy constructor
     ColorHSL(const Color &color_);
 
     // Construct ColorHSL using the specified HSL values
     ColorHSL(const double hue_,const double saturation_,
       const double lightness_);
 
     // Destructor
     ~ColorHSL();
 
     // Assignment operator from base class
     ColorHSL& operator=(const Color& color_);
 
     // Hue color
     void hue(const double hue_);
     double hue(void) const;
 
     // Lightness color
     void lightness(const double lightness_);
     double lightness(void) const;
 
     // Saturation color
     void saturation(const double saturation_);
     double saturation(void) const;
 
   protected:
 
     // Constructor to construct with PixelInfo*
     ColorHSL(PixelInfo *rep_,PixelType pixelType_);
   };
 
   //
   // Monochrome color
   //
   // Color arguments are constrained to 'false' (black pixel) and 'true'
   // (white pixel)
   class MagickPPExport ColorMono: public Color
   {
   public:
 
     // Default constructor
     ColorMono(void);
 
     // Construct ColorMono (false=black, true=white)
     ColorMono(const bool mono_);
 
     // Copy constructor
     ColorMono(const Color &color_);
 
     // Destructor
     ~ColorMono();
 
     // Assignment operator from base class
     ColorMono& operator=(const Color& color_);
 
     // Mono color
     void mono(const bool mono_);
     bool mono(void) const;
 
   protected:
 
     // Constructor to construct with PixelInfo*
     ColorMono(PixelInfo* rep_,PixelType pixelType_);
   };
 
   class MagickPPExport ColorRGB: public Color
   {
   public:
 
     // Default constructor
     ColorRGB(void);
 
     // Copy constructor
     ColorRGB(const Color &color_);
 
     // Construct ColorRGB using the specified RGB values
     ColorRGB(const double red_,const double green_,const double blue_);
 
     // Construct ColorRGB using the specified RGBA values
     ColorRGB(const double red_,const double green_,const double blue_,
       const double alpha_);
 
     // Destructor
     ~ColorRGB(void);
 
     // Assignment operator from base class
     ColorRGB& operator=(const Color& color_);
 
     // Alpha level (range 0 to 1.0)
     void alpha(const double alpha_);
     double alpha(void) const;
 
     // Blue color (range 0.0 to 1.0)
     void blue(const double blue_);
     double blue(void) const;
 
     // Green color (range 0 to 1.0)
     void green(const double green_);
     double green(void) const;
 
     // Red color (range 0 to 1.0)
     void red(const double red_);
     double red(void) const;
 
   protected:
 
     // Constructor to construct with PixelInfo*
     ColorRGB(PixelInfo *rep_,PixelType pixelType_);
   };
 
   //
   // YUV Colorspace color
   //
   // Argument ranges:
   //        Y:  0.0 through 1.0
   //        U: -0.5 through 0.5
   //        V: -0.5 through 0.5
   class MagickPPExport ColorYUV: public Color
   {
   public:
 
     // Default constructor
     ColorYUV(void);
 
     // Copy constructor
     ColorYUV(const Color &color_);
 
     // Construct ColorYUV using the specified YUV values
     ColorYUV(const double y_,const double u_,const double v_);
 
     // Destructor
     ~ColorYUV(void);
 
     // Assignment operator from base class
     ColorYUV& operator=(const Color& color_);
 
     // Color U (0.0 through 1.0)
     void u(const double u_);
     double u(void) const;
 
     // Color V (-0.5 through 0.5)
     void v(const double v_);
     double v(void) const;
 
     // Color Y (-0.5 through 0.5)
     void y(const double y_);
     double y(void) const;
 
   protected:
 
     // Constructor to construct with PixelInfo*
     ColorYUV(PixelInfo *rep_,PixelType pixelType_);
 
   private:
 
     void convert(const double y_,const double u_,const double v_);
 
   };
 } // namespace Magick
 
 #endif // Magick_Color_header

This page was automatically generated by the 2.3.7 LXR engine. The LXR team