% %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1998 %
% %
% %
-% Copyright 1999-2012 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 %
#include "MagickCore/blob.h"
#include "MagickCore/cache.h"
#include "MagickCore/cache-view.h"
+#include "MagickCore/channel.h"
#include "MagickCore/color.h"
#include "MagickCore/colorspace-private.h"
#include "MagickCore/composite.h"
next_direction=((path_info[i].point.y > point.y) ||
((path_info[i].point.y == point.y) &&
(path_info[i].point.x > point.x))) ? 1 : -1;
- if ((direction != 0) && (direction != next_direction))
+ if ((points != (PointInfo *) NULL) && (direction != 0) &&
+ (direction != next_direction))
{
/*
New edge.
double
determinant;
- determinant=MagickEpsilonReciprocal(affine->sx*affine->sy-affine->rx*
+ determinant=PerceptibleReciprocal(affine->sx*affine->sy-affine->rx*
affine->ry);
inverse_affine.sx=determinant*affine->sy;
inverse_affine.rx=determinant*(-affine->rx);
SegmentInfo
edge;
- size_t
- height,
- width;
-
ssize_t
start,
stop,
inverse_affine=InverseAffineMatrix(affine);
GetPixelInfo(image,&zero);
start=(ssize_t) ceil(edge.y1-0.5);
- stop=(ssize_t) ceil(edge.y2-0.5);
- height=(size_t) (floor(edge.y2-0.5)-ceil(edge.y1-0.5));
- width=(size_t) (floor(edge.x2-0.5)-ceil(edge.x1-0.5));
+ stop=(ssize_t) floor(edge.y2+0.5);
source_view=AcquireVirtualCacheView(source,exception);
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
- dynamic_number_threads(image,width,height,1)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(source,image,1,1)
#endif
for (y=start; y <= stop; y++)
{
if (inverse_edge.x2 < inverse_edge.x1)
continue;
q=GetCacheViewAuthenticPixels(image_view,(ssize_t) ceil(inverse_edge.x1-
- 0.5),y,(size_t) ((ssize_t) floor(inverse_edge.x2-0.5)-(ssize_t) ceil(
- inverse_edge.x1-0.5)),1,exception);
+ 0.5),y,(size_t) (floor(inverse_edge.x2+0.5)-ceil(inverse_edge.x1-0.5)+1),
+ 1,exception);
if (q == (Quantum *) NULL)
continue;
pixel=zero;
composite=zero;
x_offset=0;
- for (x=(ssize_t) ceil(inverse_edge.x1-0.5); x <= (ssize_t) floor(inverse_edge.x2-0.5); x++)
+ for (x=(ssize_t) ceil(inverse_edge.x1-0.5); x <= (ssize_t) floor(inverse_edge.x2+0.5); x++)
{
point.x=(double) x*inverse_affine.sx+y*inverse_affine.ry+
inverse_affine.tx;
status=NegateImage(clip_mask,MagickFalse,exception);
(void) SetImageMask(image,clip_mask,exception);
clip_mask=DestroyImage(clip_mask);
+ status&=DrawImage(image,clone_info,exception);
clone_info=DestroyDrawInfo(clone_info);
- status=DrawImage(image,clone_info,exception);
if (image->debug != MagickFalse)
(void) LogMagickEvent(DrawEvent,GetMagickModule(),"end clip-path");
return(status != 0 ? MagickTrue : MagickFalse);
j++;
dash_polygon[0].coordinates=(size_t) j;
dash_polygon[j].primitive=UndefinedPrimitive;
- status|=DrawStrokePolygon(image,clone_info,dash_polygon,exception);
+ status&=DrawStrokePolygon(image,clone_info,dash_polygon,exception);
}
n++;
if (draw_info->dash_pattern[n] == 0.0)
j++;
dash_polygon[0].coordinates=(size_t) j;
dash_polygon[j].primitive=UndefinedPrimitive;
- status|=DrawStrokePolygon(image,clone_info,dash_polygon,exception);
+ status&=DrawStrokePolygon(image,clone_info,dash_polygon,exception);
}
dash_polygon=(PrimitiveInfo *) RelinquishMagickMemory(dash_polygon);
clone_info=DestroyDrawInfo(clone_info);
**graphic_context;
MagickBooleanType
- proceed,
+ proceed;
+
+ MagickStatusType
status;
double
if (*draw_info->primitive != '@')
primitive=AcquireString(draw_info->primitive);
else
- primitive=FileToString(draw_info->primitive+1,~0,exception);
+ primitive=FileToString(draw_info->primitive+1,~0UL,exception);
if (primitive == (char *) NULL)
return(MagickFalse);
primitive_extent=(double) strlen(primitive);
graphic_context[n]->decorate=(DecorationType) decorate;
break;
}
+ if (LocaleCompare("direction",keyword) == 0)
+ {
+ ssize_t
+ direction;
+
+ GetMagickToken(q,&q,token);
+ direction=ParseCommandOption(MagickDirectionOptions,MagickFalse,
+ token);
+ if (direction == -1)
+ status=MagickFalse;
+ else
+ graphic_context[n]->direction=(DirectionType) direction;
+ break;
+ }
status=MagickFalse;
break;
}
&graphic_context[n]->fill_pattern,exception);
else
{
- status=QueryColorCompliance(token,AllCompliance,
+ status&=QueryColorCompliance(token,AllCompliance,
&graphic_context[n]->fill,exception);
if (status == MagickFalse)
{
if (n <= 0)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- DrawError,"UnbalancedGraphicContextPushPop","'%s'",token);
+ DrawError,"UnbalancedGraphicContextPushPop","`%s'",token);
n=0;
break;
}
if (graphic_context == (DrawInfo **) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",
image->filename);
break;
}
&graphic_context[n]->stroke_pattern,exception);
else
{
- status=QueryColorCompliance(token,AllCompliance,
+ status&=QueryColorCompliance(token,AllCompliance,
&graphic_context[n]->stroke,exception);
if (status == MagickFalse)
{
if (graphic_context[n]->dash_pattern == (double *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",
image->filename);
break;
}
if (primitive_info == (PrimitiveInfo *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
break;
}
}
{
if (primitive_info[j].coordinates > 107)
(void) ThrowMagickException(exception,GetMagickModule(),DrawError,
- "TooManyBezierCoordinates","'%s'",token);
+ "TooManyBezierCoordinates","`%s'",token);
length=BezierQuantum*primitive_info[j].coordinates;
break;
}
if (primitive_info == (PrimitiveInfo *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",
image->filename);
break;
}
if ((n != 0) && (graphic_context[n]->clip_mask != (char *) NULL) &&
(LocaleCompare(graphic_context[n]->clip_mask,
graphic_context[n-1]->clip_mask) != 0))
- (void) DrawClipPath(image,graphic_context[n],
+ status&=DrawClipPath(image,graphic_context[n],
graphic_context[n]->clip_mask,exception);
- (void) DrawPrimitive(image,graphic_context[n],primitive_info,exception);
+ status&=DrawPrimitive(image,graphic_context[n],primitive_info,
+ exception);
}
if (primitive_info->text != (char *) NULL)
primitive_info->text=(char *) RelinquishMagickMemory(
primitive_extent);
if (proceed == MagickFalse)
break;
+ if (status == 0)
+ break;
}
if (image->debug != MagickFalse)
(void) LogMagickEvent(DrawEvent,GetMagickModule(),"end draw-image");
if (status == MagickFalse)
ThrowBinaryException(DrawError,"NonconformingDrawingPrimitiveDefinition",
keyword);
- return(status);
+ return(status != 0 ? MagickTrue : MagickFalse);
}
\f
/*
q.y=(double) y-gradient_vector->y1;
length=sqrt(q.x*q.x+q.y*q.y);
gamma=sqrt(p.x*p.x+p.y*p.y)*length;
- gamma=MagickEpsilonReciprocal(gamma);
+ gamma=PerceptibleReciprocal(gamma);
scale=p.x*q.x+p.y*q.y;
offset=gamma*scale*length;
return(offset);
const SegmentInfo
*gradient_vector;
+ double
+ length;
+
MagickBooleanType
status;
PixelInfo
zero;
- double
- length;
-
PointInfo
point;
RectangleInfo
bounding_box;
- size_t
- height,
- width;
-
ssize_t
y;
bounding_box=gradient->bounding_box;
status=MagickTrue;
GetPixelInfo(image,&zero);
- height=bounding_box.height-bounding_box.y;
- width=bounding_box.width-bounding_box.x;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
- dynamic_number_threads(image,width,height,1)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,1,1)
#endif
for (y=bounding_box.y; y < (ssize_t) bounding_box.height; y++)
{
image_info->size=AcquireString(geometry);
*pattern=AcquireImage(image_info,exception);
image_info=DestroyImageInfo(image_info);
- (void) QueryColorCompliance("#00000000",AllCompliance,
+ (void) QueryColorCompliance("#000000ff",AllCompliance,
&(*pattern)->background_color,exception);
(void) SetImageBackgroundColor(*pattern,exception);
if (image->debug != MagickFalse)
}
static double GetFillAlpha(PolygonInfo *polygon_info,const double mid,
- const MagickBooleanType fill,const FillRule fill_rule,const double x,
- const double y,double *stroke_alpha)
+ const MagickBooleanType fill,const FillRule fill_rule,const ssize_t x,
+ const ssize_t y,double *stroke_alpha)
{
double
alpha,
p=polygon_info->edges;
for (j=0; j < (ssize_t) polygon_info->number_edges; j++, p++)
{
- if (y <= (p->bounds.y1-mid-0.5))
+ if ((double) y <= (p->bounds.y1-mid-0.5))
break;
- if (y > (p->bounds.y2+mid+0.5))
+ if ((double) y > (p->bounds.y2+mid+0.5))
{
(void) DestroyEdge(polygon_info,(size_t) j);
continue;
}
- if ((x <= (p->bounds.x1-mid-0.5)) || (x > (p->bounds.x2+mid+0.5)))
+ if (((double) x <= (p->bounds.x1-mid-0.5)) ||
+ ((double) x > (p->bounds.x2+mid+0.5)))
continue;
i=(ssize_t) MagickMax((double) p->highwater,1.0);
for ( ; i < (ssize_t) p->number_points; i++)
{
- if (y <= (p->points[i-1].y-mid-0.5))
+ if ((double) y <= (p->points[i-1].y-mid-0.5))
break;
- if (y > (p->points[i].y+mid+0.5))
+ if ((double) y > (p->points[i].y+mid+0.5))
continue;
- if (p->scanline != y)
+ if (p->scanline != (double) y)
{
- p->scanline=y;
+ p->scanline=(double) y;
p->highwater=(size_t) i;
}
/*
beta=delta.x*(x-q->x)+delta.y*(y-q->y);
if (beta < 0.0)
{
- delta.x=x-q->x;
- delta.y=y-q->y;
+ delta.x=(double) x-q->x;
+ delta.y=(double) y-q->y;
distance=delta.x*delta.x+delta.y*delta.y;
}
else
alpha=delta.x*delta.x+delta.y*delta.y;
if (beta > alpha)
{
- delta.x=x-(q+1)->x;
- delta.y=y-(q+1)->y;
+ delta.x=(double) x-(q+1)->x;
+ delta.y=(double) y-(q+1)->y;
distance=delta.x*delta.x+delta.y*delta.y;
}
else
{
- alpha=MagickEpsilonReciprocal(alpha);
+ alpha=1.0/alpha;
beta=delta.x*(y-q->y)-delta.y*(x-q->x);
distance=alpha*beta*beta;
}
p=polygon_info->edges;
for (j=0; j < (ssize_t) polygon_info->number_edges; j++, p++)
{
- if (y <= p->bounds.y1)
+ if ((double) y <= p->bounds.y1)
break;
- if ((y > p->bounds.y2) || (x <= p->bounds.x1))
+ if (((double) y > p->bounds.y2) || ((double) x <= p->bounds.x1))
continue;
- if (x > p->bounds.x2)
+ if ((double) x > p->bounds.x2)
{
winding_number+=p->direction ? 1 : -1;
continue;
}
i=(ssize_t) MagickMax((double) p->highwater,1.0);
for ( ; i < (ssize_t) p->number_points; i++)
- if (y <= p->points[i].y)
+ if ((double) y <= p->points[i].y)
break;
q=p->points+i-1;
if ((((q+1)->x-q->x)*(y-q->y)) <= (((q+1)->y-q->y)*(x-q->x)))
SegmentInfo
bounds;
- size_t
- height,
- width;
-
ssize_t
start,
stop,
polygon_info=AcquirePolygonThreadSet(draw_info,primitive_info);
if (polygon_info == (PolygonInfo **) NULL)
return(MagickFalse);
+DisableMSCWarning(4127)
if (0)
DrawBoundingRectangles(image,draw_info,polygon_info[0],exception);
+RestoreMSCWarning
if (image->debug != MagickFalse)
(void) LogMagickEvent(DrawEvent,GetMagickModule()," begin draw-polygon");
fill=(primitive_info->method == FillToBorderMethod) ||
}
bounds.x1-=(mid+1.0);
bounds.x1=bounds.x1 < 0.0 ? 0.0 : (size_t) ceil(bounds.x1-0.5) >=
- image->columns ? (double) image->columns-1.0 : bounds.x1;
+ image->columns ? (double) image->columns-1 : bounds.x1;
bounds.y1-=(mid+1.0);
bounds.y1=bounds.y1 < 0.0 ? 0.0 : (size_t) ceil(bounds.y1-0.5) >=
- image->rows ? (double) image->rows-1.0 : bounds.y1;
+ image->rows ? (double) image->rows-1 : bounds.y1;
bounds.x2+=(mid+1.0);
- bounds.x2=bounds.x2 < 0.0 ? 0.0 : (size_t) floor(bounds.x2-0.5) >=
- image->columns ? (double) image->columns-1.0 : bounds.x2;
+ bounds.x2=bounds.x2 < 0.0 ? 0.0 : (size_t) floor(bounds.x2+0.5) >=
+ image->columns ? (double) image->columns-1 : bounds.x2;
bounds.y2+=(mid+1.0);
- bounds.y2=bounds.y2 < 0.0 ? 0.0 : (size_t) floor(bounds.y2-0.5) >=
- image->rows ? (double) image->rows-1.0 : bounds.y2;
+ bounds.y2=bounds.y2 < 0.0 ? 0.0 : (size_t) floor(bounds.y2+0.5) >=
+ image->rows ? (double) image->rows-1 : bounds.y2;
status=MagickTrue;
image_view=AcquireAuthenticCacheView(image,exception);
- height=(size_t) (floor(bounds.y2-0.5)-ceil(bounds.y1-0.5));
- width=(size_t) (floor(bounds.x2-0.5)-ceil(bounds.x1-0.5));
if (primitive_info->coordinates == 1)
{
/*
Draw point.
*/
start=(ssize_t) ceil(bounds.y1-0.5);
- stop=(ssize_t) floor(bounds.y2-0.5);
+ stop=(ssize_t) floor(bounds.y2+0.5);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
- dynamic_number_threads(image,width,height,1)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,1,1)
#endif
for (y=start; y <= stop; y++)
{
if (status == MagickFalse)
continue;
start=(ssize_t) ceil(bounds.x1-0.5);
- stop=(ssize_t) floor(bounds.x2-0.5);
+ stop=(ssize_t) floor(bounds.x2+0.5);
x=start;
- q=GetCacheViewAuthenticPixels(image_view,x,y,(size_t) (stop-x+1),
- 1,exception);
+ q=GetCacheViewAuthenticPixels(image_view,x,y,(size_t) (stop-x+1),1,
+ exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
if (image->alpha_trait != BlendPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
start=(ssize_t) ceil(bounds.y1-0.5);
- stop=(ssize_t) floor(bounds.y2-0.5);
+ stop=(ssize_t) floor(bounds.y2+0.5);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
- dynamic_number_threads(image,width,height,1)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,1,1)
#endif
for (y=start; y <= stop; y++)
{
if (status == MagickFalse)
continue;
start=(ssize_t) ceil(bounds.x1-0.5);
- stop=(ssize_t) floor(bounds.x2-0.5);
+ stop=(ssize_t) floor(bounds.x2+0.5);
q=GetCacheViewAuthenticPixels(image_view,start,y,(size_t) (stop-start+1),1,
exception);
if (q == (Quantum *) NULL)
Fill and/or stroke.
*/
fill_alpha=GetFillAlpha(polygon_info[id],mid,fill,draw_info->fill_rule,
- x+0.5,y+0.5,&stroke_alpha);
+ x,y,&stroke_alpha);
if (draw_info->stroke_antialias == MagickFalse)
{
fill_alpha=fill_alpha > 0.25 ? 1.0 : 0.0;
if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
((IsPixelInfoGray(&draw_info->fill) == MagickFalse) ||
(IsPixelInfoGray(&draw_info->stroke) == MagickFalse)))
- (void) SetImageColorspace(image,RGBColorspace,exception);
+ (void) SetImageColorspace(image,sRGBColorspace,exception);
status=MagickTrue;
x=(ssize_t) ceil(primitive_info->point.x-0.5);
y=(ssize_t) ceil(primitive_info->point.y-0.5);
target.green=(double) draw_info->border_color.green;
target.blue=(double) draw_info->border_color.blue;
}
- (void) FloodfillPaintImage(image,draw_info,&target,x,y,
+ status&=FloodfillPaintImage(image,draw_info,&target,x,y,
primitive_info->method == FloodfillMethod ? MagickFalse :
MagickTrue,exception);
break;
target.blue=(double) draw_info->border_color.blue;
}
channel_mask=SetImageChannelMask(image,AlphaChannel);
- (void) FloodfillPaintImage(image,draw_info,&target,x,y,
+ status&=FloodfillPaintImage(image,draw_info,&target,x,y,
primitive_info->method == FloodfillMethod ? MagickFalse :
MagickTrue,exception);
(void) SetImageChannelMask(image,channel_mask);
(void) FormatLocaleString(geometry,MaxTextExtent,"%+f%+f",
primitive_info->point.x,primitive_info->point.y);
(void) CloneString(&clone_info->geometry,geometry);
- status=AnnotateImage(image,clone_info,exception);
+ status&=AnnotateImage(image,clone_info,exception);
clone_info=DestroyDrawInfo(clone_info);
break;
}
clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
clone_info->stroke_width=0.0;
clone_info->stroke.alpha=(Quantum) TransparentAlpha;
- status=DrawPolygonPrimitive(image,clone_info,primitive_info,
+ status&=DrawPolygonPrimitive(image,clone_info,primitive_info,
exception);
clone_info=DestroyDrawInfo(clone_info);
(void) DrawDashPolygon(draw_info,primitive_info,image,exception);
clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
clone_info->stroke_width=0.0;
clone_info->stroke.alpha=(Quantum) TransparentAlpha;
- status=DrawPolygonPrimitive(image,clone_info,primitive_info,
+ status&=DrawPolygonPrimitive(image,clone_info,primitive_info,
exception);
clone_info=DestroyDrawInfo(clone_info);
- status|=DrawStrokePolygon(image,draw_info,primitive_info,exception);
+ status&=DrawStrokePolygon(image,draw_info,primitive_info,exception);
break;
}
- status=DrawPolygonPrimitive(image,draw_info,primitive_info,exception);
+ status&=DrawPolygonPrimitive(image,draw_info,primitive_info,exception);
break;
}
}
*clone_info;
MagickBooleanType
- closed_path,
+ closed_path;
+
+ MagickStatusType
status;
PrimitiveInfo
for (p=primitive_info; p->primitive != UndefinedPrimitive; p+=p->coordinates)
{
stroke_polygon=TraceStrokePolygon(draw_info,p);
- status=DrawPolygonPrimitive(image,clone_info,stroke_polygon,exception);
+ status&=DrawPolygonPrimitive(image,clone_info,stroke_polygon,exception);
+ if (status == 0)
+ break;
stroke_polygon=(PrimitiveInfo *) RelinquishMagickMemory(stroke_polygon);
q=p+p->coordinates-1;
closed_path=(q->point.x == p->point.x) && (q->point.y == p->point.y) ?
if (image->debug != MagickFalse)
(void) LogMagickEvent(DrawEvent,GetMagickModule(),
" end draw-stroke-polygon");
- return(status);
+ return(status != 0 ? MagickTrue : MagickFalse);
}
\f
/*
exception=AcquireExceptionInfo();
(void) QueryColorCompliance("#000F",AllCompliance,&draw_info->fill,
exception);
- (void) QueryColorCompliance("#FFF0",AllCompliance,&draw_info->stroke,
+ (void) QueryColorCompliance("#FFFF",AllCompliance,&draw_info->stroke,
exception);
draw_info->stroke_width=1.0;
draw_info->alpha=OpaqueAlpha;
points[1].y=(double) (cosine*end.y/radii.y-sine*end.x/radii.y);
alpha=points[1].x-points[0].x;
beta=points[1].y-points[0].y;
- factor=MagickEpsilonReciprocal(alpha*alpha+beta*beta)-0.25;
+ factor=PerceptibleReciprocal(alpha*alpha+beta*beta)-0.25;
if (factor <= 0.0)
factor=0.0;
else
y=degrees.y;
while (y < degrees.x)
y+=360.0;
- angle.y=(double) (DegreesToRadians(y)-MagickEpsilon);
+ angle.y=(double) DegreesToRadians(y);
for (p=primitive_info; angle.x < angle.y; angle.x+=step)
{
point.x=cos(fmod(angle.x,DegreesToRadians(360.0)))*stop.x+start.x;
z_count;
attribute=0;
+ end.x=0.0;
+ end.y=0.0;
point.x=0.0;
point.y=0.0;
start.x=0.0;
start.y=0.0;
number_coordinates=0;
z_count=0;
+ (void) ResetMagickMemory(points,0,sizeof(*points));
primitive_type=primitive_info->primitive;
q=primitive_info;
for (p=path; *p != '\0'; )
projects / imagemagick / blobdiff