% July 1998 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/monitor-private.h"
#include "MagickCore/paint.h"
#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/resource_.h"
+#include "MagickCore/statistic.h"
#include "MagickCore/string_.h"
#include "MagickCore/thread-private.h"
\f
status;
PixelInfo
- fill,
+ fill_color,
pixel;
- PixelPacket
- fill_color;
-
register SegmentInfo
*s;
return(MagickFalse);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- if (image->matte == MagickFalse)
- (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
+ if (IsGrayColorspace(image->colorspace) != MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ if ((image->matte == MagickFalse) && (draw_info->fill.matte != MagickFalse))
+ (void) SetImageAlpha(image,OpaqueAlpha,exception);
/*
Set floodfill state.
*/
- floodplane_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ floodplane_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+ exception);
if (floodplane_image == (Image *) NULL)
return(MagickFalse);
- (void) SetImageAlphaChannel(floodplane_image,OpaqueAlphaChannel,exception);
+ SetImageColorspace(floodplane_image,GRAYColorspace,exception);
+ (void) EvaluateImage(floodplane_image,SetEvaluateOperator,0.0,exception);
segment_stack=(SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
sizeof(*segment_stack));
if (segment_stack == (SegmentInfo *) NULL)
Push initial segment on stack.
*/
status=MagickTrue;
- fill_color.black=0.0;
- fill_color.index=0.0;
x=x_offset;
y=y_offset;
start=0;
s=segment_stack;
PushSegmentStack(y,x,x,1);
PushSegmentStack(y+1,x,x,-1);
- GetPixelInfo(image,&fill);
GetPixelInfo(image,&pixel);
- image_view=AcquireCacheView(image);
- floodplane_view=AcquireCacheView(floodplane_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ floodplane_view=AcquireAuthenticCacheView(floodplane_image,exception);
while (s > segment_stack)
{
register const Quantum
q+=x1*GetPixelChannels(floodplane_image);
for (x=x1; x >= 0; x--)
{
- if (GetPixelAlpha(image,q) == TransparentAlpha)
+ if (GetPixelGray(floodplane_image,q) != 0)
break;
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
break;
- SetPixelAlpha(floodplane_image,TransparentAlpha,q);
+ SetPixelGray(floodplane_image,QuantumRange,q);
p-=GetPixelChannels(image);
q-=GetPixelChannels(floodplane_image);
}
{
p=GetCacheViewVirtualPixels(image_view,x,y,image->columns-x,1,
exception);
- q=GetCacheViewAuthenticPixels(floodplane_view,x,y,
- image->columns-x,1,exception);
+ q=GetCacheViewAuthenticPixels(floodplane_view,x,y,image->columns-
+ x,1,exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
break;
for ( ; x < (ssize_t) image->columns; x++)
{
- if (GetPixelAlpha(image,q) == TransparentAlpha)
+ if (GetPixelGray(floodplane_image,q) != 0)
break;
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
break;
- SetPixelAlpha(floodplane_image,TransparentAlpha,q);
+ SetPixelGray(floodplane_image,QuantumRange,q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(floodplane_image);
}
break;
for ( ; x <= x2; x++)
{
- if (GetPixelAlpha(image,q) == TransparentAlpha)
+ if (GetPixelGray(floodplane_image,q) != 0)
break;
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
break;
p+=GetPixelChannels(image);
/*
Tile fill color onto floodplane.
*/
- p=GetCacheViewVirtualPixels(floodplane_view,0,y,image->columns,1,
- exception);
+ p=GetCacheViewVirtualPixels(floodplane_view,0,y,image->columns,1,exception);
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (GetPixelAlpha(floodplane_image,p) != OpaqueAlpha)
+ if (GetPixelGray(floodplane_image,p) != 0)
{
(void) GetFillColor(draw_info,x,y,&fill_color,exception);
- SetPixelInfoPacket(image,&fill_color,&fill);
- if (image->colorspace == CMYKColorspace)
- ConvertRGBToCMYK(&fill);
- if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
- SetPixelRed(image,ClampToQuantum(fill.red),q);
- if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
- SetPixelGreen(image,ClampToQuantum(fill.green),q);
- if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
- SetPixelBlue(image,ClampToQuantum(fill.blue),q);
- if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
- SetPixelBlack(image,ClampToQuantum(fill.black),q);
- if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
- SetPixelAlpha(image,ClampToQuantum(fill.alpha),q);
+ SetPixelInfoPixel(image,&fill_color,q);
}
p+=GetPixelChannels(floodplane_image);
q+=GetPixelChannels(image);
% The format of the GradientImage method is:
%
% MagickBooleanType GradientImage(Image *image,const GradientType type,
-% const SpreadMethod method,const PixelPacket *start_color,
-% const PixelPacket *stop_color,ExceptionInfo *exception)
+% const SpreadMethod method,const PixelInfo *start_color,
+% const PixelInfo *stop_color,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
MagickExport MagickBooleanType GradientImage(Image *image,
const GradientType type,const SpreadMethod method,
- const PixelPacket *start_color,const PixelPacket *stop_color,
+ const PixelInfo *start_color,const PixelInfo *stop_color,
ExceptionInfo *exception)
{
DrawInfo
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(start_color != (const PixelPacket *) NULL);
- assert(stop_color != (const PixelPacket *) NULL);
+ assert(start_color != (const PixelInfo *) NULL);
+ assert(stop_color != (const PixelInfo *) NULL);
draw_info=AcquireDrawInfo();
gradient=(&draw_info->gradient);
gradient->type=type;
sizeof(*gradient->stops));
for (i=0; i < (ssize_t) gradient->number_stops; i++)
GetPixelInfo(image,&gradient->stops[i].color);
- SetPixelInfoPacket(image,start_color,&gradient->stops[0].color);
+ gradient->stops[0].color=(*start_color);
gradient->stops[0].offset=0.0;
- SetPixelInfoPacket(image,stop_color,&gradient->stops[1].color);
+ gradient->stops[1].color=(*stop_color);
gradient->stops[1].offset=1.0;
/*
Draw a gradient on the image.
*/
- status=DrawGradientImage(image,draw_info);
+ status=DrawGradientImage(image,draw_info,exception);
draw_info=DestroyDrawInfo(draw_info);
- if ((start_color->alpha == OpaqueAlpha) && (stop_color->alpha == OpaqueAlpha))
+ if ((start_color->matte == MagickFalse) && (stop_color->matte == MagickFalse))
image->matte=MagickFalse;
- if ((IsPixelPacketGray(start_color) != MagickFalse) &&
- (IsPixelPacketGray(stop_color) != MagickFalse))
+ if ((IsPixelInfoGray(start_color) != MagickFalse) &&
+ (IsPixelInfoGray(stop_color) != MagickFalse))
image->type=GrayscaleType;
return(status);
}
i;
assert(histogram != (size_t **) NULL);
- for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
+ for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
if (histogram[i] != (size_t *) NULL)
histogram[i]=(size_t *) RelinquishMagickMemory(histogram[i]);
histogram=(size_t **) RelinquishMagickMemory(histogram);
width;
ssize_t
+ center,
y;
/*
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- paint_view=AcquireCacheView(paint_image);
+ center=(ssize_t) GetPixelChannels(image)*(image->columns+width)*(width/2L)+
+ GetPixelChannels(image)*(width/2L);
+ image_view=AcquireVirtualCacheView(image,exception);
+ paint_view=AcquireAuthenticCacheView(paint_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) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
ssize_t
j,
k,
+ n,
v;
/*
Assign most frequent color.
*/
- i=0;
+ k=0;
j=0;
count=0;
- (void) ResetMagickMemory(histogram,0,NumberPaintBins*sizeof(*histogram));
+ (void) ResetMagickMemory(histogram,0,NumberPaintBins* sizeof(*histogram));
for (v=0; v < (ssize_t) width; v++)
{
for (u=0; u < (ssize_t) width; u++)
{
- k=(ssize_t) ScaleQuantumToChar(GetPixelIntensity(image,p+
- GetPixelChannels(image)*(u+i)));
- histogram[k]++;
- if (histogram[k] > count)
+ n=(ssize_t) ScaleQuantumToChar(GetPixelIntensity(image,p+
+ GetPixelChannels(image)*(u+k)));
+ histogram[n]++;
+ if (histogram[n] > count)
{
- j=i+u;
- count=histogram[k];
+ j=k+u;
+ count=histogram[n];
}
}
- i+=(ssize_t) (image->columns+width);
+ k+=(ssize_t) (image->columns+width);
+ }
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(paint_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ paint_traits,
+ traits;
+
+ channel=GetPixelChannelMapChannel(image,i);
+ traits=GetPixelChannelMapTraits(image,channel);
+ paint_traits=GetPixelChannelMapTraits(paint_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (paint_traits == UndefinedPixelTrait))
+ continue;
+ if ((paint_traits & CopyPixelTrait) != 0)
+ {
+ SetPixelChannel(paint_image,channel,p[center+i],q);
+ continue;
+ }
+ SetPixelChannel(paint_image,channel,p[j*GetPixelChannels(image)+i],q);
}
- if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
- SetPixelRed(paint_image,GetPixelRed(image,p+j*
- GetPixelChannels(image)),q);
- if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
- SetPixelGreen(paint_image,GetPixelGreen(image,p+j*
- GetPixelChannels(image)),q);
- if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
- SetPixelBlue(paint_image,GetPixelBlue(image,p+j*
- GetPixelChannels(image)),q);
- if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
- SetPixelBlack(paint_image,GetPixelBlack(image,p+j*
- GetPixelChannels(image)),q);
- if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
- SetPixelAlpha(paint_image,GetPixelAlpha(image,p+j*
- GetPixelChannels(image)),q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(paint_image);
}
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_OilPaintImage)
+ #pragma omp critical (MagickCore_OilPaintImage)
#endif
proceed=SetImageProgress(image,OilPaintImageTag,progress++,image->rows);
if (proceed == MagickFalse)
% The format of the OpaquePaintImage method is:
%
% MagickBooleanType OpaquePaintImage(Image *image,
-% const PixelPacket *target,const PixelPacket *fill,
+% const PixelInfo *target,const PixelInfo *fill,
% const MagickBooleanType invert,ExceptionInfo *exception)
%
% A description of each parameter follows:
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
+ if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
+ (IsPixelInfoGray(fill) != MagickFalse))
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ if ((fill->matte != MagickFalse) && (image->matte == MagickFalse))
+ (void) SetImageAlpha(image,OpaqueAlpha,exception);
/*
Make image color opaque.
*/
status=MagickTrue;
progress=0;
GetPixelInfo(image,&zero);
- 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) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
- {
- if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
- SetPixelRed(image,ClampToQuantum(fill->red),q);
- if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
- SetPixelGreen(image,ClampToQuantum(fill->green),q);
- if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
- SetPixelBlue(image,ClampToQuantum(fill->blue),q);
- if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
- SetPixelBlack(image,ClampToQuantum(fill->black),q);
- if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
- SetPixelAlpha(image,ClampToQuantum(fill->alpha),q);
- }
+ SetPixelInfoPixel(image,fill,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_OpaquePaintImage)
+ #pragma omp critical (MagickCore_OpaquePaintImage)
#endif
proceed=SetImageProgress(image,OpaquePaintImageTag,progress++,
image->rows);
status=MagickTrue;
progress=0;
GetPixelInfo(image,&zero);
- 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) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
SetPixelAlpha(image,opacity,q);
q+=GetPixelChannels(image);
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_TransparentPaintImage)
+ #pragma omp critical (MagickCore_TransparentPaintImage)
#endif
proceed=SetImageProgress(image,TransparentPaintImageTag,progress++,
image->rows);
*/
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) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
GetPixelInfo(image,&pixel);
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
match=((pixel.red >= low->red) && (pixel.red <= high->red) &&
(pixel.green >= low->green) && (pixel.green <= high->green) &&
(pixel.blue >= low->blue) && (pixel.blue <= high->blue)) ? MagickTrue :
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_TransparentPaintImageChroma)
+ #pragma omp critical (MagickCore_TransparentPaintImageChroma)
#endif
proceed=SetImageProgress(image,TransparentPaintImageTag,progress++,
image->rows);