% July 1992 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2012 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 %
/*
Typdef declarations.
*/
-typedef struct _RealPixelPacket
+typedef struct _RealPixelInfo
{
MagickRealType
red,
green,
blue,
alpha;
-} RealPixelPacket;
+} RealPixelInfo;
typedef struct _NodeInfo
{
MagickSizeType
number_unique;
- RealPixelPacket
+ RealPixelInfo
total_color;
MagickRealType
MagickSizeType
transparent_pixels;
- RealPixelPacket
+ RealPixelInfo
target;
MagickRealType
ssize_t
*cache;
- RealPixelPacket
+ RealPixelInfo
error[ErrorQueueLength];
MagickRealType
*GetNodeInfo(CubeInfo *,const size_t,const size_t,NodeInfo *);
static MagickBooleanType
- AssignImageColors(Image *,CubeInfo *),
+ AssignImageColors(Image *,CubeInfo *,ExceptionInfo *),
ClassifyImageColors(CubeInfo *,const Image *,ExceptionInfo *),
- DitherImage(Image *,CubeInfo *),
- SetGrayscaleImage(Image *);
+ DitherImage(Image *,CubeInfo *,ExceptionInfo *),
+ SetGrayscaleImage(Image *,ExceptionInfo *);
static size_t
DefineImageColormap(Image *,CubeInfo *,NodeInfo *);
*/
static inline void AssociateAlphaPixel(const Image *image,
- const CubeInfo *cube_info,const Quantum *pixel,RealPixelPacket *alpha_pixel)
+ const CubeInfo *cube_info,const Quantum *pixel,RealPixelInfo *alpha_pixel)
{
MagickRealType
alpha;
alpha_pixel->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
}
-static inline void AssociateAlphaPixelPacket(const Image *image,
- const CubeInfo *cube_info,const PixelPacket *pixel,
- RealPixelPacket *alpha_pixel)
+static inline void AssociateAlphaPixelInfo(const Image *image,
+ const CubeInfo *cube_info,const PixelInfo *pixel,
+ RealPixelInfo *alpha_pixel)
{
MagickRealType
alpha;
}
static inline size_t ColorToNodeId(const CubeInfo *cube_info,
- const RealPixelPacket *pixel,size_t index)
+ const RealPixelInfo *pixel,size_t index)
{
size_t
id;
return(id);
}
-static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info)
+static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info,
+ ExceptionInfo *exception)
{
#define AssignImageTag "Assign/Image"
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
(void) TransformImageColorspace((Image *) image,
- cube_info->quantize_info->colorspace);
+ cube_info->quantize_info->colorspace,exception);
else
if ((image->colorspace != GRAYColorspace) &&
- (IsRGBColorspace(image->colorspace) == MagickFalse) &&
+ (IssRGBColorspace(image->colorspace) == MagickFalse) &&
(image->colorspace != CMYColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
- if (AcquireImageColormap(image,cube_info->colors) == MagickFalse)
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
+ if (AcquireImageColormap(image,cube_info->colors,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
image->colors=0;
*/
if ((cube_info->quantize_info->dither != MagickFalse) &&
(cube_info->quantize_info->dither_method != NoDitherMethod))
- (void) DitherImage(image,cube_info);
+ (void) DitherImage(image,cube_info,exception);
else
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
status=MagickTrue;
- exception=(&image->exception);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(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)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
cube=(*cube_info);
for (x=0; x < (ssize_t) image->columns; x+=count)
{
- RealPixelPacket
+ RealPixelInfo
pixel;
register const NodeInfo
*/
for (count=1; (x+count) < (ssize_t) image->columns; count++)
{
- PixelPacket
+ PixelInfo
packet;
- GetPixelPacket(image,q+count*GetPixelChannels(image),&packet);
+ GetPixelInfoPixel(image,q+count*GetPixelChannels(image),&packet);
if (IsPixelEquivalent(image,q,&packet) == MagickFalse)
break;
}
SetPixelIndex(image,(Quantum) index,q);
if (cube.quantize_info->measure_error == MagickFalse)
{
- SetPixelRed(image,image->colormap[index].red,q);
- SetPixelGreen(image,image->colormap[index].green,q);
- SetPixelBlue(image,image->colormap[index].blue,q);
+ SetPixelRed(image,ClampToQuantum(
+ image->colormap[index].red),q);
+ SetPixelGreen(image,ClampToQuantum(
+ image->colormap[index].green),q);
+ SetPixelBlue(image,ClampToQuantum(
+ image->colormap[index].blue),q);
if (cube.associate_alpha != MagickFalse)
- SetPixelAlpha(image,image->colormap[index].alpha,q);
+ SetPixelAlpha(image,ClampToQuantum(
+ image->colormap[index].alpha),q);
}
q+=GetPixelChannels(image);
}
image_view=DestroyCacheView(image_view);
}
if (cube_info->quantize_info->measure_error != MagickFalse)
- (void) GetImageQuantizeError(image);
+ (void) GetImageQuantizeError(image,exception);
if ((cube_info->quantize_info->number_colors == 2) &&
(cube_info->quantize_info->colorspace == GRAYColorspace))
{
- Quantum
+ double
intensity;
- register PixelPacket
+ register PixelInfo
*restrict q;
register ssize_t
q=image->colormap;
for (i=0; i < (ssize_t) image->colors; i++)
{
- intensity=(Quantum) ((MagickRealType) GetPixelPacketIntensity(q) <
+ intensity=(double) ((MagickRealType) GetPixelInfoIntensity(q) <
((MagickRealType) QuantumRange/2.0) ? 0 : QuantumRange);
q->red=intensity;
q->green=intensity;
q++;
}
}
- (void) SyncImage(image);
+ (void) SyncImage(image,exception);
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
return(MagickTrue);
}
\f
NodeInfo
*node_info;
- RealPixelPacket
+ RealPixelInfo
error,
mid,
midpoint,
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
(void) TransformImageColorspace((Image *) image,
- cube_info->quantize_info->colorspace);
+ cube_info->quantize_info->colorspace,exception);
else
if ((image->colorspace != GRAYColorspace) &&
(image->colorspace != CMYColorspace) &&
- (IsRGBColorspace(image->colorspace) == MagickFalse))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
+ (IssRGBColorspace(image->colorspace) == MagickFalse))
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
midpoint.red=(MagickRealType) QuantumRange/2.0;
midpoint.green=(MagickRealType) QuantumRange/2.0;
midpoint.blue=(MagickRealType) QuantumRange/2.0;
midpoint.alpha=(MagickRealType) QuantumRange/2.0;
error.alpha=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*/
for (count=1; (x+(ssize_t) count) < (ssize_t) image->columns; count++)
{
- PixelPacket
+ PixelInfo
packet;
- GetPixelPacket(image,p+count*GetPixelChannels(image),&packet);
+ GetPixelInfoPixel(image,p+count*GetPixelChannels(image),&packet);
if (IsPixelEquivalent(image,p,&packet) == MagickFalse)
break;
}
node_info->child[id]=GetNodeInfo(cube_info,id,level,node_info);
if (node_info->child[id] == (NodeInfo *) NULL)
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",
+ ResourceLimitError,"MemoryAllocationFailed","'%s'",
image->filename);
if (level == MaxTreeDepth)
cube_info->colors++;
*/
for (count=1; (x+(ssize_t) count) < (ssize_t) image->columns; count++)
{
- PixelPacket
+ PixelInfo
packet;
- GetPixelPacket(image,p+count*GetPixelChannels(image),&packet);
+ GetPixelInfoPixel(image,p+count*GetPixelChannels(image),&packet);
if (IsPixelEquivalent(image,p,&packet) == MagickFalse)
break;
}
image_view=DestroyCacheView(image_view);
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
return(MagickTrue);
}
\f
beta,
distance;
- register PixelPacket
+ register PixelInfo
*restrict p;
- register RealPixelPacket
+ register RealPixelInfo
*restrict q;
/*
%
% The format of the CompressImageColormap method is:
%
-% MagickBooleanType CompressImageColormap(Image *image)
+% MagickBooleanType CompressImageColormap(Image *image,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType CompressImageColormap(Image *image)
+MagickExport MagickBooleanType CompressImageColormap(Image *image,
+ ExceptionInfo *exception)
{
QuantizeInfo
quantize_info;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- if (IsPaletteImage(image,&image->exception) == MagickFalse)
+ if (IsPaletteImage(image,exception) == MagickFalse)
return(MagickFalse);
GetQuantizeInfo(&quantize_info);
quantize_info.number_colors=image->colors;
quantize_info.tree_depth=MaxTreeDepth;
- return(QuantizeImage(&quantize_info,image));
+ return(QuantizeImage(&quantize_info,image,exception));
}
\f
/*
register MagickRealType
alpha;
- register PixelPacket
+ register PixelInfo
*restrict q;
/*
alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
if (cube_info->associate_alpha == MagickFalse)
{
- q->red=ClampToQuantum((MagickRealType)
+ q->red=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
+ q->green=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.blue));
+ q->blue=(double) ClampToQuantum((MagickRealType)
+ (alpha*(double) QuantumRange*node_info->total_color.blue));
q->alpha=OpaqueAlpha;
}
else
opacity=(MagickRealType) (alpha*QuantumRange*
node_info->total_color.alpha);
- q->alpha=ClampToQuantum(opacity);
+ q->alpha=(double) ClampToQuantum(opacity);
if (q->alpha == OpaqueAlpha)
{
- q->red=ClampToQuantum((MagickRealType)
+ q->red=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
+ q->green=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
+ q->blue=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.blue));
}
else
gamma=(MagickRealType) (QuantumScale*q->alpha);
gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
- q->red=ClampToQuantum((MagickRealType)
+ q->red=(double) ClampToQuantum((MagickRealType)
(alpha*gamma*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
+ q->green=(double) ClampToQuantum((MagickRealType)
(alpha*gamma*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
+ q->blue=(double) ClampToQuantum((MagickRealType)
(alpha*gamma*QuantumRange*node_info->total_color.blue));
if (node_info->number_unique > cube_info->transparent_pixels)
{
%
% The format of the DitherImage method is:
%
-% MagickBooleanType DitherImage(Image *image,CubeInfo *cube_info)
+% MagickBooleanType DitherImage(Image *image,CubeInfo *cube_info,
+% ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o cube_info: A pointer to the Cube structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static RealPixelPacket **DestroyPixelThreadSet(RealPixelPacket **pixels)
+static RealPixelInfo **DestroyPixelThreadSet(RealPixelInfo **pixels)
{
register ssize_t
i;
- assert(pixels != (RealPixelPacket **) NULL);
+ assert(pixels != (RealPixelInfo **) NULL);
for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
- if (pixels[i] != (RealPixelPacket *) NULL)
- pixels[i]=(RealPixelPacket *) RelinquishMagickMemory(pixels[i]);
- pixels=(RealPixelPacket **) RelinquishMagickMemory(pixels);
+ if (pixels[i] != (RealPixelInfo *) NULL)
+ pixels[i]=(RealPixelInfo *) RelinquishMagickMemory(pixels[i]);
+ pixels=(RealPixelInfo **) RelinquishMagickMemory(pixels);
return(pixels);
}
-static RealPixelPacket **AcquirePixelThreadSet(const size_t count)
+static RealPixelInfo **AcquirePixelThreadSet(const size_t count)
{
- RealPixelPacket
+ RealPixelInfo
**pixels;
register ssize_t
number_threads;
number_threads=GetOpenMPMaximumThreads();
- pixels=(RealPixelPacket **) AcquireQuantumMemory(number_threads,
+ pixels=(RealPixelInfo **) AcquireQuantumMemory(number_threads,
sizeof(*pixels));
- if (pixels == (RealPixelPacket **) NULL)
- return((RealPixelPacket **) NULL);
+ if (pixels == (RealPixelInfo **) NULL)
+ return((RealPixelInfo **) NULL);
(void) ResetMagickMemory(pixels,0,number_threads*sizeof(*pixels));
for (i=0; i < (ssize_t) number_threads; i++)
{
- pixels[i]=(RealPixelPacket *) AcquireQuantumMemory(count,
+ pixels[i]=(RealPixelInfo *) AcquireQuantumMemory(count,
2*sizeof(**pixels));
- if (pixels[i] == (RealPixelPacket *) NULL)
+ if (pixels[i] == (RealPixelInfo *) NULL)
return(DestroyPixelThreadSet(pixels));
}
return(pixels);
}
static inline ssize_t CacheOffset(CubeInfo *cube_info,
- const RealPixelPacket *pixel)
+ const RealPixelInfo *pixel)
{
#define RedShift(pixel) (((pixel) >> CacheShift) << (0*(8-CacheShift)))
#define GreenShift(pixel) (((pixel) >> CacheShift) << (1*(8-CacheShift)))
return(offset);
}
-static MagickBooleanType FloydSteinbergDither(Image *image,CubeInfo *cube_info)
+static MagickBooleanType FloydSteinbergDither(Image *image,CubeInfo *cube_info,
+ ExceptionInfo *exception)
{
#define DitherImageTag "Dither/Image"
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
- RealPixelPacket
+ RealPixelInfo
**pixels;
ssize_t
Distribute quantization error using Floyd-Steinberg.
*/
pixels=AcquirePixelThreadSet(image->columns);
- if (pixels == (RealPixelPacket **) NULL)
+ if (pixels == (RealPixelInfo **) NULL)
return(MagickFalse);
- exception=(&image->exception);
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
const int
CubeInfo
cube;
- RealPixelPacket
+ RealPixelInfo
*current,
*previous;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
v=(ssize_t) ((y & 0x01) != 0 ? -1 : 1);
for (x=0; x < (ssize_t) image->columns; x++)
{
- RealPixelPacket
+ RealPixelInfo
color,
pixel;
SetPixelIndex(image,(Quantum) index,q);
if (cube.quantize_info->measure_error == MagickFalse)
{
- SetPixelRed(image,image->colormap[index].red,q);
- SetPixelGreen(image,image->colormap[index].green,q);
- SetPixelBlue(image,image->colormap[index].blue,q);
+ SetPixelRed(image,ClampToQuantum(image->colormap[index].red),q);
+ SetPixelGreen(image,ClampToQuantum(image->colormap[index].green),q);
+ SetPixelBlue(image,ClampToQuantum(image->colormap[index].blue),q);
if (cube.associate_alpha != MagickFalse)
- SetPixelAlpha(image,image->colormap[index].alpha,q);
+ SetPixelAlpha(image,ClampToQuantum(image->colormap[index].alpha),q);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
/*
Store the error.
*/
- AssociateAlphaPixelPacket(image,&cube,image->colormap+index,&color);
+ AssociateAlphaPixelInfo(image,&cube,image->colormap+index,&color);
current[u].red=pixel.red-color.red;
current[u].green=pixel.green-color.green;
current[u].blue=pixel.blue-color.blue;
}
static MagickBooleanType
- RiemersmaDither(Image *,CacheView *,CubeInfo *,const unsigned int);
+ RiemersmaDither(Image *,CacheView *,CubeInfo *,const unsigned int,
+ ExceptionInfo *exception);
static void Riemersma(Image *image,CacheView *image_view,CubeInfo *cube_info,
- const size_t level,const unsigned int direction)
+ const size_t level,const unsigned int direction,ExceptionInfo *exception)
{
if (level == 1)
switch (direction)
{
case WestGravity:
{
- (void) RiemersmaDither(image,image_view,cube_info,EastGravity);
- (void) RiemersmaDither(image,image_view,cube_info,SouthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,WestGravity);
+ (void) RiemersmaDither(image,image_view,cube_info,EastGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,SouthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,WestGravity,
+ exception);
break;
}
case EastGravity:
{
- (void) RiemersmaDither(image,image_view,cube_info,WestGravity);
- (void) RiemersmaDither(image,image_view,cube_info,NorthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,EastGravity);
+ (void) RiemersmaDither(image,image_view,cube_info,WestGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,NorthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,EastGravity,
+ exception);
break;
}
case NorthGravity:
{
- (void) RiemersmaDither(image,image_view,cube_info,SouthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,EastGravity);
- (void) RiemersmaDither(image,image_view,cube_info,NorthGravity);
+ (void) RiemersmaDither(image,image_view,cube_info,SouthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,EastGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,NorthGravity,
+ exception);
break;
}
case SouthGravity:
{
- (void) RiemersmaDither(image,image_view,cube_info,NorthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,WestGravity);
- (void) RiemersmaDither(image,image_view,cube_info,SouthGravity);
+ (void) RiemersmaDither(image,image_view,cube_info,NorthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,WestGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,SouthGravity,
+ exception);
break;
}
default:
{
case WestGravity:
{
- Riemersma(image,image_view,cube_info,level-1,NorthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,EastGravity);
- Riemersma(image,image_view,cube_info,level-1,WestGravity);
- (void) RiemersmaDither(image,image_view,cube_info,SouthGravity);
- Riemersma(image,image_view,cube_info,level-1,WestGravity);
- (void) RiemersmaDither(image,image_view,cube_info,WestGravity);
- Riemersma(image,image_view,cube_info,level-1,SouthGravity);
+ Riemersma(image,image_view,cube_info,level-1,NorthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,EastGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,WestGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,SouthGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,WestGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,WestGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,SouthGravity,
+ exception);
break;
}
case EastGravity:
{
- Riemersma(image,image_view,cube_info,level-1,SouthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,WestGravity);
- Riemersma(image,image_view,cube_info,level-1,EastGravity);
- (void) RiemersmaDither(image,image_view,cube_info,NorthGravity);
- Riemersma(image,image_view,cube_info,level-1,EastGravity);
- (void) RiemersmaDither(image,image_view,cube_info,EastGravity);
- Riemersma(image,image_view,cube_info,level-1,NorthGravity);
+ Riemersma(image,image_view,cube_info,level-1,SouthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,WestGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,EastGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,NorthGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,EastGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,EastGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,NorthGravity,
+ exception);
break;
}
case NorthGravity:
{
- Riemersma(image,image_view,cube_info,level-1,WestGravity);
- (void) RiemersmaDither(image,image_view,cube_info,SouthGravity);
- Riemersma(image,image_view,cube_info,level-1,NorthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,EastGravity);
- Riemersma(image,image_view,cube_info,level-1,NorthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,NorthGravity);
- Riemersma(image,image_view,cube_info,level-1,EastGravity);
+ Riemersma(image,image_view,cube_info,level-1,WestGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,SouthGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,NorthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,EastGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,NorthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,NorthGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,EastGravity,
+ exception);
break;
}
case SouthGravity:
{
- Riemersma(image,image_view,cube_info,level-1,EastGravity);
- (void) RiemersmaDither(image,image_view,cube_info,NorthGravity);
- Riemersma(image,image_view,cube_info,level-1,SouthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,WestGravity);
- Riemersma(image,image_view,cube_info,level-1,SouthGravity);
- (void) RiemersmaDither(image,image_view,cube_info,SouthGravity);
- Riemersma(image,image_view,cube_info,level-1,WestGravity);
+ Riemersma(image,image_view,cube_info,level-1,EastGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,NorthGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,SouthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,WestGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,SouthGravity,
+ exception);
+ (void) RiemersmaDither(image,image_view,cube_info,SouthGravity,
+ exception);
+ Riemersma(image,image_view,cube_info,level-1,WestGravity,
+ exception);
break;
}
default:
}
static MagickBooleanType RiemersmaDither(Image *image,CacheView *image_view,
- CubeInfo *cube_info,const unsigned int direction)
+ CubeInfo *cube_info,const unsigned int direction,ExceptionInfo *exception)
{
#define DitherImageTag "Dither/Image"
MagickBooleanType
proceed;
- RealPixelPacket
+ RealPixelInfo
color,
pixel;
if ((p->x >= 0) && (p->x < (ssize_t) image->columns) &&
(p->y >= 0) && (p->y < (ssize_t) image->rows))
{
- ExceptionInfo
- *exception;
-
register Quantum
*restrict q;
/*
Distribute error.
*/
- exception=(&image->exception);
q=GetCacheViewAuthenticPixels(image_view,p->x,p->y,1,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
return(MagickFalse);
AssociateAlphaPixel(image,cube_info,q,&pixel);
for (i=0; i < ErrorQueueLength; i++)
SetPixelIndex(image,(Quantum) index,q);
if (cube_info->quantize_info->measure_error == MagickFalse)
{
- SetPixelRed(image,image->colormap[index].red,q);
- SetPixelGreen(image,image->colormap[index].green,q);
- SetPixelBlue(image,image->colormap[index].blue,q);
+ SetPixelRed(image,ClampToQuantum(image->colormap[index].red),q);
+ SetPixelGreen(image,ClampToQuantum(image->colormap[index].green),q);
+ SetPixelBlue(image,ClampToQuantum(image->colormap[index].blue),q);
if (cube_info->associate_alpha != MagickFalse)
- SetPixelAlpha(image,image->colormap[index].alpha,q);
+ SetPixelAlpha(image,ClampToQuantum(image->colormap[index].alpha),q);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
return(MagickFalse);
*/
(void) CopyMagickMemory(p->error,p->error+1,(ErrorQueueLength-1)*
sizeof(p->error[0]));
- AssociateAlphaPixelPacket(image,cube_info,image->colormap+index,&color);
+ AssociateAlphaPixelInfo(image,cube_info,image->colormap+index,&color);
p->error[ErrorQueueLength-1].red=pixel.red-color.red;
p->error[ErrorQueueLength-1].green=pixel.green-color.green;
p->error[ErrorQueueLength-1].blue=pixel.blue-color.blue;
return(y);
}
-static MagickBooleanType DitherImage(Image *image,CubeInfo *cube_info)
+static MagickBooleanType DitherImage(Image *image,CubeInfo *cube_info,
+ ExceptionInfo *exception)
{
CacheView
*image_view;
depth;
if (cube_info->quantize_info->dither_method != RiemersmaDitherMethod)
- return(FloydSteinbergDither(image,cube_info));
+ return(FloydSteinbergDither(image,cube_info,exception));
/*
Distribute quantization error along a Hilbert curve.
*/
depth++;
cube_info->offset=0;
cube_info->span=(MagickSizeType) image->columns*image->rows;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
if (depth > 1)
- Riemersma(image,image_view,cube_info,depth-1,NorthGravity);
- status=RiemersmaDither(image,image_view,cube_info,ForgetGravity);
+ Riemersma(image,image_view,cube_info,depth-1,NorthGravity,exception);
+ status=RiemersmaDither(image,image_view,cube_info,ForgetGravity,exception);
image_view=DestroyCacheView(image_view);
return(status);
}
%
% The format of the GetImageQuantizeError method is:
%
-% MagickBooleanType GetImageQuantizeError(Image *image)
+% MagickBooleanType GetImageQuantizeError(Image *image,
+% ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType GetImageQuantizeError(Image *image)
+MagickExport MagickBooleanType GetImageQuantizeError(Image *image,
+ ExceptionInfo *exception)
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickRealType
alpha,
area,
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- image->total_colors=GetNumberColors(image,(FILE *) NULL,&image->exception);
+ image->total_colors=GetNumberColors(image,(FILE *) NULL,exception);
(void) ResetMagickMemory(&image->error,0,sizeof(image->error));
if (image->storage_class == DirectClass)
return(MagickTrue);
maximum_error=0.0;
mean_error_per_pixel=0.0;
mean_error=0.0;
- exception=(&image->exception);
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
% %
% %
% %
-% P o s t e r i z e I m a g e C h a n n e l %
+% P o s t e r i z e I m a g e %
% %
% %
% %
% The format of the PosterizeImage method is:
%
% MagickBooleanType PosterizeImage(Image *image,const size_t levels,
-% const MagickBooleanType dither)
+% const MagickBooleanType dither,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o dither: Set this integer value to something other than zero to dither
% the mapped image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline ssize_t MagickRound(MagickRealType x)
}
MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
- const MagickBooleanType dither)
+ const MagickBooleanType dither,ExceptionInfo *exception)
{
#define PosterizeImageTag "Posterize/Image"
#define PosterizePixel(pixel) (Quantum) (QuantumRange*(MagickRound( \
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (image->storage_class == PseudoClass)
#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)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
Posterize colormap.
*/
if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].red=PosterizePixel(image->colormap[i].red);
+ image->colormap[i].red=(double)
+ PosterizePixel(image->colormap[i].red);
if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].green=PosterizePixel(image->colormap[i].green);
+ image->colormap[i].green=(double)
+ PosterizePixel(image->colormap[i].green);
if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].blue=PosterizePixel(image->colormap[i].blue);
+ image->colormap[i].blue=(double)
+ PosterizePixel(image->colormap[i].blue);
if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].alpha=PosterizePixel(image->colormap[i].alpha);
+ image->colormap[i].alpha=(double)
+ PosterizePixel(image->colormap[i].alpha);
}
/*
Posterize image.
*/
status=MagickTrue;
progress=0;
- exception=(&image->exception);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(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)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
levels,MaxColormapSize+1);
quantize_info->dither=dither;
quantize_info->tree_depth=MaxTreeDepth;
- status=QuantizeImage(quantize_info,image);
+ status=QuantizeImage(quantize_info,image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
return(status);
}
% The format of the QuantizeImage method is:
%
% MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
+
+static MagickBooleanType DirectToColormapImage(Image *image,
+ ExceptionInfo *exception)
+{
+ CacheView
+ *image_view;
+
+ MagickBooleanType
+ status;
+
+ register ssize_t
+ i;
+
+ size_t
+ number_colors;
+
+ ssize_t
+ y;
+
+ status=MagickTrue;
+ number_colors=(size_t) (image->columns*image->rows);
+ if (AcquireImageColormap(image,number_colors,exception) == MagickFalse)
+ ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
+ image->filename);
+ if (image->colors != number_colors)
+ return(MagickFalse);
+ i=0;
+ image_view=AcquireAuthenticCacheView(image,exception);
+ for (y=0; y < (ssize_t) image->rows; y++)
+ {
+ MagickBooleanType
+ proceed;
+
+ register Quantum
+ *restrict q;
+
+ register ssize_t
+ x;
+
+ q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ image->colormap[i].red=(double) GetPixelRed(image,q);
+ image->colormap[i].green=(double) GetPixelGreen(image,q);
+ image->colormap[i].blue=(double) GetPixelBlue(image,q);
+ image->colormap[i].alpha=(double) GetPixelAlpha(image,q);
+ SetPixelIndex(image,(Quantum) i,q);
+ i++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
+ break;
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) y,
+ image->rows);
+ if (proceed == MagickFalse)
+ status=MagickFalse;
+ }
+ image_view=DestroyCacheView(image_view);
+ return(status);
+}
+
MagickExport MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
maximum_colors=MaxColormapSize;
if (maximum_colors > MaxColormapSize)
maximum_colors=MaxColormapSize;
- if ((IsImageGray(image,&image->exception) != MagickFalse) &&
+ if ((image->columns*image->rows) <= maximum_colors)
+ (void) DirectToColormapImage(image,exception);
+ if ((IsImageGray(image,exception) != MagickFalse) &&
(image->matte == MagickFalse))
- (void) SetGrayscaleImage(image);
+ (void) SetGrayscaleImage(image,exception);
if ((image->storage_class == PseudoClass) &&
(image->colors <= maximum_colors))
return(MagickTrue);
if (cube_info == (CubeInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- status=ClassifyImageColors(cube_info,image,&image->exception);
+ status=ClassifyImageColors(cube_info,image,exception);
if (status != MagickFalse)
{
/*
Reduce the number of colors in the image.
*/
ReduceImageColors(image,cube_info);
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
}
DestroyCubeInfo(cube_info);
return(status);
% The format of the QuantizeImages method is:
%
% MagickBooleanType QuantizeImages(const QuantizeInfo *quantize_info,
-% Image *images)
+% Image *images,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o images: Specifies a pointer to a list of Image structures.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType QuantizeImages(const QuantizeInfo *quantize_info,
- Image *images)
+ Image *images,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
/*
Handle a single image with QuantizeImage.
*/
- status=QuantizeImage(quantize_info,images);
+ status=QuantizeImage(quantize_info,images,exception);
return(status);
}
status=MagickFalse;
cube_info=GetCubeInfo(quantize_info,depth,maximum_colors);
if (cube_info == (CubeInfo *) NULL)
{
- (void) ThrowMagickException(&images->exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ ResourceLimitError,"MemoryAllocationFailed","'%s'",images->filename);
return(MagickFalse);
}
number_images=GetImageListLength(images);
{
progress_monitor=SetImageProgressMonitor(image,(MagickProgressMonitor) NULL,
image->client_data);
- status=ClassifyImageColors(cube_info,image,&image->exception);
+ status=ClassifyImageColors(cube_info,image,exception);
if (status == MagickFalse)
break;
(void) SetImageProgressMonitor(image,progress_monitor,image->client_data);
{
progress_monitor=SetImageProgressMonitor(image,(MagickProgressMonitor)
NULL,image->client_data);
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
if (status == MagickFalse)
break;
(void) SetImageProgressMonitor(image,progress_monitor,
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% RemapImage() replaces the colors of an image with the closest color from
-% a reference image.
+% RemapImage() replaces the colors of an image with a dither of the colors
+% provided.
%
% The format of the RemapImage method is:
%
% MagickBooleanType RemapImage(const QuantizeInfo *quantize_info,
-% Image *image,const Image *remap_image)
+% Image *image,const Image *remap_image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o remap_image: the reference image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType RemapImage(const QuantizeInfo *quantize_info,
- Image *image,const Image *remap_image)
+ Image *image,const Image *remap_image,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
if (cube_info == (CubeInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- status=ClassifyImageColors(cube_info,remap_image,&image->exception);
+ status=ClassifyImageColors(cube_info,remap_image,exception);
if (status != MagickFalse)
{
/*
Classify image colors from the reference image.
*/
cube_info->quantize_info->number_colors=cube_info->colors;
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
}
DestroyCubeInfo(cube_info);
return(status);
% The format of the RemapImage method is:
%
% MagickBooleanType RemapImages(const QuantizeInfo *quantize_info,
-% Image *images,Image *remap_image)
+% Image *images,Image *remap_image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o remap_image: the reference image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType RemapImages(const QuantizeInfo *quantize_info,
- Image *images,const Image *remap_image)
+ Image *images,const Image *remap_image,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
/*
Create a global colormap for an image sequence.
*/
- status=QuantizeImages(quantize_info,images);
+ status=QuantizeImages(quantize_info,images,exception);
return(status);
}
/*
if (cube_info == (CubeInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- status=ClassifyImageColors(cube_info,remap_image,&image->exception);
+ status=ClassifyImageColors(cube_info,remap_image,exception);
if (status != MagickFalse)
{
/*
image=images;
for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
{
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
if (status == MagickFalse)
break;
}
%
% The format of the SetGrayscaleImage method is:
%
-% MagickBooleanType SetGrayscaleImage(Image *image)
+% MagickBooleanType SetGrayscaleImage(Image *image,ExceptionInfo *exeption)
%
% A description of each parameter follows:
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
#if defined(__cplusplus) || defined(c_plusplus)
static int IntensityCompare(const void *x,const void *y)
{
- PixelPacket
+ PixelInfo
*color_1,
*color_2;
ssize_t
intensity;
- color_1=(PixelPacket *) x;
- color_2=(PixelPacket *) y;
- intensity=GetPixelPacketIntensity(color_1)-(ssize_t)
- GetPixelPacketIntensity(color_2);
+ color_1=(PixelInfo *) x;
+ color_2=(PixelInfo *) y;
+ intensity=GetPixelInfoIntensity(color_1)-(ssize_t)
+ GetPixelInfoIntensity(color_2);
return((int) intensity);
}
}
#endif
-static MagickBooleanType SetGrayscaleImage(Image *image)
+static MagickBooleanType SetGrayscaleImage(Image *image,
+ ExceptionInfo *exception)
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
- PixelPacket
+ PixelInfo
*colormap;
register ssize_t
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->type != GrayscaleType)
- (void) TransformImageColorspace(image,GRAYColorspace);
+ (void) TransformImageColorspace(image,GRAYColorspace,exception);
colormap_index=(ssize_t *) AcquireQuantumMemory(MaxMap+1,
sizeof(*colormap_index));
if (colormap_index == (ssize_t *) NULL)
image->filename);
if (image->storage_class != PseudoClass)
{
- ExceptionInfo
- *exception;
-
for (i=0; i <= (ssize_t) MaxMap; i++)
colormap_index[i]=(-1);
- if (AcquireImageColormap(image,MaxMap+1) == MagickFalse)
+ if (AcquireImageColormap(image,MaxMap+1,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
image->colors=0;
status=MagickTrue;
- exception=(&image->exception);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(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)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
if (colormap_index[intensity] < 0)
{
colormap_index[intensity]=(ssize_t) image->colors;
- image->colormap[image->colors].red=GetPixelRed(image,q);
- image->colormap[image->colors].green=GetPixelGreen(image,q);
- image->colormap[image->colors].blue=GetPixelBlue(image,q);
+ image->colormap[image->colors].red=(double)
+ GetPixelRed(image,q);
+ image->colormap[image->colors].green=(double)
+ GetPixelGreen(image,q);
+ image->colormap[image->colors].blue=(double)
+ GetPixelBlue(image,q);
image->colors++;
}
}
image_view=DestroyCacheView(image_view);
}
for (i=0; i < (ssize_t) image->colors; i++)
- image->colormap[i].alpha=(unsigned short) i;
- qsort((void *) image->colormap,image->colors,sizeof(PixelPacket),
+ image->colormap[i].alpha=(double) i;
+ qsort((void *) image->colormap,image->colors,sizeof(PixelInfo),
IntensityCompare);
- colormap=(PixelPacket *) AcquireQuantumMemory(image->colors,
+ colormap=(PixelInfo *) AcquireQuantumMemory(image->colors,
sizeof(*colormap));
- if (colormap == (PixelPacket *) NULL)
+ if (colormap == (PixelInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
j=0;
colormap[j]=image->colormap[0];
for (i=0; i < (ssize_t) image->colors; i++)
{
- if (IsPixelPacketEquivalent(&colormap[j],&image->colormap[i]) == MagickFalse)
+ if (IsPixelInfoEquivalent(&colormap[j],&image->colormap[i]) == MagickFalse)
{
j++;
colormap[j]=image->colormap[i];
colormap_index[(ssize_t) image->colormap[i].alpha]=j;
}
image->colors=(size_t) (j+1);
- image->colormap=(PixelPacket *) RelinquishMagickMemory(image->colormap);
+ image->colormap=(PixelInfo *) RelinquishMagickMemory(image->colormap);
image->colormap=colormap;
status=MagickTrue;
- exception=(&image->exception);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(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)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
image_view=DestroyCacheView(image_view);
colormap_index=(ssize_t *) RelinquishMagickMemory(colormap_index);
image->type=GrayscaleType;
- if (IsImageMonochrome(image,&image->exception) != MagickFalse)
+ if (IsImageMonochrome(image,exception) != MagickFalse)
image->type=BilevelType;
return(status);
}