% December 2003 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/resource_.h"
#include "MagickCore/string_.h"
#include "MagickCore/statistic.h"
+#include "MagickCore/thread-private.h"
#include "MagickCore/transform.h"
#include "MagickCore/utility.h"
#include "MagickCore/version.h"
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% CompareImages() compares one or more pixel channels of an image to a
+% CompareImages() compares one or more pixel channels of an image to a
% reconstructed image and returns the difference image.
%
% The format of the CompareImages method is:
return((Image *) NULL);
}
(void) SetImageAlphaChannel(highlight_image,OpaqueAlphaChannel,exception);
- (void) QueryColorCompliance("#f1001ecc",AllCompliance,&highlight,
- exception);
+ (void) QueryColorCompliance("#f1001e33",AllCompliance,&highlight,exception);
artifact=GetImageArtifact(image,"highlight-color");
if (artifact != (const char *) NULL)
- (void) QueryColorCompliance(artifact,AllCompliance,&highlight,
- exception);
- (void) QueryColorCompliance("#ffffffcc",AllCompliance,&lowlight,
- exception);
+ (void) QueryColorCompliance(artifact,AllCompliance,&highlight,exception);
+ (void) QueryColorCompliance("#ffffff33",AllCompliance,&lowlight,exception);
artifact=GetImageArtifact(image,"lowlight-color");
if (artifact != (const char *) NULL)
(void) QueryColorCompliance(artifact,AllCompliance,&lowlight,exception);
Generate difference image.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
- highlight_view=AcquireCacheView(highlight_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
+ highlight_view=AcquireAuthenticCacheView(highlight_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,highlight_image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ SetPixelInfoPixel(highlight_image,&lowlight,r);
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ r+=GetPixelChannels(highlight_image);
+ continue;
+ }
difference=MagickFalse;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- MagickRealType
+ double
distance;
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
- continue;
- distance=p[i]-(MagickRealType)
- GetPixelChannel(reconstruct_image,channel,q);
+ distance=p[i]-(double) GetPixelChannel(reconstruct_image,channel,q);
if (fabs((double) distance) >= MagickEpsilon)
difference=MagickTrue;
}
if (difference == MagickFalse)
- SetPixelPixelInfo(highlight_image,&lowlight,r);
+ SetPixelInfoPixel(highlight_image,&lowlight,r);
else
- SetPixelPixelInfo(highlight_image,&highlight,r);
+ SetPixelInfoPixel(highlight_image,&highlight,r);
p+=GetPixelChannels(image);
q+=GetPixelChannels(reconstruct_image);
r+=GetPixelChannels(highlight_image);
highlight_view=DestroyCacheView(highlight_view);
reconstruct_view=DestroyCacheView(reconstruct_view);
image_view=DestroyCacheView(image_view);
- (void) CompositeImage(difference_image,image->compose,highlight_image,0,0,
- exception);
+ (void) CompositeImage(difference_image,highlight_image,image->compose,
+ MagickTrue,0,0,exception);
highlight_image=DestroyImage(highlight_image);
if (status == MagickFalse)
difference_image=DestroyImage(difference_image);
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetImageDistortion() compares one or more pixel channels of an image to a
+% GetImageDistortion() compares one or more pixel channels of an image to a
% reconstructed image and returns the specified distortion metric.
%
-% The format of the CompareImages method is:
+% The format of the GetImageDistortion method is:
%
% MagickBooleanType GetImageDistortion(const Image *image,
% const Image *reconstruct_image,const MetricType metric,
Compute the absolute difference in pixels between two images.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
difference=MagickFalse;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
- continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
if (p[i] != GetPixelChannel(reconstruct_image,channel,q))
difference=MagickTrue;
if (difference != MagickFalse)
{
channel_distortion[i]++;
- channel_distortion[MaxPixelChannels]++;
+ channel_distortion[CompositePixelChannel]++;
}
p+=GetPixelChannels(image);
q+=GetPixelChannels(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_GetAbsoluteError)
+ #pragma omp critical (MagickCore_GetAbsoluteError)
#endif
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]+=channel_distortion[i];
channels=0;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
+ PixelChannel
+ channel;
+
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
if ((traits & UpdatePixelTrait) != 0)
channels++;
}
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- MagickRealType
+ double
distance;
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
- continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
- distance=QuantumScale*(p[i]-(MagickRealType) GetPixelChannel(
- reconstruct_image,channel,q));
+ distance=QuantumScale*(p[i]-(double) GetPixelChannel(reconstruct_image,
+ channel,q));
distance*=distance;
channel_distortion[i]+=distance;
- channel_distortion[MaxPixelChannels]+=distance;
+ channel_distortion[CompositePixelChannel]+=distance;
}
p+=GetPixelChannels(image);
q+=GetPixelChannels(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_GetMeanSquaredError)
+ #pragma omp critical (MagickCore_GetFuzzDistortion)
#endif
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]+=channel_distortion[i];
image_view=DestroyCacheView(image_view);
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]/=((double) image->columns*image->rows);
- distortion[MaxPixelChannels]/=(double) GetImageChannels(image);
- distortion[MaxPixelChannels]=sqrt(distortion[MaxPixelChannels]);
+ distortion[CompositePixelChannel]/=(double) GetImageChannels(image);
+ distortion[CompositePixelChannel]=sqrt(distortion[CompositePixelChannel]);
return(status);
}
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- MagickRealType
+ double
distance;
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
- continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
- distance=QuantumScale*fabs(p[i]-(MagickRealType) GetPixelChannel(
+ distance=QuantumScale*fabs(p[i]-(double) GetPixelChannel(
reconstruct_image,channel,q));
channel_distortion[i]+=distance;
- channel_distortion[MaxPixelChannels]+=distance;
+ channel_distortion[CompositePixelChannel]+=distance;
}
p+=GetPixelChannels(image);
q+=GetPixelChannels(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_GetMeanAbsoluteError)
+ #pragma omp critical (MagickCore_GetMeanAbsoluteError)
#endif
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]+=channel_distortion[i];
image_view=DestroyCacheView(image_view);
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]/=((double) image->columns*image->rows);
- distortion[MaxPixelChannels]/=(double) GetImageChannels(image);
+ distortion[CompositePixelChannel]/=(double) GetImageChannels(image);
return(status);
}
MagickBooleanType
status;
- MagickRealType
+ double
alpha,
area,
beta,
area=0.0;
maximum_error=0.0;
mean_error=0.0;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- MagickRealType
+ double
distance;
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
- continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
distance=fabs((double) (alpha*p[i]-beta*GetPixelChannel(
reconstruct_image,channel,q)));
distortion[i]+=distance;
- distortion[MaxPixelChannels]+=distance;
+ distortion[CompositePixelChannel]+=distance;
mean_error+=distance*distance;
if (distance > maximum_error)
maximum_error=distance;
}
reconstruct_view=DestroyCacheView(reconstruct_view);
image_view=DestroyCacheView(image_view);
- image->error.mean_error_per_pixel=distortion[MaxPixelChannels]/area;
+ image->error.mean_error_per_pixel=distortion[CompositePixelChannel]/area;
image->error.normalized_mean_error=QuantumScale*QuantumScale*mean_error/area;
image->error.normalized_maximum_error=QuantumScale*maximum_error;
return(status);
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- MagickRealType
+ double
distance;
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
- continue;
- distance=QuantumScale*(p[i]-(MagickRealType) GetPixelChannel(
+ distance=QuantumScale*(p[i]-(double) GetPixelChannel(
reconstruct_image,channel,q));
distance*=distance;
channel_distortion[i]+=distance;
- channel_distortion[MaxPixelChannels]+=distance;
+ channel_distortion[CompositePixelChannel]+=distance;
}
p+=GetPixelChannels(image);
q+=GetPixelChannels(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_GetMeanSquaredError)
+ #pragma omp critical (MagickCore_GetMeanSquaredError)
#endif
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]+=channel_distortion[i];
image_view=DestroyCacheView(image_view);
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]/=((double) image->columns*image->rows);
- distortion[MaxPixelChannels]/=GetImageChannels(image);
+ distortion[CompositePixelChannel]/=GetImageChannels(image);
return(status);
}
MagickOffsetType
progress;
- MagickRealType
+ double
area;
register ssize_t
progress=0;
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]=0.0;
- area=1.0/((MagickRealType) image->columns*image->rows-1);
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ area=1.0/((double) image->columns*image->rows-1);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
- continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
distortion[i]+=area*QuantumScale*(p[i]-image_statistics[i].mean)*
(GetPixelChannel(reconstruct_image,channel,q)-
reconstruct_statistics[channel].mean);
}
p+=GetPixelChannels(image);
- q+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
}
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
/*
Divide by the standard deviation.
*/
- distortion[MaxPixelChannels]=0.0;
+ distortion[CompositePixelChannel]=0.0;
for (i=0; i < MaxPixelChannels; i++)
{
- MagickRealType
+ double
gamma;
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelChannel(image,i);
gamma=image_statistics[i].standard_deviation*
reconstruct_statistics[channel].standard_deviation;
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ gamma=PerceptibleReciprocal(gamma);
distortion[i]=QuantumRange*gamma*distortion[i];
- distortion[MaxPixelChannels]+=distortion[i]*distortion[i];
+ distortion[CompositePixelChannel]+=distortion[i]*distortion[i];
}
- distortion[MaxPixelChannels]=sqrt(distortion[MaxPixelChannels]/
+ distortion[CompositePixelChannel]=sqrt(distortion[CompositePixelChannel]/
GetImageChannels(image));
/*
Free resources.
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- q=GetCacheViewVirtualPixels(reconstruct_view,0,y,
- reconstruct_image->columns,1,exception);
+ q=GetCacheViewVirtualPixels(reconstruct_view,0,y,reconstruct_image->columns,
+ 1,exception);
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL))
{
status=MagickFalse;
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- MagickRealType
+ double
distance;
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
- continue;
- distance=QuantumScale*fabs(p[i]-(MagickRealType) GetPixelChannel(
+ distance=QuantumScale*fabs(p[i]-(double) GetPixelChannel(
reconstruct_image,channel,q));
if (distance > channel_distortion[i])
channel_distortion[i]=distance;
- if (distance > channel_distortion[MaxPixelChannels])
- channel_distortion[MaxPixelChannels]=distance;
+ if (distance > channel_distortion[CompositePixelChannel])
+ channel_distortion[CompositePixelChannel]=distance;
}
p+=GetPixelChannels(image);
- q+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_GetPeakAbsoluteError)
+ #pragma omp critical (MagickCore_GetPeakAbsoluteError)
#endif
for (i=0; i <= MaxPixelChannels; i++)
if (channel_distortion[i] > distortion[i])
break;
}
}
- *distortion=channel_distortion[MaxPixelChannels];
+ *distortion=channel_distortion[CompositePixelChannel];
channel_distortion=(double *) RelinquishMagickMemory(channel_distortion);
return(status);
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetImageDistrortion() compares the pixel channels of an image to a
+% GetImageDistortions() compares the pixel channels of an image to a
% reconstructed image and returns the specified distortion metric for each
% channel.
%
-% The format of the CompareImages method is:
+% The format of the GetImageDistortions method is:
%
% double *GetImageDistortions(const Image *image,
% const Image *reconstruct_image,const MetricType metric,
MagickBooleanType
status;
- MagickRealType
+ double
area,
maximum_error,
mean_error,
maximum_error=0.0;
mean_error_per_pixel=0.0;
mean_error=0.0;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(reconstruct_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- MagickRealType
+ double
distance;
PixelChannel
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ reconstruct_traits=GetPixelChannelTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (reconstruct_traits == UndefinedPixelTrait))
- continue;
- if ((reconstruct_traits & UpdatePixelTrait) == 0)
+ (reconstruct_traits == UndefinedPixelTrait) ||
+ ((reconstruct_traits & UpdatePixelTrait) == 0))
continue;
- distance=fabs(p[i]-(MagickRealType) GetPixelChannel(reconstruct_image,
+ distance=fabs(p[i]-(double) GetPixelChannel(reconstruct_image,
channel,q));
mean_error_per_pixel+=distance;
mean_error+=distance*distance;
*/
status=MagickTrue;
progress=0;
- similarity_view=AcquireCacheView(similarity_image);
+ similarity_view=AcquireAuthenticCacheView(similarity_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) (image->rows-reference->rows+1); y++)
{
similarity=GetSimilarityMetric(image,reference,metric,x,y,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_SimilarityImage)
+ #pragma omp critical (MagickCore_SimilarityImage)
#endif
if (similarity < *similarity_metric)
{
offset->x=x;
offset->y=y;
}
- for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ if (GetPixelMask(similarity_image,q) != 0)
+ {
+ q+=GetPixelChannels(similarity_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(similarity_image); i++)
{
PixelChannel
channel;
similarity_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
- similarity_traits=GetPixelChannelMapTraits(similarity_image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ similarity_traits=GetPixelChannelTraits(similarity_image,channel);
if ((traits == UndefinedPixelTrait) ||
- (similarity_traits == UndefinedPixelTrait))
- continue;
- if ((similarity_traits & UpdatePixelTrait) == 0)
+ (similarity_traits == UndefinedPixelTrait) ||
+ ((similarity_traits & UpdatePixelTrait) == 0))
continue;
SetPixelChannel(similarity_image,channel,ClampToQuantum(QuantumRange-
QuantumRange*similarity),q);
}
q+=GetPixelChannels(similarity_image);
}
- if (SyncCacheViewAuthenticPixels(similarity_view,exception) == MagickFalse)
+ if (IfMagickFalse( SyncCacheViewAuthenticPixels(similarity_view,exception) ))
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
- MagickBooleanType
- proceed;
-
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_SimilarityImage)
+ #pragma omp critical (MagickCore_SimilarityImage)
#endif
- proceed=SetImageProgress(image,SimilarityImageTag,progress++,
- image->rows);
- if (proceed == MagickFalse)
+ if (IfMagickFalse(SetImageProgress(image,SimilarityImageTag,
+ progress++,image->rows) ))
status=MagickFalse;
}
}
similarity_view=DestroyCacheView(similarity_view);
+ if (status == MagickFalse)
+ similarity_image=DestroyImage(similarity_image);
return(similarity_image);
}
projects / imagemagick / blobdiff