% MagickCore Methods to Reduce the Number of Unique Colors in an Image %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1992 %
% %
% %
-% Copyright 1999-2011 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 %
%
% The algorithm maps this domain onto a tree in which each node
% represents a cube within that domain. In the following discussion
-% these cubes are defined by the coordinate of two opposite vertices:
-% The vertex nearest the origin in RGB space and the vertex farthest from
-% the origin.
+% these cubes are defined by the coordinate of two opposite vertices (vertex
+% nearest the origin in RGB space and the vertex farthest from the origin).
%
% The tree's root node represents the entire domain, (0,0,0) through
% (Cmax,Cmax,Cmax). Each lower level in the tree is generated by
#include "MagickCore/monitor-private.h"
#include "MagickCore/option.h"
#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/pixel-private.h"
#include "MagickCore/quantize.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
+#include "MagickCore/resource_.h"
#include "MagickCore/string_.h"
#include "MagickCore/thread-private.h"
\f
*/
typedef struct _RealPixelInfo
{
- MagickRealType
+ double
red,
green,
blue,
RealPixelInfo
total_color;
- MagickRealType
+ double
quantize_error;
size_t
RealPixelInfo
target;
- MagickRealType
+ double
distance,
pruning_threshold,
next_threshold;
Nodes
*node_queue;
+ MemoryInfo
+ *memory_info;
+
ssize_t
*cache;
RealPixelInfo
error[ErrorQueueLength];
- MagickRealType
+ double
weights[ErrorQueueLength];
QuantizeInfo
static MagickBooleanType
AssignImageColors(Image *,CubeInfo *,ExceptionInfo *),
ClassifyImageColors(CubeInfo *,const Image *,ExceptionInfo *),
- DitherImage(Image *,CubeInfo *),
+ DitherImage(Image *,CubeInfo *,ExceptionInfo *),
SetGrayscaleImage(Image *,ExceptionInfo *);
static size_t
const char
*option;
- quantize_info->dither=image_info->dither;
+ quantize_info->dither_method=image_info->dither == MagickFalse ?
+ NoDitherMethod : RiemersmaDitherMethod;
option=GetImageOption(image_info,"dither");
if (option != (const char *) NULL)
quantize_info->dither_method=(DitherMethod) ParseCommandOption(
static inline void AssociateAlphaPixel(const Image *image,
const CubeInfo *cube_info,const Quantum *pixel,RealPixelInfo *alpha_pixel)
{
- MagickRealType
+ double
alpha;
if ((cube_info->associate_alpha == MagickFalse) ||
(GetPixelAlpha(image,pixel)== OpaqueAlpha))
{
- alpha_pixel->red=(MagickRealType) GetPixelRed(image,pixel);
- alpha_pixel->green=(MagickRealType) GetPixelGreen(image,pixel);
- alpha_pixel->blue=(MagickRealType) GetPixelBlue(image,pixel);
- alpha_pixel->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
+ alpha_pixel->red=(double) GetPixelRed(image,pixel);
+ alpha_pixel->green=(double) GetPixelGreen(image,pixel);
+ alpha_pixel->blue=(double) GetPixelBlue(image,pixel);
+ alpha_pixel->alpha=(double) GetPixelAlpha(image,pixel);
return;
}
- alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,pixel));
+ alpha=(double) (QuantumScale*GetPixelAlpha(image,pixel));
alpha_pixel->red=alpha*GetPixelRed(image,pixel);
alpha_pixel->green=alpha*GetPixelGreen(image,pixel);
alpha_pixel->blue=alpha*GetPixelBlue(image,pixel);
- alpha_pixel->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
+ alpha_pixel->alpha=(double) GetPixelAlpha(image,pixel);
}
-static inline void AssociateAlphaPixelInfo(const Image *image,
- const CubeInfo *cube_info,const PixelInfo *pixel,
- RealPixelInfo *alpha_pixel)
+static inline void AssociateAlphaPixelInfo(const CubeInfo *cube_info,
+ const PixelInfo *pixel,RealPixelInfo *alpha_pixel)
{
- MagickRealType
+ double
alpha;
if ((cube_info->associate_alpha == MagickFalse) ||
(pixel->alpha == OpaqueAlpha))
{
- alpha_pixel->red=(MagickRealType) pixel->red;
- alpha_pixel->green=(MagickRealType) pixel->green;
- alpha_pixel->blue=(MagickRealType) pixel->blue;
- alpha_pixel->alpha=(MagickRealType) pixel->alpha;
+ alpha_pixel->red=(double) pixel->red;
+ alpha_pixel->green=(double) pixel->green;
+ alpha_pixel->blue=(double) pixel->blue;
+ alpha_pixel->alpha=(double) pixel->alpha;
return;
}
- alpha=(MagickRealType) (QuantumScale*pixel->alpha);
+ alpha=(double) (QuantumScale*pixel->alpha);
alpha_pixel->red=alpha*pixel->red;
alpha_pixel->green=alpha*pixel->green;
alpha_pixel->blue=alpha*pixel->blue;
- alpha_pixel->alpha=(MagickRealType) pixel->alpha;
+ alpha_pixel->alpha=(double) pixel->alpha;
}
-static inline Quantum ClampToUnsignedQuantum(const MagickRealType value)
+static inline Quantum ClampPixel(const MagickRealType value)
{
- if (value <= 0.0)
- return((Quantum) 0);
- if (value >= QuantumRange)
+ if (value < 0.0f)
+ return(0);
+ if (value >= (MagickRealType) QuantumRange)
return((Quantum) QuantumRange);
- return((Quantum) (value+0.5));
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+ return((Quantum) (value+0.5f));
+#else
+ return(value);
+#endif
}
static inline size_t ColorToNodeId(const CubeInfo *cube_info,
size_t
id;
- id=(size_t) (((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->red)) >> index) & 0x01) |
- ((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->green)) >> index) & 0x01) << 1 |
- ((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->blue)) >> index) & 0x01) << 2);
+ id=(size_t) (((ScaleQuantumToChar(ClampPixel(pixel->red)) >> index) & 0x01) |
+ ((ScaleQuantumToChar(ClampPixel(pixel->green)) >> index) & 0x01) << 1 |
+ ((ScaleQuantumToChar(ClampPixel(pixel->blue)) >> index) & 0x01) << 2);
if (cube_info->associate_alpha != MagickFalse)
- id|=((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->alpha)) >> index) & 0x1) << 3;
+ id|=((ScaleQuantumToChar(ClampPixel(pixel->alpha)) >> index) & 0x1) << 3;
return(id);
}
(void) TransformImageColorspace((Image *) image,
cube_info->quantize_info->colorspace,exception);
else
- if ((image->colorspace != GRAYColorspace) &&
- (IsRGBColorspace(image->colorspace) == MagickFalse) &&
- (image->colorspace != CMYColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
if (AcquireImageColormap(image,cube_info->colors,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
/*
Create a reduced color image.
*/
- if ((cube_info->quantize_info->dither != MagickFalse) &&
+ if ((cube_info->quantize_info->dither_method != NoDitherMethod) &&
(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) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
Find closest color among siblings and their children.
*/
cube.target=pixel;
- cube.distance=(MagickRealType) (4.0*(QuantumRange+1.0)*
+ cube.distance=(double) (4.0*(QuantumRange+1.0)*
(QuantumRange+1.0)+1.0);
ClosestColor(image,&cube,node_info->parent);
index=cube.color_number;
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 PixelInfo
q=image->colormap;
for (i=0; i < (ssize_t) image->colors; i++)
{
- intensity=(Quantum) ((MagickRealType) GetPixelInfoIntensity(q) <
- ((MagickRealType) QuantumRange/2.0) ? 0 : QuantumRange);
+ intensity=(double) (GetPixelInfoLuma(q) < (QuantumRange/2.0) ? 0 :
+ QuantumRange);
q->red=intensity;
q->green=intensity;
q->blue=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,exception);
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
return(MagickTrue);
}
\f
MagickBooleanType
associate_alpha;
- associate_alpha=image->matte;
- if (cube_info->quantize_info->colorspace == TransparentColorspace)
- associate_alpha=MagickFalse;
+ associate_alpha=image->alpha_trait == BlendPixelTrait ? MagickTrue :
+ MagickFalse;
if ((cube_info->quantize_info->number_colors == 2) &&
(cube_info->quantize_info->colorspace == GRAYColorspace))
associate_alpha=MagickFalse;
MagickBooleanType
proceed;
- MagickRealType
+ double
bisect;
NodeInfo
(void) TransformImageColorspace((Image *) image,
cube_info->quantize_info->colorspace,exception);
else
- if ((image->colorspace != GRAYColorspace) &&
- (image->colorspace != CMYColorspace) &&
- (IsRGBColorspace(image->colorspace) == MagickFalse))
- (void) TransformImageColorspace((Image *) image,RGBColorspace,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;
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
+ midpoint.red=(double) QuantumRange/2.0;
+ midpoint.green=(double) QuantumRange/2.0;
+ midpoint.blue=(double) QuantumRange/2.0;
+ midpoint.alpha=(double) 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
}
AssociateAlphaPixel(image,cube_info,p,&pixel);
index=MaxTreeDepth-1;
- bisect=((MagickRealType) QuantumRange+1.0)/2.0;
+ bisect=((double) QuantumRange+1.0)/2.0;
mid=midpoint;
node_info=cube_info->root;
for (level=1; level <= MaxTreeDepth; level++)
*/
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'",
- image->filename);
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",
+ image->filename);
+ continue;
+ }
if (level == MaxTreeDepth)
cube_info->colors++;
}
error.blue=QuantumScale*(pixel.blue-mid.blue);
if (cube_info->associate_alpha != MagickFalse)
error.alpha=QuantumScale*(pixel.alpha-mid.alpha);
- node_info->quantize_error+=sqrt((double) (count*error.red*error.red+
- count*error.green*error.green+count*error.blue*error.blue+
- count*error.alpha*error.alpha));
+ node_info->quantize_error+=count*sqrt((double) (error.red*error.red+
+ error.green*error.green+error.blue*error.blue+
+ error.alpha*error.alpha));
cube_info->root->quantize_error+=node_info->quantize_error;
index--;
}
Sum RGB for this leaf for later derivation of the mean cube color.
*/
node_info->number_unique+=count;
- node_info->total_color.red+=count*QuantumScale*pixel.red;
- node_info->total_color.green+=count*QuantumScale*pixel.green;
- node_info->total_color.blue+=count*QuantumScale*pixel.blue;
+ node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
+ node_info->total_color.green+=count*QuantumScale*ClampPixel(pixel.green);
+ node_info->total_color.blue+=count*QuantumScale*ClampPixel(pixel.blue);
if (cube_info->associate_alpha != MagickFalse)
- node_info->total_color.alpha+=count*QuantumScale*pixel.alpha;
+ node_info->total_color.alpha+=count*QuantumScale*ClampPixel(
+ pixel.alpha);
p+=count*GetPixelChannels(image);
}
if (cube_info->colors > cube_info->maximum_colors)
}
AssociateAlphaPixel(image,cube_info,p,&pixel);
index=MaxTreeDepth-1;
- bisect=((MagickRealType) QuantumRange+1.0)/2.0;
+ bisect=((double) QuantumRange+1.0)/2.0;
mid=midpoint;
node_info=cube_info->root;
for (level=1; level <= cube_info->depth; level++)
*/
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",
- image->filename);
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ ResourceLimitError,"MemoryAllocationFailed","%s",
+ image->filename);
+ continue;
+ }
if (level == cube_info->depth)
cube_info->colors++;
}
error.blue=QuantumScale*(pixel.blue-mid.blue);
if (cube_info->associate_alpha != MagickFalse)
error.alpha=QuantumScale*(pixel.alpha-mid.alpha);
- node_info->quantize_error+=sqrt((double) (count*error.red*error.red+
- count*error.green*error.green+count*error.blue*error.blue+
- count*error.alpha*error.alpha));
+ node_info->quantize_error+=count*sqrt((double) (error.red*error.red+
+ error.green*error.green+error.blue*error.blue+
+ error.alpha*error.alpha));
cube_info->root->quantize_error+=node_info->quantize_error;
index--;
}
Sum RGB for this leaf for later derivation of the mean cube color.
*/
node_info->number_unique+=count;
- node_info->total_color.red+=count*QuantumScale*pixel.red;
- node_info->total_color.green+=count*QuantumScale*pixel.green;
- node_info->total_color.blue+=count*QuantumScale*pixel.blue;
+ node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
+ node_info->total_color.green+=count*QuantumScale*ClampPixel(pixel.green);
+ node_info->total_color.blue+=count*QuantumScale*ClampPixel(pixel.blue);
if (cube_info->associate_alpha != MagickFalse)
- node_info->total_color.alpha+=count*QuantumScale*pixel.alpha;
+ node_info->total_color.alpha+=count*QuantumScale*ClampPixel(
+ pixel.alpha);
p+=count*GetPixelChannels(image);
}
proceed=SetImageProgress(image,ClassifyImageTag,(MagickOffsetType) y,
image_view=DestroyCacheView(image_view);
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
- return(MagickTrue);
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
+ return(y < (ssize_t) image->rows ? MagickFalse : MagickTrue);
}
\f
/*
return(clone_info);
clone_info->number_colors=quantize_info->number_colors;
clone_info->tree_depth=quantize_info->tree_depth;
- clone_info->dither=quantize_info->dither;
clone_info->dither_method=quantize_info->dither_method;
clone_info->colorspace=quantize_info->colorspace;
clone_info->measure_error=quantize_info->measure_error;
ClosestColor(image,cube_info,node_info->child[i]);
if (node_info->number_unique != 0)
{
- MagickRealType
+ double
pixel;
- register MagickRealType
+ register double
alpha,
beta,
distance;
beta=1.0;
if (cube_info->associate_alpha != MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*p->alpha);
- beta=(MagickRealType) (QuantumScale*q->alpha);
+ alpha=(double) (QuantumScale*p->alpha);
+ beta=(double) (QuantumScale*q->alpha);
}
pixel=alpha*p->red-beta*q->red;
distance=pixel*pixel;
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;
(void) DefineImageColormap(image,cube_info,node_info->child[i]);
if (node_info->number_unique != 0)
{
- register MagickRealType
+ register double
alpha;
register PixelInfo
Colormap entry is defined by the mean color in this cube.
*/
q=image->colormap+image->colors;
- alpha=(MagickRealType) ((MagickOffsetType) node_info->number_unique);
- alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
+ alpha=(double) ((MagickOffsetType) node_info->number_unique);
+ alpha=PerceptibleReciprocal(alpha);
if (cube_info->associate_alpha == MagickFalse)
{
- q->red=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.blue));
- q->alpha=OpaqueAlpha;
+ q->red=(double) ClampToQuantum(alpha*QuantumRange*
+ node_info->total_color.red);
+ q->green=(double) ClampToQuantum(alpha*QuantumRange*
+ node_info->total_color.green);
+ q->blue=(double) ClampToQuantum(alpha*QuantumRange*
+ node_info->total_color.blue);
+ q->alpha=(double) OpaqueAlpha;
}
else
{
- MagickRealType
+ double
opacity;
- opacity=(MagickRealType) (alpha*QuantumRange*
- node_info->total_color.alpha);
- q->alpha=ClampToQuantum(opacity);
+ opacity=(double) (alpha*QuantumRange*node_info->total_color.alpha);
+ q->alpha=(double) ClampToQuantum((opacity));
if (q->alpha == OpaqueAlpha)
{
- q->red=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.blue));
+ q->red=(double) ClampToQuantum(alpha*QuantumRange*
+ node_info->total_color.red);
+ q->green=(double) ClampToQuantum(alpha*QuantumRange*
+ node_info->total_color.green);
+ q->blue=(double) ClampToQuantum(alpha*QuantumRange*
+ node_info->total_color.blue);
}
else
{
- MagickRealType
+ double
gamma;
- gamma=(MagickRealType) (QuantumScale*q->alpha);
- gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
- q->red=ClampToQuantum((MagickRealType)
- (alpha*gamma*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
- (alpha*gamma*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
- (alpha*gamma*QuantumRange*node_info->total_color.blue));
+ gamma=(double) (QuantumScale*q->alpha);
+ gamma=PerceptibleReciprocal(gamma);
+ q->red=(double) ClampToQuantum(alpha*gamma*QuantumRange*
+ node_info->total_color.red);
+ q->green=(double) ClampToQuantum(alpha*gamma*QuantumRange*
+ node_info->total_color.green);
+ q->blue=(double) ClampToQuantum(alpha*gamma*QuantumRange*
+ node_info->total_color.blue);
if (node_info->number_unique > cube_info->transparent_pixels)
{
cube_info->transparent_pixels=node_info->number_unique;
cube_info->node_queue);
cube_info->node_queue=nodes;
} while (cube_info->node_queue != (Nodes *) NULL);
- if (cube_info->cache != (ssize_t *) NULL)
- cube_info->cache=(ssize_t *) RelinquishMagickMemory(cube_info->cache);
+ if (cube_info->memory_info != (MemoryInfo *) NULL)
+ cube_info->memory_info=RelinquishVirtualMemory(cube_info->memory_info);
cube_info->quantize_info=DestroyQuantizeInfo(cube_info->quantize_info);
cube_info=(CubeInfo *) RelinquishMagickMemory(cube_info);
}
%
% 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 RealPixelInfo **DestroyPixelThreadSet(RealPixelInfo **pixels)
i;
assert(pixels != (RealPixelInfo **) NULL);
- for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
+ for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
if (pixels[i] != (RealPixelInfo *) NULL)
pixels[i]=(RealPixelInfo *) RelinquishMagickMemory(pixels[i]);
pixels=(RealPixelInfo **) RelinquishMagickMemory(pixels);
size_t
number_threads;
- number_threads=GetOpenMPMaximumThreads();
+ number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
pixels=(RealPixelInfo **) AcquireQuantumMemory(number_threads,
sizeof(*pixels));
if (pixels == (RealPixelInfo **) NULL)
(void) ResetMagickMemory(pixels,0,number_threads*sizeof(*pixels));
for (i=0; i < (ssize_t) number_threads; i++)
{
- pixels[i]=(RealPixelInfo *) AcquireQuantumMemory(count,
- 2*sizeof(**pixels));
+ pixels[i]=(RealPixelInfo *) AcquireQuantumMemory(count,2*sizeof(**pixels));
if (pixels[i] == (RealPixelInfo *) NULL)
return(DestroyPixelThreadSet(pixels));
}
ssize_t
offset;
- offset=(ssize_t)
- (RedShift(ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->red))) |
- GreenShift(ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->green))) |
- BlueShift(ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->blue))));
+ offset=(ssize_t) (RedShift(ScaleQuantumToChar(ClampPixel(pixel->red))) |
+ GreenShift(ScaleQuantumToChar(ClampPixel(pixel->green))) |
+ BlueShift(ScaleQuantumToChar(ClampPixel(pixel->blue))));
if (cube_info->associate_alpha != MagickFalse)
- offset|=AlphaShift(ScaleQuantumToChar(ClampToUnsignedQuantum(
- pixel->alpha)));
+ offset|=AlphaShift(ScaleQuantumToChar(ClampPixel(pixel->alpha)));
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;
pixels=AcquirePixelThreadSet(image->columns);
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
pixel.alpha+=3*previous[u-v].alpha/16;
}
}
- pixel.red=(MagickRealType) ClampToUnsignedQuantum(pixel.red);
- pixel.green=(MagickRealType) ClampToUnsignedQuantum(pixel.green);
- pixel.blue=(MagickRealType) ClampToUnsignedQuantum(pixel.blue);
+ pixel.red=(double) ClampPixel(pixel.red);
+ pixel.green=(double) ClampPixel(pixel.green);
+ pixel.blue=(double) ClampPixel(pixel.blue);
if (cube.associate_alpha != MagickFalse)
- pixel.alpha=(MagickRealType) ClampToUnsignedQuantum(pixel.alpha);
+ pixel.alpha=(double) ClampPixel(pixel.alpha);
i=CacheOffset(&cube,&pixel);
if (cube.cache[i] < 0)
{
Find closest color among siblings and their children.
*/
cube.target=pixel;
- cube.distance=(MagickRealType) (4.0*(QuantumRange+1.0)*(QuantumRange+
- 1.0)+1.0);
+ cube.distance=(double) (4.0*(QuantumRange+1.0)*(QuantumRange+1.0)+
+ 1.0);
ClosestColor(image,&cube,node_info->parent);
cube.cache[i]=(ssize_t) cube.color_number;
}
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.
*/
- AssociateAlphaPixelInfo(image,&cube,image->colormap+index,&color);
+ AssociateAlphaPixelInfo(&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;
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_FloydSteinbergDither)
-#endif
proceed=SetImageProgress(image,DitherImageTag,(MagickOffsetType) y,
image->rows);
if (proceed == MagickFalse)
}
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"
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 == (Quantum *) NULL)
return(MagickFalse);
if (cube_info->associate_alpha != MagickFalse)
pixel.alpha+=p->weights[i]*p->error[i].alpha;
}
- pixel.red=(MagickRealType) ClampToUnsignedQuantum(pixel.red);
- pixel.green=(MagickRealType) ClampToUnsignedQuantum(pixel.green);
- pixel.blue=(MagickRealType) ClampToUnsignedQuantum(pixel.blue);
+ pixel.red=(double) ClampPixel(pixel.red);
+ pixel.green=(double) ClampPixel(pixel.green);
+ pixel.blue=(double) ClampPixel(pixel.blue);
if (cube_info->associate_alpha != MagickFalse)
- pixel.alpha=(MagickRealType) ClampToUnsignedQuantum(pixel.alpha);
+ pixel.alpha=(double) ClampPixel(pixel.alpha);
i=CacheOffset(cube_info,&pixel);
if (p->cache[i] < 0)
{
break;
node_info=node_info->child[id];
}
- node_info=node_info->parent;
/*
Find closest color among siblings and their children.
*/
p->target=pixel;
- p->distance=(MagickRealType) (4.0*(QuantumRange+1.0)*((MagickRealType)
+ p->distance=(double) (4.0*(QuantumRange+1.0)*((double)
QuantumRange+1.0)+1.0);
ClosestColor(image,p,node_info->parent);
p->cache[i]=(ssize_t) p->color_number;
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]));
- AssociateAlphaPixelInfo(image,cube_info,image->colormap+index,&color);
+ AssociateAlphaPixelInfo(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);
}
CubeInfo
*cube_info;
- MagickRealType
+ double
sum,
weight;
return((CubeInfo *) NULL);
cube_info->root->parent=cube_info->root;
cube_info->quantize_info=CloneQuantizeInfo(quantize_info);
- if (cube_info->quantize_info->dither == MagickFalse)
+ if (cube_info->quantize_info->dither_method == NoDitherMethod)
return(cube_info);
/*
Initialize dither resources.
*/
length=(size_t) (1UL << (4*(8-CacheShift)));
- cube_info->cache=(ssize_t *) AcquireQuantumMemory(length,
- sizeof(*cube_info->cache));
- if (cube_info->cache == (ssize_t *) NULL)
+ cube_info->memory_info=AcquireVirtualMemory(length,sizeof(*cube_info->cache));
+ if (cube_info->memory_info == (MemoryInfo *) NULL)
return((CubeInfo *) NULL);
+ cube_info->cache=(ssize_t *) GetVirtualMemoryBlob(cube_info->memory_info);
/*
Initialize color cache.
*/
weight=1.0;
for (i=0; i < ErrorQueueLength; i++)
{
- cube_info->weights[ErrorQueueLength-i-1]=1.0/weight;
+ cube_info->weights[ErrorQueueLength-i-1]=PerceptibleReciprocal(weight);
weight*=exp(log(((double) QuantumRange+1.0))/(ErrorQueueLength-1.0));
}
/*
%
% 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
+ double
alpha,
area,
beta,
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
for (x=0; x < (ssize_t) image->columns; x++)
{
index=1UL*GetPixelIndex(image,p);
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
- alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,p));
- beta=(MagickRealType) (QuantumScale*image->colormap[index].alpha);
+ alpha=(double) (QuantumScale*GetPixelAlpha(image,p));
+ beta=(double) (QuantumScale*image->colormap[index].alpha);
}
distance=fabs(alpha*GetPixelRed(image,p)-beta*
image->colormap[index].red);
assert(quantize_info != (QuantizeInfo *) NULL);
(void) ResetMagickMemory(quantize_info,0,sizeof(*quantize_info));
quantize_info->number_colors=256;
- quantize_info->dither=MagickTrue;
quantize_info->dither_method=RiemersmaDitherMethod;
quantize_info->colorspace=UndefinedColorspace;
quantize_info->measure_error=MagickFalse;
% The format of the PosterizeImage method is:
%
% MagickBooleanType PosterizeImage(Image *image,const size_t levels,
-% const MagickBooleanType dither,ExceptionInfo *exception)
+% const DitherMethod dither_method,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o levels: Number of color levels allowed in each channel. Very low values
% (2, 3, or 4) have the most visible effect.
%
-% o dither: Set this integer value to something other than zero to dither
-% the mapped image.
+% o dither_method: choose from UndefinedDitherMethod, NoDitherMethod,
+% RiemersmaDitherMethod, FloydSteinbergDitherMethod.
%
% o exception: return any errors or warnings in this structure.
%
*/
-static inline ssize_t MagickRound(MagickRealType x)
+static inline double MagickRound(double x)
{
/*
Round the fraction to nearest integer.
*/
- if (x >= 0.0)
- return((ssize_t) (x+0.5));
- return((ssize_t) (x-0.5));
+ if ((x-floor(x)) < (ceil(x)-x))
+ return(floor(x));
+ return(ceil(x));
}
MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
- const MagickBooleanType dither,ExceptionInfo *exception)
+ const DitherMethod dither_method,ExceptionInfo *exception)
{
#define PosterizeImageTag "Posterize/Image"
#define PosterizePixel(pixel) (Quantum) (QuantumRange*(MagickRound( \
(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) \
+ magick_threads(image,image,1,1)
#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;
- 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) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
(image->colorspace == CMYKColorspace))
SetPixelBlack(image,PosterizePixel(GetPixelBlack(image,q)),q);
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->matte == MagickTrue))
+ (image->alpha_trait == BlendPixelTrait))
SetPixelAlpha(image,PosterizePixel(GetPixelAlpha(image,q)),q);
q+=GetPixelChannels(image);
}
quantize_info=AcquireQuantizeInfo((ImageInfo *) NULL);
quantize_info->number_colors=(size_t) MagickMin((ssize_t) levels*levels*
levels,MaxColormapSize+1);
- quantize_info->dither=dither;
+ quantize_info->dither_method=dither_method;
quantize_info->tree_depth=MaxTreeDepth;
status=QuantizeImage(quantize_info,image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
if (image->colors != number_colors)
return(MagickFalse);
i=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
MagickBooleanType
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- image->colormap[i].red=GetPixelRed(image,q);
- image->colormap[i].green=GetPixelGreen(image,q);
- image->colormap[i].blue=GetPixelBlue(image,q);
- image->colormap[i].alpha=GetPixelAlpha(image,q);
+ 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);
maximum_colors=MaxColormapSize;
if (maximum_colors > MaxColormapSize)
maximum_colors=MaxColormapSize;
- if ((image->columns*image->rows) <= maximum_colors)
- (void) DirectToColormapImage(image,&image->exception);
- if ((IsImageGray(image,&image->exception) != MagickFalse) &&
- (image->matte == MagickFalse))
- (void) SetGrayscaleImage(image,exception);
+ if (image->alpha_trait != BlendPixelTrait)
+ {
+ if ((image->columns*image->rows) <= maximum_colors)
+ (void) DirectToColormapImage(image,exception);
+ if (IsImageGray(image,exception) != MagickFalse)
+ (void) SetGrayscaleImage(image,exception);
+ }
if ((image->storage_class == PseudoClass) &&
(image->colors <= maximum_colors))
return(MagickTrue);
colors=maximum_colors;
for (depth=1; colors != 0; depth++)
colors>>=2;
- if ((quantize_info->dither != MagickFalse) && (depth > 2))
+ if ((quantize_info->dither_method != NoDitherMethod) && (depth > 2))
depth--;
- if ((image->matte != MagickFalse) && (depth > 5))
+ if ((image->alpha_trait == BlendPixelTrait) && (depth > 5))
depth--;
+ if (IsImageGray(image,exception) != MagickFalse)
+ depth=MaxTreeDepth;
}
/*
Initialize color cube.
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)
{
/*
colors=maximum_colors;
for (depth=1; colors != 0; depth++)
colors>>=2;
- if (quantize_info->dither != MagickFalse)
+ if (quantize_info->dither_method != NoDitherMethod)
depth--;
}
/*
cube_info=GetCubeInfo(quantize_info,depth,maximum_colors);
if (cube_info == (CubeInfo *) NULL)
{
- (void) ThrowMagickException(&images->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
return(MagickFalse);
}
{
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);
% %
% %
% %
++ Q u a n t i z e E r r o r F l a t t e n %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% QuantizeErrorFlatten() traverses the color cube and flattens the quantization
+% error into a sorted 1D array. This accelerates the color reduction process.
+%
+% Contributed by Yoya.
+%
+% The format of the QuantizeImages method is:
+%
+% size_t QuantizeErrorFlatten(const Image *image,const CubeInfo *cube_info,
+% const NodeInfo *node_info,const ssize_t offset,
+% MagickRealType *quantize_error)
+%
+% A description of each parameter follows.
+%
+% o image: the image.
+%
+% o cube_info: A pointer to the Cube structure.
+%
+% o node_info: pointer to node in color cube tree that is current pointer.
+%
+% o offset: quantize error offset.
+%
+% o quantize_error: the quantization error vector.
+%
+*/
+static size_t QuantizeErrorFlatten(const Image *image,const CubeInfo *cube_info,
+ const NodeInfo *node_info,const ssize_t offset,MagickRealType *quantize_error)
+{
+ register ssize_t
+ i;
+
+ size_t
+ n,
+ number_children;
+
+ if (offset >= (ssize_t) cube_info->nodes)
+ return(0);
+ quantize_error[offset]=node_info->quantize_error;
+ n=1;
+ number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
+ for (i=0; i < (ssize_t) number_children ; i++)
+ if (node_info->child[i] != (NodeInfo *) NULL)
+ n+=QuantizeErrorFlatten(image,cube_info,node_info->child[i],offset+n,
+ quantize_error);
+ return(n);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+ R e d u c e %
% %
% %
% o cube_info: A pointer to the Cube structure.
%
*/
+
+static int MagickRealTypeCompare(const void *error_p,const void *error_q)
+{
+ MagickRealType
+ *p,
+ *q;
+
+ p=(MagickRealType *) error_p;
+ q=(MagickRealType *) error_q;
+ if (*p > *q)
+ return(1);
+ if (fabs((double) (*q-*p)) <= MagickEpsilon)
+ return(0);
+ return(-1);
+}
+
static void ReduceImageColors(const Image *image,CubeInfo *cube_info)
{
#define ReduceImageTag "Reduce/Image"
span;
cube_info->next_threshold=0.0;
+ if ((cube_info->colors > cube_info->maximum_colors) &&
+ (cube_info->nodes > 128))
+ {
+ MagickRealType
+ *quantize_error;
+
+ /*
+ Enable rapid reduction of the number of unique colors.
+ */
+ quantize_error=(MagickRealType *) AcquireQuantumMemory(cube_info->nodes,
+ sizeof(*quantize_error));
+ if (quantize_error != (MagickRealType *) NULL)
+ {
+ (void) QuantizeErrorFlatten(image,cube_info,cube_info->root,0,
+ quantize_error);
+ qsort(quantize_error,cube_info->nodes,sizeof(MagickRealType),
+ MagickRealTypeCompare);
+ cube_info->next_threshold=quantize_error[MagickMax(cube_info->nodes-
+ 110*(cube_info->maximum_colors+1)/100,0)];
+ quantize_error=(MagickRealType *) RelinquishMagickMemory(
+ quantize_error);
+ }
+ }
for (span=cube_info->colors; cube_info->colors > cube_info->maximum_colors; )
{
cube_info->pruning_threshold=cube_info->next_threshold;
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% 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:
%
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)
{
/*
color_1=(PixelInfo *) x;
color_2=(PixelInfo *) y;
- intensity=GetPixelInfoIntensity(color_1)-(ssize_t)
- GetPixelInfoIntensity(color_2);
+ intensity=(ssize_t) (GetPixelInfoIntensity(color_1)-(ssize_t)
+ GetPixelInfoIntensity(color_2));
return((int) intensity);
}
image->filename);
image->colors=0;
status=MagickTrue;
- 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) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (colormap_index[intensity] < 0)
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_SetGrayscaleImage)
+ #pragma omp critical (MagickCore_SetGrayscaleImage)
#endif
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++;
}
}
- SetPixelIndex(image,(Quantum)
- colormap_index[intensity],q);
+ SetPixelIndex(image,(Quantum) colormap_index[intensity],q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
image_view=DestroyCacheView(image_view);
}
for (i=0; i < (ssize_t) image->colors; i++)
- image->colormap[i].alpha=(unsigned short) i;
+ image->colormap[i].alpha=(double) i;
qsort((void *) image->colormap,image->colors,sizeof(PixelInfo),
IntensityCompare);
- colormap=(PixelInfo *) AcquireQuantumMemory(image->colors,
- sizeof(*colormap));
+ colormap=(PixelInfo *) AcquireQuantumMemory(image->colors,sizeof(*colormap));
if (colormap == (PixelInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
image->colormap=(PixelInfo *) RelinquishMagickMemory(image->colormap);
image->colormap=colormap;
status=MagickTrue;
- 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) \
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
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);
}
projects / imagemagick / blobdiff