Static build of Imagemagick 7.0.5-5

bin/7.0.5-5/include/ImageMagick-7/Magick++/Statistic.h

@@ -0,0 +1,307 @@
+// This may look like C code, but it is really -*- C++ -*-
+//
+// Copyright Dirk Lemstra 2014-2015
+//
+// Definition of channel moments.
+//
+
+#if !defined (Magick_ChannelMoments_header)
+#define Magick_ChannelMoments_header
+
+#include "Magick++/Include.h"
+#include <vector>
+
+namespace Magick
+{
+  class Image;
+
+  class MagickPPExport ChannelMoments
+  {
+  public:
+
+    // Default constructor
+    ChannelMoments(void);
+
+    // Copy constructor
+    ChannelMoments(const ChannelMoments &channelMoments_);
+
+    // Destroy channel moments
+    ~ChannelMoments(void);
+
+    // X position of centroid
+    double centroidX(void) const;
+
+    // Y position of centroid
+    double centroidY(void) const;
+
+    // The channel
+    PixelChannel channel(void) const;
+
+    // X position of ellipse axis
+    double ellipseAxisX(void) const;
+
+    // Y position of ellipse axis
+    double ellipseAxisY(void) const;
+
+    // Ellipse angle
+    double ellipseAngle(void) const;
+
+    // Ellipse eccentricity
+    double ellipseEccentricity(void) const;
+
+    // Ellipse intensity
+    double ellipseIntensity(void) const;
+
+    // Hu invariants (valid range for index is 0-7)
+    double huInvariants(const size_t index_) const;
+
+    // Does object contain valid channel moments?
+    bool isValid() const;
+
+    //
+    // Implemementation methods
+    //
+
+    ChannelMoments(const PixelChannel channel_,
+      const MagickCore::ChannelMoments *channelMoments_);
+
+  private:
+    PixelChannel _channel;
+    std::vector<double> _huInvariants;
+    double _centroidX;
+    double _centroidY;
+    double _ellipseAxisX;
+    double _ellipseAxisY;
+    double _ellipseAngle;
+    double _ellipseEccentricity;
+    double _ellipseIntensity;
+  };
+
+  class MagickPPExport ChannelPerceptualHash
+  {
+  public:
+
+    // Default constructor
+    ChannelPerceptualHash(void);
+
+    // Copy constructor
+    ChannelPerceptualHash(const ChannelPerceptualHash &channelPerceptualHash_);
+
+    // Constructor using the specified hash string
+    ChannelPerceptualHash(const PixelChannel channel_,
+      const std::string &hash_);
+
+    // Destroy channel perceptual hash
+    ~ChannelPerceptualHash(void);
+
+    // Return hash string
+    operator std::string() const;
+
+    // The channel
+    PixelChannel channel(void) const;
+
+    // Does object contain valid channel perceptual hash?
+    bool isValid() const;
+
+    // Returns the sum squared difference between this hash and the other hash
+    double sumSquaredDifferences(
+      const ChannelPerceptualHash &channelPerceptualHash_);
+
+    // SRGB hu preceptual hash (valid range for index is 0-6)
+    double srgbHuPhash(const size_t index_) const;
+
+    // HCLp hu preceptual hash (valid range for index is 0-6)
+    double hclpHuPhash(const size_t index_) const;
+
+    //
+    // Implemementation methods
+    //
+
+    ChannelPerceptualHash(const PixelChannel channel_,
+      const MagickCore::ChannelPerceptualHash *channelPerceptualHash_);
+
+  private:
+    PixelChannel _channel;
+    std::vector<double> _srgbHuPhash;
+    std::vector<double> _hclpHuPhash;
+  };
+
+  // Obtain image statistics. Statistics are normalized to the range
+  // of 0.0 to 1.0 and are output to the specified ImageStatistics
+  // structure.
+  class MagickPPExport ChannelStatistics
+  {
+  public:
+
+    // Default constructor
+    ChannelStatistics(void);
+
+    // Copy constructor
+    ChannelStatistics(const ChannelStatistics &channelStatistics_);
+
+    // Destroy channel statistics
+    ~ChannelStatistics(void);
+
+    // Area
+    double area() const;
+
+    // The channel
+    PixelChannel channel(void) const;
+
+    // Depth
+    size_t depth() const;
+
+    // Entropy
+    double entropy() const;
+
+    // Does object contain valid channel statistics?
+    bool isValid() const;
+
+    // Kurtosis
+    double kurtosis() const;
+
+    // Minimum value observed
+    double maxima() const;
+
+    // Average (mean) value observed
+    double mean() const;
+
+    // Maximum value observed
+    double minima() const;
+
+    // Skewness
+    double skewness() const;
+
+    // Standard deviation, sqrt(variance)
+    double standardDeviation() const;
+
+    // Sum
+    double sum() const;
+
+    // Sum cubed
+    double sumCubed() const;
+
+    // Sum fourth power
+    double sumFourthPower() const;
+
+    // Sum squared
+    double sumSquared() const;
+
+    // Variance
+    double variance() const;
+
+    //
+    // Implemementation methods
+    //
+
+    ChannelStatistics(const PixelChannel channel_,
+      const MagickCore::ChannelStatistics *channelStatistics_);
+
+  private:
+    PixelChannel _channel;
+    double _area;
+    size_t _depth;
+    double _entropy;
+    double _kurtosis;
+    double _maxima;
+    double _mean;
+    double _minima;
+    double _skewness;
+    double _standardDeviation;
+    double _sum;
+    double _sumCubed;
+    double _sumFourthPower;
+    double _sumSquared;
+    double _variance;
+  };
+
+  class MagickPPExport ImageMoments
+  {
+  public:
+
+    // Default constructor
+    ImageMoments(void);
+
+    // Copy constructor
+    ImageMoments(const ImageMoments &imageMoments_);
+
+    // Destroy image moments
+    ~ImageMoments(void);
+
+    // Returns the moments for the specified channel
+    ChannelMoments channel(const PixelChannel channel_) const;
+
+    //
+    // Implemementation methods
+    //
+    ImageMoments(const Image &image_);
+
+  private:
+    std::vector<ChannelMoments> _channels;
+  };
+
+  class MagickPPExport ImagePerceptualHash
+  {
+  public:
+
+    // Default constructor
+    ImagePerceptualHash(void);
+
+    // Copy constructor
+    ImagePerceptualHash(const ImagePerceptualHash &imagePerceptualHash_);
+
+    // Constructor using the specified hash string
+    ImagePerceptualHash(const std::string &hash_);
+
+    // Destroy image perceptual hash
+    ~ImagePerceptualHash(void);
+
+    // Return hash string
+    operator std::string() const;
+
+    // Returns the perceptual hash for the specified channel
+    ChannelPerceptualHash channel(const PixelChannel channel_) const;
+
+    // Does object contain valid perceptual hash?
+    bool isValid() const;
+
+    // Returns the sum squared difference between this hash and the other hash
+    double sumSquaredDifferences(
+      const ImagePerceptualHash &channelPerceptualHash_);
+
+    //
+    // Implemementation methods
+    //
+    ImagePerceptualHash(const Image &image_);
+
+  private:
+    std::vector<ChannelPerceptualHash> _channels;
+  };
+
+  class MagickPPExport ImageStatistics
+  {
+  public:
+
+    // Default constructor
+    ImageStatistics(void);
+
+    // Copy constructor
+    ImageStatistics(const ImageStatistics &imageStatistics_);
+
+    // Destroy image statistics
+    ~ImageStatistics(void);
+
+    // Returns the statistics for the specified channel
+    ChannelStatistics channel(const PixelChannel channel_) const;
+
+    //
+    // Implemementation methods
+    //
+    ImageStatistics(const Image &image_);
+
+  private:
+    std::vector<ChannelStatistics> _channels;
+  };
+}
+
+#endif // Magick_ChannelMoments_header