Magick++: Statistic.cpp Source File

Magick++ 7.0.10

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