%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CloneDrawInfo() makes a copy of the given draw_info structure. If NULL
-% is specified, a new draw_info structure is created initialized to
-% default values, according to the given image_info.
+% is specified, a new DrawInfo structure is created initialized to default
+% values.
%
% The format of the CloneDrawInfo method is:
%
SegmentInfo
edge;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
size_t
height,
width;
+#endif
ssize_t
start,
inverse_affine=InverseAffineMatrix(affine);
GetPixelInfo(image,&zero);
start=(ssize_t) ceil(edge.y1-0.5);
- stop=(ssize_t) ceil(edge.y2-0.5);
+ stop=(ssize_t) floor(edge.y2+0.5);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
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));
+#endif
source_view=AcquireVirtualCacheView(source,exception);
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
+ #pragma omp parallel for schedule(static,4) shared(status) \
dynamic_number_threads(image,width,height,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) floor(
- inverse_edge.x1+0.5)+1),1,exception);
+ 0.5),y,(size_t) ((ssize_t) floor(inverse_edge.x2+0.5)-(ssize_t) ceil(
+ inverse_edge.x1-0.5)),1,exception);
if (q == (Quantum *) NULL)
continue;
pixel=zero;
status=NegateImage(clip_mask,MagickFalse,exception);
(void) SetImageMask(image,clip_mask,exception);
clip_mask=DestroyImage(clip_mask);
- clone_info=DestroyDrawInfo(clone_info);
status=DrawImage(image,clone_info,exception);
+ clone_info=DestroyDrawInfo(clone_info);
if (image->debug != MagickFalse)
(void) LogMagickEvent(DrawEvent,GetMagickModule(),"end clip-path");
return(status != 0 ? MagickTrue : MagickFalse);
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
}
- number_points=2047;
+ number_points=6553;
primitive_info=(PrimitiveInfo *) AcquireQuantumMemory((size_t) number_points,
sizeof(*primitive_info));
if (primitive_info == (PrimitiveInfo *) NULL)
RectangleInfo
bounding_box;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
size_t
height,
width;
+#endif
ssize_t
y;
bounding_box=gradient->bounding_box;
status=MagickTrue;
GetPixelInfo(image,&zero);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
height=bounding_box.height-bounding_box.y;
width=bounding_box.width-bounding_box.x;
+#endif
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
+ #pragma omp parallel for schedule(static,4) shared(status) \
dynamic_number_threads(image,width,height,1)
#endif
for (y=bounding_box.y; y < (ssize_t) bounding_box.height; y++)
return(polygon_info);
}
-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)
+static double GetFillAlpha(PolygonInfo *polygon_info,const double mid,
+ const MagickBooleanType fill,const FillRule fill_rule,const ssize_t x,
+ const ssize_t y,double *stroke_alpha)
{
double
alpha,
PointInfo
delta;
- register EdgeInfo
- *p;
-
register const PointInfo
*q;
+ register EdgeInfo
+ *p;
+
register ssize_t
i;
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=1.0/alpha;
+ alpha=MagickEpsilonReciprocal(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;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
size_t
height,
width;
+#endif
ssize_t
start,
}
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;
+ 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;
+ image->rows ? (double) image->rows-1 : bounds.y2;
status=MagickTrue;
image_view=AcquireAuthenticCacheView(image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
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));
+#endif
if (primitive_info->coordinates == 1)
{
/*
start=(ssize_t) ceil(bounds.y1-0.5);
stop=(ssize_t) floor(bounds.y2+0.5);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
+ #pragma omp parallel for schedule(static,4) shared(status) \
dynamic_number_threads(image,width,height,1)
#endif
for (y=start; y <= stop; y++)
start=(ssize_t) ceil(bounds.x1-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;
/*
Draw polygon or line.
*/
- if (image->matte == 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);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status) \
+ #pragma omp parallel for schedule(static,4) shared(status) \
dynamic_number_threads(image,width,height,1)
#endif
for (y=start; y <= stop; y++)
Fill and/or stroke.
*/
fill_alpha=GetFillAlpha(polygon_info[id],mid,fill,draw_info->fill_rule,
- (double) x,(double) y,&stroke_alpha);
+ x,y,&stroke_alpha);
if (draw_info->stroke_antialias == MagickFalse)
{
fill_alpha=fill_alpha > 0.25 ? 1.0 : 0.0;
}
case MattePrimitive:
{
- if (image->matte == MagickFalse)
+ if (image->alpha_trait != BlendPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
switch (primitive_info->method)
{
target.green=(double) draw_info->border_color.green;
target.blue=(double) draw_info->border_color.blue;
}
- channel_mask=SetPixelChannelMask(image,AlphaChannel);
+ channel_mask=SetImageChannelMask(image,AlphaChannel);
(void) FloodfillPaintImage(image,draw_info,&target,x,y,
primitive_info->method == FloodfillMethod ? MagickFalse :
MagickTrue,exception);
- (void) SetPixelChannelMask(image,channel_mask);
+ (void) SetImageChannelMask(image,channel_mask);
break;
}
case ResetMethod:
(void) TransformImage(&composite_image,(char *) NULL,geometry,
exception);
}
- if (composite_image->matte == MagickFalse)
+ if (composite_image->alpha_trait != BlendPixelTrait)
(void) SetImageAlphaChannel(composite_image,OpaqueAlphaChannel,
exception);
if (draw_info->alpha != OpaqueAlpha)
projects / imagemagick / blobdiff