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