cube_info->quantize_info->colorspace,exception);
else
if ((image->colorspace != GRAYColorspace) &&
- (IsRGBColorspace(image->colorspace) == MagickFalse) &&
+ (IssRGBColorspace(image->colorspace) == MagickFalse) &&
(image->colorspace != CMYColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
if (AcquireImageColormap(image,cube_info->colors,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
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)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
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);
}
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) <
+ intensity=(double) ((MagickRealType) GetPixelInfoIntensity(q) <
((MagickRealType) QuantumRange/2.0) ? 0 : QuantumRange);
q->red=intensity;
q->green=intensity;
(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
else
if ((image->colorspace != GRAYColorspace) &&
(image->colorspace != CMYColorspace) &&
- (IsRGBColorspace(image->colorspace) == MagickFalse))
- (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
+ (IssRGBColorspace(image->colorspace) == MagickFalse))
+ (void) TransformImageColorspace((Image *) image,sRGBColorspace,exception);
midpoint.red=(MagickRealType) QuantumRange/2.0;
midpoint.green=(MagickRealType) QuantumRange/2.0;
midpoint.blue=(MagickRealType) QuantumRange/2.0;
midpoint.alpha=(MagickRealType) QuantumRange/2.0;
error.alpha=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
node_info->child[id]=GetNodeInfo(cube_info,id,level,node_info);
if (node_info->child[id] == (NodeInfo *) NULL)
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",
+ ResourceLimitError,"MemoryAllocationFailed","'%s'",
image->filename);
if (level == MaxTreeDepth)
cube_info->colors++;
image_view=DestroyCacheView(image_view);
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
alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
if (cube_info->associate_alpha == MagickFalse)
{
- q->red=ClampToQuantum((MagickRealType)
+ q->red=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
+ q->green=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
- (alpha*QuantumRange*node_info->total_color.blue));
+ q->blue=(double) ClampToQuantum((MagickRealType)
+ (alpha*(double) QuantumRange*node_info->total_color.blue));
q->alpha=OpaqueAlpha;
}
else
opacity=(MagickRealType) (alpha*QuantumRange*
node_info->total_color.alpha);
- q->alpha=ClampToQuantum(opacity);
+ q->alpha=(double) ClampToQuantum(opacity);
if (q->alpha == OpaqueAlpha)
{
- q->red=ClampToQuantum((MagickRealType)
+ q->red=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
+ q->green=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
+ q->blue=(double) ClampToQuantum((MagickRealType)
(alpha*QuantumRange*node_info->total_color.blue));
}
else
gamma=(MagickRealType) (QuantumScale*q->alpha);
gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
- q->red=ClampToQuantum((MagickRealType)
+ q->red=(double) ClampToQuantum((MagickRealType)
(alpha*gamma*QuantumRange*node_info->total_color.red));
- q->green=ClampToQuantum((MagickRealType)
+ q->green=(double) ClampToQuantum((MagickRealType)
(alpha*gamma*QuantumRange*node_info->total_color.green));
- q->blue=ClampToQuantum((MagickRealType)
+ q->blue=(double) ClampToQuantum((MagickRealType)
(alpha*gamma*QuantumRange*node_info->total_color.blue));
if (node_info->number_unique > cube_info->transparent_pixels)
{
if (pixels == (RealPixelInfo **) NULL)
return(MagickFalse);
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
const int
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;
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);
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,exception);
status=RiemersmaDither(image,image_view,cube_info,ForgetGravity,exception);
maximum_error=0.0;
mean_error_per_pixel=0.0;
mean_error=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (image->storage_class == PseudoClass)
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
Posterize colormap.
*/
if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].red=PosterizePixel(image->colormap[i].red);
+ image->colormap[i].red=(double)
+ PosterizePixel(image->colormap[i].red);
if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].green=PosterizePixel(image->colormap[i].green);
+ image->colormap[i].green=(double)
+ PosterizePixel(image->colormap[i].green);
if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].blue=PosterizePixel(image->colormap[i].blue);
+ image->colormap[i].blue=(double)
+ PosterizePixel(image->colormap[i].blue);
if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
- image->colormap[i].alpha=PosterizePixel(image->colormap[i].alpha);
+ image->colormap[i].alpha=(double)
+ PosterizePixel(image->colormap[i].alpha);
}
/*
Posterize image.
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (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);
if (cube_info == (CubeInfo *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+ ResourceLimitError,"MemoryAllocationFailed","'%s'",images->filename);
return(MagickFalse);
}
number_images=GetImageListLength(images);
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% 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:
%
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)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (colormap_index[intensity] < 0)
{
colormap_index[intensity]=(ssize_t) image->colors;
- image->colormap[image->colors].red=GetPixelRed(image,q);
- image->colormap[image->colors].green=GetPixelGreen(image,q);
- image->colormap[image->colors].blue=GetPixelBlue(image,q);
+ image->colormap[image->colors].red=(double)
+ GetPixelRed(image,q);
+ image->colormap[image->colors].green=(double)
+ GetPixelGreen(image,q);
+ image->colormap[image->colors].blue=(double)
+ GetPixelBlue(image,q);
image->colors++;
}
}
image_view=DestroyCacheView(image_view);
}
for (i=0; i < (ssize_t) image->colors; i++)
- image->colormap[i].alpha=(unsigned short) i;
+ image->colormap[i].alpha=(double) i;
qsort((void *) image->colormap,image->colors,sizeof(PixelInfo),
IntensityCompare);
colormap=(PixelInfo *) AcquireQuantumMemory(image->colors,
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)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{