File: Color.tex

package info (click to toggle)
imagemagick 6:6.0.6.2-2.9
  • links: PTS
  • area: main
  • in suites: sarge
  • size: 33,284 kB
  • ctags: 14,844
  • sloc: ansic: 190,790; cpp: 17,203; sh: 8,740; perl: 4,190; makefile: 1,740; tcl: 459
file content (247 lines) | stat: -rw-r--r-- 6,951 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
\section{Magick::Color}
\scriptsize{
\begin{verbatim}

Color is the base color class in Magick++. It is a simple container class
for the pixel red, green, blue, and alpha values scaled to fit ImageMagick's
Quantum size. Normally users will instantiate a class derived from Color
which supports the color model that fits the needs of the application. The
Color class may be constructed directly from an X11-style color string.

Available derived color specification classes are shown in the following
table:

                            Color Derived Classes

 ColorRGB Representation of RGB color with red, green, and blue specified
          as ratios (0 to 1)


 ColorGrayRepresentation of grayscale RGB color (equal parts red, green,
          and blue) specified as a ratio (0 to 1)

 ColorMonoRepresentation of a black/white color (true/false)

 ColorYUV Representation of a color in the YUV colorspace


ImageMagick may be compiled to support 32 or 64 bit pixels of type
PixelPacket. This is controlled by the value of the QuantumDepth define. The
default is 64 bit pixels, which provide the best accuracy. If memory
consumption must be minimized, or processing time must be minimized, then
ImageMagick may be compiled with QuantumDepth=8. The following table shows
the relationship between QuantumDepth, the type of Quantum, and the overall
PixelPacket size.

         Effect Of QuantumDepth Values

 QuantumDepth Quantum Typedef  PixelPacket Size

 8            unsigned char    32 bits

 16           unsigned short   64 bits


Color Class

The Color base class is not intended to be used directly. Normally a user
will construct a derived class or inherit from this class. Color arguments
are must be scaled to fit the Quantum size. The Color class contains a
pointer to a PixelPacket, which may be allocated by the Color class, or may
refer to an existing pixel in an image.

An alternate way to contruct the class is via an X11-compatable color
specification string.

class Color
{
  public:
    Color ( Quantum red_,
     Quantum green_,
     Quantum blue_ );
    Color ( Quantum red_,
     Quantum green_,
     Quantum blue_,
     Quantum alpha_ );
    Color ( const std::string &x11color_ );
    Color ( const char * x11color_ );
    Color ( void );
    virtual        ~Color ( void );
    Color ( const Color & color_ );

    // Red color (range 0 to MaxRGB)
    void           redQuantum ( Quantum red_ );
    Quantum        redQuantum ( void ) const;

    // Green color (range 0 to MaxRGB)
    void           greenQuantum ( Quantum green_ );
    Quantum        greenQuantum ( void ) const;

    // Blue color (range 0 to MaxRGB)
    void           blueQuantum ( Quantum blue_ );
    Quantum        blueQuantum ( void ) const;

    // Alpha level (range OpaqueOpacity=0 to TransparentOpacity=MaxRGB)
    void           alphaQuantum ( Quantum alpha_ );
    Quantum        alphaQuantum ( void ) const;

    // Scaled (to 1.0) version of alpha for use in sub-classes
    // (range opaque=0 to transparent=1.0)
    void           alpha ( double alpha_ );
    double         alpha ( void ) const;

    // Does object contain valid color?
    void           isValid ( bool valid_ );
    bool           isValid ( void ) const;

    // Set color via X11 color specification string
    const Color& operator= ( const std::string &x11color_ );
    const Color& operator= ( const char * x11color_ );

    // Assignment operator
    Color& operator= ( const Color& color_ );

    // Return X11 color specification string
    /* virtual */ operator std::string() const;

    // Return ImageMagick PixelPacket
    operator PixelPacket() const;

    // Construct color via ImageMagick PixelPacket
    Color ( const PixelPacket &color_ );

    // Set color via ImageMagick PixelPacket
    const Color& operator= ( PixelPacket &color_ );
};


ColorRGB

Representation of an RGB color. All color arguments have a valid range of
0.0 - 1.0.

class ColorRGB : public Color
{
  public:
    ColorRGB ( double red_, double green_, double blue_ );
    ColorRGB ( void );
    ColorRGB ( const Color & color_ );
    /* virtual */  ~ColorRGB ( void );

    void           red ( double red_ );
    double         red ( void ) const;

    void           green ( double green_ );
    double         green ( void ) const;

    void           blue ( double blue_ );
    double         blue ( void ) const;

    // Assignment operator from base class
    ColorRGB& operator= ( const Color& color_ );
};


ColorGray

Representation of a grayscale color (in RGB colorspace). 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 ColorGray : public Color
{
  public:
    ColorGray ( double shade_ );
    ColorGray ( void );
    ColorGray ( const Color & color_ );
    /* virtual */ ~ColorGray ();

    void           shade ( double shade_ );
    double         shade ( void ) const;

    // Assignment operator from base class
    ColorGray& operator= ( const Color& color_ );
};


ColorMono

Representation of a black/white pixel (in RGB colorspace). Color arguments
are constrained to 'false' (black pixel) and 'true' (white pixel).

class ColorMono : public Color
{
  public:
    ColorMono ( bool mono_ );
    ColorMono ( void );
    ColorMono ( const Color & color_ );
    /* virtual */ ~ColorMono ();

    void           mono ( bool mono_ );
    bool           mono ( void ) const;

    // Assignment operator from base class
    ColorMono& operator= ( const Color& color_ );
};


ColorHSL

Representation of a color in Hue/Saturation/Luminosity (HSL) colorspace.

class ColorHSL : public Color
{
  public:
    ColorHSL ( double hue_, double saturation_, double luminosity_ );
    ColorHSL ( void );
    ColorHSL ( const Color & color_ );
    /* virtual */  ~ColorHSL ( );

    void           hue ( double hue_ );
    double         hue ( void ) const;

    void           saturation ( double saturation_ );
    double         saturation ( void ) const;

    void           luminosity ( double luminosity_ );
    double         luminosity ( void ) const;

    // Assignment operator from base class
    ColorHSL& operator= ( const Color& color_ );
};


ColorYUV

Representation of a color in YUV colorspace (used to encode color for
television transmission).

 Argument ranges:
        Y:  0.0 through 1.0
        U: -0.5 through 0.5
        V: -0.5 through 0.5

class ColorYUV : public Color
{
  public:
    ColorYUV ( double y_, double u_, double v_ );
    ColorYUV ( void );
    ColorYUV ( const Color & color_ );
    /* virtual */ ~ColorYUV ( void );

    void           u ( double u_ );
    double         u ( void ) const;

    void           v ( double v_ );
    double         v ( void ) const;

    void           y ( double y_ );
    double         y ( void ) const;

    // Assignment operator from base class
    ColorYUV& operator= ( const Color& color_ );
};


\end{verbatim}
}