EIC code displayed by LXR master/​include/​ImageMagick-7/​Magick++/​Statistic.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-30 10:11:40

 // This may look like C code, but it is really -*- C++ -*-
 //
 // Copyright @ 2014 ImageMagick Studio LLC, a non-profit organization
 // dedicated to making software imaging solutions freely available.
 //
 // 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;
 
     //
     // Implementation 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;
 
     //
     // Implementation 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;
 
     //
     // Implementation 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;
 
     //
     // Implementation 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_);
 
     //
     // Implementation 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;
 
     //
     // Implementation methods
     //
     ImageStatistics(const Image &image_);
 
   private:
     std::vector<ChannelStatistics> _channels;
   };
 }
 
 #endif // Magick_ChannelMoments_header

This page was automatically generated by the 2.3.7 LXR engine. The LXR team