CPixelManip.h
Go to the documentation of this file.
1 #ifndef iipr_CPixelManip_included
2 #define iipr_CPixelManip_included
3 
4 
5 // Qt includes
6 #include <QtCore/QtGlobal>
7 
8 
9 namespace iipr
10 {
11 
12 
13 #pragma pack(push, 1)
14 
15 
20 {
21 public:
22  class Rgba
23  {
24  public:
25  Rgba()
26  : m_b(0), m_g(0), m_r(0), m_a(255)
27  {
28  }
29 
30  Rgba(quint8 r, quint8 g, quint8 b, quint8 a = 255)
31  : m_r(r), m_g(g), m_b(b), m_a(a)
32  {
33  }
34 
35  quint8 m_b;
36  quint8 m_g;
37  quint8 m_r;
38  quint8 m_a;
39  };
40 
41  class Rgb
42  {
43  public:
44  Rgb()
45  : m_r(0), m_g(0), m_b(0)
46  {
47  }
48 
49  Rgb(quint8 r, quint8 g, quint8 b)
50  : m_r(r), m_g(g), m_b(b)
51  {
52  }
53 
54  quint8 m_r;
55  quint8 m_g;
56  quint8 m_b;
57  };
58 
59  template <typename IntType, int Shift, bool DoCropMin = true, bool DoCropMax = true>
61  {
62  public:
64  {
65  }
66 
68  : m_gray(value.m_gray)
69  {
70  }
71 
72  GrayCropAccum32(int value)
73  : m_gray(IntType(value) << Shift)
74  {
75  }
76 
77  GrayCropAccum32(quint8 value)
78  : m_gray(IntType(value) << Shift)
79  {
80  }
81 
82  GrayCropAccum32(quint16 value)
83  : m_gray(IntType(value) << Shift)
84  {
85  }
86 
87  GrayCropAccum32(quint32 value)
88  : m_gray(IntType(value) << Shift)
89  {
90  }
91 
92  GrayCropAccum32(quint64 value)
93  : m_gray(IntType(value) << Shift)
94  {
95  }
96 
97  GrayCropAccum32(double value)
98  : m_gray(IntType(value * (1 << Shift)))
99  {
100  }
101 
102  bool operator==(const GrayCropAccum32& value)
103  {
104  return m_gray == value.m_gray;
105  }
106 
107  bool operator==(int value)
108  {
109  return m_gray == (IntType(value) << Shift);
110  }
111 
112  bool operator==(double value)
113  {
114  return m_gray == IntType(value * (1 << Shift));
115  }
116 
117  bool operator!=(const GrayCropAccum32& value)
118  {
119  return m_gray != value.m_gray;
120  }
121 
122  bool operator!=(int value)
123  {
124  return m_gray != (IntType(value) << Shift);
125  }
126 
127  bool operator!=(double value)
128  {
129  return m_gray != IntType(value * (1 << Shift));
130  }
131 
133  {
134  m_gray = value.m_gray;
135 
136  return *this;
137  }
138 /*
139  GrayCropAccum32& operator=(unsigned long long value)
140  {
141  m_gray = IntType(value) << Shift;
142 
143  return *this;
144  }
145 
146  GrayCropAccum32& operator=(unsigned int value)
147  {
148  m_gray = IntType(value) << Shift;
149 
150  return *this;
151  }
152 
153  GrayCropAccum32& operator=(double value)
154  {
155  m_gray = IntType(value * (1 << Shift));
156 
157  return *this;
158  }
159 */
161  {
162  m_gray += value.m_gray;
163 
164  return *this;
165  }
166 
167  GrayCropAccum32& operator+=(unsigned int value)
168  {
169  m_gray += IntType(value) << Shift;
170 
171  return *this;
172  }
173 
175  {
176  m_gray += IntType(value * (1 << Shift));
177 
178  return *this;
179  }
180 
182  {
183  m_gray -= value.m_gray;
184 
185  return *this;
186  }
187 
188  GrayCropAccum32& operator-=(unsigned int value)
189  {
190  m_gray -= IntType(value) << Shift;
191 
192  return *this;
193  }
194 
196  {
197  m_gray -= IntType(value * (1 << Shift));
198 
199  return *this;
200  }
201 
203  {
204  m_gray = IntType((quint64(m_gray) * quint64(value.m_gray)) >> Shift);
205 
206  return *this;
207  }
208 
209  GrayCropAccum32& operator*=(unsigned int value)
210  {
211  m_gray *= IntType(value);
212 
213  return *this;
214  }
215 
217  {
218  m_gray = IntType(m_gray * value);
219 
220  return *this;
221  }
222 
224  {
225  GrayCropAccum32 retVal;
226 
227  retVal.m_gray = m_gray / value;
228 
229  return retVal;
230  }
231 
233  {
234  GrayCropAccum32 retVal;
235 
236  retVal.m_gray = IntType(m_gray / value);
237 
238  return retVal;
239  }
240 
241  operator quint8()
242  {
243 
244  if (DoCropMin && (m_gray < 0)){
245  return 0;
246  }
247  if (DoCropMax && (m_gray > (IntType(0xff) << Shift))){
248  return 0xff;
249  }
250 
251  return quint8(m_gray >> Shift);
252  }
253 
254  operator quint16()
255  {
256  if (DoCropMin && (m_gray < 0)){
257  return 0;
258  }
259  if (DoCropMin && (m_gray > (IntType(0xffff) << Shift))){
260  return 0xffff;
261  }
262 
263  return quint16(m_gray >> Shift);
264  }
265 
266  operator quint32()
267  {
268  if (DoCropMin && (m_gray < 0)){
269  return 0;
270  }
271 
272  return quint32(m_gray >> Shift);
273  }
274 
275  operator Rgba()
276  {
277  quint8 grayValue;
278 
279  if (DoCropMin && (m_gray < 0)){
280  grayValue = 0;
281  }
282  else if (DoCropMin && (m_gray > (0xff << Shift))){
283  grayValue = 0xff;
284  }
285  else{
286  grayValue = quint8(m_gray >> Shift);
287  }
288 
289  return Rgba(grayValue, grayValue, grayValue);
290  }
291 
292  protected:
293  IntType m_gray;
294  };
295 
296  template <typename IntType, int Shift, bool DoCropMin = true, bool DoCropMax = true>
298  {
299  public:
301  {
302  }
303 
305  : m_r(value.m_r), m_g(value.m_g), m_b(value.m_b)
306  {
307  }
308 
309  RgbCropAccum32(const Rgba& value)
310  : m_r(IntType(value.m_r) << Shift), m_g(IntType(value.m_g) << Shift), m_b(IntType(value.m_b) << Shift)
311  {
312  }
313 
314  RgbCropAccum32(const Rgb& value)
315  : m_r(IntType(value.m_r) << Shift), m_g(IntType(value.m_g) << Shift), m_b(IntType(value.m_b) << Shift)
316  {
317  }
318 
319  RgbCropAccum32(int value)
320  : m_r(IntType(value) << Shift), m_g(IntType(value) << Shift), m_b(IntType(value) << Shift)
321  {
322  }
323 
324  RgbCropAccum32(quint8 value)
325  : m_r(IntType(value) << Shift), m_g(IntType(value) << Shift), m_b(IntType(value) << Shift)
326  {
327  }
328 
329  RgbCropAccum32(quint16 value)
330  : m_r(IntType(value) << Shift), m_g(IntType(value) << Shift), m_b(IntType(value) << Shift)
331  {
332  }
333 
334  RgbCropAccum32(quint32 value)
335  : m_r(IntType(value) << Shift), m_g(IntType(value) << Shift), m_b(IntType(value) << Shift)
336  {
337  }
338 
339  RgbCropAccum32(quint64 value)
340  : m_r(IntType(value) << Shift), m_g(IntType(value) << Shift), m_b(IntType(value) << Shift)
341  {
342  }
343 
344  RgbCropAccum32(double value)
345  : m_r(IntType(value * (1 << Shift))), m_g(IntType(value * (1 << Shift))), m_b(IntType(value * (1 << Shift)))
346  {
347  }
348 
349  bool operator==(const RgbCropAccum32& value)
350  {
351  return (m_r == value.m_r) && (m_g == value.m_g) && (m_b == value.m_b);
352  }
353 
354  bool operator==(int value)
355  {
356  IntType gray = (IntType(value) << Shift);
357 
358  return (m_r == gray) && (m_g == gray) && (m_b == gray);
359  }
360 
361  bool operator==(double value)
362  {
363  IntType gray = IntType(value * (1 << Shift));
364 
365  return (m_r == gray) && (m_g == gray) && (m_b == gray);
366  }
367 
368  bool operator!=(const RgbCropAccum32& value)
369  {
370  return (m_r != value.m_r) || (m_g != value.m_g) || (m_b != value.m_b);
371  }
372 
373  bool operator!=(int value)
374  {
375  IntType gray = (IntType(value) << Shift);
376 
377  return (m_r != gray) || (m_g != gray) || (m_b != gray);
378  }
379 
380  bool operator!=(double value)
381  {
382  IntType gray = IntType(value * (1 << Shift));
383 
384  return (m_r != gray) || (m_g != gray) || (m_b != gray);
385  }
386 
388  {
389  m_r = value.m_r;
390  m_g = value.m_g;
391  m_b = value.m_b;
392 
393  return *this;
394  }
395 
397  {
398  m_r += value.m_r;
399  m_g += value.m_g;
400  m_b += value.m_b;
401 
402  return *this;
403  }
404 
406  {
407  m_r += IntType(value.m_r) << Shift;
408  m_g += IntType(value.m_g) << Shift;
409  m_b += IntType(value.m_b) << Shift;
410 
411  return *this;
412  }
413 
414  RgbCropAccum32& operator+=(unsigned int value)
415  {
416  IntType gray = IntType(value) << Shift;
417  m_r += gray;
418  m_g += gray;
419  m_b += gray;
420 
421  return *this;
422  }
423 
424  RgbCropAccum32& operator+=(double value)
425  {
426  IntType gray = IntType(value * (1 << Shift));
427  m_r += gray;
428  m_g += gray;
429  m_b += gray;
430 
431  return *this;
432  }
433 
435  {
436  m_r -= value.m_r;
437  m_g -= value.m_g;
438  m_b -= value.m_b;
439 
440  return *this;
441  }
442 
444  {
445  m_r -= IntType(value.m_r) << Shift;
446  m_g -= IntType(value.m_g) << Shift;
447  m_b -= IntType(value.m_b) << Shift;
448 
449  return *this;
450  }
451 
452  RgbCropAccum32& operator-=(quint32 value)
453  {
454  IntType gray = IntType(value) << Shift;
455  m_r -= gray;
456  m_g -= gray;
457  m_b -= gray;
458 
459  return *this;
460  }
461 
462  RgbCropAccum32& operator-=(double value)
463  {
464  IntType gray = IntType(value * (1 << Shift));
465  m_r -= gray;
466  m_g -= gray;
467  m_b -= gray;
468 
469  return *this;
470  }
471 
473  {
474  m_r = IntType(quint64(m_r) * quint64(value.m_r) >> Shift);;
475  m_g = IntType(quint64(m_g) * quint64(value.m_g) >> Shift);;
476  m_b = IntType(quint64(m_b) * quint64(value.m_b) >> Shift);;
477 
478  return *this;
479  }
480 
482  {
483  m_r *= IntType(value);
484  m_g *= IntType(value);
485  m_b *= IntType(value);
486 
487  return *this;
488  }
489 
490  RgbCropAccum32& operator*=(double value)
491  {
492  m_r = IntType(m_r * value);
493  m_g = IntType(m_g * value);
494  m_b = IntType(m_b * value);
495 
496  return *this;
497  }
498 
500  {
501  RgbCropAccum32 retVal;
502 
503  retVal.m_r = m_r / value;
504  retVal.m_g = m_g / value;
505  retVal.m_b = m_b / value;
506 
507  return retVal;
508  }
509 
510  RgbCropAccum32 operator/(double value)
511  {
512  RgbCropAccum32 retVal;
513 
514  retVal.m_r = IntType(m_r / value);
515  retVal.m_g = IntType(m_g / value);
516  retVal.m_b = IntType(m_b / value);
517 
518  return retVal;
519  }
520 
521  operator quint8()
522  {
523  quint64 grayValue = (quint64(m_r) + quint64(m_g) + quint64(m_b)) / 3;
524 
525  if (DoCropMin && (grayValue < 0)){
526  return 0;
527  }
528  if (DoCropMin && (grayValue > (0xff << Shift))){
529  return 0xff;
530  }
531 
532  return quint8(grayValue >> Shift);
533  }
534 
535  operator quint16()
536  {
537  quint64 grayValue = (quint64(m_r) + quint64(m_g) + quint64(m_b)) / 3;
538 
539  if (DoCropMin && (grayValue < 0)){
540  return 0;
541  }
542  if (DoCropMin && (grayValue > (0xffff << Shift))){
543  return 0xffff;
544  }
545 
546  return quint16(grayValue >> Shift);
547  }
548 
549  operator quint32()
550  {
551  quint64 grayValue = (quint64(m_r) + quint64(m_g) + quint64(m_b)) / 3;
552 
553  if (DoCropMin && (grayValue < 0)){
554  return 0;
555  }
556 
557  return quint32(grayValue >> Shift);
558  }
559 
560  operator float()
561  {
562  return (float(m_r) + float(m_g) + float(m_b)) / (3 << Shift);
563  }
564 
565  operator double()
566  {
567  return (double(m_r) + double(m_g) + double(m_b)) / (3 << Shift);
568  }
569 
570  operator Rgba()
571  {
572  IntType red = m_r;
573  if (DoCropMin && (red < 0)){
574  red = 0;
575  }
576  else if (DoCropMin && (red > (0xff << Shift))){
577  red = 0xff;
578  }
579 
580  IntType green = m_g;
581  if (DoCropMin && (green < 0)){
582  green = 0;
583  }
584  else if (DoCropMin && (green > (0xff << Shift))){
585  green = 0xff;
586  }
587 
588  IntType blue = m_b;
589  if (DoCropMin && (blue < 0)){
590  blue = 0;
591  }
592  else if (DoCropMin && (blue > (0xff << Shift))){
593  blue = 0xff;
594  }
595 
596  return Rgba(quint8(red >> Shift), quint8(green >> Shift), quint8(blue >> Shift));
597  }
598 
599  operator Rgb()
600  {
601  IntType red = m_r;
602  if (DoCropMin && (red < 0)){
603  red = 0;
604  }
605  else if (DoCropMin && (red > (0xff << Shift))){
606  red = 0xff;
607  }
608 
609  IntType green = m_g;
610  if (DoCropMin && (green < 0)){
611  green = 0;
612  }
613  else if (DoCropMin && (green > (0xff << Shift))){
614  green = 0xff;
615  }
616 
617  IntType blue = m_b;
618  if (DoCropMin && (blue < 0)){
619  blue = 0;
620  }
621  else if (DoCropMin && (blue > (0xff << Shift))){
622  blue = 0xff;
623  }
624 
625  return Rgb(quint8(red >> Shift), quint8(green >> Shift), quint8(blue >> Shift));
626  }
627 
628  protected:
629  IntType m_r;
630  IntType m_g;
631  IntType m_b;
632  };
633 
634  template <typename IntType, int Shift, bool DoCropMin = true, bool DoCropMax = true>
635  class RgbaCropAccum32: public RgbCropAccum32<IntType, Shift, DoCropMin, DoCropMax>
636  {
637  public:
639 
641  {
642  }
643 
645  : BaseClass(value),
646  m_a(value.m_a)
647  {
648  }
649 
650  RgbaCropAccum32(const Rgba& value)
651  : BaseClass(value),
652  m_a(IntType(255) << Shift)
653  {
654  }
655 
656  RgbaCropAccum32(int value)
657  : BaseClass(value),
658  m_a(IntType(255) << Shift)
659  {
660  }
661 
662  RgbaCropAccum32(quint8 value)
663  : BaseClass(value),
664  m_a(IntType(255) << Shift)
665  {
666  }
667 
668  RgbaCropAccum32(quint16 value)
669  : BaseClass(value),
670  m_a(IntType(255) << Shift)
671  {
672  }
673 
674  RgbaCropAccum32(quint32 value)
675  : BaseClass(value),
676  m_a(IntType(255) << Shift)
677  {
678  }
679 
680  RgbaCropAccum32(quint64 value)
681  : BaseClass(value),
682  m_a(IntType(255) << Shift)
683  {
684  }
685 
686  RgbaCropAccum32(double value)
687  : BaseClass(value),
688  m_a(IntType(255) << Shift)
689  {
690  }
691 
692  bool operator==(const RgbaCropAccum32& value)
693  {
694  return (BaseClass::m_r == value.m_r) && (BaseClass::m_g == value.m_g) && (BaseClass::m_b == value.m_b) && (m_a == value.m_a);
695  }
696 
697  bool operator==(int value)
698  {
699  IntType gray = (IntType(value) << Shift);
700 
701  return (BaseClass::m_r == gray) && (BaseClass::m_g == gray) && (BaseClass::m_b == gray) && (m_a == (IntType(255) << Shift));
702  }
703 
704  bool operator==(double value)
705  {
706  IntType gray = IntType(value * (1 << Shift));
707 
708  return (BaseClass::m_r == gray) && (BaseClass::m_g == gray) && (BaseClass::m_b == gray) && (m_a == (IntType(255) << Shift));
709  }
710 
711  bool operator!=(const RgbaCropAccum32& value)
712  {
713  return (BaseClass::m_r != value.m_r) || (BaseClass::m_g != value.m_g) || (BaseClass::m_b != value.m_b) || (m_a != value.m_a);
714  }
715 
716  bool operator!=(int value)
717  {
718  IntType gray = (IntType(value) << Shift);
719 
720  return (BaseClass::m_r != gray) || (BaseClass::m_g != gray) || (BaseClass::m_b != gray) || (m_a != (IntType(255) << Shift));
721  }
722 
723  bool operator!=(double value)
724  {
725  IntType gray = IntType(value * (1 << Shift));
726 
727  return (BaseClass::m_r != gray) || (BaseClass::m_g != gray) || (BaseClass::m_b != gray) || (m_a != (IntType(255) << Shift));
728  }
729 
731  {
732  BaseClass::m_r = value.m_r;
733  BaseClass::m_g = value.m_g;
734  BaseClass::m_b = value.m_b;
735 
736  m_a = value.m_a;
737 
738  return *this;
739  }
740 
742  {
743  IntType a = (m_a + value.m_a) / 2;
744  if (a != 0){
745  BaseClass::m_r = (BaseClass::m_r * m_a + value.m_r * value.m_a) / a;
746  BaseClass::m_g = (BaseClass::m_g * m_a + value.m_g * value.m_a) / a;
747  BaseClass::m_b = (BaseClass::m_b * m_a + value.m_b * value.m_a) / a;
748  }
749  m_a = a;
750 
751  return *this;
752  }
753 
755  {
756  IntType a = (m_a + (IntType(value.m_a) << Shift)) / 2;
757  if (a != 0){
758  BaseClass::m_r = (BaseClass::m_r * (m_a >> Shift) + (IntType(value.m_r) * IntType(value.m_a) << Shift)) / a;
759  BaseClass::m_g = (BaseClass::m_g * (m_a >> Shift) + (IntType(value.m_g) * IntType(value.m_a) << Shift)) / a;
760  BaseClass::m_b = (BaseClass::m_b * (m_a >> Shift) + (IntType(value.m_b) * IntType(value.m_a) << Shift)) / a;
761  }
762  m_a = a;
763 
764  return *this;
765  }
766 
767  RgbaCropAccum32& operator+=(unsigned int value)
768  {
769  IntType gray_corr = (IntType(value) * IntType(255) << Shift);
770  IntType a = (m_a + (IntType(255) << Shift)) / 2;
771  if (a != 0){
772  BaseClass::m_r = (BaseClass::m_r * (m_a >> Shift) + gray_corr) / a;
773  BaseClass::m_g = (BaseClass::m_g * (m_a >> Shift) + gray_corr) / a;
774  BaseClass::m_b = (BaseClass::m_b * (m_a >> Shift) + gray_corr) / a;
775  }
776  m_a = a;
777 
778  return *this;
779  }
780 
782  {
783  IntType gray_corr = IntType(value * (255 << Shift));
784  IntType a = (m_a + (IntType(255) << Shift)) / 2;
785  if (a != 0){
786  BaseClass::m_r = (BaseClass::m_r * (m_a >> Shift) + gray_corr) / a;
787  BaseClass::m_g = (BaseClass::m_g * (m_a >> Shift) + gray_corr) / a;
788  BaseClass::m_b = (BaseClass::m_b * (m_a >> Shift) + gray_corr) / a;
789  }
790  m_a = a;
791 
792  return *this;
793  }
794 
796  {
797  BaseClass::operator*=(value);
798 
799  return *this;
800  }
801 
803  {
804  BaseClass::operator*=(value);
805 
806  return *this;
807  }
808 
810  {
811  BaseClass::operator*=(value);
812 
813  return *this;
814  }
815 
817  {
818  BaseClass::operator/=(value);
819 
820  return *this;
821  }
822 
824  {
825  BaseClass::operator/=(value);
826 
827  return *this;
828  }
829 
830  operator Rgba()
831  {
832  IntType red = BaseClass::m_r;
833  if (DoCropMin && (red < 0)){
834  red = 0;
835  }
836  else if (DoCropMin && (red > (0xff << Shift))){
837  red = 0xff;
838  }
839 
840  IntType green = BaseClass::m_g;
841  if (DoCropMin && (green < 0)){
842  green = 0;
843  }
844  else if (DoCropMin && (green > (0xff << Shift))){
845  green = 0xff;
846  }
847 
848  IntType blue = BaseClass::m_b;
849  if (DoCropMin && (blue < 0)){
850  blue = 0;
851  }
852  else if (DoCropMin && (blue > (0xff << Shift))){
853  blue = 0xff;
854  }
855 
856  return Rgba(quint8(red >> Shift), quint8(green >> Shift), quint8(blue >> Shift), quint8(m_a >> Shift));
857  }
858 
859  protected:
860  IntType m_a;
861  };
862 };
863 
864 
865 #pragma pack(pop)
866 
867 
868 } // namespace iipr
869 
870 
871 #endif // !iipr_CPixelManip_included
872 
873 
GrayCropAccum32 & operator*=(double value)
Definition: CPixelManip.h:216
RgbaCropAccum32 & operator*=(const RgbaCropAccum32 &value)
Definition: CPixelManip.h:795
RgbCropAccum32< IntType, Shift, DoCropMin, DoCropMax > BaseClass
Definition: CPixelManip.h:638
RgbaCropAccum32(const Rgba &value)
Definition: CPixelManip.h:650
GrayCropAccum32 & operator+=(const GrayCropAccum32 &value)
Definition: CPixelManip.h:160
RgbCropAccum32 operator/(double value)
Definition: CPixelManip.h:510
GrayCropAccum32 & operator-=(const GrayCropAccum32 &value)
Definition: CPixelManip.h:181
RgbCropAccum32 & operator*=(const RgbCropAccum32 &value)
Definition: CPixelManip.h:472
GrayCropAccum32 & operator*=(const GrayCropAccum32 &value)
Definition: CPixelManip.h:202
Set pixel performance optimized classes designed to be used for pixel manipulation in template proces...
Definition: CPixelManip.h:19
GrayCropAccum32 operator/(double value)
Definition: CPixelManip.h:232
RgbaCropAccum32 & operator*=(double value)
Definition: CPixelManip.h:809
bool operator!=(const GrayCropAccum32 &value)
Definition: CPixelManip.h:117
RgbCropAccum32 operator/(int value)
Definition: CPixelManip.h:499
RgbCropAccum32(const RgbCropAccum32 &value)
Definition: CPixelManip.h:304
GrayCropAccum32 & operator+=(double value)
Definition: CPixelManip.h:174
RgbaCropAccum32 operator/(int value)
Definition: CPixelManip.h:816
GrayCropAccum32 & operator-=(unsigned int value)
Definition: CPixelManip.h:188
RgbCropAccum32 & operator-=(const RgbCropAccum32 &value)
Definition: CPixelManip.h:434
GrayCropAccum32 operator/(int value)
Definition: CPixelManip.h:223
RgbCropAccum32 & operator+=(double value)
Definition: CPixelManip.h:424
RgbaCropAccum32 & operator+=(unsigned int value)
Definition: CPixelManip.h:767
RgbaCropAccum32 & operator*=(int value)
Definition: CPixelManip.h:802
RgbCropAccum32 & operator+=(const Rgba &value)
Definition: CPixelManip.h:405
RgbaCropAccum32 operator/(double value)
Definition: CPixelManip.h:823
RgbCropAccum32 & operator+=(unsigned int value)
Definition: CPixelManip.h:414
bool operator!=(const RgbaCropAccum32 &value)
Definition: CPixelManip.h:711
RgbCropAccum32 & operator=(const RgbCropAccum32 &value)
Definition: CPixelManip.h:387
RgbaCropAccum32(const RgbaCropAccum32 &value)
Definition: CPixelManip.h:644
GrayCropAccum32 & operator-=(double value)
Definition: CPixelManip.h:195
RgbCropAccum32 & operator-=(quint32 value)
Definition: CPixelManip.h:452
RgbCropAccum32 & operator-=(double value)
Definition: CPixelManip.h:462
RgbaCropAccum32 & operator+=(const RgbaCropAccum32 &value)
Definition: CPixelManip.h:741
RgbCropAccum32 & operator+=(const RgbCropAccum32 &value)
Definition: CPixelManip.h:396
GrayCropAccum32 & operator+=(unsigned int value)
Definition: CPixelManip.h:167
bool operator==(const RgbaCropAccum32 &value)
Definition: CPixelManip.h:692
RgbCropAccum32 & operator*=(int value)
Definition: CPixelManip.h:481
Rgb(quint8 r, quint8 g, quint8 b)
Definition: CPixelManip.h:49
Rgba(quint8 r, quint8 g, quint8 b, quint8 a=255)
Definition: CPixelManip.h:30
RgbaCropAccum32 & operator+=(double value)
Definition: CPixelManip.h:781
RgbCropAccum32(const Rgb &value)
Definition: CPixelManip.h:314
bool operator!=(const RgbCropAccum32 &value)
Definition: CPixelManip.h:368
RgbaCropAccum32 & operator+=(const Rgba &value)
Definition: CPixelManip.h:754
RgbCropAccum32 & operator*=(double value)
Definition: CPixelManip.h:490
bool operator==(const GrayCropAccum32 &value)
Definition: CPixelManip.h:102
bool operator==(const RgbCropAccum32 &value)
Definition: CPixelManip.h:349
RgbaCropAccum32 & operator=(const RgbaCropAccum32 &value)
Definition: CPixelManip.h:730
GrayCropAccum32 & operator*=(unsigned int value)
Definition: CPixelManip.h:209
RgbCropAccum32(const Rgba &value)
Definition: CPixelManip.h:309
RgbCropAccum32 & operator-=(const Rgba &value)
Definition: CPixelManip.h:443
GrayCropAccum32(const GrayCropAccum32 &value)
Definition: CPixelManip.h:67
GrayCropAccum32 & operator=(const GrayCropAccum32 &value)
Definition: CPixelManip.h:132

© 2007-2017 Witold Gantzke and Kirill Lepskiy