Magick++: Statistic.cpp Source File

Magick++ 7.1.0

Statistic.cpp
Go to the documentation of this file.
1 // This may look like C code, but it is really -*- C++ -*-
2 //
3 // Copyright @ 2014 ImageMagick Studio LLC, a non-profit organization
4 // dedicated to making software imaging solutions freely available.
5 //
6 // Implementation of channel moments.
7 //
8
9 #define MAGICKCORE_IMPLEMENTATION 1
10 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1
11
12 #include "Magick++/Include.h"
13 #include "Magick++/Exception.h"
14 #include "Magick++/Statistic.h"
15 #include "Magick++/Image.h"
16
17 using namespace std;
18
19 Magick::ChannelMoments::ChannelMoments(void)
20 : _channel(SyncPixelChannel),
21 _huInvariants(8),
22 _centroidX(0.0),
23 _centroidY(0.0),
24 _ellipseAxisX(0.0),
25 _ellipseAxisY(0.0),
26 _ellipseAngle(0.0),
27 _ellipseEccentricity(0.0),
28 _ellipseIntensity(0.0)
29 {
30 }
31
32 Magick::ChannelMoments::ChannelMoments(const ChannelMoments &channelMoments_)
33 : _channel(channelMoments_._channel),
34 _huInvariants(channelMoments_._huInvariants),
35 _centroidX(channelMoments_._centroidX),
36 _centroidY(channelMoments_._centroidY),
37 _ellipseAxisX(channelMoments_._ellipseAxisX),
38 _ellipseAxisY(channelMoments_._ellipseAxisY),
39 _ellipseAngle(channelMoments_._ellipseAngle),
40 _ellipseEccentricity(channelMoments_._ellipseEccentricity),
41 _ellipseIntensity(channelMoments_._ellipseIntensity)
42 {
43 }
44
45 Magick::ChannelMoments::~ChannelMoments(void)
46 {
47 }
48
49 double Magick::ChannelMoments::centroidX(void) const
50 {
51 return(_centroidX);
52 }
53
54 double Magick::ChannelMoments::centroidY(void) const
55 {
56 return(_centroidY);
57 }
58
59 Magick::PixelChannel Magick::ChannelMoments::channel(void) const
60 {
61 return(_channel);
62 }
63
64 double Magick::ChannelMoments::ellipseAxisX(void) const
65 {
66 return(_ellipseAxisX);
67 }
68
69 double Magick::ChannelMoments::ellipseAxisY(void) const
70 {
71 return(_ellipseAxisY);
72 }
73
74 double Magick::ChannelMoments::ellipseAngle(void) const
75 {
76 return(_ellipseAngle);
77 }
78
79 double Magick::ChannelMoments::ellipseEccentricity(void) const
80 {
81 return(_ellipseEccentricity);
82 }
83
84 double Magick::ChannelMoments::ellipseIntensity(void) const
85 {
86 return(_ellipseIntensity);
87 }
88
89 double Magick::ChannelMoments::huInvariants(const size_t index_) const
90 {
91 if (index_ > 7)
92 throw ErrorOption("Valid range for index is 0-7");
93
94 return(_huInvariants.at(index_));
95 }
96
97 bool Magick::ChannelMoments::isValid() const
98 {
99 return(_channel != SyncPixelChannel);
100 }
101
102 Magick::ChannelMoments::ChannelMoments(const PixelChannel channel_,
103 const MagickCore::ChannelMoments *channelMoments_)
104 : _channel(channel_),
105 _huInvariants(),
106 _centroidX(channelMoments_->centroid.x),
107 _centroidY(channelMoments_->centroid.y),
108 _ellipseAxisX(channelMoments_->ellipse_axis.x),
109 _ellipseAxisY(channelMoments_->ellipse_axis.y),
110 _ellipseAngle(channelMoments_->ellipse_angle),
111 _ellipseEccentricity(channelMoments_->ellipse_eccentricity),
112 _ellipseIntensity(channelMoments_->ellipse_intensity)
113 {
114 ssize_t
115 i;
116
117 for (i=0; i<8; i++)
118 _huInvariants.push_back(channelMoments_->invariant[i]);
119 }
120
121 Magick::ChannelPerceptualHash::ChannelPerceptualHash(void)
122 : _channel(SyncPixelChannel),
123 _srgbHuPhash(7),
124 _hclpHuPhash(7)
125 {
126 }
127
128 Magick::ChannelPerceptualHash::ChannelPerceptualHash(
129 const ChannelPerceptualHash &channelPerceptualHash_)
130 : _channel(channelPerceptualHash_._channel),
131 _srgbHuPhash(channelPerceptualHash_._srgbHuPhash),
132 _hclpHuPhash(channelPerceptualHash_._hclpHuPhash)
133 {
134 }
135
136 Magick::ChannelPerceptualHash::ChannelPerceptualHash(
137 const PixelChannel channel_,const std::string &hash_)
138 : _channel(channel_),
139 _srgbHuPhash(7),
140 _hclpHuPhash(7)
141 {
142 ssize_t
143 i;
144
145 if (hash_.length() != 70)
146 throw ErrorOption("Invalid hash length");
147
148 for (i=0; i<14; i++)
149 {
150 unsigned int
151 hex;
152
153 double
154 value;
155
156 if (sscanf(hash_.substr(i*5,5).c_str(),"%05x",&hex) != 1)
157 throw ErrorOption("Invalid hash value");
158
159 value=((unsigned short)hex) / pow(10.0, (double)(hex >> 17));
160 if (hex & (1 << 16))
161 value=-value;
162 if (i < 7)
163 _srgbHuPhash[i]=value;
164 else
165 _hclpHuPhash[i-7]=value;
166 }
167 }
168
169 Magick::ChannelPerceptualHash::~ChannelPerceptualHash(void)
170 {
171 }
172
173 Magick::ChannelPerceptualHash::operator std::string() const
174 {
175 std::string
176 hash;
177
178 ssize_t
179 i;
180
181 if (!isValid())
182 return(std::string());
183
184 for (i=0; i<14; i++)
185 {
186 char
187 buffer[6];
188
189 double
190 value;
191
192 unsigned int
193 hex;
194
195 if (i < 7)
196 value=_srgbHuPhash[i];
197 else
198 value=_hclpHuPhash[i-7];
199
200 hex=0;
201 while(hex < 7 && fabs(value*10) < 65536)
202 {
203 value=value*10;
204 hex++;
205 }
206
207 hex=(hex<<1);
208 if (value < 0.0)
209 hex|=1;
210 hex=(hex<<16)+(unsigned int)(value < 0.0 ? -(value - 0.5) : value + 0.5);
211 (void) FormatLocaleString(buffer,6,"%05x",hex);
212 hash+=std::string(buffer);
213 }
214 return(hash);
215 }
216
217 Magick::PixelChannel Magick::ChannelPerceptualHash::channel() const
218 {
219 return(_channel);
220 }
221
222 bool Magick::ChannelPerceptualHash::isValid() const
223 {
224 return(_channel != SyncPixelChannel);
225 }
226
227 double Magick::ChannelPerceptualHash::sumSquaredDifferences(
228 const ChannelPerceptualHash &channelPerceptualHash_)
229 {
230 double
231 ssd;
232
233 ssize_t
234 i;
235
236 ssd=0.0;
237 for (i=0; i<7; i++)
238 {
239 ssd+=((_srgbHuPhash[i]-channelPerceptualHash_._srgbHuPhash[i])*
240 (_srgbHuPhash[i]-channelPerceptualHash_._srgbHuPhash[i]));
241 ssd+=((_hclpHuPhash[i]-channelPerceptualHash_._hclpHuPhash[i])*
242 (_hclpHuPhash[i]-channelPerceptualHash_._hclpHuPhash[i]));
243 }
244 return(ssd);
245 }
246
247 double Magick::ChannelPerceptualHash::srgbHuPhash(const size_t index_) const
248 {
249 if (index_ > 6)
250 throw ErrorOption("Valid range for index is 0-6");
251
252 return(_srgbHuPhash.at(index_));
253 }
254
255 double Magick::ChannelPerceptualHash::hclpHuPhash(const size_t index_) const
256 {
257 if (index_ > 6)
258 throw ErrorOption("Valid range for index is 0-6");
259
260 return(_hclpHuPhash.at(index_));
261 }
262
263 Magick::ChannelPerceptualHash::ChannelPerceptualHash(
264 const PixelChannel channel_,
265 const MagickCore::ChannelPerceptualHash *channelPerceptualHash_)
266 : _channel(channel_),
267 _srgbHuPhash(7),
268 _hclpHuPhash(7)
269 {
270 ssize_t
271 i;
272
273 for (i=0; i<7; i++)
274 {
275 _srgbHuPhash[i]=channelPerceptualHash_->phash[0][i];
276 _hclpHuPhash[i]=channelPerceptualHash_->phash[1][i];
277 }
278 }
279
280 Magick::ChannelStatistics::ChannelStatistics(void)
281 : _channel(SyncPixelChannel),
282 _area(0.0),
283 _depth(0.0),
284 _entropy(0.0),
285 _kurtosis(0.0),
286 _maxima(0.0),
287 _mean(0.0),
288 _minima(0.0),
289 _skewness(0.0),
290 _standardDeviation(0.0),
291 _sum(0.0),
292 _sumCubed(0.0),
293 _sumFourthPower(0.0),
294 _sumSquared(0.0),
295 _variance(0.0)
296 {
297 }
298
299 Magick::ChannelStatistics::ChannelStatistics(
300 const ChannelStatistics &channelStatistics_)
301 : _channel(channelStatistics_._channel),
302 _area(channelStatistics_._area),
303 _depth(channelStatistics_._depth),
304 _entropy(channelStatistics_._entropy),
305 _kurtosis(channelStatistics_._kurtosis),
306 _maxima(channelStatistics_._maxima),
307 _mean(channelStatistics_._mean),
308 _minima(channelStatistics_._minima),
309 _skewness(channelStatistics_._skewness),
310 _standardDeviation(channelStatistics_._standardDeviation),
311 _sum(channelStatistics_._sum),
312 _sumCubed(channelStatistics_._sumCubed),
313 _sumFourthPower(channelStatistics_._sumFourthPower),
314 _sumSquared(channelStatistics_._sumSquared),
315 _variance(channelStatistics_._variance)
316 {
317 }
318
319 Magick::ChannelStatistics::~ChannelStatistics(void)
320 {
321 }
322
323 double Magick::ChannelStatistics::area() const
324 {
325 return(_area);
326 }
327
328 Magick::PixelChannel Magick::ChannelStatistics::channel() const
329 {
330 return(_channel);
331 }
332
333 size_t Magick::ChannelStatistics::depth() const
334 {
335 return(_depth);
336 }
337
338 double Magick::ChannelStatistics::entropy() const
339 {
340 return(_entropy);
341 }
342
343 bool Magick::ChannelStatistics::isValid() const
344 {
345 return(_channel != SyncPixelChannel);
346 }
347
348 double Magick::ChannelStatistics::kurtosis() const
349 {
350 return(_kurtosis);
351 }
352
353 double Magick::ChannelStatistics::maxima() const
354 {
355 return(_maxima);
356 }
357
358 double Magick::ChannelStatistics::mean() const
359 {
360 return(_mean);
361 }
362
363 double Magick::ChannelStatistics::minima() const
364 {
365 return(_minima);
366 }
367
368 double Magick::ChannelStatistics::skewness() const
369 {
370 return(_skewness);
371 }
372
373 double Magick::ChannelStatistics::standardDeviation() const
374 {
375 return(_standardDeviation);
376 }
377
378 double Magick::ChannelStatistics::sum() const
379 {
380 return(_sum);
381 }
382
383 double Magick::ChannelStatistics::sumCubed() const
384 {
385 return(_sumCubed);
386 }
387
388 double Magick::ChannelStatistics::sumFourthPower() const
389 {
390 return(_sumFourthPower);
391 }
392
393 double Magick::ChannelStatistics::sumSquared() const
394 {
395 return(_sumSquared);
396 }
397
398 double Magick::ChannelStatistics::variance() const
399 {
400 return(_variance);
401 }
402
403 Magick::ChannelStatistics::ChannelStatistics(const PixelChannel channel_,
404 const MagickCore::ChannelStatistics *channelStatistics_)
405 : _channel(channel_),
406 _area(channelStatistics_->area),
407 _depth(channelStatistics_->depth),
408 _entropy(channelStatistics_->entropy),
409 _kurtosis(channelStatistics_->kurtosis),
410 _maxima(channelStatistics_->maxima),
411 _mean(channelStatistics_->mean),
412 _minima(channelStatistics_->minima),
413 _skewness(channelStatistics_->skewness),
414 _standardDeviation(channelStatistics_->standard_deviation),
415 _sum(channelStatistics_->sum),
416 _sumCubed(channelStatistics_->sum_cubed),
417 _sumFourthPower(channelStatistics_->sum_fourth_power),
418 _sumSquared(channelStatistics_->sum_squared),
419 _variance(channelStatistics_->variance)
420 {
421 }
422
423 Magick::ImageMoments::ImageMoments(void)
424 : _channels()
425 {
426 }
427
428 Magick::ImageMoments::ImageMoments(const ImageMoments &imageMoments_)
429 : _channels(imageMoments_._channels)
430 {
431 }
432
433 Magick::ImageMoments::~ImageMoments(void)
434 {
435 }
436
437 Magick::ChannelMoments Magick::ImageMoments::channel(
438 const PixelChannel channel_) const
439 {
440 for (std::vector<ChannelMoments>::const_iterator it = _channels.begin();
441 it != _channels.end(); ++it)
442 {
443 if (it->channel() == channel_)
444 return(*it);
445 }
446 return(ChannelMoments());
447 }
448
449 Magick::ImageMoments::ImageMoments(const Image &image_)
450 : _channels()
451 {
452 MagickCore::ChannelMoments*
453 channel_moments;
454
455 GetPPException;
456 channel_moments=GetImageMoments(image_.constImage(),exceptionInfo);
457 if (channel_moments != (MagickCore::ChannelMoments *) NULL)
458 {
459 ssize_t
460 i;
461
462 for (i=0; i < (ssize_t) GetPixelChannels(image_.constImage()); i++)
463 {
464 PixelChannel channel=GetPixelChannelChannel(image_.constImage(),i);
465 PixelTrait traits=GetPixelChannelTraits(image_.constImage(),channel);
466 if (traits == UndefinedPixelTrait)
467 continue;
468 if ((traits & UpdatePixelTrait) == 0)
469 continue;
470 _channels.push_back(Magick::ChannelMoments(channel,
471 &channel_moments[channel]));
472 }
473 _channels.push_back(Magick::ChannelMoments(CompositePixelChannel,
474 &channel_moments[CompositePixelChannel]));
475 channel_moments=(MagickCore::ChannelMoments *) RelinquishMagickMemory(
476 channel_moments);
477 }
478 ThrowPPException(image_.quiet());
479 }
480
481 Magick::ImagePerceptualHash::ImagePerceptualHash(void)
482 : _channels()
483 {
484 }
485
486 Magick::ImagePerceptualHash::ImagePerceptualHash(
487 const ImagePerceptualHash &imagePerceptualHash_)
488 : _channels(imagePerceptualHash_._channels)
489 {
490 }
491
492 Magick::ImagePerceptualHash::ImagePerceptualHash(const std::string &hash_)
493 : _channels()
494 {
495 if (hash_.length() != 210)
496 throw ErrorOption("Invalid hash length");
497
498 _channels.push_back(Magick::ChannelPerceptualHash(RedPixelChannel,
499 hash_.substr(0, 70)));
500 _channels.push_back(Magick::ChannelPerceptualHash(GreenPixelChannel,
501 hash_.substr(70, 70)));
502 _channels.push_back(Magick::ChannelPerceptualHash(BluePixelChannel,
503 hash_.substr(140, 70)));
504 }
505
506 Magick::ImagePerceptualHash::~ImagePerceptualHash(void)
507 {
508 }
509
510 Magick::ImagePerceptualHash::operator std::string() const
511 {
512 if (!isValid())
513 return(std::string());
514
515 return static_cast<std::string>(_channels[0]) +
516 static_cast<std::string>(_channels[1]) +
517 static_cast<std::string>(_channels[2]);
518 }
519
520 Magick::ChannelPerceptualHash Magick::ImagePerceptualHash::channel(
521 const PixelChannel channel_) const
522 {
523 for (std::vector<ChannelPerceptualHash>::const_iterator it =
524 _channels.begin(); it != _channels.end(); ++it)
525 {
526 if (it->channel() == channel_)
527 return(*it);
528 }
529 return(ChannelPerceptualHash());
530 }
531
532 bool Magick::ImagePerceptualHash::isValid() const
533 {
534 if (_channels.size() != 3)
535 return(false);
536
537 if (_channels[0].channel() != RedPixelChannel)
538 return(false);
539
540 if (_channels[1].channel() != GreenPixelChannel)
541 return(false);
542
543 if (_channels[2].channel() != BluePixelChannel)
544 return(false);
545
546 return(true);
547 }
548
549 double Magick::ImagePerceptualHash::sumSquaredDifferences(
550 const ImagePerceptualHash &channelPerceptualHash_)
551 {
552 double
553 ssd;
554
555 ssize_t
556 i;
557
558 if (!isValid())
559 throw ErrorOption("instance is not valid");
560 if (!channelPerceptualHash_.isValid())
561 throw ErrorOption("channelPerceptualHash_ is not valid");
562
563 ssd=0.0;
564 for (i=0; i<3; i++)
565 {
566 ssd+=_channels[i].sumSquaredDifferences(_channels[i]);
567 }
568 return(ssd);
569 }
570
571 Magick::ImagePerceptualHash::ImagePerceptualHash(
572 const Image &image_)
573 : _channels()
574 {
575 MagickCore::ChannelPerceptualHash*
576 channel_perceptual_hash;
577
578 PixelTrait
579 traits;
580
581 GetPPException;
582 channel_perceptual_hash=GetImagePerceptualHash(image_.constImage(),
583 exceptionInfo);
584 if (channel_perceptual_hash != (MagickCore::ChannelPerceptualHash *) NULL)
585 {
586 traits=GetPixelChannelTraits(image_.constImage(),RedPixelChannel);
587 if ((traits & UpdatePixelTrait) != 0)
588 _channels.push_back(Magick::ChannelPerceptualHash(RedPixelChannel,
589 &channel_perceptual_hash[RedPixelChannel]));
590 traits=GetPixelChannelTraits(image_.constImage(),GreenPixelChannel);
591 if ((traits & UpdatePixelTrait) != 0)
592 _channels.push_back(Magick::ChannelPerceptualHash(GreenPixelChannel,
593 &channel_perceptual_hash[GreenPixelChannel]));
594 traits=GetPixelChannelTraits(image_.constImage(),BluePixelChannel);
595 if ((traits & UpdatePixelTrait) != 0)
596 _channels.push_back(Magick::ChannelPerceptualHash(BluePixelChannel,
597 &channel_perceptual_hash[BluePixelChannel]));
598 channel_perceptual_hash=(MagickCore::ChannelPerceptualHash *)
599 RelinquishMagickMemory(channel_perceptual_hash);
600 }
601 ThrowPPException(image_.quiet());
602 }
603
604 Magick::ImageStatistics::ImageStatistics(void)
605 : _channels()
606 {
607 }
608
609 Magick::ImageStatistics::ImageStatistics(
610 const ImageStatistics &imageStatistics_)
611 : _channels(imageStatistics_._channels)
612 {
613 }
614
615 Magick::ImageStatistics::~ImageStatistics(void)
616 {
617 }
618
619 Magick::ChannelStatistics Magick::ImageStatistics::channel(
620 const PixelChannel channel_) const
621 {
622 for (std::vector<ChannelStatistics>::const_iterator it = _channels.begin();
623 it != _channels.end(); ++it)
624 {
625 if (it->channel() == channel_)
626 return(*it);
627 }
628 return(ChannelStatistics());
629 }
630
631 Magick::ImageStatistics::ImageStatistics(const Image &image_)
632 : _channels()
633 {
634 MagickCore::ChannelStatistics*
635 channel_statistics;
636
637 GetPPException;
638 channel_statistics=GetImageStatistics(image_.constImage(),exceptionInfo);
639 if (channel_statistics != (MagickCore::ChannelStatistics *) NULL)
640 {
641 ssize_t
642 i;
643
644 for (i=0; i < (ssize_t) GetPixelChannels(image_.constImage()); i++)
645 {
646 PixelChannel channel=GetPixelChannelChannel(image_.constImage(),i);
647 PixelTrait traits=GetPixelChannelTraits(image_.constImage(),channel);
648 if (traits == UndefinedPixelTrait)
649 continue;
650 if ((traits & UpdatePixelTrait) == 0)
651 continue;
652 _channels.push_back(Magick::ChannelStatistics(channel,
653 &channel_statistics[channel]));
654 }
655 _channels.push_back(Magick::ChannelStatistics(CompositePixelChannel,
656 &channel_statistics[CompositePixelChannel]));
657 channel_statistics=(MagickCore::ChannelStatistics *) RelinquishMagickMemory(
658 channel_statistics);
659 }
660 ThrowPPException(image_.quiet());
661 }
Magick::ChannelStatistics::maxima
double maxima() const
Definition: Statistic.cpp:353
Magick::ChannelMoments::centroidY
double centroidY(void) const
Definition: Statistic.cpp:54
Magick::ChannelMoments
Definition: Statistic.h:19
Magick::ChannelStatistics::standardDeviation
double standardDeviation() const
Definition: Statistic.cpp:373
Magick::ImageMoments::channel
ChannelMoments channel(const PixelChannel channel_) const
Definition: Statistic.cpp:437
Magick::ChannelPerceptualHash::~ChannelPerceptualHash
~ChannelPerceptualHash(void)
Definition: Statistic.cpp:169
Magick::ChannelStatistics::ChannelStatistics
ChannelStatistics(void)
Definition: Statistic.cpp:280
Magick::ChannelPerceptualHash::channel
PixelChannel channel(void) const
Definition: Statistic.cpp:217
Magick::ChannelMoments::ellipseIntensity
double ellipseIntensity(void) const
Definition: Statistic.cpp:84
Magick::ChannelPerceptualHash::sumSquaredDifferences
double sumSquaredDifferences(const ChannelPerceptualHash &channelPerceptualHash_)
Definition: Statistic.cpp:227
Magick::ChannelPerceptualHash::srgbHuPhash
double srgbHuPhash(const size_t index_) const
Definition: Statistic.cpp:247
Magick::ImagePerceptualHash::channel
ChannelPerceptualHash channel(const PixelChannel channel_) const
Definition: Statistic.cpp:520
Magick::ChannelMoments::channel
PixelChannel channel(void) const
Definition: Statistic.cpp:59
Magick::Image::constImage
const MagickCore::Image * constImage(void) const
Definition: Image.cpp:5029
Magick::ChannelStatistics::sumCubed
double sumCubed() const
Definition: Statistic.cpp:383
Magick::ImagePerceptualHash
Definition: Statistic.h:244
Magick::ImageMoments
Definition: Statistic.h:219
Statistic.h
Magick::Image::quiet
void quiet(const bool quiet_)
Definition: Image.cpp:1316
std
STL namespace.
Magick::ChannelStatistics::isValid
bool isValid() const
Definition: Statistic.cpp:343
Magick::ErrorOption
Definition: Exception.h:170
Magick::ImagePerceptualHash::sumSquaredDifferences
double sumSquaredDifferences(const ImagePerceptualHash &channelPerceptualHash_)
Definition: Statistic.cpp:549
Magick::ChannelPerceptualHash
Definition: Statistic.h:81
Magick::ChannelStatistics::~ChannelStatistics
~ChannelStatistics(void)
Definition: Statistic.cpp:319
Magick::ChannelStatistics::variance
double variance() const
Definition: Statistic.cpp:398
Magick::ChannelStatistics::minima
double minima() const
Definition: Statistic.cpp:363
Image.h
Magick::ChannelStatistics::sumFourthPower
double sumFourthPower() const
Definition: Statistic.cpp:388
Magick::ChannelStatistics::skewness
double skewness() const
Definition: Statistic.cpp:368
Magick::ChannelMoments::ChannelMoments
ChannelMoments(void)
Definition: Statistic.cpp:19
Magick::ChannelStatistics
Definition: Statistic.h:133
Magick::ChannelStatistics::sum
double sum() const
Definition: Statistic.cpp:378
Magick::ChannelMoments::huInvariants
double huInvariants(const size_t index_) const
Definition: Statistic.cpp:89
Magick::ChannelMoments::ellipseAxisY
double ellipseAxisY(void) const
Definition: Statistic.cpp:69
Magick::ImageMoments::ImageMoments
ImageMoments(void)
Definition: Statistic.cpp:423
Magick::ImageStatistics::ImageStatistics
ImageStatistics(void)
Definition: Statistic.cpp:604
Magick::ChannelStatistics::depth
size_t depth() const
Definition: Statistic.cpp:333
Magick::ChannelPerceptualHash::isValid
bool isValid() const
Definition: Statistic.cpp:222
ThrowPPException
#define ThrowPPException(quiet)
Definition: Include.h:1580
Magick::ChannelStatistics::entropy
double entropy() const
Definition: Statistic.cpp:338
Magick::ChannelStatistics::mean
double mean() const
Definition: Statistic.cpp:358
Magick::ChannelMoments::ellipseEccentricity
double ellipseEccentricity(void) const
Definition: Statistic.cpp:79
Include.h
Magick::ChannelPerceptualHash::ChannelPerceptualHash
ChannelPerceptualHash(void)
Definition: Statistic.cpp:121
Magick::ImagePerceptualHash::ImagePerceptualHash
ImagePerceptualHash(void)
Definition: Statistic.cpp:481
Magick::ImageStatistics
Definition: Statistic.h:282
Magick::ChannelPerceptualHash::hclpHuPhash
double hclpHuPhash(const size_t index_) const
Definition: Statistic.cpp:255
Magick::ChannelMoments::ellipseAxisX
double ellipseAxisX(void) const
Definition: Statistic.cpp:64
Magick::ImageStatistics::channel
ChannelStatistics channel(const PixelChannel channel_) const
Definition: Statistic.cpp:619
Magick::ChannelMoments::isValid
bool isValid() const
Definition: Statistic.cpp:97
Magick::ImageMoments::~ImageMoments
~ImageMoments(void)
Definition: Statistic.cpp:433
Magick::ChannelMoments::centroidX
double centroidX(void) const
Definition: Statistic.cpp:49
Magick::ChannelStatistics::channel
PixelChannel channel(void) const
Definition: Statistic.cpp:328
Magick::ChannelStatistics::area
double area() const
Definition: Statistic.cpp:323
GetPPException
#define GetPPException
Definition: Include.h:1561
Magick::ChannelStatistics::kurtosis
double kurtosis() const
Definition: Statistic.cpp:348
Magick::ImageStatistics::~ImageStatistics
~ImageStatistics(void)
Definition: Statistic.cpp:615
Exception.h
Magick::Image
Definition: Image.h:55
Magick::ImagePerceptualHash::~ImagePerceptualHash
~ImagePerceptualHash(void)
Definition: Statistic.cpp:506
Magick::ImagePerceptualHash::isValid
bool isValid() const
Definition: Statistic.cpp:532
Magick::ChannelMoments::~ChannelMoments
~ChannelMoments(void)
Definition: Statistic.cpp:45
Magick::ChannelMoments::ellipseAngle
double ellipseAngle(void) const
Definition: Statistic.cpp:74
Magick::ChannelStatistics::sumSquared
double sumSquared() const
Definition: Statistic.cpp:393