Loading...
Searching...
No Matches
Statistic.cpp
// 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.
//
// Implementation of channel moments.
//
#define MAGICKCORE_IMPLEMENTATION 1
#define MAGICK_PLUSPLUS_IMPLEMENTATION 1
#include "Magick++/Include.h"
#include "Magick++/Exception.h"
#include "Magick++/Statistic.h"
#include "Magick++/Image.h"
using namespace std;
Magick::ChannelMoments::ChannelMoments(void)
: _channel(SyncPixelChannel),
_huInvariants(8),
_centroidX(0.0),
_centroidY(0.0),
_ellipseAxisX(0.0),
_ellipseAxisY(0.0),
_ellipseAngle(0.0),
_ellipseEccentricity(0.0),
_ellipseIntensity(0.0)
{
}
Magick::ChannelMoments::ChannelMoments(const ChannelMoments &channelMoments_)
: _channel(channelMoments_._channel),
_huInvariants(channelMoments_._huInvariants),
_centroidX(channelMoments_._centroidX),
_centroidY(channelMoments_._centroidY),
_ellipseAxisX(channelMoments_._ellipseAxisX),
_ellipseAxisY(channelMoments_._ellipseAxisY),
_ellipseAngle(channelMoments_._ellipseAngle),
_ellipseEccentricity(channelMoments_._ellipseEccentricity),
_ellipseIntensity(channelMoments_._ellipseIntensity)
{
}
Magick::ChannelMoments::~ChannelMoments(void)
{
}
double Magick::ChannelMoments::centroidX(void) const
{
return(_centroidX);
}
double Magick::ChannelMoments::centroidY(void) const
{
return(_centroidY);
}
Magick::PixelChannel Magick::ChannelMoments::channel(void) const
{
return(_channel);
}
double Magick::ChannelMoments::ellipseAxisX(void) const
{
return(_ellipseAxisX);
}
double Magick::ChannelMoments::ellipseAxisY(void) const
{
return(_ellipseAxisY);
}
double Magick::ChannelMoments::ellipseAngle(void) const
{
return(_ellipseAngle);
}
double Magick::ChannelMoments::ellipseEccentricity(void) const
{
return(_ellipseEccentricity);
}
double Magick::ChannelMoments::ellipseIntensity(void) const
{
return(_ellipseIntensity);
}
double Magick::ChannelMoments::huInvariants(const size_t index_) const
{
if (index_ > 7)
throw ErrorOption("Valid range for index is 0-7");
return(_huInvariants.at(index_));
}
bool Magick::ChannelMoments::isValid() const
{
return(_channel != SyncPixelChannel);
}
Magick::ChannelMoments::ChannelMoments(const PixelChannel channel_,
const MagickCore::ChannelMoments *channelMoments_)
: _channel(channel_),
_huInvariants(),
_centroidX(channelMoments_->centroid.x),
_centroidY(channelMoments_->centroid.y),
_ellipseAxisX(channelMoments_->ellipse_axis.x),
_ellipseAxisY(channelMoments_->ellipse_axis.y),
_ellipseAngle(channelMoments_->ellipse_angle),
_ellipseEccentricity(channelMoments_->ellipse_eccentricity),
_ellipseIntensity(channelMoments_->ellipse_intensity)
{
ssize_t
i;
for (i=0; i<8; i++)
_huInvariants.push_back(channelMoments_->invariant[i]);
}
Magick::ChannelPerceptualHash::ChannelPerceptualHash(void)
: _channel(SyncPixelChannel),
_srgbHuPhash(7),
_hclpHuPhash(7)
{
}
Magick::ChannelPerceptualHash::ChannelPerceptualHash(
const ChannelPerceptualHash &channelPerceptualHash_)
: _channel(channelPerceptualHash_._channel),
_srgbHuPhash(channelPerceptualHash_._srgbHuPhash),
_hclpHuPhash(channelPerceptualHash_._hclpHuPhash)
{
}
Magick::ChannelPerceptualHash::ChannelPerceptualHash(
const PixelChannel channel_,const std::string &hash_)
: _channel(channel_),
_srgbHuPhash(7),
_hclpHuPhash(7)
{
size_t
i;
if (hash_.length() != 70)
throw ErrorOption("Invalid hash length");
for (i=0; i<14; i++)
{
unsigned int
hex;
double
value;
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__MINGW32__)
if (sscanf_s(hash_.substr(i*5,5).c_str(),"%05x",&hex) != 1)
#else
if (sscanf(hash_.substr(i*5,5).c_str(),"%05x",&hex) != 1)
#endif
throw ErrorOption("Invalid hash value");
value=((unsigned short)hex) / pow(10.0, (double)(hex >> 17));
if (hex & (1 << 16))
value=-value;
if (i < 7)
_srgbHuPhash[i]=value;
else
_hclpHuPhash[i-7]=value;
}
}
Magick::ChannelPerceptualHash::~ChannelPerceptualHash(void)
{
}
Magick::ChannelPerceptualHash::operator std::string() const
{
std::string
hash;
size_t
i;
if (!isValid())
return(std::string());
for (i=0; i<14; i++)
{
char
buffer[6];
double
value;
unsigned int
hex;
if (i < 7)
value=_srgbHuPhash[i];
else
value=_hclpHuPhash[i-7];
hex=0;
while(hex < 7 && fabs(value*10) < 65536)
{
value=value*10;
hex++;
}
hex=(hex<<1);
if (value < 0.0)
hex|=1;
hex=(hex<<16)+(unsigned int)(value < 0.0 ? -(value - 0.5) : value + 0.5);
(void) FormatLocaleString(buffer,6,"%05x",hex);
hash+=std::string(buffer);
}
return(hash);
}
Magick::PixelChannel Magick::ChannelPerceptualHash::channel() const
{
return(_channel);
}
bool Magick::ChannelPerceptualHash::isValid() const
{
return(_channel != SyncPixelChannel);
}
double Magick::ChannelPerceptualHash::sumSquaredDifferences(
const ChannelPerceptualHash &channelPerceptualHash_)
{
double
ssd;
size_t
i;
ssd=0.0;
for (i=0; i<7; i++)
{
ssd+=((_srgbHuPhash[i]-channelPerceptualHash_._srgbHuPhash[i])*
(_srgbHuPhash[i]-channelPerceptualHash_._srgbHuPhash[i]));
ssd+=((_hclpHuPhash[i]-channelPerceptualHash_._hclpHuPhash[i])*
(_hclpHuPhash[i]-channelPerceptualHash_._hclpHuPhash[i]));
}
return(ssd);
}
double Magick::ChannelPerceptualHash::srgbHuPhash(const size_t index_) const
{
if (index_ > 6)
throw ErrorOption("Valid range for index is 0-6");
return(_srgbHuPhash.at(index_));
}
double Magick::ChannelPerceptualHash::hclpHuPhash(const size_t index_) const
{
if (index_ > 6)
throw ErrorOption("Valid range for index is 0-6");
return(_hclpHuPhash.at(index_));
}
Magick::ChannelPerceptualHash::ChannelPerceptualHash(
const PixelChannel channel_,
const MagickCore::ChannelPerceptualHash *channelPerceptualHash_)
: _channel(channel_),
_srgbHuPhash(7),
_hclpHuPhash(7)
{
size_t
i;
for (i=0; i<7; i++)
{
_srgbHuPhash[i]=channelPerceptualHash_->phash[0][i];
_hclpHuPhash[i]=channelPerceptualHash_->phash[1][i];
}
}
Magick::ChannelStatistics::ChannelStatistics(void)
: _channel(SyncPixelChannel),
_area(0.0),
_depth(0),
_entropy(0.0),
_kurtosis(0.0),
_maxima(0.0),
_mean(0.0),
_minima(0.0),
_skewness(0.0),
_standardDeviation(0.0),
_sum(0.0),
_sumCubed(0.0),
_sumFourthPower(0.0),
_sumSquared(0.0),
_variance(0.0)
{
}
Magick::ChannelStatistics::ChannelStatistics(
const ChannelStatistics &channelStatistics_)
: _channel(channelStatistics_._channel),
_area(channelStatistics_._area),
_depth(channelStatistics_._depth),
_entropy(channelStatistics_._entropy),
_kurtosis(channelStatistics_._kurtosis),
_maxima(channelStatistics_._maxima),
_mean(channelStatistics_._mean),
_minima(channelStatistics_._minima),
_skewness(channelStatistics_._skewness),
_standardDeviation(channelStatistics_._standardDeviation),
_sum(channelStatistics_._sum),
_sumCubed(channelStatistics_._sumCubed),
_sumFourthPower(channelStatistics_._sumFourthPower),
_sumSquared(channelStatistics_._sumSquared),
_variance(channelStatistics_._variance)
{
}
Magick::ChannelStatistics::~ChannelStatistics(void)
{
}
double Magick::ChannelStatistics::area() const
{
return(_area);
}
Magick::PixelChannel Magick::ChannelStatistics::channel() const
{
return(_channel);
}
size_t Magick::ChannelStatistics::depth() const
{
return(_depth);
}
double Magick::ChannelStatistics::entropy() const
{
return(_entropy);
}
bool Magick::ChannelStatistics::isValid() const
{
return(_channel != SyncPixelChannel);
}
double Magick::ChannelStatistics::kurtosis() const
{
return(_kurtosis);
}
double Magick::ChannelStatistics::maxima() const
{
return(_maxima);
}
double Magick::ChannelStatistics::mean() const
{
return(_mean);
}
double Magick::ChannelStatistics::minima() const
{
return(_minima);
}
double Magick::ChannelStatistics::skewness() const
{
return(_skewness);
}
double Magick::ChannelStatistics::standardDeviation() const
{
return(_standardDeviation);
}
double Magick::ChannelStatistics::sum() const
{
return(_sum);
}
double Magick::ChannelStatistics::sumCubed() const
{
return(_sumCubed);
}
double Magick::ChannelStatistics::sumFourthPower() const
{
return(_sumFourthPower);
}
double Magick::ChannelStatistics::sumSquared() const
{
return(_sumSquared);
}
double Magick::ChannelStatistics::variance() const
{
return(_variance);
}
Magick::ChannelStatistics::ChannelStatistics(const PixelChannel channel_,
const MagickCore::ChannelStatistics *channelStatistics_)
: _channel(channel_),
_area(channelStatistics_->area),
_depth(channelStatistics_->depth),
_entropy(channelStatistics_->entropy),
_kurtosis(channelStatistics_->kurtosis),
_maxima(channelStatistics_->maxima),
_mean(channelStatistics_->mean),
_minima(channelStatistics_->minima),
_skewness(channelStatistics_->skewness),
_standardDeviation(channelStatistics_->standard_deviation),
_sum(channelStatistics_->sum),
_sumCubed(channelStatistics_->sum_cubed),
_sumFourthPower(channelStatistics_->sum_fourth_power),
_sumSquared(channelStatistics_->sum_squared),
_variance(channelStatistics_->variance)
{
}
Magick::ImageMoments::ImageMoments(void)
: _channels()
{
}
Magick::ImageMoments::ImageMoments(const ImageMoments &imageMoments_)
: _channels(imageMoments_._channels)
{
}
Magick::ImageMoments::~ImageMoments(void)
{
}
Magick::ChannelMoments Magick::ImageMoments::channel(
const PixelChannel channel_) const
{
for (std::vector<ChannelMoments>::const_iterator it = _channels.begin();
it != _channels.end(); ++it)
{
if (it->channel() == channel_)
return(*it);
}
return(ChannelMoments());
}
Magick::ImageMoments::ImageMoments(const Image &image_)
: _channels()
{
MagickCore::ChannelMoments*
channel_moments;
GetPPException;
channel_moments=GetImageMoments(image_.constImage(),exceptionInfo);
if (channel_moments != (MagickCore::ChannelMoments *) NULL)
{
ssize_t
i;
for (i=0; i < (ssize_t) GetPixelChannels(image_.constImage()); i++)
{
PixelChannel channel=GetPixelChannelChannel(image_.constImage(),i);
PixelTrait traits=GetPixelChannelTraits(image_.constImage(),channel);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
continue;
_channels.push_back(Magick::ChannelMoments(channel,
&channel_moments[channel]));
}
_channels.push_back(Magick::ChannelMoments(CompositePixelChannel,
&channel_moments[CompositePixelChannel]));
channel_moments=(MagickCore::ChannelMoments *) RelinquishMagickMemory(
channel_moments);
}
ThrowPPException(image_.quiet());
}
Magick::ImagePerceptualHash::ImagePerceptualHash(void)
: _channels()
{
}
Magick::ImagePerceptualHash::ImagePerceptualHash(
const ImagePerceptualHash &imagePerceptualHash_)
: _channels(imagePerceptualHash_._channels)
{
}
Magick::ImagePerceptualHash::ImagePerceptualHash(const std::string &hash_)
: _channels()
{
if (hash_.length() != 210)
throw ErrorOption("Invalid hash length");
_channels.push_back(Magick::ChannelPerceptualHash(RedPixelChannel,
hash_.substr(0, 70)));
_channels.push_back(Magick::ChannelPerceptualHash(GreenPixelChannel,
hash_.substr(70, 70)));
_channels.push_back(Magick::ChannelPerceptualHash(BluePixelChannel,
hash_.substr(140, 70)));
}
Magick::ImagePerceptualHash::~ImagePerceptualHash(void)
{
}
Magick::ImagePerceptualHash::operator std::string() const
{
if (!isValid())
return(std::string());
return static_cast<std::string>(_channels[0]) +
static_cast<std::string>(_channels[1]) +
static_cast<std::string>(_channels[2]);
}
Magick::ChannelPerceptualHash Magick::ImagePerceptualHash::channel(
const PixelChannel channel_) const
{
for (std::vector<ChannelPerceptualHash>::const_iterator it =
_channels.begin(); it != _channels.end(); ++it)
{
if (it->channel() == channel_)
return(*it);
}
return(ChannelPerceptualHash());
}
bool Magick::ImagePerceptualHash::isValid() const
{
if (_channels.size() != 3)
return(false);
if (_channels[0].channel() != RedPixelChannel)
return(false);
if (_channels[1].channel() != GreenPixelChannel)
return(false);
if (_channels[2].channel() != BluePixelChannel)
return(false);
return(true);
}
double Magick::ImagePerceptualHash::sumSquaredDifferences(
const ImagePerceptualHash &channelPerceptualHash_)
{
double
ssd;
size_t
i;
if (!isValid())
throw ErrorOption("instance is not valid");
if (!channelPerceptualHash_.isValid())
throw ErrorOption("channelPerceptualHash_ is not valid");
ssd=0.0;
for (i=0; i<3; i++)
{
ssd+=_channels[i].sumSquaredDifferences(_channels[i]);
}
return(ssd);
}
Magick::ImagePerceptualHash::ImagePerceptualHash(
const Image &image_)
: _channels()
{
MagickCore::ChannelPerceptualHash*
channel_perceptual_hash;
PixelTrait
traits;
GetPPException;
channel_perceptual_hash=GetImagePerceptualHash(image_.constImage(),
exceptionInfo);
if (channel_perceptual_hash != (MagickCore::ChannelPerceptualHash *) NULL)
{
traits=GetPixelChannelTraits(image_.constImage(),RedPixelChannel);
if ((traits & UpdatePixelTrait) != 0)
_channels.push_back(Magick::ChannelPerceptualHash(RedPixelChannel,
&channel_perceptual_hash[RedPixelChannel]));
traits=GetPixelChannelTraits(image_.constImage(),GreenPixelChannel);
if ((traits & UpdatePixelTrait) != 0)
_channels.push_back(Magick::ChannelPerceptualHash(GreenPixelChannel,
&channel_perceptual_hash[GreenPixelChannel]));
traits=GetPixelChannelTraits(image_.constImage(),BluePixelChannel);
if ((traits & UpdatePixelTrait) != 0)
_channels.push_back(Magick::ChannelPerceptualHash(BluePixelChannel,
&channel_perceptual_hash[BluePixelChannel]));
channel_perceptual_hash=(MagickCore::ChannelPerceptualHash *)
RelinquishMagickMemory(channel_perceptual_hash);
}
ThrowPPException(image_.quiet());
}
Magick::ImageStatistics::ImageStatistics(void)
: _channels()
{
}
Magick::ImageStatistics::ImageStatistics(
const ImageStatistics &imageStatistics_)
: _channels(imageStatistics_._channels)
{
}
Magick::ImageStatistics::~ImageStatistics(void)
{
}
Magick::ChannelStatistics Magick::ImageStatistics::channel(
const PixelChannel channel_) const
{
for (std::vector<ChannelStatistics>::const_iterator it = _channels.begin();
it != _channels.end(); ++it)
{
if (it->channel() == channel_)
return(*it);
}
return(ChannelStatistics());
}
Magick::ImageStatistics::ImageStatistics(const Image &image_)
: _channels()
{
MagickCore::ChannelStatistics*
channel_statistics;
GetPPException;
channel_statistics=GetImageStatistics(image_.constImage(),exceptionInfo);
if (channel_statistics != (MagickCore::ChannelStatistics *) NULL)
{
ssize_t
i;
for (i=0; i < (ssize_t) GetPixelChannels(image_.constImage()); i++)
{
PixelChannel channel=GetPixelChannelChannel(image_.constImage(),i);
PixelTrait traits=GetPixelChannelTraits(image_.constImage(),channel);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
continue;
_channels.push_back(Magick::ChannelStatistics(channel,
&channel_statistics[channel]));
}
_channels.push_back(Magick::ChannelStatistics(CompositePixelChannel,
&channel_statistics[CompositePixelChannel]));
channel_statistics=(MagickCore::ChannelStatistics *) RelinquishMagickMemory(
channel_statistics);
}
ThrowPPException(image_.quiet());
}
Magick::ChannelMoments
Definition Statistic.h:20
Magick::ChannelPerceptualHash
Definition Statistic.h:82
Magick::ChannelStatistics
Definition Statistic.h:134
Magick::ErrorOption
Definition Exception.h:171
Magick::ImagePerceptualHash
Definition Statistic.h:245
Magick::Image
Definition Image.h:56