|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% CCCC OOO M M PPPP AAA RRRR EEEEE % |
|
|
% C O O MM MM P P A A R R E % |
|
|
% C O O M M M PPPP AAAAA RRRR EEE % |
|
|
% C O O M M P A A R R E % |
|
|
% CCCC OOO M M P A A R R EEEEE % |
|
|
% % |
|
|
% % |
|
|
% MagickCore Image Comparison Methods % |
|
|
% % |
|
|
% Software Design % |
|
|
% Cristy % |
|
|
% December 2003 % |
|
|
% % |
|
|
% % |
|
|
% Copyright 1999-2016 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 % |
|
|
% obtain a copy of the License at % |
|
|
% % |
|
|
% http://www.imagemagick.org/script/license.php % |
|
|
% % |
|
|
% Unless required by applicable law or agreed to in writing, software % |
|
|
% distributed under the License is distributed on an "AS IS" BASIS, % |
|
|
% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % |
|
|
% See the License for the specific language governing permissions and % |
|
|
% limitations under the License. % |
|
|
% % |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% |
|
|
% |
|
|
% |
|
|
*/ |
|
|
|
|
|
/* |
|
|
Include declarations. |
|
|
*/ |
|
|
#include "MagickCore/studio.h" |
|
|
#include "MagickCore/artifact.h" |
|
|
#include "MagickCore/attribute.h" |
|
|
#include "MagickCore/cache-view.h" |
|
|
#include "MagickCore/channel.h" |
|
|
#include "MagickCore/client.h" |
|
|
#include "MagickCore/color.h" |
|
|
#include "MagickCore/color-private.h" |
|
|
#include "MagickCore/colorspace.h" |
|
|
#include "MagickCore/colorspace-private.h" |
|
|
#include "MagickCore/compare.h" |
|
|
#include "MagickCore/composite-private.h" |
|
|
#include "MagickCore/constitute.h" |
|
|
#include "MagickCore/exception-private.h" |
|
|
#include "MagickCore/geometry.h" |
|
|
#include "MagickCore/image-private.h" |
|
|
#include "MagickCore/list.h" |
|
|
#include "MagickCore/log.h" |
|
|
#include "MagickCore/memory_.h" |
|
|
#include "MagickCore/monitor.h" |
|
|
#include "MagickCore/monitor-private.h" |
|
|
#include "MagickCore/option.h" |
|
|
#include "MagickCore/pixel-accessor.h" |
|
|
#include "MagickCore/property.h" |
|
|
#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" |
|
|
|
|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% C o m p a r e I m a g e % |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% |
|
|
% 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: |
|
|
% |
|
|
% Image *CompareImages(const Image *image,const Image *reconstruct_image, |
|
|
% const MetricType metric,double *distortion,ExceptionInfo *exception) |
|
|
% |
|
|
% A description of each parameter follows: |
|
|
% |
|
|
% o image: the image. |
|
|
% |
|
|
% o reconstruct_image: the reconstruct image. |
|
|
% |
|
|
% o metric: the metric. |
|
|
% |
|
|
% o distortion: the computed distortion between the images. |
|
|
% |
|
|
% o exception: return any errors or warnings in this structure. |
|
|
% |
|
|
*/ |
|
|
|
|
|
static size_t GetImageChannels(const Image *image) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
size_t |
|
|
channels; |
|
|
|
|
|
channels=0; |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
if ((traits & UpdatePixelTrait) != 0) |
|
|
channels++; |
|
|
} |
|
|
return(channels == 0 ? (size_t) 1 : channels); |
|
|
} |
|
|
|
|
|
MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image, |
|
|
const MetricType metric,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*highlight_view, |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
double |
|
|
fuzz; |
|
|
|
|
|
const char |
|
|
*artifact; |
|
|
|
|
|
Image |
|
|
*difference_image, |
|
|
*highlight_image; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
PixelInfo |
|
|
highlight, |
|
|
lowlight; |
|
|
|
|
|
RectangleInfo |
|
|
geometry; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
if (image->debug != MagickFalse) |
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
|
|
assert(reconstruct_image != (const Image *) NULL); |
|
|
assert(reconstruct_image->signature == MagickCoreSignature); |
|
|
assert(distortion != (double *) NULL); |
|
|
*distortion=0.0; |
|
|
if (image->debug != MagickFalse) |
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
|
|
status=GetImageDistortion(image,reconstruct_image,metric,distortion, |
|
|
exception); |
|
|
if (status == MagickFalse) |
|
|
return((Image *) NULL); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
SetGeometry(image,&geometry); |
|
|
geometry.width=columns; |
|
|
geometry.height=rows; |
|
|
difference_image=ExtentImage(image,&geometry,exception); |
|
|
if (difference_image == (Image *) NULL) |
|
|
return((Image *) NULL); |
|
|
(void) SetImageAlphaChannel(difference_image,OpaqueAlphaChannel,exception); |
|
|
highlight_image=CloneImage(image,columns,rows,MagickTrue,exception); |
|
|
if (highlight_image == (Image *) NULL) |
|
|
{ |
|
|
difference_image=DestroyImage(difference_image); |
|
|
return((Image *) NULL); |
|
|
} |
|
|
status=SetImageStorageClass(highlight_image,DirectClass,exception); |
|
|
if (status == MagickFalse) |
|
|
{ |
|
|
difference_image=DestroyImage(difference_image); |
|
|
highlight_image=DestroyImage(highlight_image); |
|
|
return((Image *) NULL); |
|
|
} |
|
|
(void) SetImageAlphaChannel(highlight_image,OpaqueAlphaChannel,exception); |
|
|
(void) QueryColorCompliance("#f1001ecc",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); |
|
|
artifact=GetImageArtifact(image,"lowlight-color"); |
|
|
if (artifact != (const char *) NULL) |
|
|
(void) QueryColorCompliance(artifact,AllCompliance,&lowlight,exception); |
|
|
/* |
|
|
Generate difference image. |
|
|
*/ |
|
|
status=MagickTrue; |
|
|
fuzz=GetFuzzyColorDistance(image,reconstruct_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(static,4) shared(status) \ |
|
|
magick_threads(image,highlight_image,rows,1) |
|
|
#endif |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
MagickBooleanType |
|
|
sync; |
|
|
|
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register Quantum |
|
|
*magick_restrict r; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
if (status == MagickFalse) |
|
|
continue; |
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
r=QueueCacheViewAuthenticPixels(highlight_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL) || |
|
|
(r == (Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
continue; |
|
|
} |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
MagickStatusType |
|
|
difference; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
SetPixelViaPixelInfo(highlight_image,&lowlight,r); |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
r+=GetPixelChannels(highlight_image); |
|
|
continue; |
|
|
} |
|
|
difference=MagickFalse; |
|
|
Sa=QuantumScale*GetPixelAlpha(image,p); |
|
|
Da=QuantumScale*GetPixelAlpha(reconstruct_image,q); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=Sa*p[i]-Da*GetPixelChannel(reconstruct_image,channel,q); |
|
|
if ((distance*distance) > fuzz) |
|
|
{ |
|
|
difference=MagickTrue; |
|
|
break; |
|
|
} |
|
|
} |
|
|
if (difference == MagickFalse) |
|
|
SetPixelViaPixelInfo(highlight_image,&lowlight,r); |
|
|
else |
|
|
SetPixelViaPixelInfo(highlight_image,&highlight,r); |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
r+=GetPixelChannels(highlight_image); |
|
|
} |
|
|
sync=SyncCacheViewAuthenticPixels(highlight_view,exception); |
|
|
if (sync == MagickFalse) |
|
|
status=MagickFalse; |
|
|
} |
|
|
highlight_view=DestroyCacheView(highlight_view); |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
(void) CompositeImage(difference_image,highlight_image,image->compose, |
|
|
MagickTrue,0,0,exception); |
|
|
(void) SetImageAlphaChannel(difference_image,OffAlphaChannel,exception); |
|
|
highlight_image=DestroyImage(highlight_image); |
|
|
if (status == MagickFalse) |
|
|
difference_image=DestroyImage(difference_image); |
|
|
return(difference_image); |
|
|
} |
|
|
|
|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% G e t I m a g e D i s t o r t i o n % |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% |
|
|
% GetImageDistortion() compares one or more pixel channels of an image to a |
|
|
% reconstructed image and returns the specified distortion metric. |
|
|
% |
|
|
% The format of the GetImageDistortion method is: |
|
|
% |
|
|
% MagickBooleanType GetImageDistortion(const Image *image, |
|
|
% const Image *reconstruct_image,const MetricType metric, |
|
|
% double *distortion,ExceptionInfo *exception) |
|
|
% |
|
|
% A description of each parameter follows: |
|
|
% |
|
|
% o image: the image. |
|
|
% |
|
|
% o reconstruct_image: the reconstruct image. |
|
|
% |
|
|
% o metric: the metric. |
|
|
% |
|
|
% o distortion: the computed distortion between the images. |
|
|
% |
|
|
% o exception: return any errors or warnings in this structure. |
|
|
% |
|
|
*/ |
|
|
|
|
|
static MagickBooleanType GetAbsoluteDistortion(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
double |
|
|
fuzz; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
/* |
|
|
Compute the absolute difference in pixels between two images. |
|
|
*/ |
|
|
status=MagickTrue; |
|
|
fuzz=GetFuzzyColorDistance(image,reconstruct_image); |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) shared(status) \ |
|
|
magick_threads(image,image,rows,1) |
|
|
#endif |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
double |
|
|
channel_distortion[MaxPixelChannels+1]; |
|
|
|
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
j, |
|
|
x; |
|
|
|
|
|
if (status == MagickFalse) |
|
|
continue; |
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
continue; |
|
|
} |
|
|
(void) ResetMagickMemory(channel_distortion,0,sizeof(channel_distortion)); |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
MagickBooleanType |
|
|
difference; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
difference=MagickFalse; |
|
|
Sa=QuantumScale*GetPixelAlpha(image,p); |
|
|
Da=QuantumScale*GetPixelAlpha(reconstruct_image,q); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=Sa*p[i]-Da*GetPixelChannel(reconstruct_image,channel,q); |
|
|
if ((distance*distance) > fuzz) |
|
|
{ |
|
|
channel_distortion[i]++; |
|
|
difference=MagickTrue; |
|
|
} |
|
|
} |
|
|
if (difference != MagickFalse) |
|
|
channel_distortion[CompositePixelChannel]++; |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_GetAbsoluteError) |
|
|
#endif |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
distortion[j]+=channel_distortion[j]; |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetFuzzDistortion(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
register ssize_t |
|
|
j; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
status=MagickTrue; |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) shared(status) \ |
|
|
magick_threads(image,image,rows,1) |
|
|
#endif |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
double |
|
|
channel_distortion[MaxPixelChannels+1]; |
|
|
|
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
if (status == MagickFalse) |
|
|
continue; |
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
continue; |
|
|
} |
|
|
(void) ResetMagickMemory(channel_distortion,0,sizeof(channel_distortion)); |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
Sa=QuantumScale*GetPixelAlpha(image,p); |
|
|
Da=QuantumScale*GetPixelAlpha(reconstruct_image,q); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=QuantumScale*(Sa*p[i]-Da*GetPixelChannel(reconstruct_image, |
|
|
channel,q)); |
|
|
channel_distortion[i]+=distance*distance; |
|
|
channel_distortion[CompositePixelChannel]+=distance*distance; |
|
|
} |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_GetFuzzDistortion) |
|
|
#endif |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
distortion[j]+=channel_distortion[j]; |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
distortion[j]/=((double) columns*rows); |
|
|
distortion[CompositePixelChannel]/=(double) GetImageChannels(image); |
|
|
distortion[CompositePixelChannel]=sqrt(distortion[CompositePixelChannel]); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
register ssize_t |
|
|
j; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
status=MagickTrue; |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) shared(status) \ |
|
|
magick_threads(image,image,rows,1) |
|
|
#endif |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
double |
|
|
channel_distortion[MaxPixelChannels+1]; |
|
|
|
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
if (status == MagickFalse) |
|
|
continue; |
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
continue; |
|
|
} |
|
|
(void) ResetMagickMemory(channel_distortion,0,sizeof(channel_distortion)); |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
Sa=QuantumScale*GetPixelAlpha(image,p); |
|
|
Da=QuantumScale*GetPixelAlpha(reconstruct_image,q); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=QuantumScale*fabs(Sa*p[i]-Da*GetPixelChannel(reconstruct_image, |
|
|
channel,q)); |
|
|
channel_distortion[i]+=distance; |
|
|
channel_distortion[CompositePixelChannel]+=distance; |
|
|
} |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_GetMeanAbsoluteError) |
|
|
#endif |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
distortion[j]+=channel_distortion[j]; |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
distortion[j]/=((double) columns*rows); |
|
|
distortion[CompositePixelChannel]/=(double) GetImageChannels(image); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetMeanErrorPerPixel(Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
double |
|
|
area, |
|
|
maximum_error, |
|
|
mean_error; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
status=MagickTrue; |
|
|
area=0.0; |
|
|
maximum_error=0.0; |
|
|
mean_error=0.0; |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
Sa=QuantumScale*GetPixelAlpha(image,p); |
|
|
Da=QuantumScale*GetPixelAlpha(reconstruct_image,q); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=fabs(Sa*p[i]-Da*GetPixelChannel(reconstruct_image,channel,q)); |
|
|
distortion[i]+=distance; |
|
|
distortion[CompositePixelChannel]+=distance; |
|
|
mean_error+=distance*distance; |
|
|
if (distance > maximum_error) |
|
|
maximum_error=distance; |
|
|
area++; |
|
|
} |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
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); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetMeanSquaredDistortion(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
register ssize_t |
|
|
j; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
status=MagickTrue; |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) shared(status) \ |
|
|
magick_threads(image,image,rows,1) |
|
|
#endif |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
double |
|
|
channel_distortion[MaxPixelChannels+1]; |
|
|
|
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
if (status == MagickFalse) |
|
|
continue; |
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
continue; |
|
|
} |
|
|
(void) ResetMagickMemory(channel_distortion,0,sizeof(channel_distortion)); |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
Sa=QuantumScale*GetPixelAlpha(image,p); |
|
|
Da=QuantumScale*GetPixelAlpha(reconstruct_image,q); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=QuantumScale*(Sa*p[i]-Da*GetPixelChannel(reconstruct_image, |
|
|
channel,q)); |
|
|
channel_distortion[i]+=distance*distance; |
|
|
channel_distortion[CompositePixelChannel]+=distance*distance; |
|
|
} |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_GetMeanSquaredError) |
|
|
#endif |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
distortion[j]+=channel_distortion[j]; |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
distortion[j]/=((double) columns*rows); |
|
|
distortion[CompositePixelChannel]/=GetImageChannels(image); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetNormalizedCrossCorrelationDistortion( |
|
|
const Image *image,const Image *reconstruct_image,double *distortion, |
|
|
ExceptionInfo *exception) |
|
|
{ |
|
|
#define SimilarityImageTag "Similarity/Image" |
|
|
|
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
ChannelStatistics |
|
|
*image_statistics, |
|
|
*reconstruct_statistics; |
|
|
|
|
|
double |
|
|
area; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
MagickOffsetType |
|
|
progress; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
/* |
|
|
Normalize to account for variation due to lighting and exposure condition. |
|
|
*/ |
|
|
image_statistics=GetImageStatistics(image,exception); |
|
|
reconstruct_statistics=GetImageStatistics(reconstruct_image,exception); |
|
|
if ((image_statistics == (ChannelStatistics *) NULL) || |
|
|
(reconstruct_statistics == (ChannelStatistics *) NULL)) |
|
|
{ |
|
|
if (image_statistics != (ChannelStatistics *) NULL) |
|
|
image_statistics=(ChannelStatistics *) RelinquishMagickMemory( |
|
|
image_statistics); |
|
|
if (reconstruct_statistics != (ChannelStatistics *) NULL) |
|
|
reconstruct_statistics=(ChannelStatistics *) RelinquishMagickMemory( |
|
|
reconstruct_statistics); |
|
|
return(MagickFalse); |
|
|
} |
|
|
status=MagickTrue; |
|
|
progress=0; |
|
|
for (i=0; i <= MaxPixelChannels; i++) |
|
|
distortion[i]=0.0; |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
area=1.0/((double) columns*rows); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
Sa=QuantumScale*(image->alpha_trait != UndefinedPixelTrait ? |
|
|
GetPixelAlpha(image,p) : OpaqueAlpha); |
|
|
Da=QuantumScale*(reconstruct_image->alpha_trait != UndefinedPixelTrait ? |
|
|
GetPixelAlpha(reconstruct_image,q) : OpaqueAlpha); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
if (channel == AlphaPixelChannel) |
|
|
{ |
|
|
distortion[i]+=area*QuantumScale*(p[i]- |
|
|
image_statistics[channel].mean)*(GetPixelChannel( |
|
|
reconstruct_image,channel,q)- |
|
|
reconstruct_statistics[channel].mean); |
|
|
} |
|
|
else |
|
|
{ |
|
|
distortion[i]+=area*QuantumScale*(Sa*p[i]- |
|
|
image_statistics[channel].mean)*(Da*GetPixelChannel( |
|
|
reconstruct_image,channel,q)- |
|
|
reconstruct_statistics[channel].mean); |
|
|
} |
|
|
} |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
if (image->progress_monitor != (MagickProgressMonitor) NULL) |
|
|
{ |
|
|
MagickBooleanType |
|
|
proceed; |
|
|
|
|
|
proceed=SetImageProgress(image,SimilarityImageTag,progress++,rows); |
|
|
if (proceed == MagickFalse) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
/* |
|
|
Divide by the standard deviation. |
|
|
*/ |
|
|
distortion[CompositePixelChannel]=0.0; |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
gamma; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
gamma=image_statistics[channel].standard_deviation* |
|
|
reconstruct_statistics[channel].standard_deviation; |
|
|
gamma=PerceptibleReciprocal(gamma); |
|
|
distortion[i]=QuantumRange*gamma*distortion[i]; |
|
|
distortion[CompositePixelChannel]+=distortion[i]*distortion[i]; |
|
|
} |
|
|
distortion[CompositePixelChannel]=sqrt(distortion[CompositePixelChannel]/ |
|
|
GetImageChannels(image)); |
|
|
/* |
|
|
Free resources. |
|
|
*/ |
|
|
reconstruct_statistics=(ChannelStatistics *) RelinquishMagickMemory( |
|
|
reconstruct_statistics); |
|
|
image_statistics=(ChannelStatistics *) RelinquishMagickMemory( |
|
|
image_statistics); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
status=MagickTrue; |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) shared(status) \ |
|
|
magick_threads(image,image,rows,1) |
|
|
#endif |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
double |
|
|
channel_distortion[MaxPixelChannels+1]; |
|
|
|
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
j, |
|
|
x; |
|
|
|
|
|
if (status == MagickFalse) |
|
|
continue; |
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL)) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
continue; |
|
|
} |
|
|
(void) ResetMagickMemory(channel_distortion,0,sizeof(channel_distortion)); |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
double |
|
|
Da, |
|
|
Sa; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
Sa=QuantumScale*GetPixelAlpha(image,p); |
|
|
Da=QuantumScale*GetPixelAlpha(reconstruct_image,q); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=QuantumScale*fabs(Sa*p[i]-Da*GetPixelChannel(reconstruct_image, |
|
|
channel,q)); |
|
|
if (distance > channel_distortion[i]) |
|
|
channel_distortion[i]=distance; |
|
|
if (distance > channel_distortion[CompositePixelChannel]) |
|
|
channel_distortion[CompositePixelChannel]=distance; |
|
|
} |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_GetPeakAbsoluteError) |
|
|
#endif |
|
|
for (j=0; j <= MaxPixelChannels; j++) |
|
|
if (channel_distortion[j] > distortion[j]) |
|
|
distortion[j]=channel_distortion[j]; |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
static inline double MagickLog10(const double x) |
|
|
{ |
|
|
#define Log10Epsilon (1.0e-11) |
|
|
|
|
|
if (fabs(x) < Log10Epsilon) |
|
|
return(log10(Log10Epsilon)); |
|
|
return(log10(fabs(x))); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetPeakSignalToNoiseRatio(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
status=GetMeanSquaredDistortion(image,reconstruct_image,distortion,exception); |
|
|
for (i=0; i <= MaxPixelChannels; i++) |
|
|
distortion[i]=20.0*MagickLog10((double) 1.0/sqrt(distortion[i])); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetPerceptualHashDistortion(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
ChannelPerceptualHash |
|
|
*image_phash, |
|
|
*reconstruct_phash; |
|
|
|
|
|
ssize_t |
|
|
channel; |
|
|
|
|
|
/* |
|
|
Compute perceptual hash in the sRGB colorspace. |
|
|
*/ |
|
|
image_phash=GetImagePerceptualHash(image,exception); |
|
|
if (image_phash == (ChannelPerceptualHash *) NULL) |
|
|
return(MagickFalse); |
|
|
reconstruct_phash=GetImagePerceptualHash(reconstruct_image,exception); |
|
|
if (reconstruct_phash == (ChannelPerceptualHash *) NULL) |
|
|
{ |
|
|
image_phash=(ChannelPerceptualHash *) RelinquishMagickMemory(image_phash); |
|
|
return(MagickFalse); |
|
|
} |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) |
|
|
#endif |
|
|
for (channel=0; channel < MaxPixelChannels; channel++) |
|
|
{ |
|
|
double |
|
|
difference; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
difference=0.0; |
|
|
for (i=0; i < MaximumNumberOfImageMoments; i++) |
|
|
{ |
|
|
double |
|
|
alpha, |
|
|
beta; |
|
|
|
|
|
alpha=image_phash[channel].srgb_hu_phash[i]; |
|
|
beta=reconstruct_phash[channel].srgb_hu_phash[i]; |
|
|
difference+=(beta-alpha)*(beta-alpha); |
|
|
} |
|
|
distortion[channel]+=difference; |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_GetPerceptualHashDistortion) |
|
|
#endif |
|
|
distortion[CompositePixelChannel]+=difference; |
|
|
} |
|
|
/* |
|
|
Compute perceptual hash in the HCLP colorspace. |
|
|
*/ |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) |
|
|
#endif |
|
|
for (channel=0; channel < MaxPixelChannels; channel++) |
|
|
{ |
|
|
double |
|
|
difference; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
difference=0.0; |
|
|
for (i=0; i < MaximumNumberOfImageMoments; i++) |
|
|
{ |
|
|
double |
|
|
alpha, |
|
|
beta; |
|
|
|
|
|
alpha=image_phash[channel].hclp_hu_phash[i]; |
|
|
beta=reconstruct_phash[channel].hclp_hu_phash[i]; |
|
|
difference+=(beta-alpha)*(beta-alpha); |
|
|
} |
|
|
distortion[channel]+=difference; |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_GetPerceptualHashDistortion) |
|
|
#endif |
|
|
distortion[CompositePixelChannel]+=difference; |
|
|
} |
|
|
/* |
|
|
Free resources. |
|
|
*/ |
|
|
reconstruct_phash=(ChannelPerceptualHash *) RelinquishMagickMemory( |
|
|
reconstruct_phash); |
|
|
image_phash=(ChannelPerceptualHash *) RelinquishMagickMemory(image_phash); |
|
|
return(MagickTrue); |
|
|
} |
|
|
|
|
|
static MagickBooleanType GetRootMeanSquaredDistortion(const Image *image, |
|
|
const Image *reconstruct_image,double *distortion,ExceptionInfo *exception) |
|
|
{ |
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
status=GetMeanSquaredDistortion(image,reconstruct_image,distortion,exception); |
|
|
for (i=0; i <= MaxPixelChannels; i++) |
|
|
distortion[i]=sqrt(distortion[i]); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
MagickExport MagickBooleanType GetImageDistortion(Image *image, |
|
|
const Image *reconstruct_image,const MetricType metric,double *distortion, |
|
|
ExceptionInfo *exception) |
|
|
{ |
|
|
double |
|
|
*channel_distortion; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
size_t |
|
|
length; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
if (image->debug != MagickFalse) |
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
|
|
assert(reconstruct_image != (const Image *) NULL); |
|
|
assert(reconstruct_image->signature == MagickCoreSignature); |
|
|
assert(distortion != (double *) NULL); |
|
|
*distortion=0.0; |
|
|
if (image->debug != MagickFalse) |
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
|
|
/* |
|
|
Get image distortion. |
|
|
*/ |
|
|
length=MaxPixelChannels+1; |
|
|
channel_distortion=(double *) AcquireQuantumMemory(length, |
|
|
sizeof(*channel_distortion)); |
|
|
if (channel_distortion == (double *) NULL) |
|
|
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); |
|
|
(void) ResetMagickMemory(channel_distortion,0,length* |
|
|
sizeof(*channel_distortion)); |
|
|
switch (metric) |
|
|
{ |
|
|
case AbsoluteErrorMetric: |
|
|
{ |
|
|
status=GetAbsoluteDistortion(image,reconstruct_image,channel_distortion, |
|
|
exception); |
|
|
break; |
|
|
} |
|
|
case FuzzErrorMetric: |
|
|
{ |
|
|
status=GetFuzzDistortion(image,reconstruct_image,channel_distortion, |
|
|
exception); |
|
|
break; |
|
|
} |
|
|
case MeanAbsoluteErrorMetric: |
|
|
{ |
|
|
status=GetMeanAbsoluteDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case MeanErrorPerPixelErrorMetric: |
|
|
{ |
|
|
status=GetMeanErrorPerPixel(image,reconstruct_image,channel_distortion, |
|
|
exception); |
|
|
break; |
|
|
} |
|
|
case MeanSquaredErrorMetric: |
|
|
{ |
|
|
status=GetMeanSquaredDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case NormalizedCrossCorrelationErrorMetric: |
|
|
default: |
|
|
{ |
|
|
status=GetNormalizedCrossCorrelationDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case PeakAbsoluteErrorMetric: |
|
|
{ |
|
|
status=GetPeakAbsoluteDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case PeakSignalToNoiseRatioErrorMetric: |
|
|
{ |
|
|
status=GetPeakSignalToNoiseRatio(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case PerceptualHashErrorMetric: |
|
|
{ |
|
|
status=GetPerceptualHashDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case RootMeanSquaredErrorMetric: |
|
|
{ |
|
|
status=GetRootMeanSquaredDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
} |
|
|
*distortion=channel_distortion[CompositePixelChannel]; |
|
|
channel_distortion=(double *) RelinquishMagickMemory(channel_distortion); |
|
|
(void) FormatImageProperty(image,"distortion","%.*g",GetMagickPrecision(), |
|
|
*distortion); |
|
|
return(status); |
|
|
} |
|
|
|
|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% G e t I m a g e D i s t o r t i o n s % |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% |
|
|
% 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 GetImageDistortions method is: |
|
|
% |
|
|
% double *GetImageDistortions(const Image *image, |
|
|
% const Image *reconstruct_image,const MetricType metric, |
|
|
% ExceptionInfo *exception) |
|
|
% |
|
|
% A description of each parameter follows: |
|
|
% |
|
|
% o image: the image. |
|
|
% |
|
|
% o reconstruct_image: the reconstruct image. |
|
|
% |
|
|
% o metric: the metric. |
|
|
% |
|
|
% o exception: return any errors or warnings in this structure. |
|
|
% |
|
|
*/ |
|
|
MagickExport double *GetImageDistortions(Image *image, |
|
|
const Image *reconstruct_image,const MetricType metric, |
|
|
ExceptionInfo *exception) |
|
|
{ |
|
|
double |
|
|
*channel_distortion; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
size_t |
|
|
length; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
if (image->debug != MagickFalse) |
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
|
|
assert(reconstruct_image != (const Image *) NULL); |
|
|
assert(reconstruct_image->signature == MagickCoreSignature); |
|
|
if (image->debug != MagickFalse) |
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
|
|
/* |
|
|
Get image distortion. |
|
|
*/ |
|
|
length=MaxPixelChannels+1UL; |
|
|
channel_distortion=(double *) AcquireQuantumMemory(length, |
|
|
sizeof(*channel_distortion)); |
|
|
if (channel_distortion == (double *) NULL) |
|
|
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); |
|
|
(void) ResetMagickMemory(channel_distortion,0,length* |
|
|
sizeof(*channel_distortion)); |
|
|
status=MagickTrue; |
|
|
switch (metric) |
|
|
{ |
|
|
case AbsoluteErrorMetric: |
|
|
{ |
|
|
status=GetAbsoluteDistortion(image,reconstruct_image,channel_distortion, |
|
|
exception); |
|
|
break; |
|
|
} |
|
|
case FuzzErrorMetric: |
|
|
{ |
|
|
status=GetFuzzDistortion(image,reconstruct_image,channel_distortion, |
|
|
exception); |
|
|
break; |
|
|
} |
|
|
case MeanAbsoluteErrorMetric: |
|
|
{ |
|
|
status=GetMeanAbsoluteDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case MeanErrorPerPixelErrorMetric: |
|
|
{ |
|
|
status=GetMeanErrorPerPixel(image,reconstruct_image,channel_distortion, |
|
|
exception); |
|
|
break; |
|
|
} |
|
|
case MeanSquaredErrorMetric: |
|
|
{ |
|
|
status=GetMeanSquaredDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case NormalizedCrossCorrelationErrorMetric: |
|
|
default: |
|
|
{ |
|
|
status=GetNormalizedCrossCorrelationDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case PeakAbsoluteErrorMetric: |
|
|
{ |
|
|
status=GetPeakAbsoluteDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case PeakSignalToNoiseRatioErrorMetric: |
|
|
{ |
|
|
status=GetPeakSignalToNoiseRatio(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case PerceptualHashErrorMetric: |
|
|
{ |
|
|
status=GetRootMeanSquaredDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
case RootMeanSquaredErrorMetric: |
|
|
{ |
|
|
status=GetRootMeanSquaredDistortion(image,reconstruct_image, |
|
|
channel_distortion,exception); |
|
|
break; |
|
|
} |
|
|
} |
|
|
if (status == MagickFalse) |
|
|
{ |
|
|
channel_distortion=(double *) RelinquishMagickMemory(channel_distortion); |
|
|
return((double *) NULL); |
|
|
} |
|
|
return(channel_distortion); |
|
|
} |
|
|
|
|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% I s I m a g e s E q u a l % |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% |
|
|
% IsImagesEqual() compare the pixels of two images and returns immediately |
|
|
% if any pixel is not identical. |
|
|
% |
|
|
% The format of the IsImagesEqual method is: |
|
|
% |
|
|
% MagickBooleanType IsImagesEqual(const Image *image, |
|
|
% const Image *reconstruct_image,ExceptionInfo *exception) |
|
|
% |
|
|
% A description of each parameter follows. |
|
|
% |
|
|
% o image: the image. |
|
|
% |
|
|
% o reconstruct_image: the reconstruct image. |
|
|
% |
|
|
% o exception: return any errors or warnings in this structure. |
|
|
% |
|
|
*/ |
|
|
MagickExport MagickBooleanType IsImagesEqual(const Image *image, |
|
|
const Image *reconstruct_image,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
assert(reconstruct_image != (const Image *) NULL); |
|
|
assert(reconstruct_image->signature == MagickCoreSignature); |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL)) |
|
|
break; |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=fabs(p[i]-(double) GetPixelChannel(reconstruct_image, |
|
|
channel,q)); |
|
|
if (distance >= MagickEpsilon) |
|
|
break; |
|
|
} |
|
|
if (i < (ssize_t) GetPixelChannels(image)) |
|
|
break; |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
if (x < (ssize_t) columns) |
|
|
break; |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
return(y < (ssize_t) rows ? MagickFalse : MagickTrue); |
|
|
} |
|
|
|
|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% S e t I m a g e C o l o r M e t r i c % |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% |
|
|
% SetImageColorMetric() measures the difference between colors at each pixel |
|
|
% location of two images. A value other than 0 means the colors match |
|
|
% exactly. Otherwise an error measure is computed by summing over all |
|
|
% pixels in an image the distance squared in RGB space between each image |
|
|
% pixel and its corresponding pixel in the reconstruct image. The error |
|
|
% measure is assigned to these image members: |
|
|
% |
|
|
% o mean_error_per_pixel: The mean error for any single pixel in |
|
|
% the image. |
|
|
% |
|
|
% o normalized_mean_error: The normalized mean quantization error for |
|
|
% any single pixel in the image. This distance measure is normalized to |
|
|
% a range between 0 and 1. It is independent of the range of red, green, |
|
|
% and blue values in the image. |
|
|
% |
|
|
% o normalized_maximum_error: The normalized maximum quantization |
|
|
% error for any single pixel in the image. This distance measure is |
|
|
% normalized to a range between 0 and 1. It is independent of the range |
|
|
% of red, green, and blue values in your image. |
|
|
% |
|
|
% A small normalized mean square error, accessed as |
|
|
% image->normalized_mean_error, suggests the images are very similar in |
|
|
% spatial layout and color. |
|
|
% |
|
|
% The format of the SetImageColorMetric method is: |
|
|
% |
|
|
% MagickBooleanType SetImageColorMetric(Image *image, |
|
|
% const Image *reconstruct_image,ExceptionInfo *exception) |
|
|
% |
|
|
% A description of each parameter follows. |
|
|
% |
|
|
% o image: the image. |
|
|
% |
|
|
% o reconstruct_image: the reconstruct image. |
|
|
% |
|
|
% o exception: return any errors or warnings in this structure. |
|
|
% |
|
|
*/ |
|
|
MagickExport MagickBooleanType SetImageColorMetric(Image *image, |
|
|
const Image *reconstruct_image,ExceptionInfo *exception) |
|
|
{ |
|
|
CacheView |
|
|
*image_view, |
|
|
*reconstruct_view; |
|
|
|
|
|
double |
|
|
area, |
|
|
maximum_error, |
|
|
mean_error, |
|
|
mean_error_per_pixel; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
size_t |
|
|
columns, |
|
|
rows; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
assert(reconstruct_image != (const Image *) NULL); |
|
|
assert(reconstruct_image->signature == MagickCoreSignature); |
|
|
area=0.0; |
|
|
maximum_error=0.0; |
|
|
mean_error_per_pixel=0.0; |
|
|
mean_error=0.0; |
|
|
rows=MagickMax(image->rows,reconstruct_image->rows); |
|
|
columns=MagickMax(image->columns,reconstruct_image->columns); |
|
|
image_view=AcquireVirtualCacheView(image,exception); |
|
|
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception); |
|
|
for (y=0; y < (ssize_t) rows; y++) |
|
|
{ |
|
|
register const Quantum |
|
|
*magick_restrict p, |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
p=GetCacheViewVirtualPixels(image_view,0,y,columns,1,exception); |
|
|
q=GetCacheViewVirtualPixels(reconstruct_view,0,y,columns,1,exception); |
|
|
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL)) |
|
|
break; |
|
|
for (x=0; x < (ssize_t) columns; x++) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,p) == 0) |
|
|
{ |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
continue; |
|
|
} |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
double |
|
|
distance; |
|
|
|
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait reconstruct_traits=GetPixelChannelTraits(reconstruct_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(reconstruct_traits == UndefinedPixelTrait) || |
|
|
((reconstruct_traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
distance=fabs(p[i]-(double) GetPixelChannel(reconstruct_image, |
|
|
channel,q)); |
|
|
if (distance >= MagickEpsilon) |
|
|
{ |
|
|
mean_error_per_pixel+=distance; |
|
|
mean_error+=distance*distance; |
|
|
if (distance > maximum_error) |
|
|
maximum_error=distance; |
|
|
} |
|
|
area++; |
|
|
} |
|
|
p+=GetPixelChannels(image); |
|
|
q+=GetPixelChannels(reconstruct_image); |
|
|
} |
|
|
} |
|
|
reconstruct_view=DestroyCacheView(reconstruct_view); |
|
|
image_view=DestroyCacheView(image_view); |
|
|
image->error.mean_error_per_pixel=(double) (mean_error_per_pixel/area); |
|
|
image->error.normalized_mean_error=(double) (QuantumScale*QuantumScale* |
|
|
mean_error/area); |
|
|
image->error.normalized_maximum_error=(double) (QuantumScale*maximum_error); |
|
|
status=image->error.mean_error_per_pixel == 0.0 ? MagickTrue : MagickFalse; |
|
|
return(status); |
|
|
} |
|
|
|
|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% S i m i l a r i t y I m a g e % |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% |
|
|
% SimilarityImage() compares the reference image of the image and returns the |
|
|
% best match offset. In addition, it returns a similarity image such that an |
|
|
% exact match location is completely white and if none of the pixels match, |
|
|
% black, otherwise some gray level in-between. |
|
|
% |
|
|
% The format of the SimilarityImageImage method is: |
|
|
% |
|
|
% Image *SimilarityImage(const Image *image,const Image *reference, |
|
|
% const MetricType metric,const double similarity_threshold, |
|
|
% RectangleInfo *offset,double *similarity,ExceptionInfo *exception) |
|
|
% |
|
|
% A description of each parameter follows: |
|
|
% |
|
|
% o image: the image. |
|
|
% |
|
|
% o reference: find an area of the image that closely resembles this image. |
|
|
% |
|
|
% o metric: the metric. |
|
|
% |
|
|
% o similarity_threshold: minimum distortion for (sub)image match. |
|
|
% |
|
|
% o offset: the best match offset of the reference image within the image. |
|
|
% |
|
|
% o similarity: the computed similarity between the images. |
|
|
% |
|
|
% o exception: return any errors or warnings in this structure. |
|
|
% |
|
|
*/ |
|
|
|
|
|
static double GetSimilarityMetric(const Image *image,const Image *reference, |
|
|
const MetricType metric,const ssize_t x_offset,const ssize_t y_offset, |
|
|
ExceptionInfo *exception) |
|
|
{ |
|
|
double |
|
|
distortion; |
|
|
|
|
|
Image |
|
|
*similarity_image; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
RectangleInfo |
|
|
geometry; |
|
|
|
|
|
SetGeometry(reference,&geometry); |
|
|
geometry.x=x_offset; |
|
|
geometry.y=y_offset; |
|
|
similarity_image=CropImage(image,&geometry,exception); |
|
|
if (similarity_image == (Image *) NULL) |
|
|
return(0.0); |
|
|
distortion=0.0; |
|
|
status=GetImageDistortion(similarity_image,reference,metric,&distortion, |
|
|
exception); |
|
|
similarity_image=DestroyImage(similarity_image); |
|
|
if (status == MagickFalse) |
|
|
return(0.0); |
|
|
return(distortion); |
|
|
} |
|
|
|
|
|
MagickExport Image *SimilarityImage(const Image *image,const Image *reference, |
|
|
const MetricType metric,const double similarity_threshold, |
|
|
RectangleInfo *offset,double *similarity_metric,ExceptionInfo *exception) |
|
|
{ |
|
|
#define SimilarityImageTag "Similarity/Image" |
|
|
|
|
|
CacheView |
|
|
*similarity_view; |
|
|
|
|
|
Image |
|
|
*similarity_image; |
|
|
|
|
|
MagickBooleanType |
|
|
status; |
|
|
|
|
|
MagickOffsetType |
|
|
progress; |
|
|
|
|
|
ssize_t |
|
|
y; |
|
|
|
|
|
assert(image != (const Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
if (image->debug != MagickFalse) |
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
|
|
assert(exception != (ExceptionInfo *) NULL); |
|
|
assert(exception->signature == MagickCoreSignature); |
|
|
assert(offset != (RectangleInfo *) NULL); |
|
|
SetGeometry(reference,offset); |
|
|
*similarity_metric=MagickMaximumValue; |
|
|
similarity_image=CloneImage(image,image->columns-reference->columns+1, |
|
|
image->rows-reference->rows+1,MagickTrue,exception); |
|
|
if (similarity_image == (Image *) NULL) |
|
|
return((Image *) NULL); |
|
|
status=SetImageStorageClass(similarity_image,DirectClass,exception); |
|
|
if (status == MagickFalse) |
|
|
{ |
|
|
similarity_image=DestroyImage(similarity_image); |
|
|
return((Image *) NULL); |
|
|
} |
|
|
(void) SetImageAlphaChannel(similarity_image,DeactivateAlphaChannel, |
|
|
exception); |
|
|
/* |
|
|
Measure similarity of reference image against image. |
|
|
*/ |
|
|
status=MagickTrue; |
|
|
progress=0; |
|
|
similarity_view=AcquireAuthenticCacheView(similarity_image,exception); |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp parallel for schedule(static,4) \ |
|
|
shared(progress,status,similarity_metric) \ |
|
|
magick_threads(image,image,image->rows,1) |
|
|
#endif |
|
|
for (y=0; y < (ssize_t) (image->rows-reference->rows+1); y++) |
|
|
{ |
|
|
double |
|
|
similarity; |
|
|
|
|
|
register Quantum |
|
|
*magick_restrict q; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
if (status == MagickFalse) |
|
|
continue; |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp flush(similarity_metric) |
|
|
#endif |
|
|
if (*similarity_metric <= similarity_threshold) |
|
|
continue; |
|
|
q=GetCacheViewAuthenticPixels(similarity_view,0,y,similarity_image->columns, |
|
|
1,exception); |
|
|
if (q == (Quantum *) NULL) |
|
|
{ |
|
|
status=MagickFalse; |
|
|
continue; |
|
|
} |
|
|
for (x=0; x < (ssize_t) (image->columns-reference->columns+1); x++) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp flush(similarity_metric) |
|
|
#endif |
|
|
if (*similarity_metric <= similarity_threshold) |
|
|
break; |
|
|
similarity=GetSimilarityMetric(image,reference,metric,x,y,exception); |
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_SimilarityImage) |
|
|
#endif |
|
|
if ((metric == NormalizedCrossCorrelationErrorMetric) || |
|
|
(metric == UndefinedErrorMetric)) |
|
|
similarity=1.0-similarity; |
|
|
if (similarity < *similarity_metric) |
|
|
{ |
|
|
offset->x=x; |
|
|
offset->y=y; |
|
|
*similarity_metric=similarity; |
|
|
} |
|
|
if (metric == PerceptualHashErrorMetric) |
|
|
similarity=MagickMin(0.01*similarity,1.0); |
|
|
if (GetPixelReadMask(similarity_image,q) == 0) |
|
|
{ |
|
|
SetPixelBackgoundColor(similarity_image,q); |
|
|
q+=GetPixelChannels(similarity_image); |
|
|
continue; |
|
|
} |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
PixelTrait similarity_traits=GetPixelChannelTraits(similarity_image, |
|
|
channel); |
|
|
if ((traits == UndefinedPixelTrait) || |
|
|
(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) |
|
|
status=MagickFalse; |
|
|
if (image->progress_monitor != (MagickProgressMonitor) NULL) |
|
|
{ |
|
|
MagickBooleanType |
|
|
proceed; |
|
|
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT) |
|
|
#pragma omp critical (MagickCore_SimilarityImage) |
|
|
#endif |
|
|
proceed=SetImageProgress(image,SimilarityImageTag,progress++, |
|
|
image->rows); |
|
|
if (proceed == MagickFalse) |
|
|
status=MagickFalse; |
|
|
} |
|
|
} |
|
|
similarity_view=DestroyCacheView(similarity_view); |
|
|
if (status == MagickFalse) |
|
|
similarity_image=DestroyImage(similarity_image); |
|
|
return(similarity_image); |
|
|
}
|
|
|
|
