Magick++  7.0.7
Convert, Edit, Or Compose Bitmap Images
Color.cpp
Go to the documentation of this file.
1 // This may look like C code, but it is really -*- C++ -*-
2 //
3 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
4 // Copyright Dirk Lemstra 2013-2015
5 //
6 // Color Implementation
7 //
8 
9 #define MAGICKCORE_IMPLEMENTATION
10 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1
11 
12 #include "Magick++/Include.h"
13 #include <string>
14 
15 using namespace std;
16 
17 #include "Magick++/Color.h"
18 #include "Magick++/Exception.h"
19 
21  const Magick::Color &right_)
22 {
23  return((left_.isValid() == right_.isValid()) &&
24  (left_.quantumRed() == right_.quantumRed()) &&
25  (left_.quantumGreen() == right_.quantumGreen()) &&
26  (left_.quantumBlue() == right_.quantumBlue()));
27 }
28 
30  const Magick::Color &right_)
31 {
32  return(!(left_ == right_));
33 }
34 
36  const Magick::Color &right_)
37 {
38  return(!(left_ < right_ ) && (left_ != right_ ));
39 }
40 
42  const Magick::Color &right_)
43 {
44  if(left_.quantumRed() < right_.quantumRed())
45  return(true);
46  if(left_.quantumRed() > right_.quantumRed())
47  return(false);
48  if(left_.quantumGreen() < right_.quantumGreen())
49  return(true);
50  if(left_.quantumGreen() > right_.quantumGreen())
51  return(false);
52  if(left_.quantumBlue() < right_.quantumBlue())
53  return(true);
54  return(false);
55 }
56 
58  const Magick::Color &right_)
59 {
60  return((left_ > right_) || (left_ == right_));
61 }
62 
64  const Magick::Color &right_)
65 {
66  return((left_ < right_) || (left_ == right_));
67 }
68 
70  : _pixel(new PixelInfo),
71  _isValid(false),
72  _pixelOwn(true),
73  _pixelType(RGBPixel)
74 {
75  initPixel();
76 }
77 
78 Magick::Color::Color(const Magick::Quantum red_,const Magick::Quantum green_,
79  const Quantum blue_)
80  : _pixel(new PixelInfo),
81  _isValid(true),
82  _pixelOwn(true),
83  _pixelType(RGBPixel)
84 {
85  initPixel();
86 
87  quantumAlpha(OpaqueAlpha);
88  quantumBlack(0);
89  quantumBlue(blue_);
90  quantumGreen(green_);
91  quantumRed(red_);
92 }
93 
94 Magick::Color::Color(const Magick::Quantum red_,const Magick::Quantum green_,
95  const Magick::Quantum blue_, const Magick::Quantum alpha_)
96  : _pixel(new PixelInfo),
97  _isValid(true),
98  _pixelOwn(true),
99  _pixelType(RGBPixel)
100 {
101  initPixel();
102 
103  quantumAlpha(alpha_);
104  quantumBlack(0);
105  quantumBlue(blue_);
106  quantumGreen(green_);
107  quantumRed(red_);
108  if (alpha_ != OpaqueAlpha)
109  _pixelType=RGBAPixel;
110 }
111 
112 Magick::Color::Color(const Magick::Quantum cyan_,const Magick::Quantum magenta_,
113  const Magick::Quantum yellow_,const Magick::Quantum black_,
114  const Magick::Quantum alpha_)
115  : _pixel(new PixelInfo),
116  _isValid(true),
117  _pixelOwn(true),
118  _pixelType(CMYKPixel)
119 {
120  initPixel();
121 
122  quantumAlpha(alpha_);
123  quantumBlack(black_);
124  quantumBlue(yellow_);
125  quantumGreen(magenta_);
126  quantumRed(cyan_);
127  if (alpha_ != OpaqueAlpha)
128  _pixelType=CMYKAPixel;
129 }
130 
131 Magick::Color::Color(const char *color_)
132  : _pixel(new PixelInfo),
133  _isValid(true),
134  _pixelOwn(true),
135  _pixelType(RGBPixel)
136 {
137  initPixel();
138 
139  // Use operator = implementation
140  *this=color_;
141 }
142 
144  : _pixel(new PixelInfo),
145  _isValid(color_._isValid),
146  _pixelOwn(true),
147  _pixelType(color_._pixelType)
148 {
149  *_pixel=*color_._pixel;
150 }
151 
152 Magick::Color::Color(const PixelInfo &color_)
153  : _pixel(new PixelInfo),
154  _isValid(true),
155  _pixelOwn(true)
156 {
157  *_pixel=color_;
158  setPixelType(color_);
159 }
160 
161 Magick::Color::Color(const std::string &color_)
162  : _pixel(new PixelInfo),
163  _isValid(true),
164  _pixelOwn(true),
165  _pixelType(RGBPixel)
166 {
167  initPixel();
168 
169  // Use operator = implementation
170  *this=color_;
171 }
172 
174 {
175  if (_pixelOwn)
176  delete _pixel;
177 
178  _pixel=(PixelInfo *)NULL;
179 }
180 
182 {
183  // If not being set to ourself
184  if (this != &color_)
185  {
186  // Copy pixel value
187  *_pixel=*color_._pixel;
188 
189  // Validity
190  _isValid=color_._isValid;
191 
192  // Copy pixel type
193  _pixelType=color_._pixelType;
194  }
195  return(*this);
196 }
197 
198 const Magick::Color& Magick::Color::operator=(const char *color_)
199 {
200  *this=std::string(color_);
201  return(*this);
202 }
203 
204 const Magick::Color& Magick::Color::operator=(const MagickCore::PixelInfo &color_)
205 {
206  *_pixel=color_;
207  setPixelType(color_);
208 
209  return(*this);
210 }
211 
212 const Magick::Color& Magick::Color::operator=(const std::string &color_)
213 {
214  PixelInfo
215  target_color;
216 
217  initPixel();
219  if (QueryColorCompliance(color_.c_str(),AllCompliance,&target_color,
220  exceptionInfo))
221  {
222  quantumAlpha(target_color.alpha);
223  quantumBlack(target_color.black);
224  quantumBlue(target_color.blue);
225  quantumGreen(target_color.green);
226  quantumRed(target_color.red);
227 
228  setPixelType(target_color);
229  }
230  else
231  _isValid = false;
232  ThrowPPException(false);
233 
234  return(*this);
235 }
236 
237 Magick::Color::operator MagickCore::PixelInfo() const
238 {
239  return *_pixel;
240 }
241 
242 Magick::Color::operator std::string() const
243 {
244  char
245  colorbuf[MagickPathExtent];
246 
247  PixelInfo
248  pixel;
249 
250  if (!isValid())
251  return std::string("none");
252 
253  pixel.colorspace=(_pixelType == RGBPixel || _pixelType == RGBAPixel) ?
254  RGBColorspace : CMYKColorspace;
255  pixel.alpha_trait=(_pixelType == RGBAPixel || _pixelType == CMYKAPixel) ?
256  BlendPixelTrait : UndefinedPixelTrait;
257  pixel.depth=MAGICKCORE_QUANTUM_DEPTH;
258  pixel.alpha=_pixel->alpha;
259  pixel.alpha_trait=_pixel->alpha_trait;
260  pixel.black=_pixel->black;
261  pixel.blue=_pixel->blue;
262  pixel.green=_pixel->green;
263  pixel.red=_pixel->red;
264  GetColorTuple(&pixel,MagickTrue,colorbuf);
265 
266  return(std::string(colorbuf));
267 }
268 
269 bool Magick::Color::isFuzzyEquivalent(const Color &color_, const double fuzz_) const
270 {
271  PixelInfo
272  p,
273  q;
274 
275  p=*_pixel;
276  p.fuzz=fuzz_;
277  q=*color_._pixel;
278  q.fuzz=fuzz_;
279  return (IsFuzzyEquivalencePixelInfo(&p, &q) != MagickFalse);
280 }
281 
282 bool Magick::Color::isValid(void) const
283 {
284  return(_isValid);
285 }
286 
288 {
289  return(_pixelType);
290 }
291 
292 void Magick::Color::isValid(bool valid_)
293 {
294  if ((valid_ && isValid()) || (!valid_ && !isValid()))
295  return;
296 
297  if (!_pixelOwn)
298  {
299  _pixel=new PixelInfo;
300  _pixelOwn=true;
301  }
302 
303  _isValid=valid_;
304 
305  initPixel();
306 }
307 
308 void Magick::Color::quantumAlpha(const Magick::Quantum alpha_)
309 {
310  _pixel->alpha=alpha_;
311  if (alpha_ == QuantumRange)
312  {
313  _pixel->alpha_trait=UndefinedPixelTrait;
314  if (_pixelType == RGBAPixel)
315  _pixelType=RGBPixel;
316  else if (_pixelType == CMYKAPixel)
317  _pixelType=CMYKPixel;
318  }
319  else
320  {
321  _pixel->alpha_trait=BlendPixelTrait;
322  if (_pixelType == RGBPixel)
323  _pixelType=RGBAPixel;
324  else if (_pixelType == CMYKPixel)
325  _pixelType=CMYKAPixel;
326  }
327  _isValid=true;
328 }
329 
330 Magick::Quantum Magick::Color::quantumAlpha(void) const
331 {
332  return(_pixel->alpha);
333 }
334 
335 void Magick::Color::quantumBlack(const Magick::Quantum black_)
336 {
337  _pixel->black=black_;
338  _isValid=true;
339 }
340 
341 Magick::Quantum Magick::Color::quantumBlack(void) const
342 {
343  return(_pixel->black);
344 }
345 
346 void Magick::Color::quantumBlue(const Magick::Quantum blue_)
347 {
348  _pixel->blue=blue_;
349  _isValid=true;
350 }
351 
352 Magick::Quantum Magick::Color::quantumBlue(void) const
353 {
354  return(_pixel->blue);
355 }
356 
357 void Magick::Color::quantumGreen(const Magick::Quantum green_)
358 {
359  _pixel->green=green_;
360  _isValid=true;
361 }
362 
363 Magick::Quantum Magick::Color::quantumGreen(void) const
364 {
365  return(_pixel->green);
366 }
367 
368 void Magick::Color::quantumRed(const Magick::Quantum red_)
369 {
370  _pixel->red=red_;
371  _isValid=true;
372 }
373 
374 Magick::Quantum Magick::Color::quantumRed(void) const
375 {
376  return _pixel->red;
377 }
378 
380  : _pixel(new PixelInfo),
381  _isValid(false),
382  _pixelOwn(true),
383  _pixelType(pixelType_)
384 {
385  initPixel();
386 }
387 
388 Magick::Color::Color(PixelInfo* rep_,PixelType pixelType_)
389  : _pixel(rep_),
390  _isValid(true),
391  _pixelOwn(false),
392  _pixelType(pixelType_)
393 {
394 }
395 
396 void Magick::Color::pixel(PixelInfo *rep_,PixelType pixelType_)
397 {
398  if (_pixelOwn)
399  delete _pixel;
400 
401  _pixel=rep_;
402  _pixelOwn=false;
403  _isValid=true;
404  _pixelType=pixelType_;
405 }
406 
407 Magick::Quantum Magick::Color::scaleDoubleToQuantum(const double double_)
408 {
409  return(static_cast<Magick::Quantum>(double_*QuantumRange));
410 }
411 
412 double Magick::Color::scaleQuantumToDouble(const Magick::Quantum quantum_)
413 {
414 #if (MAGICKCORE_QUANTUM_DEPTH < 32)
415  return(static_cast<double>(quantum_)/QuantumRange);
416 #else
417  return(quantum_/QuantumRange);
418 #endif
419 }
420 
421 void Magick::Color::initPixel()
422 {
423  MagickCore::GetPixelInfo((MagickCore::Image *) NULL, _pixel);
424  if (_pixelType == CMYKPixel || _pixelType == CMYKAPixel)
425  _pixel->colorspace=CMYKColorspace;
426 }
427 
428 void Magick::Color::setPixelType(const PixelInfo &color_)
429 {
430  if (color_.colorspace == CMYKColorspace)
431  _pixelType=color_.alpha_trait != UndefinedPixelTrait ? CMYKAPixel :
432  CMYKPixel;
433  else
434  _pixelType=color_.alpha_trait != UndefinedPixelTrait ? RGBAPixel :
435  RGBPixel;
436 }
437 
439  : Color(CMYKPixel)
440 {
441 }
442 
444  : Color(color_)
445 {
446 }
447 
448 Magick::ColorCMYK::ColorCMYK(const double cyan_,const double magenta_,
449  const double yellow_,const double black_)
450  : Color(CMYKPixel)
451 {
452  cyan(cyan_);
453  magenta(magenta_);
454  yellow(yellow_);
455  black(black_);
456 }
457 
458 Magick::ColorCMYK::ColorCMYK(const double cyan_,const double magenta_,
459  const double yellow_,const double black_,const double alpha_)
460  : Color(CMYKAPixel)
461 {
462  cyan(cyan_);
463  magenta(magenta_);
464  yellow(yellow_);
465  black(black_);
466  alpha(alpha_);
467 }
468 
470 {
471 }
472 
474 {
475  *static_cast<Magick::Color*>(this)=color_;
476  return(*this);
477 }
478 
479 void Magick::ColorCMYK::alpha(const double alpha_)
480 {
482 }
483 
484 double Magick::ColorCMYK::alpha(void) const
485 {
487 }
488 
489 void Magick::ColorCMYK::black(const double black_)
490 {
492 }
493 
494 double Magick::ColorCMYK::black(void) const
495 {
497 }
498 
499 void Magick::ColorCMYK::cyan(const double cyan_)
500 {
502 }
503 
504 double Magick::ColorCMYK::cyan(void) const
505 {
506  return(scaleQuantumToDouble(quantumRed()));
507 }
508 
509 void Magick::ColorCMYK::magenta(const double magenta_)
510 {
512 }
513 
514 double Magick::ColorCMYK::magenta(void) const
515 {
517 }
518 
519 void Magick::ColorCMYK::yellow(const double yellow_)
520 {
522 }
523 
524 double Magick::ColorCMYK::yellow(void) const
525 {
527 }
528 
529 Magick::ColorCMYK::ColorCMYK(PixelInfo *rep_,PixelType pixelType_)
530  : Color(rep_,pixelType_)
531 {
532 }
533 
535  : Color()
536 {
537 }
538 
540  : Color(color_)
541 {
542 }
543 
546  scaleDoubleToQuantum(shade_))
547 {
548 }
549 
551 {
552 }
553 
554 void Magick::ColorGray::shade(double shade_)
555 {
556  Quantum gray=scaleDoubleToQuantum(shade_);
557  quantumRed(gray);
558  quantumGreen(gray);
559  quantumBlue(gray);
560 }
561 
562 double Magick::ColorGray::shade(void) const
563 {
565 }
566 
568 {
569  *static_cast<Magick::Color*>(this)=color_;
570  return(*this);
571 }
572 
573 Magick::ColorGray::ColorGray(PixelInfo *rep_,PixelType pixelType_)
574 : Color(rep_,pixelType_)
575 {
576 }
577 
579  : Color()
580 {
581 }
582 
584  : Color(color_)
585 {
586 }
587 
588 Magick::ColorHSL::ColorHSL(const double hue_,const double saturation_,
589  const double lightness_)
590  : Color()
591 {
592  double
593  blue,
594  green,
595  red;
596 
597  ConvertHSLToRGB(hue_,saturation_,lightness_,&red,&green,&blue);
598 
599  quantumRed(red);
600  quantumGreen(green);
601  quantumBlue(blue);
602 }
603 
605 {
606 }
607 
609 {
610  *static_cast<Magick::Color*>(this) = color_;
611  return(*this);
612 }
613 
614 void Magick::ColorHSL::hue(const double hue_)
615 {
616  double
617  hue,
618  lightness,
619  saturation;
620 
621  double
622  blue,
623  green,
624  red;
625 
626  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
627  &lightness);
628 
629  hue=hue_;
630 
631  ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
632 
633  quantumRed(ClampToQuantum(red));
634  quantumGreen(ClampToQuantum(green));
635  quantumBlue(ClampToQuantum(blue));
636 }
637 
638 double Magick::ColorHSL::hue(void) const
639 {
640  double
641  hue,
642  lightness,
643  saturation;
644 
645  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
646  &lightness);
647 
648  return(hue);
649 }
650 
651 void Magick::ColorHSL::lightness (const double lightness_)
652 {
653  double
654  hue,
655  lightness,
656  saturation;
657 
658  double
659  blue,
660  green,
661  red;
662 
663  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
664  &lightness);
665 
666  lightness=lightness_;
667 
668  ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
669 
670  quantumRed(ClampToQuantum(red));
671  quantumGreen(ClampToQuantum(green));
672  quantumBlue(ClampToQuantum(blue));
673 }
674 
675 double Magick::ColorHSL::lightness (void) const
676 {
677  double
678  hue,
679  lightness,
680  saturation;
681 
682  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
683  &lightness);
684 
685  return(lightness);
686 }
687 
688 void Magick::ColorHSL::saturation(const double saturation_)
689 {
690  double
691  hue,
692  lightness,
693  saturation;
694 
695  double
696  blue,
697  green,
698  red;
699 
700  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
701  &lightness);
702 
703  saturation=saturation_;
704 
705  ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
706 
707  quantumRed(ClampToQuantum(red));
708  quantumGreen(ClampToQuantum(green));
709  quantumBlue(ClampToQuantum(blue));
710 }
711 
713 {
714  double
715  hue,
716  lightness,
717  saturation;
718 
719  ConvertRGBToHSL(quantumRed(),quantumGreen(),quantumBlue(),&hue,&saturation,
720  &lightness);
721 
722  return(saturation);
723 }
724 
726  : Color()
727 {
728 }
729 
731  : Color((mono_ ? QuantumRange : 0),(mono_ ? QuantumRange : 0),
732  (mono_ ? QuantumRange : 0))
733 {
734 }
735 
737  : Color(color_)
738 {
739 }
740 
742 {
743 }
744 
746 {
747  *static_cast<Magick::Color*>(this)=color_;
748  return(*this);
749 }
750 
751 void Magick::ColorMono::mono(bool mono_)
752 {
753  quantumRed(mono_ ? QuantumRange : 0);
754  quantumGreen(mono_ ? QuantumRange : 0);
755  quantumBlue(mono_ ? QuantumRange : 0);
756 }
757 
758 bool Magick::ColorMono::mono(void) const
759 {
760  return(quantumGreen() == 0);
761 }
762 
763 Magick::ColorMono::ColorMono(PixelInfo *rep_,PixelType pixelType_)
764  : Color(rep_,pixelType_)
765 {
766 }
767 
769  : Color()
770 {
771 }
772 
774  : Color(color_)
775 {
776 }
777 
778 Magick::ColorRGB::ColorRGB(const double red_,const double green_,
779  const double blue_)
781  scaleDoubleToQuantum(blue_))
782 {
783 }
784 
785 Magick::ColorRGB::ColorRGB(const double red_,const double green_,
786  const double blue_,const double alpha_)
789 {
790 }
791 
793 {
794 }
795 
797 {
798  *static_cast<Magick::Color*>(this)=color_;
799  return(*this);
800 }
801 
802 void Magick::ColorRGB::alpha(const double alpha_)
803 {
805 }
806 
807 double Magick::ColorRGB::alpha(void) const
808 {
810 }
811 
812 void Magick::ColorRGB::blue(const double blue_)
813 {
815 }
816 
817 double Magick::ColorRGB::blue(void) const
818 {
820 }
821 
822 void Magick::ColorRGB::green(const double green_)
823 {
825 }
826 
827 double Magick::ColorRGB::green(void) const
828 {
830 }
831 
832 void Magick::ColorRGB::red(const double red_)
833 {
835 }
836 
837 double Magick::ColorRGB::red(void) const
838 {
839  return(scaleQuantumToDouble(quantumRed()));
840 }
841 
842 Magick::ColorRGB::ColorRGB(PixelInfo *rep_,PixelType pixelType_)
843  : Color(rep_,pixelType_)
844 {
845 }
846 
848  : Color()
849 {
850 }
851 
853  : Color(color_)
854 {
855 }
856 
857 Magick::ColorYUV::ColorYUV(const double y_,const double u_,const double v_)
858  : Color()
859 {
860  convert(y_, u_, v_);
861 }
862 
864 {
865 }
866 
868 {
869  *static_cast<Magick::Color*>(this)=color_;
870  return(*this);
871 }
872 
873 void Magick::ColorYUV::u(const double u_)
874 {
875  convert(y(), u_, v());
876 }
877 
878 double Magick::ColorYUV::u(void) const
879 {
880  return(scaleQuantumToDouble((-0.14740 * quantumRed()) - (0.28950 *
881  quantumGreen()) + (0.43690 * quantumBlue())));
882 }
883 
884 void Magick::ColorYUV::v(const double v_)
885 {
886  convert(y(), u(), v_);
887 }
888 
889 double Magick::ColorYUV::v(void) const
890 {
891  return(scaleQuantumToDouble((0.61500 * quantumRed()) - (0.51500 *
892  quantumGreen()) - (0.10000 * quantumBlue())));
893 }
894 
895 void Magick::ColorYUV::y(const double y_)
896 {
897  convert(y_, u(), v());
898 }
899 
900 double Magick::ColorYUV::y ( void ) const
901 {
902  return(scaleQuantumToDouble((0.29900 * quantumRed()) + (0.58700 *
903  quantumGreen()) + (0.11400 * quantumBlue())));
904 }
905 
906 void Magick::ColorYUV::convert(const double y_,const double u_,const double v_)
907 {
908  quantumRed(scaleDoubleToQuantum(y_ + 1.13980 * v_));
909  quantumGreen(scaleDoubleToQuantum(y_ - (0.39380 * u_) - (0.58050 * v_)));
910  quantumBlue(scaleDoubleToQuantum(y_ + 2.02790 * u_));
911 }
912 
913 Magick::ColorYUV::ColorYUV(PixelInfo *rep_,PixelType pixelType_)
914  : Color(rep_,pixelType_)
915 {
916 }
ColorYUV & operator=(const Color &color_)
Definition: Color.cpp:867
MagickPPExport int operator!=(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:29
~ColorCMYK(void)
Definition: Color.cpp:469
double shade(void) const
Definition: Color.cpp:562
void quantumGreen(const Quantum green_)
Definition: Color.cpp:357
Quantum quantumGreen(void) const
Definition: Color.cpp:363
Quantum quantumAlpha(void) const
Definition: Color.cpp:330
~ColorRGB(void)
Definition: Color.cpp:792
double lightness(void) const
Definition: Color.cpp:675
ColorYUV(void)
Definition: Color.cpp:847
bool isValid(void) const
Definition: Color.cpp:282
Quantum quantumBlue(void) const
Definition: Color.cpp:352
STL namespace.
void quantumBlue(const Quantum blue_)
Definition: Color.cpp:346
MagickPPExport int operator<(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:41
double u(void) const
Definition: Color.cpp:878
double black(void) const
Definition: Color.cpp:494
double green(void) const
Definition: Color.cpp:827
double alpha(void) const
Definition: Color.cpp:807
ColorGray & operator=(const Color &color_)
Definition: Color.cpp:567
MagickPPExport int operator<=(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:63
ColorRGB(void)
Definition: Color.cpp:768
MagickPPExport int operator>=(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:57
double hue(void) const
Definition: Color.cpp:638
Quantum quantumRed(void) const
Definition: Color.cpp:374
ColorCMYK & operator=(const Color &color_)
Definition: Color.cpp:473
#define MagickPPExport
Definition: Include.h:268
ColorRGB & operator=(const Color &color_)
Definition: Color.cpp:796
Quantum quantumBlack(void) const
Definition: Color.cpp:341
double blue(void) const
Definition: Color.cpp:817
double cyan(void) const
Definition: Color.cpp:504
~ColorYUV(void)
Definition: Color.cpp:863
double saturation(void) const
Definition: Color.cpp:712
#define ThrowPPException(quiet)
Definition: Include.h:1544
ColorHSL(void)
Definition: Color.cpp:578
static double scaleQuantumToDouble(const Quantum quantum_)
Definition: Color.cpp:412
double yellow(void) const
Definition: Color.cpp:524
bool mono(void) const
Definition: Color.cpp:758
PixelInfo * _pixel
Definition: Color.h:172
virtual ~Color(void)
Definition: Color.cpp:173
bool isFuzzyEquivalent(const Color &color_, const double fuzz_) const
Definition: Color.cpp:269
static Quantum scaleDoubleToQuantum(const double double_)
Definition: Color.cpp:407
void isValid(const bool valid_)
Definition: Color.cpp:292
double v(void) const
Definition: Color.cpp:889
void quantumRed(const Quantum red_)
Definition: Color.cpp:368
MagickPPExport int operator>(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:35
double y(void) const
Definition: Color.cpp:900
MagickPPExport int operator==(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:20
class MagickPPExport Image
Definition: Drawable.h:720
Color & operator=(const Color &color_)
Definition: Color.cpp:181
double red(void) const
Definition: Color.cpp:837
ColorMono & operator=(const Color &color_)
Definition: Color.cpp:745
Magick::Color::PixelType pixelType(void) const
Definition: Color.cpp:287
#define GetPPException
Definition: Include.h:1525
void pixel(PixelInfo *rep_, PixelType pixelType_)
Definition: Color.cpp:396
double alpha(void) const
Definition: Color.cpp:484
double magenta(void) const
Definition: Color.cpp:514
Color(void)
Definition: Color.cpp:69
ColorHSL & operator=(const Color &color_)
Definition: Color.cpp:608