% January 2010 %
% %
% %
-% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 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/studio.h"
#include "MagickCore/artifact.h"
#include "MagickCore/cache-view.h"
+#include "MagickCore/channel.h"
#include "MagickCore/color-private.h"
#include "MagickCore/enhance.h"
#include "MagickCore/exception.h"
static inline KernelInfo *LastKernelInfo(KernelInfo *kernel)
{
while (kernel->next != (KernelInfo *) NULL)
- kernel = kernel->next;
+ kernel=kernel->next;
return(kernel);
}
kernel->width,kernel->height*sizeof(*kernel->values)));
if (kernel->values == (MagickRealType *) NULL)
return(DestroyKernelInfo(kernel));
- kernel->minimum = +MagickHuge;
- kernel->maximum = -MagickHuge;
+ kernel->minimum=MagickMaximumValue;
+ kernel->maximum=(-MagickMaximumValue);
kernel->negative_range = kernel->positive_range = 0.0;
for (i=0; (i < (ssize_t) (kernel->width*kernel->height)) && (p < end); i++)
{
#endif
/* check that we recieved at least one real (non-nan) value! */
- if ( kernel->minimum == MagickHuge )
+ if (kernel->minimum == MagickMaximumValue)
return(DestroyKernelInfo(kernel));
if ( (flags & AreaValue) != 0 ) /* '@' symbol in kernel size */
MagickExport KernelInfo *AcquireKernelInfo(const char *kernel_string)
{
-
KernelInfo
*kernel,
*new_kernel;
const char
*p;
- size_t
- kernel_number;
-
if (kernel_string == (const char *) NULL)
return(ParseKernelArray(kernel_string));
- p = kernel_string;
- kernel = NULL;
- kernel_number = 0;
-
- while ( GetMagickToken(p,NULL,token), *token != '\0' ) {
+ p=kernel_string;
+ kernel=NULL;
+ while (GetMagickToken(p,NULL,token), *token != '\0')
+ {
/* ignore extra or multiple ';' kernel separators */
- if ( *token != ';' ) {
-
- /* tokens starting with alpha is a Named kernel */
- if (isalpha((int) *token) != 0)
- new_kernel = ParseKernelName(p);
- else /* otherwise a user defined kernel array */
- new_kernel = ParseKernelArray(p);
-
- /* Error handling -- this is not proper error handling! */
- if ( new_kernel == (KernelInfo *) NULL ) {
- (void) FormatLocaleFile(stderr,"Failed to parse kernel number #%.20g\n",
- (double) kernel_number);
- if ( kernel != (KernelInfo *) NULL )
- kernel=DestroyKernelInfo(kernel);
- return((KernelInfo *) NULL);
- }
+ if (*token != ';')
+ {
+ /* tokens starting with alpha is a Named kernel */
+ if (isalpha((int) ((unsigned char) *token)) != 0)
+ new_kernel=ParseKernelName(p);
+ else /* otherwise a user defined kernel array */
+ new_kernel=ParseKernelArray(p);
+
+ /* Error handling -- this is not proper error handling! */
+ if (new_kernel == (KernelInfo *) NULL)
+ {
+ if (kernel != (KernelInfo *) NULL)
+ kernel=DestroyKernelInfo(kernel);
+ return((KernelInfo *) NULL);
+ }
- /* initialise or append the kernel list */
- if ( kernel == (KernelInfo *) NULL )
- kernel = new_kernel;
- else
- LastKernelInfo(kernel)->next = new_kernel;
- }
+ /* initialise or append the kernel list */
+ if (kernel == (KernelInfo *) NULL)
+ kernel=new_kernel;
+ else
+ LastKernelInfo(kernel)->next=new_kernel;
+ }
/* look for the next kernel in list */
- p = strchr(p, ';');
- if ( p == (char *) NULL )
+ p=strchr(p,';');
+ if (p == (char *) NULL)
break;
p++;
-
}
return(kernel);
}
MagickExport KernelInfo *DestroyKernelInfo(KernelInfo *kernel)
{
assert(kernel != (KernelInfo *) NULL);
- if ( kernel->next != (KernelInfo *) NULL )
+ if (kernel->next != (KernelInfo *) NULL)
kernel->next=DestroyKernelInfo(kernel->next);
kernel->values=(MagickRealType *) RelinquishAlignedMemory(kernel->values);
kernel=(KernelInfo *) RelinquishMagickMemory(kernel);
/* check actual kernel values */
for (i=0; i < (kernel1->width*kernel1->height); i++) {
/* Test for Nan equivalence */
- if ( IsNaN(kernel1->values[i]) && !IsNaN(kernel2->values[i]) )
+ if ( IfNaN(kernel1->values[i]) && !IfNaN(kernel2->values[i]) )
return MagickFalse;
- if ( IsNaN(kernel2->values[i]) && !IsNaN(kernel1->values[i]) )
+ if ( IfNaN(kernel2->values[i]) && !IfNaN(kernel1->values[i]) )
return MagickFalse;
/* Test actual values are equivalent */
if ( fabs(kernel1->values[i] - kernel2->values[i]) >= MagickEpsilon )
*last;
last = kernel;
+DisableMSCWarning(4127)
while(1) {
+RestoreMSCWarning
clone = CloneKernelInfo(last);
RotateKernelInfo(clone, angle);
- if ( SameKernelInfo(kernel, clone) == MagickTrue )
+ if ( SameKernelInfo(kernel, clone) != MagickFalse )
break;
LastKernelInfo(last)->next = clone;
last = clone;
OffsetInfo
offset;
+ register ssize_t
+ i;
+
ssize_t
y;
size_t
- width,
- changed;
+ *changes,
+ changed,
+ width;
MagickBooleanType
status;
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
status=MagickTrue;
- changed=0;
progress=0;
image_view=AcquireVirtualCacheView(image,exception);
morphology_view=AcquireAuthenticCacheView(morphology_image,exception);
width=image->columns+kernel->width-1;
+ offset.x=0.0;
+ offset.y=0.0;
switch (method)
{
case ConvolveMorphology:
break;
}
}
+ changed=0;
+ changes=(size_t *) AcquireQuantumMemory(GetOpenMPMaximumThreads(),
+ sizeof(*changes));
+ if (changes == (size_t *) NULL)
+ ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+ for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
+ changes[i]=0;
if ((method == ConvolveMorphology) && (kernel->width == 1))
{
+ const int
+ id = GetOpenMPThreadId();
+
register ssize_t
x;
register ssize_t
u;
+ size_t
+ count;
+
ssize_t
v;
(morphology_traits == UndefinedPixelTrait))
continue;
if (((morphology_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(image,p+center) != 0))
+ (GetPixelReadMask(image,p+center) == 0))
{
SetPixelChannel(morphology_image,channel,p[center+i],q);
continue;
k=(&kernel->values[kernel->width*kernel->height-1]);
pixels=p;
pixel=bias;
- gamma=0.0;
+ count=0;
if ((morphology_traits & BlendPixelTrait) == 0)
{
/*
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) != MagickFalse)
- continue;
- pixel+=(*k)*pixels[i];
- gamma+=(*k);
+ if (IfNaN(*k) == MagickFalse)
+ {
+ pixel+=(*k)*pixels[i];
+ count++;
+ }
k--;
pixels+=GetPixelChannels(image);
}
}
- gamma=PerceptibleReciprocal(gamma);
- pixel*=gamma;
if (fabs(pixel-p[center+i]) > MagickEpsilon)
- changed++;
- SetPixelChannel(morphology_image,channel,ClampToQuantum(pixel),
- q);
+ changes[id]++;
+ gamma=(double) kernel->height*kernel->width/count;
+ SetPixelChannel(morphology_image,channel,ClampToQuantum(gamma*
+ pixel),q);
continue;
}
/*
Alpha blending.
*/
- for (v=0; v < (ssize_t) kernel->width; v++)
+ gamma=0.0;
+ for (v=0; v < (ssize_t) kernel->height; v++)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) != MagickFalse)
- continue;
- alpha=(double) (QuantumScale*GetPixelAlpha(image,pixels));
- pixel+=(*k)*alpha*pixels[i];
- gamma+=(*k)*alpha;
+ if (IfNaN(*k) == MagickFalse)
+ {
+ alpha=(double) (QuantumScale*GetPixelAlpha(image,pixels));
+ pixel+=(*k)*alpha*pixels[i];
+ gamma+=(*k)*alpha;
+ count++;
+ }
k--;
pixels+=GetPixelChannels(image);
}
}
- gamma=PerceptibleReciprocal(gamma);
- pixel*=gamma;
if (fabs(pixel-p[center+i]) > MagickEpsilon)
- changed++;
- SetPixelChannel(morphology_image,channel,ClampToQuantum(pixel),q);
+ changes[id]++;
+ gamma=PerceptibleReciprocal(gamma);
+ gamma*=(double) kernel->height*kernel->width/count;
+ SetPixelChannel(morphology_image,channel,ClampToQuantum(gamma*
+ pixel),q);
}
p+=GetPixelChannels(image);
q+=GetPixelChannels(morphology_image);
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_MorphologyImage)
+ #pragma omp critical (MagickCore_MorphologyPrimitive)
#endif
proceed=SetImageProgress(image,MorphologyTag,progress++,
image->rows);
morphology_image->type=image->type;
morphology_view=DestroyCacheView(morphology_view);
image_view=DestroyCacheView(image_view);
+ for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
+ changed+=changes[i];
+ changes=(size_t *) RelinquishMagickMemory(changes);
return(status ? (ssize_t) changed : 0);
}
/*
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
+ const int
+ id = GetOpenMPThreadId();
+
register const Quantum
*restrict p;
register ssize_t
u;
+ size_t
+ count;
+
ssize_t
v;
(morphology_traits == UndefinedPixelTrait))
continue;
if (((morphology_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(image,p+center) != 0))
+ (GetPixelReadMask(image,p+center) == 0))
{
SetPixelChannel(morphology_image,channel,p[center+i],q);
continue;
pixels=p;
maximum=0.0;
minimum=(double) QuantumRange;
+ count=kernel->width*kernel->height;
switch (method)
{
case ConvolveMorphology: pixel=bias; break;
}
default: pixel=0; break;
}
- gamma=0.0;
+ gamma=1.0;
switch (method)
{
case ConvolveMorphology:
http://www.cs.umd.edu/~djacobs/CMSC426/Convolution.pdf
*/
k=(&kernel->values[kernel->width*kernel->height-1]);
+ count=0;
if ((morphology_traits & BlendPixelTrait) == 0)
{
/*
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
pixel+=(*k)*pixels[i];
- gamma+=(*k);
+ count++;
}
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
- gamma=PerceptibleReciprocal(gamma);
- pixel*=gamma;
- continue;
+ break;
}
/*
Alpha blending.
*/
- for (v=0; v < (ssize_t) kernel->width; v++)
+ for (v=0; v < (ssize_t) kernel->height; v++)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
alpha=(double) (QuantumScale*GetPixelAlpha(image,pixels));
pixel+=(*k)*alpha*pixels[i];
gamma+=(*k)*alpha;
+ count++;
}
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
- gamma=PerceptibleReciprocal(gamma);
- pixel*=gamma;
break;
}
case ErodeMorphology:
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if ((IsNaN(*k) == MagickFalse) && (*k >= 0.5))
+ if ((IfNaN(*k) == MagickFalse) && (*k >= 0.5))
{
if ((double) pixels[i] < pixel)
pixel=(double) pixels[i];
k++;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
break;
}
added to the real value, this is currently not done, due to the
nature of the boolean kernels being used.
*/
+ count=0;
k=(&kernel->values[kernel->width*kernel->height-1]);
for (v=0; v < (ssize_t) kernel->height; v++)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if ((IsNaN(*k) == MagickFalse) && (*k > 0.5))
+ if ((IfNaN(*k) == MagickFalse) && (*k > 0.5))
{
if ((double) pixels[i] > pixel)
pixel=(double) pixels[i];
+ count++;
}
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
break;
}
cause Thinning/Thicken to not work correctly when used against a
greyscale image.
*/
+ count=0;
k=kernel->values;
for (v=0; v < (ssize_t) kernel->height; v++)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
if (*k > 0.7)
{
if ((double) pixels[i] > maximum)
maximum=(double) pixels[i];
}
+ count++;
}
k++;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
pixel-=maximum;
if (pixel < 0.0)
The kernel is not reflected for this operation.
*/
+ count=0;
k=kernel->values;
for (v=0; v < (ssize_t) kernel->height; v++)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if ((IsNaN(*k) == MagickFalse) && (*k >= 0.5))
+ if ((IfNaN(*k) == MagickFalse) && (*k >= 0.5))
{
if (GetPixelIntensity(image,pixels) < minimum)
{
pixel=(double) pixels[i];
minimum=GetPixelIntensity(image,pixels);
}
+ count++;
}
k++;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
break;
}
The kernel is not reflected for this operation.
*/
+ count=0;
k=(&kernel->values[kernel->width*kernel->height-1]);
for (v=0; v < (ssize_t) kernel->height; v++)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if ((IsNaN(*k) == MagickFalse) && (*k >= 0.5))
+ if ((IfNaN(*k) == MagickFalse) && (*k >= 0.5))
{
if (GetPixelIntensity(image,pixels) > maximum)
{
pixel=(double) pixels[i];
maximum=GetPixelIntensity(image,pixels);
}
+ count++;
}
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
break;
}
GrayErode, but with negative kernel values, and kernel rotation
applied.
*/
+ count=0;
k=(&kernel->values[kernel->width*kernel->height-1]);
for (v=0; v < (ssize_t) kernel->height; v++)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
if ((pixels[i]+(*k)) < pixel)
pixel=(double) pixels[i]+(*k);
+ count++;
}
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=image->columns*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
break;
}
break;
}
if (fabs(pixel-p[center+i]) > MagickEpsilon)
- changed++;
- SetPixelChannel(morphology_image,channel,ClampToQuantum(pixel),q);
+ changes[id]++;
+ gamma=PerceptibleReciprocal(gamma);
+ gamma*=(double) kernel->height*kernel->width/count;
+ SetPixelChannel(morphology_image,channel,ClampToQuantum(gamma*pixel),q);
}
p+=GetPixelChannels(image);
q+=GetPixelChannels(morphology_image);
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_MorphologyImage)
+ #pragma omp critical (MagickCore_MorphologyPrimitive)
#endif
proceed=SetImageProgress(image,MorphologyTag,progress++,image->rows);
if (proceed == MagickFalse)
}
morphology_view=DestroyCacheView(morphology_view);
image_view=DestroyCacheView(image_view);
- return(status ? (ssize_t)changed : -1);
+ for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
+ changed+=changes[i];
+ changes=(size_t *) RelinquishMagickMemory(changes);
+ return(status ? (ssize_t) changed : -1);
}
/*
register ssize_t
x;
+ ssize_t
+ center;
+
/*
Read virtual pixels, and authentic pixels, from the same image! We read
using virtual to get virtual pixel handling, but write back into the same
through the image iterating the distance function as we go.
*/
if (status == MagickFalse)
- break;
+ continue;
p=GetCacheViewVirtualPixels(image_view,-offset.x,y-offset.y,width,(size_t)
offset.y+1,exception);
q=GetCacheViewAuthenticPixels(morphology_view,0,y,image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- status=MagickFalse;
- if (status == MagickFalse)
- break;
+ {
+ status=MagickFalse;
+ continue;
+ }
+ center=(ssize_t) (GetPixelChannels(image)*width*offset.y+
+ GetPixelChannels(image)*offset.x);
for (x=0; x < (ssize_t) image->columns; x++)
{
register ssize_t
ssize_t
v;
- traits=GetPixelChannelTraits(image,i);
+ traits=GetPixelChannelTraits(image,(PixelChannel) i);
if (traits == UndefinedPixelTrait)
continue;
- if (((traits & CopyPixelTrait) != 0) || (GetPixelMask(image,p) != 0))
+ if (((traits & CopyPixelTrait) != 0) ||
+ (GetPixelReadMask(image,p+center) == 0))
continue;
pixels=p;
- pixel=(double) q[i];
+ pixel=(double) QuantumRange;
switch (method)
{
case DistanceMorphology:
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
if ((pixels[i]+(*k)) < pixel)
pixel=(double) pixels[i]+(*k);
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=width*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
k=(&kernel->values[kernel->width*(kernel->y+1)-1]);
pixels=q-offset.x*GetPixelChannels(image);
for (u=0; u < offset.x; u++)
{
- if ((IsNaN(*k) == MagickFalse) && ((x+u-offset.x) >= 0))
+ if ((IfNaN(*k) == MagickFalse) && ((x+u-offset.x) >= 0))
{
if ((pixels[i]+(*k)) < pixel)
pixel=(double) pixels[i]+(*k);
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
if ((pixels[i]+(*k)) < pixel)
pixel=(double) pixels[i]+(*k);
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=width*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
k=(&kernel->values[kernel->width*(kernel->y+1)-1]);
pixels=q-offset.x*GetPixelChannels(image);
for (u=0; u < offset.x; u++)
{
- if ((IsNaN(*k) == MagickFalse) && ((x+u-offset.x) >= 0))
+ if ((IfNaN(*k) == MagickFalse) && ((x+u-offset.x) >= 0))
{
if ((pixels[i]+(*k)) < pixel)
pixel=(double) pixels[i]+(*k);
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_MorphologyImage)
-#endif
proceed=SetImageProgress(image,MorphologyTag,progress++,2*image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
register ssize_t
x;
+ ssize_t
+ center;
+
/*
Read virtual pixels, and authentic pixels, from the same image. We
read using virtual to get virtual pixel handling, but write back
Only the bottom half of the kernel is processed as we up the image.
*/
if (status == MagickFalse)
- break;
+ continue;
p=GetCacheViewVirtualPixels(image_view,-offset.x,y,width,(size_t)
kernel->y+1,exception);
q=GetCacheViewAuthenticPixels(morphology_view,0,y,image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- status=MagickFalse;
- if (status == MagickFalse)
- break;
+ {
+ status=MagickFalse;
+ continue;
+ }
p+=(image->columns-1)*GetPixelChannels(image);
q+=(image->columns-1)*GetPixelChannels(image);
+ center=(ssize_t) (offset.x*GetPixelChannels(image));
for (x=(ssize_t) image->columns-1; x >= 0; x--)
{
register ssize_t
ssize_t
v;
- traits=GetPixelChannelTraits(image,i);
+ traits=GetPixelChannelTraits(image,(PixelChannel) i);
if (traits == UndefinedPixelTrait)
continue;
- if (((traits & CopyPixelTrait) != 0) || (GetPixelMask(image,p) != 0))
+ if (((traits & CopyPixelTrait) != 0) ||
+ (GetPixelReadMask(image,p+center) == 0))
continue;
pixels=p;
- pixel=(double) q[i];
+ pixel=(double) QuantumRange;
switch (method)
{
case DistanceMorphology:
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
if ((pixels[i]+(*k)) < pixel)
pixel=(double) pixels[i]+(*k);
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=width*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
k=(&kernel->values[kernel->width*kernel->y+kernel->x-1]);
pixels=q-offset.x*GetPixelChannels(image);
for (u=offset.x+1; u < (ssize_t) kernel->width; u++)
{
- if ((IsNaN(*k) == MagickFalse) &&
+ if ((IfNaN(*k) == MagickFalse) &&
((x+u-offset.x) < (ssize_t) image->columns))
{
if ((pixels[i]+(*k)) < pixel)
{
for (u=0; u < (ssize_t) kernel->width; u++)
{
- if (IsNaN(*k) == MagickFalse)
+ if (IfNaN(*k) == MagickFalse)
{
if ((pixels[i]+(*k)) < pixel)
pixel=(double) pixels[i]+(*k);
k--;
pixels+=GetPixelChannels(image);
}
- pixels+=width*GetPixelChannels(image);
+ pixels+=(image->columns-1)*GetPixelChannels(image);
}
k=(&kernel->values[kernel->width*(kernel->y+1)-1]);
pixels=q-offset.x*GetPixelChannels(image);
for (u=offset.x+1; u < (ssize_t) kernel->width; u++)
{
- if ((IsNaN(*k) == MagickFalse) &&
+ if ((IfNaN(*k) == MagickFalse) &&
((x+u-offset.x) < (ssize_t) image->columns))
{
if ((pixels[i]+(*k)) < pixel)
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_MorphologyImage)
-#endif
proceed=SetImageProgress(image,MorphologyTag,progress++,2*image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
changed; /* number pixels changed by last primitive operation */
char
- v_info[80];
+ v_info[MaxTextExtent];
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if ( iterations < 0 ) /* negative interations = infinite (well alomst) */
kernel_limit = image->columns>image->rows ? image->columns : image->rows;
- verbose = IsStringTrue(GetImageArtifact(image,"verbose"));
+ verbose = IsStringTrue(GetImageArtifact(image,"debug"));
/* initialise for cleanup */
curr_image = (Image *) image;
/* Apply special methods with special requirments
** For example, single run only, or post-processing requirements
*/
- if ( special == MagickTrue )
+ if ( special != MagickFalse )
{
rslt_image=CloneImage(image,0,0,MagickTrue,exception);
if (rslt_image == (Image *) NULL)
if (SetImageStorageClass(rslt_image,DirectClass,exception) == MagickFalse)
goto error_cleanup;
- changed = MorphologyPrimitiveDirect(rslt_image, method,
- kernel, exception);
+ changed=MorphologyPrimitiveDirect(rslt_image,method,kernel,exception);
if ( IfMagickTrue(verbose) )
(void) (void) FormatLocaleFile(stderr,
goto error_cleanup;
if ( method == VoronoiMorphology ) {
- /* Preserve the alpha channel of input image - but turned off */
+ /* Preserve the alpha channel of input image - but turned it off */
(void) SetImageAlphaChannel(rslt_image, DeactivateAlphaChannel,
exception);
(void) CompositeImage(rslt_image,image,CopyAlphaCompositeOp,
goto error_cleanup;
if (SetImageStorageClass(work_image,DirectClass,exception) == MagickFalse)
goto error_cleanup;
- /* work_image->type=image->type; ??? */
}
/* APPLY THE MORPHOLOGICAL PRIMITIVE (curr -> work) */
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MorphologyImage() applies a user supplied kernel to the image
-% according to the given mophology method.
+% MorphologyImage() applies a user supplied kernel to the image according to
+% the given mophology method.
%
% This function applies any and all user defined settings before calling
% the above internal function MorphologyApply().
* Basically all that is needed is a reversal of the kernel data!
* And a reflection of the origon
*/
- double
+ MagickRealType
t;
register MagickRealType
%
*/
MagickExport void ScaleGeometryKernelInfo (KernelInfo *kernel,
- const char *geometry)
+ const char *geometry)
{
MagickStatusType
flags;
MagickExport void ScaleKernelInfo(KernelInfo *kernel,
const double scaling_factor,const GeometryFlags normalize_flags)
{
- register ssize_t
- i;
-
register double
pos_scale,
neg_scale;
+ register ssize_t
+ i;
+
/* do the other kernels in a multi-kernel list first */
if ( kernel->next != (KernelInfo *) NULL)
ScaleKernelInfo(kernel->next, scaling_factor, normalize_flags);
neg_scale = scaling_factor/neg_scale;
for (i=0; i < (ssize_t) (kernel->width*kernel->height); i++)
- if ( ! IsNaN(kernel->values[i]) )
+ if ( ! IfNaN(kernel->values[i]) )
kernel->values[i] *= (kernel->values[i] >= 0) ? pos_scale : neg_scale;
/* convolution output range */
for (i=v=0; v < k->height; v++) {
(void) FormatLocaleFile(stderr, "%2lu:", (unsigned long) v );
for (u=0; u < k->width; u++, i++)
- if ( IsNaN(k->values[i]) )
+ if ( IfNaN(k->values[i]) )
(void) FormatLocaleFile(stderr," %*s", GetMagickPrecision()+3, "nan");
else
(void) FormatLocaleFile(stderr," %*.*lg", GetMagickPrecision()+3,
ZeroKernelNans(kernel->next);
for (i=0; i < (kernel->width*kernel->height); i++)
- if ( IsNaN(kernel->values[i]) )
+ if ( IfNaN(kernel->values[i]) )
kernel->values[i] = 0.0;
return;