i/imagemagick/imagemagick-7-doc_7.1.2.34+dfsg1-1_all.deb

// 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;


   19  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;

  };


   81  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.


  133  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;

  };


  219  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;

  };


  244  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;

  };


  282  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

Magick::ChannelMoments
Definition Statistic.h:20

Magick::ChannelPerceptualHash
Definition Statistic.h:82

Magick::ChannelStatistics
Definition Statistic.h:134

Magick::Image
Definition Image.h:56