% July 1992 %
% %
% %
-% Copyright 1999-2009 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "magick/cache-view.h"
#include "magick/color.h"
#include "magick/color-private.h"
+#include "magick/colormap.h"
#include "magick/colorspace.h"
#include "magick/enhance.h"
#include "magick/exception.h"
#include "magick/quantize.h"
#include "magick/quantum.h"
#include "magick/string_.h"
+#include "magick/thread-private.h"
\f
/*
Define declarations.
*/
+#if !defined(__APPLE__) && !defined(TARGET_OS_IPHONE)
#define CacheShift 2
+#else
+#define CacheShift 3
+#endif
#define ErrorQueueLength 16
#define MaxNodes 266817
#define MaxTreeDepth 8
MagickRealType
quantize_error;
- unsigned long
+ size_t
color_number,
id,
level;
NodeInfo
*root;
- unsigned long
+ size_t
colors,
maximum_colors;
- long
+ ssize_t
transparent_index;
MagickSizeType
pruning_threshold,
next_threshold;
- unsigned long
+ size_t
nodes,
free_nodes,
color_number;
Nodes
*node_queue;
- long
+ ssize_t
*cache;
RealPixelPacket
MagickBooleanType
associate_alpha;
- long
+ ssize_t
x,
y;
- unsigned long
+ size_t
depth;
MagickOffsetType
Method prototypes.
*/
static CubeInfo
- *GetCubeInfo(const QuantizeInfo *,const unsigned long,const unsigned long);
+ *GetCubeInfo(const QuantizeInfo *,const size_t,const size_t);
static NodeInfo
- *GetNodeInfo(CubeInfo *,const unsigned long,const unsigned long,NodeInfo *);
+ *GetNodeInfo(CubeInfo *,const size_t,const size_t,NodeInfo *);
static MagickBooleanType
AssignImageColors(Image *,CubeInfo *),
DitherImage(Image *,CubeInfo *),
SetGrayscaleImage(Image *);
-static unsigned long
+static size_t
DefineImageColormap(Image *,CubeInfo *,NodeInfo *);
static void
alpha_pixel->opacity=(MagickRealType) pixel->opacity;
}
-static inline Quantum ClipToQuantum(const MagickRealType value)
+static inline Quantum ClampToUnsignedQuantum(const MagickRealType value)
{
if (value <= 0.0)
return((Quantum) 0);
return((Quantum) (value+0.5));
}
-static inline unsigned long ColorToNodeId(const CubeInfo *cube_info,
- const RealPixelPacket *pixel,unsigned long index)
+static inline size_t ColorToNodeId(const CubeInfo *cube_info,
+ const RealPixelPacket *pixel,size_t index)
{
- unsigned long
+ size_t
id;
- id=(unsigned long) (
- ((ScaleQuantumToChar(ClipToQuantum(pixel->red)) >> index) & 0x1) |
- ((ScaleQuantumToChar(ClipToQuantum(pixel->green)) >> index) & 0x1) << 1 |
- ((ScaleQuantumToChar(ClipToQuantum(pixel->blue)) >> index) & 0x1) << 2);
+ id=(size_t) (
+ ((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->red)) >> index) & 0x1) |
+ ((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->green)) >> index) & 0x1) << 1 |
+ ((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->blue)) >> index) & 0x1) << 2);
if (cube_info->associate_alpha != MagickFalse)
- id|=((ScaleQuantumToChar(ClipToQuantum(pixel->opacity)) >> index) & 0x1)
+ id|=((ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->opacity)) >> index) & 0x1)
<< 3;
return(id);
}
{
#define AssignImageTag "Assign/Image"
- long
- y;
-
- MagickBooleanType
- proceed;
-
- RealPixelPacket
- pixel;
-
- register long
- i,
- x;
-
- register const NodeInfo
- *node_info;
-
ssize_t
- count;
-
- unsigned long
- id,
- index;
+ y;
/*
Allocate image colormap.
(void) DitherImage(image,cube_info);
else
{
+ CacheView
+ *image_view;
+
ExceptionInfo
*exception;
- CacheView
- *image_view;
+ MagickBooleanType
+ status;
+ status=MagickTrue;
exception=(&image->exception);
image_view=AcquireCacheView(image);
- for (y=0; y < (long) image->rows; y++)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
+#endif
+ for (y=0; y < (ssize_t) image->rows; y++)
{
+ CubeInfo
+ cube;
+
register IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+ register ssize_t
+ x;
+
+ ssize_t
+ count;
+
+ if (status == MagickFalse)
+ continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
- break;
+ {
+ status=MagickFalse;
+ continue;
+ }
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- for (x=0; x < (long) image->columns; x+=count)
+ cube=(*cube_info);
+ for (x=0; x < (ssize_t) image->columns; x+=count)
{
+ RealPixelPacket
+ pixel;
+
+ register const NodeInfo
+ *node_info;
+
+ register ssize_t
+ i;
+
+ size_t
+ id,
+ index;
+
/*
Identify the deepest node containing the pixel's color.
*/
- for (count=1; (x+count) < (long) image->columns; count++)
+ for (count=1; (x+count) < (ssize_t) image->columns; count++)
if (IsSameColor(image,q,q+count) == MagickFalse)
break;
- AssociateAlphaPixel(cube_info,q,&pixel);
- node_info=cube_info->root;
- for (index=MaxTreeDepth-1; (long) index > 0; index--)
+ AssociateAlphaPixel(&cube,q,&pixel);
+ node_info=cube.root;
+ for (index=MaxTreeDepth-1; (ssize_t) index > 0; index--)
{
- id=ColorToNodeId(cube_info,&pixel,index);
+ id=ColorToNodeId(&cube,&pixel,index);
if (node_info->child[id] == (NodeInfo *) NULL)
break;
node_info=node_info->child[id];
/*
Find closest color among siblings and their children.
*/
- cube_info->target=pixel;
- cube_info->distance=(MagickRealType) (4.0*(QuantumRange+1.0)*
+ cube.target=pixel;
+ cube.distance=(MagickRealType) (4.0*(QuantumRange+1.0)*
(QuantumRange+1.0)+1.0);
- ClosestColor(image,cube_info,node_info->parent);
- index=cube_info->color_number;
- for (i=0; i < (long) count; i++)
+ ClosestColor(image,&cube,node_info->parent);
+ index=cube.color_number;
+ for (i=0; i < (ssize_t) count; i++)
{
if (image->storage_class == PseudoClass)
indexes[x+i]=(IndexPacket) index;
- if (cube_info->quantize_info->measure_error == MagickFalse)
+ if (cube.quantize_info->measure_error == MagickFalse)
{
q->red=image->colormap[index].red;
q->green=image->colormap[index].green;
q->blue=image->colormap[index].blue;
- if (cube_info->associate_alpha != MagickFalse)
+ if (cube.associate_alpha != MagickFalse)
q->opacity=image->colormap[index].opacity;
}
q++;
}
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
- break;
- proceed=SetImageProgress(image,AssignImageTag,y,image->rows);
- if (proceed == MagickFalse)
- break;
+ status=MagickFalse;
+ if (image->progress_monitor != (MagickProgressMonitor) NULL)
+ {
+ MagickBooleanType
+ proceed;
+
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_AssignImageColors)
+#endif
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) y,
+ image->rows);
+ if (proceed == MagickFalse)
+ status=MagickFalse;
+ }
}
image_view=DestroyCacheView(image_view);
}
intensity;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ i;
/*
Monochrome image.
*/
q=image->colormap;
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
intensity=(Quantum) (PixelIntensity(q) < ((MagickRealType)
QuantumRange/2.0) ? 0 : QuantumRange);
{
#define ClassifyImageTag "Classify/Image"
- long
- y;
+ CacheView
+ *image_view;
MagickBooleanType
proceed;
pixel;
size_t
- count;
-
- unsigned long
+ count,
id,
index,
level;
- CacheView
- *image_view;
+ ssize_t
+ y;
/*
Classify the first cube_info->maximum_colors colors to a tree depth of 8.
midpoint.opacity=(MagickRealType) QuantumRange/2.0;
error.opacity=0.0;
image_view=AcquireCacheView(image);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
x;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
PruneLevel(image,cube_info,cube_info->root);
cube_info->depth--;
}
- for (x=0; x < (long) image->columns; x+=(long) count)
+ for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) count)
{
/*
Start at the root and descend the color cube tree.
*/
- for (count=1; (x+count) < image->columns; count++)
+ for (count=1; (x+(ssize_t) count) < (ssize_t) image->columns; count++)
if (IsSameColor(image,p,p+count) == MagickFalse)
break;
AssociateAlphaPixel(cube_info,p,&pixel);
PruneToCubeDepth(image,cube_info,cube_info->root);
break;
}
- proceed=SetImageProgress(image,ClassifyImageTag,y,image->rows);
+ proceed=SetImageProgress(image,ClassifyImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
- for (y++; y < (long) image->rows; y++)
+ for (y++; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
x;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
PruneLevel(image,cube_info,cube_info->root);
cube_info->depth--;
}
- for (x=0; x < (long) image->columns; x+=(long) count)
+ for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) count)
{
/*
Start at the root and descend the color cube tree.
*/
- for (count=1; (x+count) < image->columns; count++)
+ for (count=1; (x+(ssize_t) count) < (ssize_t) image->columns; count++)
if (IsSameColor(image,p,p+count) == MagickFalse)
break;
AssociateAlphaPixel(cube_info,p,&pixel);
if (cube_info->associate_alpha != MagickFalse)
error.opacity=QuantumScale*(pixel.opacity-mid.opacity);
node_info->quantize_error+=sqrt((double) (count*error.red*error.red+
- count*error.green*error.green+error.blue*error.blue+
+ count*error.green*error.green+count*error.blue*error.blue+
count*error.opacity*error.opacity));
cube_info->root->quantize_error+=node_info->quantize_error;
index--;
node_info->total_color.opacity+=count*QuantumScale*pixel.opacity;
p+=count;
}
- proceed=SetImageProgress(image,ClassifyImageTag,y,image->rows);
+ proceed=SetImageProgress(image,ClassifyImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
static void ClosestColor(const Image *image,CubeInfo *cube_info,
const NodeInfo *node_info)
{
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
number_children;
/*
Traverse any children.
*/
number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
- for (i=0; i < (long) number_children; i++)
+ for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
ClosestColor(image,cube_info,node_info->child[i]);
if (node_info->number_unique != 0)
distance;
register PixelPacket
- *__restrict p;
+ *restrict p;
register RealPixelPacket
- *__restrict q;
+ *restrict q;
/*
Determine if this color is "closest".
q=(&cube_info->target);
alpha=1.0;
beta=1.0;
- if (cube_info->associate_alpha == MagickFalse)
+ if (cube_info->associate_alpha != MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-p->opacity));
- beta=(MagickRealType) (QuantumScale*(QuantumRange-q->opacity));
+ alpha=(MagickRealType) (QuantumScale*GetAlphaPixelComponent(p));
+ beta=(MagickRealType) (QuantumScale*GetAlphaPixelComponent(q));
}
pixel=alpha*p->red-beta*q->red;
distance=pixel*pixel;
- if (distance < cube_info->distance)
+ if (distance <= cube_info->distance)
{
pixel=alpha*p->green-beta*q->green;
distance+=pixel*pixel;
- if (distance < cube_info->distance)
+ if (distance <= cube_info->distance)
{
pixel=alpha*p->blue-beta*q->blue;
distance+=pixel*pixel;
- if (distance < cube_info->distance)
+ if (distance <= cube_info->distance)
{
pixel=alpha-beta;
distance+=pixel*pixel;
- if (distance < cube_info->distance)
+ if (distance <= cube_info->distance)
{
cube_info->distance=distance;
cube_info->color_number=node_info->color_number;
%
% The format of the DefineImageColormap method is:
%
-% unsigned long DefineImageColormap(Image *image,CubeInfo *cube_info,
+% size_t DefineImageColormap(Image *image,CubeInfo *cube_info,
% NodeInfo *node_info)
%
% A description of each parameter follows.
% node in the color cube tree that is to be pruned.
%
*/
-static unsigned long DefineImageColormap(Image *image,CubeInfo *cube_info,
+static size_t DefineImageColormap(Image *image,CubeInfo *cube_info,
NodeInfo *node_info)
{
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
number_children;
/*
Traverse any children.
*/
number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
- for (i=0; i < (long) number_children; i++)
+ for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
- DefineImageColormap(image,cube_info,node_info->child[i]);
+ (void) DefineImageColormap(image,cube_info,node_info->child[i]);
if (node_info->number_unique != 0)
{
register MagickRealType
alpha;
register PixelPacket
- *__restrict q;
+ *restrict q;
/*
Colormap entry is defined by the mean color in this cube.
alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
if (cube_info->associate_alpha == MagickFalse)
{
- q->red=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.red));
- q->green=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.green));
- q->blue=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.blue));
- q->opacity=OpaqueOpacity;
+ SetOpacityPixelComponent(q,OpaqueOpacity);
}
else
{
opacity=(MagickRealType) (alpha*QuantumRange*
node_info->total_color.opacity);
- q->opacity=RoundToQuantum(opacity);
+ q->opacity=ClampToQuantum(opacity);
if (q->opacity == OpaqueOpacity)
{
- q->red=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.red));
- q->green=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.green));
- q->blue=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.blue));
}
else
gamma=(MagickRealType) (QuantumScale*(QuantumRange-
(MagickRealType) q->opacity));
gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
- q->red=RoundToQuantum((MagickRealType) (alpha*gamma*QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) (alpha*gamma*QuantumRange*
node_info->total_color.red));
- q->green=RoundToQuantum((MagickRealType) (alpha*gamma*
+ q->green=ClampToQuantum((MagickRealType) (alpha*gamma*
QuantumRange*node_info->total_color.green));
- q->blue=RoundToQuantum((MagickRealType) (alpha*gamma*QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) (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->transparent_index=(long) image->colors;
+ cube_info->transparent_index=(ssize_t) image->colors;
}
}
}
cube_info->node_queue);
cube_info->node_queue=nodes;
} while (cube_info->node_queue != (Nodes *) NULL);
- if (cube_info->cache != (long *) NULL)
- cube_info->cache=(long *) RelinquishMagickMemory(cube_info->cache);
+ if (cube_info->cache != (ssize_t *) NULL)
+ cube_info->cache=(ssize_t *) RelinquishMagickMemory(cube_info->cache);
cube_info->quantize_info=DestroyQuantizeInfo(cube_info->quantize_info);
cube_info=(CubeInfo *) RelinquishMagickMemory(cube_info);
}
%
*/
+static RealPixelPacket **DestroyPixelThreadSet(RealPixelPacket **pixels)
+{
+ register ssize_t
+ i;
+
+ assert(pixels != (RealPixelPacket **) NULL);
+ for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
+ if (pixels[i] != (RealPixelPacket *) NULL)
+ pixels[i]=(RealPixelPacket *) RelinquishMagickMemory(pixels[i]);
+ pixels=(RealPixelPacket **) RelinquishMagickMemory(pixels);
+ return(pixels);
+}
+
+static RealPixelPacket **AcquirePixelThreadSet(const size_t count)
+{
+ RealPixelPacket
+ **pixels;
+
+ register ssize_t
+ i;
+
+ size_t
+ number_threads;
+
+ number_threads=GetOpenMPMaximumThreads();
+ pixels=(RealPixelPacket **) AcquireQuantumMemory(number_threads,
+ sizeof(*pixels));
+ if (pixels == (RealPixelPacket **) NULL)
+ return((RealPixelPacket **) NULL);
+ (void) ResetMagickMemory(pixels,0,number_threads*sizeof(*pixels));
+ for (i=0; i < (ssize_t) number_threads; i++)
+ {
+ pixels[i]=(RealPixelPacket *) AcquireQuantumMemory(count,
+ 2*sizeof(**pixels));
+ if (pixels[i] == (RealPixelPacket *) NULL)
+ return(DestroyPixelThreadSet(pixels));
+ }
+ return(pixels);
+}
+
+static inline ssize_t CacheOffset(CubeInfo *cube_info,
+ const RealPixelPacket *pixel)
+{
+#define RedShift(pixel) (((pixel) >> CacheShift) << (0*(8-CacheShift)))
+#define GreenShift(pixel) (((pixel) >> CacheShift) << (1*(8-CacheShift)))
+#define BlueShift(pixel) (((pixel) >> CacheShift) << (2*(8-CacheShift)))
+#define AlphaShift(pixel) (((pixel) >> CacheShift) << (3*(8-CacheShift)))
+
+ ssize_t
+ offset;
+
+ offset=(ssize_t)
+ (RedShift(ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->red))) |
+ GreenShift(ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->green))) |
+ BlueShift(ScaleQuantumToChar(ClampToUnsignedQuantum(pixel->blue))));
+ if (cube_info->associate_alpha != MagickFalse)
+ offset|=AlphaShift(ScaleQuantumToChar(ClampToUnsignedQuantum(
+ pixel->opacity)));
+ return(offset);
+}
+
static MagickBooleanType FloydSteinbergDither(Image *image,CubeInfo *cube_info)
{
#define DitherImageTag "Dither/Image"
+ CacheView
+ *image_view;
+
ExceptionInfo
*exception;
- long
- u,
- v,
- y;
-
MagickBooleanType
- proceed;
+ status;
RealPixelPacket
- color,
- *current,
- pixel,
- *previous,
- *scanlines;
-
- register CubeInfo
- *p;
+ **pixels;
- unsigned long
- index;
-
- CacheView
- *image_view;
+ ssize_t
+ y;
/*
Distribute quantization error using Floyd-Steinberg.
*/
- scanlines=(RealPixelPacket *) AcquireQuantumMemory(image->columns,
- 2*sizeof(*scanlines));
- if (scanlines == (RealPixelPacket *) NULL)
+ pixels=AcquirePixelThreadSet(image->columns);
+ if (pixels == (RealPixelPacket **) NULL)
return(MagickFalse);
- p=cube_info;
exception=(&image->exception);
+ status=MagickTrue;
image_view=AcquireCacheView(image);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
+ const int
+ id = GetOpenMPThreadId();
+
+ CubeInfo
+ cube;
+
+ RealPixelPacket
+ *current,
+ *previous;
+
register IndexPacket
- *__restrict indexes;
+ *restrict indexes;
- register long
- i,
+ register PixelPacket
+ *restrict q;
+
+ register ssize_t
x;
- register PixelPacket
- *__restrict q;
+ size_t
+ index;
+ ssize_t
+ v;
+
+ if (status == MagickFalse)
+ continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
- return(MagickFalse);
+ {
+ status=MagickFalse;
+ break;
+ }
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- current=scanlines+(y & 0x01)*image->columns;
- previous=scanlines+((y+1) & 0x01)*image->columns;
- v=(y & 0x01) ? -1 : 1;
- for (x=0; x < (long) image->columns; x++)
+ cube=(*cube_info);
+ current=pixels[id]+(y & 0x01)*image->columns;
+ previous=pixels[id]+((y+1) & 0x01)*image->columns;
+ v=(ssize_t) ((y & 0x01) ? -1 : 1);
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- u=(y & 0x01) ? (long) image->columns-1-x : x;
- AssociateAlphaPixel(cube_info,q+u,&pixel);
+ RealPixelPacket
+ color,
+ pixel;
+
+ register ssize_t
+ i;
+
+ ssize_t
+ u;
+
+ u=(y & 0x01) ? (ssize_t) image->columns-1-x : x;
+ AssociateAlphaPixel(&cube,q+u,&pixel);
if (x > 0)
{
pixel.red+=7*current[u-v].red/16;
pixel.green+=7*current[u-v].green/16;
pixel.blue+=7*current[u-v].blue/16;
- if (cube_info->associate_alpha != MagickFalse)
+ if (cube.associate_alpha != MagickFalse)
pixel.opacity+=7*current[u-v].opacity/16;
}
if (y > 0)
{
- if (x < (long) (image->columns-1))
+ if (x < (ssize_t) (image->columns-1))
{
pixel.red+=previous[u+v].red/16;
pixel.green+=previous[u+v].green/16;
pixel.blue+=previous[u+v].blue/16;
- if (cube_info->associate_alpha != MagickFalse)
+ if (cube.associate_alpha != MagickFalse)
pixel.opacity+=previous[u+v].opacity/16;
}
pixel.red+=5*previous[u].red/16;
pixel.green+=5*previous[u].green/16;
pixel.blue+=5*previous[u].blue/16;
- if (cube_info->associate_alpha != MagickFalse)
+ if (cube.associate_alpha != MagickFalse)
pixel.opacity+=5*previous[u].opacity/16;
if (x > 0)
{
pixel.red+=3*previous[u-v].red/16;
pixel.green+=3*previous[u-v].green/16;
pixel.blue+=3*previous[u-v].blue/16;
- if (cube_info->associate_alpha != MagickFalse)
+ if (cube.associate_alpha != MagickFalse)
pixel.opacity+=3*previous[u-v].opacity/16;
}
}
- pixel.red=(MagickRealType) ClipToQuantum(pixel.red);
- pixel.green=(MagickRealType) ClipToQuantum(pixel.green);
- pixel.blue=(MagickRealType) ClipToQuantum(pixel.blue);
- if (cube_info->associate_alpha != MagickFalse)
- pixel.opacity=(MagickRealType) ClipToQuantum(pixel.opacity);
- i=(long) ((ScaleQuantumToChar(ClipToQuantum(pixel.red)) >> CacheShift) |
- (ScaleQuantumToChar(ClipToQuantum(pixel.green)) >> CacheShift) << 6 |
- (ScaleQuantumToChar(ClipToQuantum(pixel.blue)) >> CacheShift) << 12);
- if (cube_info->associate_alpha != MagickFalse)
- i|=((ScaleQuantumToChar(ClipToQuantum(pixel.opacity)) >> CacheShift)
- << 18);
- if (p->cache[i] < 0)
+ pixel.red=(MagickRealType) ClampToUnsignedQuantum(pixel.red);
+ pixel.green=(MagickRealType) ClampToUnsignedQuantum(pixel.green);
+ pixel.blue=(MagickRealType) ClampToUnsignedQuantum(pixel.blue);
+ if (cube.associate_alpha != MagickFalse)
+ pixel.opacity=(MagickRealType) ClampToUnsignedQuantum(pixel.opacity);
+ i=CacheOffset(&cube,&pixel);
+ if (cube.cache[i] < 0)
{
register NodeInfo
*node_info;
- register unsigned long
+ register size_t
id;
/*
Identify the deepest node containing the pixel's color.
*/
- node_info=p->root;
- for (index=MaxTreeDepth-1; (long) index > 0; index--)
+ node_info=cube.root;
+ for (index=MaxTreeDepth-1; (ssize_t) index > 0; index--)
{
- id=ColorToNodeId(cube_info,&pixel,index);
+ id=ColorToNodeId(&cube,&pixel,index);
if (node_info->child[id] == (NodeInfo *) NULL)
break;
node_info=node_info->child[id];
/*
Find closest color among siblings and their children.
*/
- p->target=pixel;
- p->distance=(MagickRealType) (4.0*(QuantumRange+1.0)*(QuantumRange+
+ cube.target=pixel;
+ cube.distance=(MagickRealType) (4.0*(QuantumRange+1.0)*(QuantumRange+
1.0)+1.0);
- ClosestColor(image,p,node_info->parent);
- p->cache[i]=(long) p->color_number;
+ ClosestColor(image,&cube,node_info->parent);
+ cube.cache[i]=(ssize_t) cube.color_number;
}
/*
Assign pixel to closest colormap entry.
*/
- index=(unsigned long) p->cache[i];
+ index=(size_t) cube.cache[i];
if (image->storage_class == PseudoClass)
indexes[u]=(IndexPacket) index;
- if (cube_info->quantize_info->measure_error == MagickFalse)
+ if (cube.quantize_info->measure_error == MagickFalse)
{
(q+u)->red=image->colormap[index].red;
(q+u)->green=image->colormap[index].green;
(q+u)->blue=image->colormap[index].blue;
- if (cube_info->associate_alpha != MagickFalse)
+ if (cube.associate_alpha != MagickFalse)
(q+u)->opacity=image->colormap[index].opacity;
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
- return(MagickFalse);
+ status=MagickFalse;
/*
Store the error.
*/
- AssociateAlphaPixel(cube_info,image->colormap+index,&color);
+ AssociateAlphaPixel(&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;
- if (cube_info->associate_alpha != MagickFalse)
+ if (cube.associate_alpha != MagickFalse)
current[u].opacity=pixel.opacity-color.opacity;
- proceed=SetImageProgress(image,DitherImageTag,p->offset,p->span);
- if (proceed == MagickFalse)
- return(MagickFalse);
- p->offset++;
+ if (image->progress_monitor != (MagickProgressMonitor) NULL)
+ {
+ MagickBooleanType
+ proceed;
+
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_FloydSteinbergDither)
+#endif
+ proceed=SetImageProgress(image,DitherImageTag,(MagickOffsetType) y,
+ image->rows);
+ if (proceed == MagickFalse)
+ status=MagickFalse;
+ }
}
}
- scanlines=(RealPixelPacket *) RelinquishMagickMemory(scanlines);
image_view=DestroyCacheView(image_view);
+ pixels=DestroyPixelThreadSet(pixels);
return(MagickTrue);
}
RiemersmaDither(Image *,CacheView *,CubeInfo *,const unsigned int);
static void Riemersma(Image *image,CacheView *image_view,CubeInfo *cube_info,
- const unsigned long level,const unsigned int direction)
+ const size_t level,const unsigned int direction)
{
if (level == 1)
switch (direction)
register CubeInfo
*p;
- unsigned long
+ size_t
index;
p=cube_info;
- if ((p->x >= 0) && (p->x < (long) image->columns) &&
- (p->y >= 0) && (p->y < (long) image->rows))
+ if ((p->x >= 0) && (p->x < (ssize_t) image->columns) &&
+ (p->y >= 0) && (p->y < (ssize_t) image->rows))
{
ExceptionInfo
*exception;
register IndexPacket
- *__restrict indexes;
-
- register long
- i;
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ i;
/*
Distribute error.
if (cube_info->associate_alpha != MagickFalse)
pixel.opacity+=p->weights[i]*p->error[i].opacity;
}
- pixel.red=(MagickRealType) ClipToQuantum(pixel.red);
- pixel.green=(MagickRealType) ClipToQuantum(pixel.green);
- pixel.blue=(MagickRealType) ClipToQuantum(pixel.blue);
- if (cube_info->associate_alpha != MagickFalse)
- pixel.opacity=(MagickRealType) ClipToQuantum(pixel.opacity);
- i=(long) ((ScaleQuantumToChar(ClipToQuantum(pixel.red)) >> CacheShift) |
- (ScaleQuantumToChar(ClipToQuantum(pixel.green)) >> CacheShift) << 6 |
- (ScaleQuantumToChar(ClipToQuantum(pixel.blue)) >> CacheShift) << 12);
+ pixel.red=(MagickRealType) ClampToUnsignedQuantum(pixel.red);
+ pixel.green=(MagickRealType) ClampToUnsignedQuantum(pixel.green);
+ pixel.blue=(MagickRealType) ClampToUnsignedQuantum(pixel.blue);
if (cube_info->associate_alpha != MagickFalse)
- i|=((ScaleQuantumToChar(ClipToQuantum(pixel.opacity)) >> CacheShift)
- << 18);
+ pixel.opacity=(MagickRealType) ClampToUnsignedQuantum(pixel.opacity);
+ i=CacheOffset(cube_info,&pixel);
if (p->cache[i] < 0)
{
register NodeInfo
*node_info;
- register unsigned long
+ register size_t
id;
/*
Identify the deepest node containing the pixel's color.
*/
node_info=p->root;
- for (index=MaxTreeDepth-1; (long) index > 0; index--)
+ for (index=MaxTreeDepth-1; (ssize_t) index > 0; index--)
{
id=ColorToNodeId(cube_info,&pixel,index);
if (node_info->child[id] == (NodeInfo *) NULL)
break;
node_info=node_info->child[id];
}
+ node_info=node_info->parent;
/*
Find closest color among siblings and their children.
*/
p->distance=(MagickRealType) (4.0*(QuantumRange+1.0)*((MagickRealType)
QuantumRange+1.0)+1.0);
ClosestColor(image,p,node_info->parent);
- p->cache[i]=(long) p->color_number;
+ p->cache[i]=(ssize_t) p->color_number;
}
/*
Assign pixel to closest colormap entry.
*/
- index=(unsigned long) (1*p->cache[i]);
+ index=(size_t) (1*p->cache[i]);
if (image->storage_class == PseudoClass)
*indexes=(IndexPacket) index;
if (cube_info->quantize_info->measure_error == MagickFalse)
return(MagickTrue);
}
-static inline long MagickMax(const long x,const long y)
+static inline ssize_t MagickMax(const ssize_t x,const ssize_t y)
{
if (x > y)
return(x);
return(y);
}
-static inline long MagickMin(const long x,const long y)
+static inline ssize_t MagickMin(const ssize_t x,const ssize_t y)
{
if (x < y)
return(x);
static MagickBooleanType DitherImage(Image *image,CubeInfo *cube_info)
{
+ CacheView
+ *image_view;
+
MagickBooleanType
status;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
depth;
- CacheView
- *image_view;
-
- if (cube_info->quantize_info->dither_method == FloydSteinbergDitherMethod)
+ if (cube_info->quantize_info->dither_method != RiemersmaDitherMethod)
return(FloydSteinbergDither(image,cube_info));
/*
Distribute quantization error along a Hilbert curve.
sizeof(*cube_info->error));
cube_info->x=0;
cube_info->y=0;
- i=MagickMax((long) image->columns,(long) image->rows);
+ i=MagickMax((ssize_t) image->columns,(ssize_t) image->rows);
for (depth=1; i != 0; depth++)
i>>=1;
- if ((long) (1L << depth) < MagickMax((long) image->columns,(long) image->rows))
+ if ((ssize_t) (1L << depth) < MagickMax((ssize_t) image->columns,(ssize_t) image->rows))
depth++;
cube_info->offset=0;
cube_info->span=(MagickSizeType) image->columns*image->rows;
% The format of the GetCubeInfo method is:
%
% CubeInfo GetCubeInfo(const QuantizeInfo *quantize_info,
-% const unsigned long depth,const unsigned long maximum_colors)
+% const size_t depth,const size_t maximum_colors)
%
% A description of each parameter follows.
%
%
*/
static CubeInfo *GetCubeInfo(const QuantizeInfo *quantize_info,
- const unsigned long depth,const unsigned long maximum_colors)
+ const size_t depth,const size_t maximum_colors)
{
CubeInfo
*cube_info;
sum,
weight;
+ register ssize_t
+ i;
+
size_t
length;
- register long
- i;
-
/*
Initialize tree to describe color cube_info.
*/
Initialize dither resources.
*/
length=(size_t) (1UL << (4*(8-CacheShift)));
- cube_info->cache=(long *) AcquireQuantumMemory(length,
+ cube_info->cache=(ssize_t *) AcquireQuantumMemory(length,
sizeof(*cube_info->cache));
- if (cube_info->cache == (long *) NULL)
+ if (cube_info->cache == (ssize_t *) NULL)
return((CubeInfo *) NULL);
/*
Initialize color cache.
*/
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
cube_info->cache[i]=(-1);
/*
Distribute weights along a curve of exponential decay.
%
% The format of the GetNodeInfo method is:
%
-% NodeInfo *GetNodeInfo(CubeInfo *cube_info,const unsigned long id,
-% const unsigned long level,NodeInfo *parent)
+% NodeInfo *GetNodeInfo(CubeInfo *cube_info,const size_t id,
+% const size_t level,NodeInfo *parent)
%
% A description of each parameter follows.
%
% o level: Specifies the level in the storage_class the node resides.
%
*/
-static NodeInfo *GetNodeInfo(CubeInfo *cube_info,const unsigned long id,
- const unsigned long level,NodeInfo *parent)
+static NodeInfo *GetNodeInfo(CubeInfo *cube_info,const size_t id,
+ const size_t level,NodeInfo *parent)
{
NodeInfo
*node_info;
*/
MagickExport MagickBooleanType GetImageQuantizeError(Image *image)
{
+ CacheView
+ *image_view;
+
ExceptionInfo
*exception;
IndexPacket
*indexes;
- long
- y;
-
MagickRealType
alpha,
area,
mean_error,
mean_error_per_pixel;
- unsigned long
+ size_t
index;
- CacheView
- *image_view;
+ ssize_t
+ y;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
mean_error=0.0;
exception=(&image->exception);
image_view=AcquireCacheView(image);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
x;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
index=1UL*indexes[x];
if (image->matte != MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-p->opacity));
+ alpha=(MagickRealType) (QuantumScale*(GetAlphaPixelComponent(p)));
beta=(MagickRealType) (QuantumScale*(QuantumRange-
image->colormap[index].opacity));
}
% %
% %
% %
-% P o s t e r i z e I m a g e %
+% P o s t e r i z e I m a g e C h a n n e l %
% %
% %
% %
%
% The format of the PosterizeImage method is:
%
-% MagickBooleanType PosterizeImage(Image *image,const unsigned long levels,
+% MagickBooleanType PosterizeImage(Image *image,const size_t levels,
+% const MagickBooleanType dither)
+% MagickBooleanType PosterizeImageChannel(Image *image,
+% const ChannelType channel,const size_t levels,
% const MagickBooleanType dither)
%
% 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: Set this integer value to something other than zero to dither
+% the mapped image.
%
*/
-MagickExport MagickBooleanType PosterizeImage(Image *image,
- const unsigned long levels,const MagickBooleanType dither)
+
+static inline ssize_t MagickRound(MagickRealType x)
{
- ExceptionInfo
- *exception;
+ /*
+ Round the fraction to nearest integer.
+ */
+ if (x >= 0.0)
+ return((ssize_t) (x+0.5));
+ return((ssize_t) (x-0.5));
+}
- Image
- *posterize_image;
+MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
+ const MagickBooleanType dither)
+{
+ MagickBooleanType
+ status;
- IndexPacket
- *indexes;
+ status=PosterizeImageChannel(image,DefaultChannels,levels,dither);
+ return(status);
+}
- long
- j,
- k,
- l,
- n;
+MagickExport MagickBooleanType PosterizeImageChannel(Image *image,
+ const ChannelType channel,const size_t levels,const MagickBooleanType dither)
+{
+#define PosterizeImageTag "Posterize/Image"
+#define PosterizePixel(pixel) (Quantum) (QuantumRange*(MagickRound( \
+ QuantumScale*pixel*(levels-1)))/MagickMax((ssize_t) levels-1,1))
+
+ CacheView
+ *image_view;
+
+ ExceptionInfo
+ *exception;
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
QuantizeInfo
*quantize_info;
- register long
+ register ssize_t
i;
- register PixelPacket
- *__restrict q;
-
- CacheView
- *posterize_view;
+ ssize_t
+ y;
- /*
- Posterize image.
- */
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- posterize_image=AcquireImage((ImageInfo *) NULL);
- if (posterize_image == (Image *) NULL)
- return(MagickFalse);
- l=1;
- while ((l*l*l) < (long) MagickMin((long) levels*levels*levels,MaxColormapSize+1))
- l++;
- status=SetImageExtent(posterize_image,(unsigned long) (l*l*l),1);
- if (status == MagickFalse)
- {
- posterize_image=DestroyImage(posterize_image);
- return(MagickFalse);
- }
- status=AcquireImageColormap(posterize_image,levels*levels*levels);
- if (status == MagickFalse)
+ if (image->storage_class == PseudoClass)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+#endif
+ for (i=0; i < (ssize_t) image->colors; i++)
{
- posterize_image=DestroyImage(posterize_image);
- return(MagickFalse);
+ /*
+ Posterize colormap.
+ */
+ if ((channel & RedChannel) != 0)
+ image->colormap[i].red=PosterizePixel(image->colormap[i].red);
+ if ((channel & GreenChannel) != 0)
+ image->colormap[i].green=PosterizePixel(image->colormap[i].green);
+ if ((channel & BlueChannel) != 0)
+ image->colormap[i].blue=PosterizePixel(image->colormap[i].blue);
+ if ((channel & OpacityChannel) != 0)
+ image->colormap[i].opacity=PosterizePixel(image->colormap[i].opacity);
}
- posterize_view=AcquireCacheView(posterize_image);
+ /*
+ Posterize image.
+ */
+ status=MagickTrue;
+ progress=0;
exception=(&image->exception);
- q=QueueCacheViewAuthenticPixels(posterize_view,0,0,posterize_image->columns,1,
- exception);
- if (q == (PixelPacket *) NULL)
- {
- posterize_view=DestroyCacheView(posterize_view);
- posterize_image=DestroyImage(posterize_image);
- return(MagickFalse);
- }
- indexes=GetCacheViewAuthenticIndexQueue(posterize_view);
- n=0;
- for (i=0; i < l; i++)
- for (j=0; j < l; j++)
- for (k=0; k < l; k++)
+ image_view=AcquireCacheView(image);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+#endif
+ for (y=0; y < (ssize_t) image->rows; y++)
+ {
+ register IndexPacket
+ *restrict indexes;
+
+ register PixelPacket
+ *restrict q;
+
+ register ssize_t
+ x;
+
+ if (status == MagickFalse)
+ continue;
+ q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
+ if (q == (PixelPacket *) NULL)
{
- posterize_image->colormap[n].red=(Quantum) (QuantumRange*i/
- MagickMax(l-1L,1L));
- posterize_image->colormap[n].green=(Quantum)
- (QuantumRange*j/MagickMax(l-1L,1L));
- posterize_image->colormap[n].blue=(Quantum) (QuantumRange*k/
- MagickMax(l-1L,1L));
- posterize_image->colormap[n].opacity=OpaqueOpacity;
- *q++=posterize_image->colormap[n];
- indexes[n]=(IndexPacket) n;
- n++;
+ status=MagickFalse;
+ continue;
}
- if (SyncCacheViewAuthenticPixels(posterize_view,exception) == MagickFalse)
+ indexes=GetCacheViewAuthenticIndexQueue(image_view);
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- posterize_view=DestroyCacheView(posterize_view);
- posterize_image=DestroyImage(posterize_image);
- return(MagickFalse);
+ if ((channel & RedChannel) != 0)
+ q->red=PosterizePixel(q->red);
+ if ((channel & GreenChannel) != 0)
+ q->green=PosterizePixel(q->green);
+ if ((channel & BlueChannel) != 0)
+ q->blue=PosterizePixel(q->blue);
+ if (((channel & OpacityChannel) != 0) &&
+ (image->matte == MagickTrue))
+ q->opacity=PosterizePixel(q->opacity);
+ if (((channel & IndexChannel) != 0) &&
+ (image->colorspace == CMYKColorspace))
+ indexes[x]=PosterizePixel(indexes[x]);
+ q++;
}
- posterize_view=DestroyCacheView(posterize_view);
+ if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
+ status=MagickFalse;
+ if (image->progress_monitor != (MagickProgressMonitor) NULL)
+ {
+ MagickBooleanType
+ proceed;
+
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_PosterizeImageChannel)
+#endif
+ proceed=SetImageProgress(image,PosterizeImageTag,progress++,
+ image->rows);
+ if (proceed == MagickFalse)
+ status=MagickFalse;
+ }
+ }
+ image_view=DestroyCacheView(image_view);
quantize_info=AcquireQuantizeInfo((ImageInfo *) NULL);
+ quantize_info->number_colors=(size_t) MagickMin((ssize_t) levels*levels*
+ levels,MaxColormapSize+1);
quantize_info->dither=dither;
- status=RemapImage(quantize_info,image,posterize_image);
+ quantize_info->tree_depth=MaxTreeDepth;
+ status=QuantizeImage(quantize_info,image);
quantize_info=DestroyQuantizeInfo(quantize_info);
- posterize_image=DestroyImage(posterize_image);
return(status);
}
\f
NodeInfo
*parent;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
number_children;
/*
Traverse any children.
*/
number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
- for (i=0; i < (long) number_children; i++)
+ for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
PruneChild(image,cube_info,node_info->child[i]);
/*
static void PruneLevel(const Image *image,CubeInfo *cube_info,
const NodeInfo *node_info)
{
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
number_children;
/*
Traverse any children.
*/
number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
- for (i=0; i < (long) number_children; i++)
+ for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
PruneLevel(image,cube_info,node_info->child[i]);
if (node_info->level == cube_info->depth)
static void PruneToCubeDepth(const Image *image,CubeInfo *cube_info,
const NodeInfo *node_info)
{
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
number_children;
/*
Traverse any children.
*/
number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
- for (i=0; i < (long) number_children; i++)
+ for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
PruneToCubeDepth(image,cube_info,node_info->child[i]);
if (node_info->level > cube_info->depth)
% o image: the image.
%
*/
+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) == MagickFalse)
+ ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
+ image->filename);
+ i=0;
+ image_view=AcquireCacheView(image);
+ for (y=0; y < (ssize_t) image->rows; y++)
+ {
+ MagickBooleanType
+ proceed;
+
+ register IndexPacket
+ *restrict indexes;
+
+ register PixelPacket
+ *restrict q;
+
+ register ssize_t
+ x;
+
+ q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
+ if (q == (const PixelPacket *) NULL)
+ break;
+ indexes=GetCacheViewAuthenticIndexQueue(image_view);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ indexes[x]=(IndexPacket) i;
+ image->colormap[i++]=(*q++);
+ }
+ 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)
{
MagickBooleanType
status;
- unsigned long
+ size_t
depth,
maximum_colors;
maximum_colors=MaxColormapSize;
if (maximum_colors > MaxColormapSize)
maximum_colors=MaxColormapSize;
+ if ((image->columns*image->rows) <= maximum_colors)
+ return(DirectToColormapImage(image,&image->exception));
if ((IsGrayImage(image,&image->exception) != MagickFalse) &&
(image->matte == MagickFalse))
(void) SetGrayscaleImage(image);
depth=quantize_info->tree_depth;
if (depth == 0)
{
- unsigned long
+ size_t
colors;
/*
MagickProgressMonitor
progress_monitor;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
depth,
maximum_colors,
number_images;
depth=quantize_info->tree_depth;
if (depth == 0)
{
- unsigned long
+ size_t
colors;
/*
if (status == MagickFalse)
break;
(void) SetImageProgressMonitor(image,progress_monitor,image->client_data);
- proceed=SetImageProgress(image,AssignImageTag,i,number_images);
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) i,
+ number_images);
if (proceed == MagickFalse)
break;
image=GetNextImageInList(image);
break;
(void) SetImageProgressMonitor(image,progress_monitor,
image->client_data);
- proceed=SetImageProgress(image,AssignImageTag,i,number_images);
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) i,
+ number_images);
if (proceed == MagickFalse)
break;
image=GetNextImageInList(image);
static void Reduce(const Image *image,CubeInfo *cube_info,
const NodeInfo *node_info)
{
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
number_children;
/*
Traverse any children.
*/
number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
- for (i=0; i < (long) number_children; i++)
+ for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
Reduce(image,cube_info,node_info->child[i]);
if (node_info->quantize_error <= cube_info->pruning_threshold)
MagickOffsetType
offset;
- unsigned long
+ size_t
span;
cube_info->next_threshold=0.0;
static int IntensityCompare(const void *x,const void *y)
{
- long
- intensity;
-
PixelPacket
*color_1,
*color_2;
+ ssize_t
+ intensity;
+
color_1=(PixelPacket *) x;
color_2=(PixelPacket *) y;
- intensity=PixelIntensityToQuantum(color_1)-(long)
+ intensity=PixelIntensityToQuantum(color_1)-(ssize_t)
PixelIntensityToQuantum(color_2);
- return(intensity);
+ return((int) intensity);
}
#if defined(__cplusplus) || defined(c_plusplus)
static MagickBooleanType SetGrayscaleImage(Image *image)
{
+ CacheView
+ *image_view;
+
ExceptionInfo
*exception;
- long
- j,
- y;
+ MagickBooleanType
+ status;
PixelPacket
*colormap;
- long
- *colormap_index;
-
- register long
+ register ssize_t
i;
- MagickBooleanType
- status;
-
- CacheView
- *image_view;
+ ssize_t
+ *colormap_index,
+ j,
+ y;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->type != GrayscaleType)
(void) TransformImageColorspace(image,GRAYColorspace);
- colormap_index=(long *) AcquireQuantumMemory(MaxMap+1,
+ colormap_index=(ssize_t *) AcquireQuantumMemory(MaxMap+1,
sizeof(*colormap_index));
- if (colormap_index == (long *) NULL)
+ if (colormap_index == (ssize_t *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
if (image->storage_class != PseudoClass)
ExceptionInfo
*exception;
- for (i=0; i <= (long) MaxMap; i++)
+ for (i=0; i <= (ssize_t) MaxMap; i++)
colormap_index[i]=(-1);
if (AcquireImageColormap(image,MaxMap+1) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
status=MagickTrue;
exception=(&image->exception);
image_view=AcquireCacheView(image);
-#if defined(_OPENMP) && (_OPENMP >= 200203)
- #pragma omp parallel for shared(status)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register IndexPacket
- *__restrict indexes;
-
- register long
- x;
+ *restrict indexes;
register const PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
continue;
}
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- register unsigned long
+ register size_t
intensity;
intensity=ScaleQuantumToMap(q->red);
if (colormap_index[intensity] < 0)
{
-#if defined(_OPENMP) && (_OPENMP >= 200203)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_SetGrayscaleImage)
#endif
if (colormap_index[intensity] < 0)
{
- colormap_index[intensity]=(long) image->colors;
+ colormap_index[intensity]=(ssize_t) image->colors;
image->colormap[image->colors]=(*q);
image->colors++;
}
}
image_view=DestroyCacheView(image_view);
}
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
image->colormap[i].opacity=(unsigned short) i;
qsort((void *) image->colormap,image->colors,sizeof(PixelPacket),
IntensityCompare);
image->filename);
j=0;
colormap[j]=image->colormap[0];
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
if (IsSameColor(image,&colormap[j],&image->colormap[i]) == MagickFalse)
{
j++;
colormap[j]=image->colormap[i];
}
- colormap_index[(long) image->colormap[i].opacity]=j;
+ colormap_index[(ssize_t) image->colormap[i].opacity]=j;
}
- image->colors=(unsigned long) (j+1);
+ image->colors=(size_t) (j+1);
image->colormap=(PixelPacket *) RelinquishMagickMemory(image->colormap);
image->colormap=colormap;
status=MagickTrue;
exception=(&image->exception);
image_view=AcquireCacheView(image);
-#if defined(_OPENMP) && (_OPENMP >= 200203)
- #pragma omp parallel for shared(status)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register IndexPacket
- *__restrict indexes;
-
- register long
- x;
+ *restrict indexes;
register const PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
continue;
}
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
indexes[x]=(IndexPacket) colormap_index[ScaleQuantumToMap(indexes[x])];
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
- colormap_index=(long *) RelinquishMagickMemory(colormap_index);
+ colormap_index=(ssize_t *) RelinquishMagickMemory(colormap_index);
image->type=GrayscaleType;
if (IsMonochromeImage(image,&image->exception) != MagickFalse)
image->type=BilevelType;
projects / imagemagick / blobdiff