MagickCore  6.8.7
draw.c
Go to the documentation of this file.
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % DDDD RRRR AAA W W %
7 % D D R R A A W W %
8 % D D RRRR AAAAA W W W %
9 % D D R RN A A WW WW %
10 % DDDD R R A A W W %
11 % %
12 % %
13 % MagickCore Image Drawing Methods %
14 % %
15 % %
16 % Software Design %
17 % John Cristy %
18 % July 1998 %
19 % %
20 % %
21 % Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
22 % dedicated to making software imaging solutions freely available. %
23 % %
24 % You may not use this file except in compliance with the License. You may %
25 % obtain a copy of the License at %
26 % %
27 % http://www.imagemagick.org/script/license.php %
28 % %
29 % Unless required by applicable law or agreed to in writing, software %
30 % distributed under the License is distributed on an "AS IS" BASIS, %
31 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
32 % See the License for the specific language governing permissions and %
33 % limitations under the License. %
34 % %
35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
36 %
37 % Bill Radcliffe of Corbis (www.corbis.com) contributed the polygon
38 % rendering code based on Paul Heckbert's "Concave Polygon Scan Conversion",
39 % Graphics Gems, 1990. Leonard Rosenthal and David Harr of Appligent
40 % (www.appligent.com) contributed the dash pattern, linecap stroking
41 % algorithm, and minor rendering improvements.
42 %
43 */
44 
45 
46 /*
47  Include declarations.
48 */
49 #include "magick/studio.h"
50 #include "magick/annotate.h"
51 #include "magick/artifact.h"
52 #include "magick/blob.h"
53 #include "magick/cache.h"
54 #include "magick/cache-view.h"
55 #include "magick/channel.h"
56 #include "magick/color.h"
57 #include "magick/color-private.h"
58 #include "magick/colorspace.h"
59 #include "magick/colorspace-private.h"
60 #include "magick/composite.h"
61 #include "magick/composite-private.h"
62 #include "magick/constitute.h"
63 #include "magick/draw.h"
64 #include "magick/draw-private.h"
65 #include "magick/enhance.h"
66 #include "magick/exception.h"
67 #include "magick/exception-private.h"
68 #include "magick/gem.h"
69 #include "magick/geometry.h"
70 #include "magick/image-private.h"
71 #include "magick/list.h"
72 #include "magick/log.h"
73 #include "magick/monitor.h"
74 #include "magick/monitor-private.h"
75 #include "magick/option.h"
76 #include "magick/paint.h"
77 #include "magick/pixel-accessor.h"
78 #include "magick/pixel-private.h"
79 #include "magick/property.h"
80 #include "magick/resample.h"
81 #include "magick/resample-private.h"
82 #include "magick/resource_.h"
83 #include "magick/string_.h"
84 #include "magick/string-private.h"
85 #include "magick/thread-private.h"
86 #include "magick/token.h"
87 #include "magick/transform.h"
88 #include "magick/utility.h"
89 
90 
91 /*
92  Define declarations.
93 */
94 #define BezierQuantum 200
95 
96 
97 /*
98  Typedef declarations.
99 */
100 typedef struct _EdgeInfo
101 {
102  SegmentInfo
103  bounds;
104 
105  double
106  scanline;
107 
108  PointInfo
109  *points;
110 
111  size_t
112  number_points;
113 
114  ssize_t
115  direction;
116 
117  MagickBooleanType
118  ghostline;
119 
120  size_t
121  highwater;
122 } EdgeInfo;
123 
124 typedef struct _ElementInfo
125 {
126  double
127  cx,
128  cy,
129  major,
130  minor,
131  angle;
132 } ElementInfo;
133 
134 typedef struct _PolygonInfo
135 {
136  EdgeInfo
137  *edges;
138 
139  size_t
140  number_edges;
141 } PolygonInfo;
142 
143 typedef enum
144 {
145  MoveToCode,
146  OpenCode,
147  GhostlineCode,
148  LineToCode,
149  EndCode
150 } PathInfoCode;
151 
152 typedef struct _PathInfo
153 {
154  PointInfo
155  point;
156 
157  PathInfoCode
158  code;
159 } PathInfo;
160 
161 
162 /*
163  Forward declarations.
164 */
165 static MagickBooleanType
166  DrawStrokePolygon(Image *,const DrawInfo *,const PrimitiveInfo *);
167 
168 static PrimitiveInfo
169  *TraceStrokePolygon(const DrawInfo *,const PrimitiveInfo *);
170 
171 static size_t
172  TracePath(PrimitiveInfo *,const char *);
173 
174 static void
175  TraceArc(PrimitiveInfo *,const PointInfo,const PointInfo,const PointInfo),
176  TraceArcPath(PrimitiveInfo *,const PointInfo,const PointInfo,const PointInfo,
177  const double,const MagickBooleanType,const MagickBooleanType),
178  TraceBezier(PrimitiveInfo *,const size_t),
179  TraceCircle(PrimitiveInfo *,const PointInfo,const PointInfo),
180  TraceEllipse(PrimitiveInfo *,const PointInfo,const PointInfo,const PointInfo),
181  TraceLine(PrimitiveInfo *,const PointInfo,const PointInfo),
182  TraceRectangle(PrimitiveInfo *,const PointInfo,const PointInfo),
183  TraceRoundRectangle(PrimitiveInfo *,const PointInfo,const PointInfo,
184  PointInfo),
185  TraceSquareLinecap(PrimitiveInfo *,const size_t,const double);
186 
187 
188 /*
189 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
190 % %
191 % %
192 % %
193 % A c q u i r e D r a w I n f o %
194 % %
195 % %
196 % %
197 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
198 %
199 % AcquireDrawInfo() returns a DrawInfo structure properly initialized.
200 %
201 % The format of the AcquireDrawInfo method is:
202 %
203 % DrawInfo *AcquireDrawInfo(void)
204 %
205 */
206 MagickExport DrawInfo *AcquireDrawInfo(void)
207 {
208  DrawInfo
209  *draw_info;
210 
211  draw_info=(DrawInfo *) AcquireMagickMemory(sizeof(*draw_info));
212  if (draw_info == (DrawInfo *) NULL)
213  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
214  GetDrawInfo((ImageInfo *) NULL,draw_info);
215  return(draw_info);
216 }
217 
218 
219 /*
220 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
221 % %
222 % %
223 % %
224 % C l o n e D r a w I n f o %
225 % %
226 % %
227 % %
228 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
229 %
230 % CloneDrawInfo() makes a copy of the given draw_info structure. If NULL
231 % is specified, a new DrawInfo structure is created initialized to default
232 % values.
233 %
234 % The format of the CloneDrawInfo method is:
235 %
236 % DrawInfo *CloneDrawInfo(const ImageInfo *image_info,
237 % const DrawInfo *draw_info)
238 %
239 % A description of each parameter follows:
240 %
241 % o image_info: the image info.
242 %
243 % o draw_info: the draw info.
244 %
245 */
246 MagickExport DrawInfo *CloneDrawInfo(const ImageInfo *image_info,
247  const DrawInfo *draw_info)
248 {
249  DrawInfo
250  *clone_info;
251 
252  clone_info=(DrawInfo *) AcquireMagickMemory(sizeof(*clone_info));
253  if (clone_info == (DrawInfo *) NULL)
254  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
255  GetDrawInfo(image_info,clone_info);
256  if (draw_info == (DrawInfo *) NULL)
257  return(clone_info);
258  if (clone_info->primitive != (char *) NULL)
259  (void) CloneString(&clone_info->primitive,draw_info->primitive);
260  if (draw_info->geometry != (char *) NULL)
261  (void) CloneString(&clone_info->geometry,draw_info->geometry);
262  clone_info->viewbox=draw_info->viewbox;
263  clone_info->affine=draw_info->affine;
264  clone_info->gravity=draw_info->gravity;
265  clone_info->fill=draw_info->fill;
266  clone_info->stroke=draw_info->stroke;
267  clone_info->stroke_width=draw_info->stroke_width;
268  if (draw_info->fill_pattern != (Image *) NULL)
269  clone_info->fill_pattern=CloneImage(draw_info->fill_pattern,0,0,MagickTrue,
270  &draw_info->fill_pattern->exception);
271  else
272  if (draw_info->tile != (Image *) NULL)
273  clone_info->fill_pattern=CloneImage(draw_info->tile,0,0,MagickTrue,
274  &draw_info->tile->exception);
275  clone_info->tile=NewImageList(); /* tile is deprecated */
276  if (draw_info->stroke_pattern != (Image *) NULL)
277  clone_info->stroke_pattern=CloneImage(draw_info->stroke_pattern,0,0,
278  MagickTrue,&draw_info->stroke_pattern->exception);
279  clone_info->stroke_antialias=draw_info->stroke_antialias;
280  clone_info->text_antialias=draw_info->text_antialias;
281  clone_info->fill_rule=draw_info->fill_rule;
282  clone_info->linecap=draw_info->linecap;
283  clone_info->linejoin=draw_info->linejoin;
284  clone_info->miterlimit=draw_info->miterlimit;
285  clone_info->dash_offset=draw_info->dash_offset;
286  clone_info->decorate=draw_info->decorate;
287  clone_info->compose=draw_info->compose;
288  if (draw_info->text != (char *) NULL)
289  (void) CloneString(&clone_info->text,draw_info->text);
290  if (draw_info->font != (char *) NULL)
291  (void) CloneString(&clone_info->font,draw_info->font);
292  if (draw_info->metrics != (char *) NULL)
293  (void) CloneString(&clone_info->metrics,draw_info->metrics);
294  if (draw_info->family != (char *) NULL)
295  (void) CloneString(&clone_info->family,draw_info->family);
296  clone_info->style=draw_info->style;
297  clone_info->stretch=draw_info->stretch;
298  clone_info->weight=draw_info->weight;
299  if (draw_info->encoding != (char *) NULL)
300  (void) CloneString(&clone_info->encoding,draw_info->encoding);
301  clone_info->pointsize=draw_info->pointsize;
302  clone_info->kerning=draw_info->kerning;
303  clone_info->interline_spacing=draw_info->interline_spacing;
304  clone_info->interword_spacing=draw_info->interword_spacing;
305  clone_info->direction=draw_info->direction;
306  if (draw_info->density != (char *) NULL)
307  (void) CloneString(&clone_info->density,draw_info->density);
308  clone_info->align=draw_info->align;
309  clone_info->undercolor=draw_info->undercolor;
310  clone_info->border_color=draw_info->border_color;
311  if (draw_info->server_name != (char *) NULL)
312  (void) CloneString(&clone_info->server_name,draw_info->server_name);
313  if (draw_info->dash_pattern != (double *) NULL)
314  {
315  register ssize_t
316  x;
317 
318  for (x=0; draw_info->dash_pattern[x] != 0.0; x++) ;
319  clone_info->dash_pattern=(double *) AcquireQuantumMemory((size_t) x+1UL,
320  sizeof(*clone_info->dash_pattern));
321  if (clone_info->dash_pattern == (double *) NULL)
322  ThrowFatalException(ResourceLimitFatalError,
323  "UnableToAllocateDashPattern");
324  (void) CopyMagickMemory(clone_info->dash_pattern,draw_info->dash_pattern,
325  (size_t) (x+1)*sizeof(*clone_info->dash_pattern));
326  }
327  clone_info->gradient=draw_info->gradient;
328  if (draw_info->gradient.stops != (StopInfo *) NULL)
329  {
330  size_t
331  number_stops;
332 
333  number_stops=clone_info->gradient.number_stops;
334  clone_info->gradient.stops=(StopInfo *) AcquireQuantumMemory((size_t)
335  number_stops,sizeof(*clone_info->gradient.stops));
336  if (clone_info->gradient.stops == (StopInfo *) NULL)
337  ThrowFatalException(ResourceLimitFatalError,
338  "UnableToAllocateDashPattern");
339  (void) CopyMagickMemory(clone_info->gradient.stops,
340  draw_info->gradient.stops,(size_t) number_stops*
341  sizeof(*clone_info->gradient.stops));
342  }
343  if (draw_info->clip_mask != (char *) NULL)
344  (void) CloneString(&clone_info->clip_mask,draw_info->clip_mask);
345  clone_info->bounds=draw_info->bounds;
346  clone_info->clip_units=draw_info->clip_units;
347  clone_info->render=draw_info->render;
348  clone_info->opacity=draw_info->opacity;
349  clone_info->element_reference=draw_info->element_reference;
350  clone_info->debug=IsEventLogging();
351  return(clone_info);
352 }
353 
354 
355 /*
356 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
357 % %
358 % %
359 % %
360 + C o n v e r t P a t h T o P o l y g o n %
361 % %
362 % %
363 % %
364 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
365 %
366 % ConvertPathToPolygon() converts a path to the more efficient sorted
367 % rendering form.
368 %
369 % The format of the ConvertPathToPolygon method is:
370 %
371 % PolygonInfo *ConvertPathToPolygon(const DrawInfo *draw_info,
372 % const PathInfo *path_info)
373 %
374 % A description of each parameter follows:
375 %
376 % o Method ConvertPathToPolygon returns the path in a more efficient sorted
377 % rendering form of type PolygonInfo.
378 %
379 % o draw_info: Specifies a pointer to an DrawInfo structure.
380 %
381 % o path_info: Specifies a pointer to an PathInfo structure.
382 %
383 %
384 */
385 
386 #if defined(__cplusplus) || defined(c_plusplus)
387 extern "C" {
388 #endif
389 
390 static int CompareEdges(const void *x,const void *y)
391 {
392  register const EdgeInfo
393  *p,
394  *q;
395 
396  /*
397  Compare two edges.
398  */
399  p=(const EdgeInfo *) x;
400  q=(const EdgeInfo *) y;
401  if ((p->points[0].y-MagickEpsilon) > q->points[0].y)
402  return(1);
403  if ((p->points[0].y+MagickEpsilon) < q->points[0].y)
404  return(-1);
405  if ((p->points[0].x-MagickEpsilon) > q->points[0].x)
406  return(1);
407  if ((p->points[0].x+MagickEpsilon) < q->points[0].x)
408  return(-1);
409  if (((p->points[1].x-p->points[0].x)*(q->points[1].y-q->points[0].y)-
410  (p->points[1].y-p->points[0].y)*(q->points[1].x-q->points[0].x)) > 0.0)
411  return(1);
412  return(-1);
413 }
414 
415 #if defined(__cplusplus) || defined(c_plusplus)
416 }
417 #endif
418 
419 static void LogPolygonInfo(const PolygonInfo *polygon_info)
420 {
421  register EdgeInfo
422  *p;
423 
424  register ssize_t
425  i,
426  j;
427 
428  (void) LogMagickEvent(DrawEvent,GetMagickModule()," begin active-edge");
429  p=polygon_info->edges;
430  for (i=0; i < (ssize_t) polygon_info->number_edges; i++)
431  {
432  (void) LogMagickEvent(DrawEvent,GetMagickModule()," edge %.20g:",
433  (double) i);
434  (void) LogMagickEvent(DrawEvent,GetMagickModule()," direction: %s",
435  p->direction != MagickFalse ? "down" : "up");
436  (void) LogMagickEvent(DrawEvent,GetMagickModule()," ghostline: %s",
437  p->ghostline != MagickFalse ? "transparent" : "opaque");
438  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
439  " bounds: %g %g - %g %g",p->bounds.x1,p->bounds.y1,
440  p->bounds.x2,p->bounds.y2);
441  for (j=0; j < (ssize_t) p->number_points; j++)
442  (void) LogMagickEvent(DrawEvent,GetMagickModule()," %g %g",
443  p->points[j].x,p->points[j].y);
444  p++;
445  }
446  (void) LogMagickEvent(DrawEvent,GetMagickModule()," end active-edge");
447 }
448 
449 static void ReversePoints(PointInfo *points,const size_t number_points)
450 {
451  PointInfo
452  point;
453 
454  register ssize_t
455  i;
456 
457  for (i=0; i < (ssize_t) (number_points >> 1); i++)
458  {
459  point=points[i];
460  points[i]=points[number_points-(i+1)];
461  points[number_points-(i+1)]=point;
462  }
463 }
464 
465 static PolygonInfo *ConvertPathToPolygon(
466  const DrawInfo *magick_unused(draw_info),const PathInfo *path_info)
467 {
468  long
469  direction,
470  next_direction;
471 
472  PointInfo
473  point,
474  *points;
475 
476  PolygonInfo
477  *polygon_info;
478 
479  SegmentInfo
480  bounds;
481 
482  register ssize_t
483  i,
484  n;
485 
486  MagickBooleanType
487  ghostline;
488 
489  size_t
490  edge,
491  number_edges,
492  number_points;
493 
494  magick_unreferenced(draw_info);
495 
496  /*
497  Convert a path to the more efficient sorted rendering form.
498  */
499  polygon_info=(PolygonInfo *) AcquireMagickMemory(sizeof(*polygon_info));
500  if (polygon_info == (PolygonInfo *) NULL)
501  return((PolygonInfo *) NULL);
502  number_edges=16;
503  polygon_info->edges=(EdgeInfo *) AcquireQuantumMemory((size_t) number_edges,
504  sizeof(*polygon_info->edges));
505  if (polygon_info->edges == (EdgeInfo *) NULL)
506  return((PolygonInfo *) NULL);
507  direction=0;
508  edge=0;
509  ghostline=MagickFalse;
510  n=0;
511  number_points=0;
512  points=(PointInfo *) NULL;
513  (void) ResetMagickMemory(&point,0,sizeof(point));
514  (void) ResetMagickMemory(&bounds,0,sizeof(bounds));
515  for (i=0; path_info[i].code != EndCode; i++)
516  {
517  if ((path_info[i].code == MoveToCode) || (path_info[i].code == OpenCode) ||
518  (path_info[i].code == GhostlineCode))
519  {
520  /*
521  Move to.
522  */
523  if ((points != (PointInfo *) NULL) && (n >= 2))
524  {
525  if (edge == number_edges)
526  {
527  number_edges<<=1;
528  polygon_info->edges=(EdgeInfo *) ResizeQuantumMemory(
529  polygon_info->edges,(size_t) number_edges,
530  sizeof(*polygon_info->edges));
531  if (polygon_info->edges == (EdgeInfo *) NULL)
532  return((PolygonInfo *) NULL);
533  }
534  polygon_info->edges[edge].number_points=(size_t) n;
535  polygon_info->edges[edge].scanline=(-1.0);
536  polygon_info->edges[edge].highwater=0;
537  polygon_info->edges[edge].ghostline=ghostline;
538  polygon_info->edges[edge].direction=(ssize_t) (direction > 0);
539  if (direction < 0)
540  ReversePoints(points,(size_t) n);
541  polygon_info->edges[edge].points=points;
542  polygon_info->edges[edge].bounds=bounds;
543  polygon_info->edges[edge].bounds.y1=points[0].y;
544  polygon_info->edges[edge].bounds.y2=points[n-1].y;
545  points=(PointInfo *) NULL;
546  ghostline=MagickFalse;
547  edge++;
548  }
549  if (points == (PointInfo *) NULL)
550  {
551  number_points=16;
552  points=(PointInfo *) AcquireQuantumMemory((size_t) number_points,
553  sizeof(*points));
554  if (points == (PointInfo *) NULL)
555  return((PolygonInfo *) NULL);
556  }
557  ghostline=path_info[i].code == GhostlineCode ? MagickTrue : MagickFalse;
558  point=path_info[i].point;
559  points[0]=point;
560  bounds.x1=point.x;
561  bounds.x2=point.x;
562  direction=0;
563  n=1;
564  continue;
565  }
566  /*
567  Line to.
568  */
569  next_direction=((path_info[i].point.y > point.y) ||
570  ((path_info[i].point.y == point.y) &&
571  (path_info[i].point.x > point.x))) ? 1 : -1;
572  if ((direction != 0) && (direction != next_direction))
573  {
574  /*
575  New edge.
576  */
577  point=points[n-1];
578  if (edge == number_edges)
579  {
580  number_edges<<=1;
581  polygon_info->edges=(EdgeInfo *) ResizeQuantumMemory(
582  polygon_info->edges,(size_t) number_edges,
583  sizeof(*polygon_info->edges));
584  if (polygon_info->edges == (EdgeInfo *) NULL)
585  return((PolygonInfo *) NULL);
586  }
587  polygon_info->edges[edge].number_points=(size_t) n;
588  polygon_info->edges[edge].scanline=(-1.0);
589  polygon_info->edges[edge].highwater=0;
590  polygon_info->edges[edge].ghostline=ghostline;
591  polygon_info->edges[edge].direction=(ssize_t) (direction > 0);
592  if (direction < 0)
593  ReversePoints(points,(size_t) n);
594  polygon_info->edges[edge].points=points;
595  polygon_info->edges[edge].bounds=bounds;
596  polygon_info->edges[edge].bounds.y1=points[0].y;
597  polygon_info->edges[edge].bounds.y2=points[n-1].y;
598  number_points=16;
599  points=(PointInfo *) AcquireQuantumMemory((size_t) number_points,
600  sizeof(*points));
601  if (points == (PointInfo *) NULL)
602  return((PolygonInfo *) NULL);
603  n=1;
604  ghostline=MagickFalse;
605  points[0]=point;
606  bounds.x1=point.x;
607  bounds.x2=point.x;
608  edge++;
609  }
610  direction=next_direction;
611  if (points == (PointInfo *) NULL)
612  continue;
613  if (n == (ssize_t) number_points)
614  {
615  number_points<<=1;
616  points=(PointInfo *) ResizeQuantumMemory(points,(size_t) number_points,
617  sizeof(*points));
618  if (points == (PointInfo *) NULL)
619  return((PolygonInfo *) NULL);
620  }
621  point=path_info[i].point;
622  points[n]=point;
623  if (point.x < bounds.x1)
624  bounds.x1=point.x;
625  if (point.x > bounds.x2)
626  bounds.x2=point.x;
627  n++;
628  }
629  if (points != (PointInfo *) NULL)
630  {
631  if (n < 2)
632  points=(PointInfo *) RelinquishMagickMemory(points);
633  else
634  {
635  if (edge == number_edges)
636  {
637  number_edges<<=1;
638  polygon_info->edges=(EdgeInfo *) ResizeQuantumMemory(
639  polygon_info->edges,(size_t) number_edges,
640  sizeof(*polygon_info->edges));
641  if (polygon_info->edges == (EdgeInfo *) NULL)
642  return((PolygonInfo *) NULL);
643  }
644  polygon_info->edges[edge].number_points=(size_t) n;
645  polygon_info->edges[edge].scanline=(-1.0);
646  polygon_info->edges[edge].highwater=0;
647  polygon_info->edges[edge].ghostline=ghostline;
648  polygon_info->edges[edge].direction=(ssize_t) (direction > 0);
649  if (direction < 0)
650  ReversePoints(points,(size_t) n);
651  polygon_info->edges[edge].points=points;
652  polygon_info->edges[edge].bounds=bounds;
653  polygon_info->edges[edge].bounds.y1=points[0].y;
654  polygon_info->edges[edge].bounds.y2=points[n-1].y;
655  ghostline=MagickFalse;
656  edge++;
657  }
658  }
659  polygon_info->number_edges=edge;
660  qsort(polygon_info->edges,(size_t) polygon_info->number_edges,
661  sizeof(*polygon_info->edges),CompareEdges);
662  if (IsEventLogging() != MagickFalse)
663  LogPolygonInfo(polygon_info);
664  return(polygon_info);
665 }
666 
667 
668 /*
669 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
670 % %
671 % %
672 % %
673 + C o n v e r t P r i m i t i v e T o P a t h %
674 % %
675 % %
676 % %
677 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
678 %
679 % ConvertPrimitiveToPath() converts a PrimitiveInfo structure into a vector
680 % path structure.
681 %
682 % The format of the ConvertPrimitiveToPath method is:
683 %
684 % PathInfo *ConvertPrimitiveToPath(const DrawInfo *draw_info,
685 % const PrimitiveInfo *primitive_info)
686 %
687 % A description of each parameter follows:
688 %
689 % o Method ConvertPrimitiveToPath returns a vector path structure of type
690 % PathInfo.
691 %
692 % o draw_info: a structure of type DrawInfo.
693 %
694 % o primitive_info: Specifies a pointer to an PrimitiveInfo structure.
695 %
696 %
697 */
698 
699 static void LogPathInfo(const PathInfo *path_info)
700 {
701  register const PathInfo
702  *p;
703 
704  (void) LogMagickEvent(DrawEvent,GetMagickModule()," begin vector-path");
705  for (p=path_info; p->code != EndCode; p++)
706  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
707  " %g %g %s",p->point.x,p->point.y,p->code == GhostlineCode ?
708  "moveto ghostline" : p->code == OpenCode ? "moveto open" :
709  p->code == MoveToCode ? "moveto" : p->code == LineToCode ? "lineto" :
710  "?");
711  (void) LogMagickEvent(DrawEvent,GetMagickModule()," end vector-path");
712 }
713 
714 static PathInfo *ConvertPrimitiveToPath(
715  const DrawInfo *magick_unused(draw_info),const PrimitiveInfo *primitive_info)
716 {
717  PathInfo
718  *path_info;
719 
720  PathInfoCode
721  code;
722 
723  PointInfo
724  p,
725  q;
726 
727  register ssize_t
728  i,
729  n;
730 
731  ssize_t
732  coordinates,
733  start;
734 
735  magick_unreferenced(draw_info);
736 
737  /*
738  Converts a PrimitiveInfo structure into a vector path structure.
739  */
740  switch (primitive_info->primitive)
741  {
742  case PointPrimitive:
743  case ColorPrimitive:
744  case MattePrimitive:
745  case TextPrimitive:
746  case ImagePrimitive:
747  return((PathInfo *) NULL);
748  default:
749  break;
750  }
751  for (i=0; primitive_info[i].primitive != UndefinedPrimitive; i++) ;
752  path_info=(PathInfo *) AcquireQuantumMemory((size_t) (2UL*i+3UL),
753  sizeof(*path_info));
754  if (path_info == (PathInfo *) NULL)
755  return((PathInfo *) NULL);
756  coordinates=0;
757  n=0;
758  p.x=(-1.0);
759  p.y=(-1.0);
760  q.x=(-1.0);
761  q.y=(-1.0);
762  start=0;
763  for (i=0; primitive_info[i].primitive != UndefinedPrimitive; i++)
764  {
765  code=LineToCode;
766  if (coordinates <= 0)
767  {
768  coordinates=(ssize_t) primitive_info[i].coordinates;
769  p=primitive_info[i].point;
770  start=n;
771  code=MoveToCode;
772  }
773  coordinates--;
774  /*
775  Eliminate duplicate points.
776  */
777  if ((i == 0) || (fabs(q.x-primitive_info[i].point.x) >= MagickEpsilon) ||
778  (fabs(q.y-primitive_info[i].point.y) >= MagickEpsilon))
779  {
780  path_info[n].code=code;
781  path_info[n].point=primitive_info[i].point;
782  q=primitive_info[i].point;
783  n++;
784  }
785  if (coordinates > 0)
786  continue;
787  if ((fabs(p.x-primitive_info[i].point.x) < MagickEpsilon) &&
788  (fabs(p.y-primitive_info[i].point.y) < MagickEpsilon))
789  continue;
790  /*
791  Mark the p point as open if it does not match the q.
792  */
793  path_info[start].code=OpenCode;
794  path_info[n].code=GhostlineCode;
795  path_info[n].point=primitive_info[i].point;
796  n++;
797  path_info[n].code=LineToCode;
798  path_info[n].point=p;
799  n++;
800  }
801  path_info[n].code=EndCode;
802  path_info[n].point.x=0.0;
803  path_info[n].point.y=0.0;
804  if (IsEventLogging() != MagickFalse)
805  LogPathInfo(path_info);
806  return(path_info);
807 }
808 
809 
810 /*
811 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
812 % %
813 % %
814 % %
815 % D e s t r o y D r a w I n f o %
816 % %
817 % %
818 % %
819 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
820 %
821 % DestroyDrawInfo() deallocates memory associated with an DrawInfo
822 % structure.
823 %
824 % The format of the DestroyDrawInfo method is:
825 %
826 % DrawInfo *DestroyDrawInfo(DrawInfo *draw_info)
827 %
828 % A description of each parameter follows:
829 %
830 % o draw_info: the draw info.
831 %
832 */
833 MagickExport DrawInfo *DestroyDrawInfo(DrawInfo *draw_info)
834 {
835  if (draw_info->debug != MagickFalse)
836  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
837  assert(draw_info != (DrawInfo *) NULL);
838  assert(draw_info->signature == MagickSignature);
839  if (draw_info->primitive != (char *) NULL)
840  draw_info->primitive=DestroyString(draw_info->primitive);
841  if (draw_info->text != (char *) NULL)
842  draw_info->text=DestroyString(draw_info->text);
843  if (draw_info->geometry != (char *) NULL)
844  draw_info->geometry=DestroyString(draw_info->geometry);
845  if (draw_info->tile != (Image *) NULL)
846  draw_info->tile=DestroyImage(draw_info->tile);
847  if (draw_info->fill_pattern != (Image *) NULL)
848  draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern);
849  if (draw_info->stroke_pattern != (Image *) NULL)
850  draw_info->stroke_pattern=DestroyImage(draw_info->stroke_pattern);
851  if (draw_info->font != (char *) NULL)
852  draw_info->font=DestroyString(draw_info->font);
853  if (draw_info->metrics != (char *) NULL)
854  draw_info->metrics=DestroyString(draw_info->metrics);
855  if (draw_info->family != (char *) NULL)
856  draw_info->family=DestroyString(draw_info->family);
857  if (draw_info->encoding != (char *) NULL)
858  draw_info->encoding=DestroyString(draw_info->encoding);
859  if (draw_info->density != (char *) NULL)
860  draw_info->density=DestroyString(draw_info->density);
861  if (draw_info->server_name != (char *) NULL)
862  draw_info->server_name=(char *)
863  RelinquishMagickMemory(draw_info->server_name);
864  if (draw_info->dash_pattern != (double *) NULL)
865  draw_info->dash_pattern=(double *) RelinquishMagickMemory(
866  draw_info->dash_pattern);
867  if (draw_info->gradient.stops != (StopInfo *) NULL)
868  draw_info->gradient.stops=(StopInfo *) RelinquishMagickMemory(
869  draw_info->gradient.stops);
870  if (draw_info->clip_mask != (char *) NULL)
871  draw_info->clip_mask=DestroyString(draw_info->clip_mask);
872  draw_info->signature=(~MagickSignature);
873  draw_info=(DrawInfo *) RelinquishMagickMemory(draw_info);
874  return(draw_info);
875 }
876 
877 
878 /*
879 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
880 % %
881 % %
882 % %
883 + D e s t r o y E d g e %
884 % %
885 % %
886 % %
887 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
888 %
889 % DestroyEdge() destroys the specified polygon edge.
890 %
891 % The format of the DestroyEdge method is:
892 %
893 % ssize_t DestroyEdge(PolygonInfo *polygon_info,const int edge)
894 %
895 % A description of each parameter follows:
896 %
897 % o polygon_info: Specifies a pointer to an PolygonInfo structure.
898 %
899 % o edge: the polygon edge number to destroy.
900 %
901 */
902 static size_t DestroyEdge(PolygonInfo *polygon_info,
903  const size_t edge)
904 {
905  assert(edge < polygon_info->number_edges);
906  polygon_info->edges[edge].points=(PointInfo *) RelinquishMagickMemory(
907  polygon_info->edges[edge].points);
908  polygon_info->number_edges--;
909  if (edge < polygon_info->number_edges)
910  (void) CopyMagickMemory(polygon_info->edges+edge,polygon_info->edges+edge+1,
911  (size_t) (polygon_info->number_edges-edge)*sizeof(*polygon_info->edges));
912  return(polygon_info->number_edges);
913 }
914 
915 
916 /*
917 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
918 % %
919 % %
920 % %
921 + D e s t r o y P o l y g o n I n f o %
922 % %
923 % %
924 % %
925 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
926 %
927 % DestroyPolygonInfo() destroys the PolygonInfo data structure.
928 %
929 % The format of the DestroyPolygonInfo method is:
930 %
931 % PolygonInfo *DestroyPolygonInfo(PolygonInfo *polygon_info)
932 %
933 % A description of each parameter follows:
934 %
935 % o polygon_info: Specifies a pointer to an PolygonInfo structure.
936 %
937 */
938 static PolygonInfo *DestroyPolygonInfo(PolygonInfo *polygon_info)
939 {
940  register ssize_t
941  i;
942 
943  for (i=0; i < (ssize_t) polygon_info->number_edges; i++)
944  polygon_info->edges[i].points=(PointInfo *)
945  RelinquishMagickMemory(polygon_info->edges[i].points);
946  polygon_info->edges=(EdgeInfo *) RelinquishMagickMemory(polygon_info->edges);
947  return((PolygonInfo *) RelinquishMagickMemory(polygon_info));
948 }
949 
950 
951 /*
952 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
953 % %
954 % %
955 % %
956 % D r a w A f f i n e I m a g e %
957 % %
958 % %
959 % %
960 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
961 %
962 % DrawAffineImage() composites the source over the destination image as
963 % dictated by the affine transform.
964 %
965 % The format of the DrawAffineImage method is:
966 %
967 % MagickBooleanType DrawAffineImage(Image *image,const Image *source,
968 % const AffineMatrix *affine)
969 %
970 % A description of each parameter follows:
971 %
972 % o image: the image.
973 %
974 % o source: the source image.
975 %
976 % o affine: the affine transform.
977 %
978 */
979 
980 static SegmentInfo AffineEdge(const Image *image,const AffineMatrix *affine,
981  const double y,const SegmentInfo *edge)
982 {
983  double
984  intercept,
985  z;
986 
987  register double
988  x;
989 
990  SegmentInfo
991  inverse_edge;
992 
993  /*
994  Determine left and right edges.
995  */
996  inverse_edge.x1=edge->x1;
997  inverse_edge.y1=edge->y1;
998  inverse_edge.x2=edge->x2;
999  inverse_edge.y2=edge->y2;
1000  z=affine->ry*y+affine->tx;
1001  if (affine->sx >= MagickEpsilon)
1002  {
1003  intercept=(-z/affine->sx);
1004  x=intercept;
1005  if (x > inverse_edge.x1)
1006  inverse_edge.x1=x;
1007  intercept=(-z+(double) image->columns)/affine->sx;
1008  x=intercept;
1009  if (x < inverse_edge.x2)
1010  inverse_edge.x2=x;
1011  }
1012  else
1013  if (affine->sx < -MagickEpsilon)
1014  {
1015  intercept=(-z+(double) image->columns)/affine->sx;
1016  x=intercept;
1017  if (x > inverse_edge.x1)
1018  inverse_edge.x1=x;
1019  intercept=(-z/affine->sx);
1020  x=intercept;
1021  if (x < inverse_edge.x2)
1022  inverse_edge.x2=x;
1023  }
1024  else
1025  if ((z < 0.0) || ((size_t) floor(z+0.5) >= image->columns))
1026  {
1027  inverse_edge.x2=edge->x1;
1028  return(inverse_edge);
1029  }
1030  /*
1031  Determine top and bottom edges.
1032  */
1033  z=affine->sy*y+affine->ty;
1034  if (affine->rx >= MagickEpsilon)
1035  {
1036  intercept=(-z/affine->rx);
1037  x=intercept;
1038  if (x > inverse_edge.x1)
1039  inverse_edge.x1=x;
1040  intercept=(-z+(double) image->rows)/affine->rx;
1041  x=intercept;
1042  if (x < inverse_edge.x2)
1043  inverse_edge.x2=x;
1044  }
1045  else
1046  if (affine->rx < -MagickEpsilon)
1047  {
1048  intercept=(-z+(double) image->rows)/affine->rx;
1049  x=intercept;
1050  if (x > inverse_edge.x1)
1051  inverse_edge.x1=x;
1052  intercept=(-z/affine->rx);
1053  x=intercept;
1054  if (x < inverse_edge.x2)
1055  inverse_edge.x2=x;
1056  }
1057  else
1058  if ((z < 0.0) || ((size_t) floor(z+0.5) >= image->rows))
1059  {
1060  inverse_edge.x2=edge->x2;
1061  return(inverse_edge);
1062  }
1063  return(inverse_edge);
1064 }
1065 
1066 static AffineMatrix InverseAffineMatrix(const AffineMatrix *affine)
1067 {
1068  AffineMatrix
1069  inverse_affine;
1070 
1071  double
1072  determinant;
1073 
1074  determinant=PerceptibleReciprocal(affine->sx*affine->sy-affine->rx*
1075  affine->ry);
1076  inverse_affine.sx=determinant*affine->sy;
1077  inverse_affine.rx=determinant*(-affine->rx);
1078  inverse_affine.ry=determinant*(-affine->ry);
1079  inverse_affine.sy=determinant*affine->sx;
1080  inverse_affine.tx=(-affine->tx)*inverse_affine.sx-affine->ty*
1081  inverse_affine.ry;
1082  inverse_affine.ty=(-affine->tx)*inverse_affine.rx-affine->ty*
1083  inverse_affine.sy;
1084  return(inverse_affine);
1085 }
1086 
1087 static inline ssize_t MagickAbsoluteValue(const ssize_t x)
1088 {
1089  if (x < 0)
1090  return(-x);
1091  return(x);
1092 }
1093 
1094 static inline double MagickMax(const double x,const double y)
1095 {
1096  if (x > y)
1097  return(x);
1098  return(y);
1099 }
1100 
1101 static inline double MagickMin(const double x,const double y)
1102 {
1103  if (x < y)
1104  return(x);
1105  return(y);
1106 }
1107 
1108 MagickExport MagickBooleanType DrawAffineImage(Image *image,
1109  const Image *source,const AffineMatrix *affine)
1110 {
1111  AffineMatrix
1112  inverse_affine;
1113 
1114  CacheView
1115  *image_view,
1116  *source_view;
1117 
1118  ExceptionInfo
1119  *exception;
1120 
1121  MagickBooleanType
1122  status;
1123 
1124  MagickPixelPacket
1125  zero;
1126 
1127  PointInfo
1128  extent[4],
1129  min,
1130  max,
1131  point;
1132 
1133  register ssize_t
1134  i;
1135 
1136  SegmentInfo
1137  edge;
1138 
1139  ssize_t
1140  start,
1141  stop,
1142  y;
1143 
1144  /*
1145  Determine bounding box.
1146  */
1147  assert(image != (Image *) NULL);
1148  assert(image->signature == MagickSignature);
1149  if (image->debug != MagickFalse)
1150  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1151  assert(source != (const Image *) NULL);
1152  assert(source->signature == MagickSignature);
1153  assert(affine != (AffineMatrix *) NULL);
1154  extent[0].x=0.0;
1155  extent[0].y=0.0;
1156  extent[1].x=(double) source->columns-1.0;
1157  extent[1].y=0.0;
1158  extent[2].x=(double) source->columns-1.0;
1159  extent[2].y=(double) source->rows-1.0;
1160  extent[3].x=0.0;
1161  extent[3].y=(double) source->rows-1.0;
1162  for (i=0; i < 4; i++)
1163  {
1164  point=extent[i];
1165  extent[i].x=point.x*affine->sx+point.y*affine->ry+affine->tx;
1166  extent[i].y=point.x*affine->rx+point.y*affine->sy+affine->ty;
1167  }
1168  min=extent[0];
1169  max=extent[0];
1170  for (i=1; i < 4; i++)
1171  {
1172  if (min.x > extent[i].x)
1173  min.x=extent[i].x;
1174  if (min.y > extent[i].y)
1175  min.y=extent[i].y;
1176  if (max.x < extent[i].x)
1177  max.x=extent[i].x;
1178  if (max.y < extent[i].y)
1179  max.y=extent[i].y;
1180  }
1181  /*
1182  Affine transform image.
1183  */
1184  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1185  return(MagickFalse);
1186  status=MagickTrue;
1187  edge.x1=MagickMax(min.x,0.0);
1188  edge.y1=MagickMax(min.y,0.0);
1189  edge.x2=MagickMin(max.x,(double) image->columns-1.0);
1190  edge.y2=MagickMin(max.y,(double) image->rows-1.0);
1191  inverse_affine=InverseAffineMatrix(affine);
1192  GetMagickPixelPacket(image,&zero);
1193  exception=(&image->exception);
1194  start=(ssize_t) ceil(edge.y1-0.5);
1195  stop=(ssize_t) floor(edge.y2+0.5);
1196  source_view=AcquireVirtualCacheView(source,exception);
1197  image_view=AcquireAuthenticCacheView(image,exception);
1198 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1199  #pragma omp parallel for schedule(static,4) shared(status) \
1200  magick_threads(source,image,1,1)
1201 #endif
1202  for (y=start; y <= stop; y++)
1203  {
1204  MagickPixelPacket
1205  composite,
1206  pixel;
1207 
1208  PointInfo
1209  point;
1210 
1211  register IndexPacket
1212  *restrict indexes;
1213 
1214  register ssize_t
1215  x;
1216 
1217  register PixelPacket
1218  *restrict q;
1219 
1220  SegmentInfo
1221  inverse_edge;
1222 
1223  ssize_t
1224  x_offset;
1225 
1226  inverse_edge=AffineEdge(source,&inverse_affine,(double) y,&edge);
1227  if (inverse_edge.x2 < inverse_edge.x1)
1228  continue;
1229  q=GetCacheViewAuthenticPixels(image_view,(ssize_t) ceil(inverse_edge.x1-
1230  0.5),y,(size_t) (floor(inverse_edge.x2+0.5)-ceil(inverse_edge.x1-0.5)+1),
1231  1,exception);
1232  if (q == (PixelPacket *) NULL)
1233  continue;
1234  indexes=GetCacheViewAuthenticIndexQueue(image_view);
1235  pixel=zero;
1236  composite=zero;
1237  x_offset=0;
1238  for (x=(ssize_t) ceil(inverse_edge.x1-0.5); x <= (ssize_t) floor(inverse_edge.x2+0.5); x++)
1239  {
1240  point.x=(double) x*inverse_affine.sx+y*inverse_affine.ry+
1241  inverse_affine.tx;
1242  point.y=(double) x*inverse_affine.rx+y*inverse_affine.sy+
1243  inverse_affine.ty;
1244  (void) InterpolateMagickPixelPacket(source,source_view,
1245  UndefinedInterpolatePixel,point.x,point.y,&pixel,exception);
1246  SetMagickPixelPacket(image,q,indexes+x_offset,&composite);
1247  MagickPixelCompositeOver(&pixel,pixel.opacity,&composite,
1248  composite.opacity,&composite);
1249  SetPixelPacket(image,&composite,q,indexes+x_offset);
1250  x_offset++;
1251  q++;
1252  }
1253  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1254  status=MagickFalse;
1255  }
1256  source_view=DestroyCacheView(source_view);
1257  image_view=DestroyCacheView(image_view);
1258  return(status);
1259 }
1260 
1261 
1262 /*
1263 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1264 % %
1265 % %
1266 % %
1267 + D r a w B o u n d i n g R e c t a n g l e s %
1268 % %
1269 % %
1270 % %
1271 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1272 %
1273 % DrawBoundingRectangles() draws the bounding rectangles on the image. This
1274 % is only useful for developers debugging the rendering algorithm.
1275 %
1276 % The format of the DrawBoundingRectangles method is:
1277 %
1278 % void DrawBoundingRectangles(Image *image,const DrawInfo *draw_info,
1279 % PolygonInfo *polygon_info)
1280 %
1281 % A description of each parameter follows:
1282 %
1283 % o image: the image.
1284 %
1285 % o draw_info: the draw info.
1286 %
1287 % o polygon_info: Specifies a pointer to a PolygonInfo structure.
1288 %
1289 */
1290 static void DrawBoundingRectangles(Image *image,const DrawInfo *draw_info,
1291  const PolygonInfo *polygon_info)
1292 {
1293  double
1294  mid;
1295 
1296  DrawInfo
1297  *clone_info;
1298 
1299  PointInfo
1300  end,
1301  resolution,
1302  start;
1303 
1304  PrimitiveInfo
1305  primitive_info[6];
1306 
1307  register ssize_t
1308  i;
1309 
1310  SegmentInfo
1311  bounds;
1312 
1313  ssize_t
1314  coordinates;
1315 
1316  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
1317  (void) QueryColorDatabase("#0000",&clone_info->fill,&image->exception);
1318  resolution.x=DefaultResolution;
1319  resolution.y=DefaultResolution;
1320  if (clone_info->density != (char *) NULL)
1321  {
1322  GeometryInfo
1323  geometry_info;
1324 
1325  MagickStatusType
1326  flags;
1327 
1328  flags=ParseGeometry(clone_info->density,&geometry_info);
1329  resolution.x=geometry_info.rho;
1330  resolution.y=geometry_info.sigma;
1331  if ((flags & SigmaValue) == MagickFalse)
1332  resolution.y=resolution.x;
1333  }
1334  mid=(resolution.x/72.0)*ExpandAffine(&clone_info->affine)*
1335  clone_info->stroke_width/2.0;
1336  bounds.x1=0.0;
1337  bounds.y1=0.0;
1338  bounds.x2=0.0;
1339  bounds.y2=0.0;
1340  if (polygon_info != (PolygonInfo *) NULL)
1341  {
1342  bounds=polygon_info->edges[0].bounds;
1343  for (i=1; i < (ssize_t) polygon_info->number_edges; i++)
1344  {
1345  if (polygon_info->edges[i].bounds.x1 < (double) bounds.x1)
1346  bounds.x1=polygon_info->edges[i].bounds.x1;
1347  if (polygon_info->edges[i].bounds.y1 < (double) bounds.y1)
1348  bounds.y1=polygon_info->edges[i].bounds.y1;
1349  if (polygon_info->edges[i].bounds.x2 > (double) bounds.x2)
1350  bounds.x2=polygon_info->edges[i].bounds.x2;
1351  if (polygon_info->edges[i].bounds.y2 > (double) bounds.y2)
1352  bounds.y2=polygon_info->edges[i].bounds.y2;
1353  }
1354  bounds.x1-=mid;
1355  bounds.x1=bounds.x1 < 0.0 ? 0.0 : bounds.x1 >= (double)
1356  image->columns ? (double) image->columns-1 : bounds.x1;
1357  bounds.y1-=mid;
1358  bounds.y1=bounds.y1 < 0.0 ? 0.0 : bounds.y1 >= (double)
1359  image->rows ? (double) image->rows-1 : bounds.y1;
1360  bounds.x2+=mid;
1361  bounds.x2=bounds.x2 < 0.0 ? 0.0 : bounds.x2 >= (double)
1362  image->columns ? (double) image->columns-1 : bounds.x2;
1363  bounds.y2+=mid;
1364  bounds.y2=bounds.y2 < 0.0 ? 0.0 : bounds.y2 >= (double)
1365  image->rows ? (double) image->rows-1 : bounds.y2;
1366  for (i=0; i < (ssize_t) polygon_info->number_edges; i++)
1367  {
1368  if (polygon_info->edges[i].direction != 0)
1369  (void) QueryColorDatabase("red",&clone_info->stroke,
1370  &image->exception);
1371  else
1372  (void) QueryColorDatabase("green",&clone_info->stroke,
1373  &image->exception);
1374  start.x=(double) (polygon_info->edges[i].bounds.x1-mid);
1375  start.y=(double) (polygon_info->edges[i].bounds.y1-mid);
1376  end.x=(double) (polygon_info->edges[i].bounds.x2+mid);
1377  end.y=(double) (polygon_info->edges[i].bounds.y2+mid);
1378  primitive_info[0].primitive=RectanglePrimitive;
1379  TraceRectangle(primitive_info,start,end);
1380  primitive_info[0].method=ReplaceMethod;
1381  coordinates=(ssize_t) primitive_info[0].coordinates;
1382  primitive_info[coordinates].primitive=UndefinedPrimitive;
1383  (void) DrawPrimitive(image,clone_info,primitive_info);
1384  }
1385  }
1386  (void) QueryColorDatabase("blue",&clone_info->stroke,&image->exception);
1387  start.x=(double) (bounds.x1-mid);
1388  start.y=(double) (bounds.y1-mid);
1389  end.x=(double) (bounds.x2+mid);
1390  end.y=(double) (bounds.y2+mid);
1391  primitive_info[0].primitive=RectanglePrimitive;
1392  TraceRectangle(primitive_info,start,end);
1393  primitive_info[0].method=ReplaceMethod;
1394  coordinates=(ssize_t) primitive_info[0].coordinates;
1395  primitive_info[coordinates].primitive=UndefinedPrimitive;
1396  (void) DrawPrimitive(image,clone_info,primitive_info);
1397  clone_info=DestroyDrawInfo(clone_info);
1398 }
1399 
1400 
1401 /*
1402 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1403 % %
1404 % %
1405 % %
1406 % D r a w C l i p P a t h %
1407 % %
1408 % %
1409 % %
1410 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1411 %
1412 % DrawClipPath() draws the clip path on the image mask.
1413 %
1414 % The format of the DrawClipPath method is:
1415 %
1416 % MagickBooleanType DrawClipPath(Image *image,const DrawInfo *draw_info,
1417 % const char *name)
1418 %
1419 % A description of each parameter follows:
1420 %
1421 % o image: the image.
1422 %
1423 % o draw_info: the draw info.
1424 %
1425 % o name: the name of the clip path.
1426 %
1427 */
1428 MagickExport MagickBooleanType DrawClipPath(Image *image,
1429  const DrawInfo *draw_info,const char *name)
1430 {
1431  char
1432  clip_mask[MaxTextExtent];
1433 
1434  const char
1435  *value;
1436 
1437  DrawInfo
1438  *clone_info;
1439 
1440  MagickStatusType
1441  status;
1442 
1443  assert(image != (Image *) NULL);
1444  assert(image->signature == MagickSignature);
1445  if (image->debug != MagickFalse)
1446  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1447  assert(draw_info != (const DrawInfo *) NULL);
1448  (void) FormatLocaleString(clip_mask,MaxTextExtent,"%s",name);
1449  value=GetImageArtifact(image,clip_mask);
1450  if (value == (const char *) NULL)
1451  return(MagickFalse);
1452  if (image->clip_mask == (Image *) NULL)
1453  {
1454  Image
1455  *clip_mask;
1456 
1457  clip_mask=CloneImage(image,image->columns,image->rows,MagickTrue,
1458  &image->exception);
1459  if (clip_mask == (Image *) NULL)
1460  return(MagickFalse);
1461  (void) SetImageClipMask(image,clip_mask);
1462  clip_mask=DestroyImage(clip_mask);
1463  }
1464  (void) QueryColorDatabase("#00000000",&image->clip_mask->background_color,
1465  &image->exception);
1466  image->clip_mask->background_color.opacity=(Quantum) TransparentOpacity;
1467  (void) SetImageBackgroundColor(image->clip_mask);
1468  if (image->debug != MagickFalse)
1469  (void) LogMagickEvent(DrawEvent,GetMagickModule(),"\nbegin clip-path %s",
1470  draw_info->clip_mask);
1471  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
1472  (void) CloneString(&clone_info->primitive,value);
1473  (void) QueryColorDatabase("#ffffff",&clone_info->fill,&image->exception);
1474  clone_info->clip_mask=(char *) NULL;
1475  status=DrawImage(image->clip_mask,clone_info);
1476  status&=NegateImage(image->clip_mask,MagickFalse);
1477  clone_info=DestroyDrawInfo(clone_info);
1478  if (image->debug != MagickFalse)
1479  (void) LogMagickEvent(DrawEvent,GetMagickModule(),"end clip-path");
1480  return(status != 0 ? MagickTrue : MagickFalse);
1481 }
1482 
1483 
1484 /*
1485 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1486 % %
1487 % %
1488 % %
1489 + D r a w D a s h P o l y g o n %
1490 % %
1491 % %
1492 % %
1493 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1494 %
1495 % DrawDashPolygon() draws a dashed polygon (line, rectangle, ellipse) on the
1496 % image while respecting the dash offset and dash pattern attributes.
1497 %
1498 % The format of the DrawDashPolygon method is:
1499 %
1500 % MagickBooleanType DrawDashPolygon(const DrawInfo *draw_info,
1501 % const PrimitiveInfo *primitive_info,Image *image)
1502 %
1503 % A description of each parameter follows:
1504 %
1505 % o draw_info: the draw info.
1506 %
1507 % o primitive_info: Specifies a pointer to a PrimitiveInfo structure.
1508 %
1509 % o image: the image.
1510 %
1511 %
1512 */
1513 static MagickBooleanType DrawDashPolygon(const DrawInfo *draw_info,
1514  const PrimitiveInfo *primitive_info,Image *image)
1515 {
1516  double
1517  length,
1518  maximum_length,
1519  offset,
1520  scale,
1521  total_length;
1522 
1523  DrawInfo
1524  *clone_info;
1525 
1526  MagickStatusType
1527  status;
1528 
1529  PrimitiveInfo
1530  *dash_polygon;
1531 
1532  register double
1533  dx,
1534  dy;
1535 
1536  register ssize_t
1537  i;
1538 
1539  size_t
1540  number_vertices;
1541 
1542  ssize_t
1543  j,
1544  n;
1545 
1546  assert(draw_info != (const DrawInfo *) NULL);
1547  if (image->debug != MagickFalse)
1548  (void) LogMagickEvent(DrawEvent,GetMagickModule()," begin draw-dash");
1549  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
1550  clone_info->miterlimit=0;
1551  for (i=0; primitive_info[i].primitive != UndefinedPrimitive; i++) ;
1552  number_vertices=(size_t) i;
1553  dash_polygon=(PrimitiveInfo *) AcquireQuantumMemory((size_t)
1554  (2UL*number_vertices+1UL),sizeof(*dash_polygon));
1555  if (dash_polygon == (PrimitiveInfo *) NULL)
1556  return(MagickFalse);
1557  dash_polygon[0]=primitive_info[0];
1558  scale=ExpandAffine(&draw_info->affine);
1559  length=scale*(draw_info->dash_pattern[0]-0.5);
1560  offset=draw_info->dash_offset != 0.0 ? scale*draw_info->dash_offset : 0.0;
1561  j=1;
1562  for (n=0; offset > 0.0; j=0)
1563  {
1564  if (draw_info->dash_pattern[n] <= 0.0)
1565  break;
1566  length=scale*(draw_info->dash_pattern[n]+(n == 0 ? -0.5 : 0.5));
1567  if (offset > length)
1568  {
1569  offset-=length;
1570  n++;
1571  length=scale*(draw_info->dash_pattern[n]+(n == 0 ? -0.5 : 0.5));
1572  continue;
1573  }
1574  if (offset < length)
1575  {
1576  length-=offset;
1577  offset=0.0;
1578  break;
1579  }
1580  offset=0.0;
1581  n++;
1582  }
1583  status=MagickTrue;
1584  maximum_length=0.0;
1585  total_length=0.0;
1586  for (i=1; i < (ssize_t) number_vertices; i++)
1587  {
1588  dx=primitive_info[i].point.x-primitive_info[i-1].point.x;
1589  dy=primitive_info[i].point.y-primitive_info[i-1].point.y;
1590  maximum_length=hypot((double) dx,dy);
1591  if (length == 0.0)
1592  {
1593  n++;
1594  if (draw_info->dash_pattern[n] == 0.0)
1595  n=0;
1596  length=scale*(draw_info->dash_pattern[n]+(n == 0 ? -0.5 : 0.5));
1597  }
1598  for (total_length=0.0; (total_length+length) <= maximum_length; )
1599  {
1600  total_length+=length;
1601  if ((n & 0x01) != 0)
1602  {
1603  dash_polygon[0]=primitive_info[0];
1604  dash_polygon[0].point.x=(double) (primitive_info[i-1].point.x+dx*
1605  total_length/maximum_length);
1606  dash_polygon[0].point.y=(double) (primitive_info[i-1].point.y+dy*
1607  total_length/maximum_length);
1608  j=1;
1609  }
1610  else
1611  {
1612  if ((j+1) > (ssize_t) (2*number_vertices))
1613  break;
1614  dash_polygon[j]=primitive_info[i-1];
1615  dash_polygon[j].point.x=(double) (primitive_info[i-1].point.x+dx*
1616  total_length/maximum_length);
1617  dash_polygon[j].point.y=(double) (primitive_info[i-1].point.y+dy*
1618  total_length/maximum_length);
1619  dash_polygon[j].coordinates=1;
1620  j++;
1621  dash_polygon[0].coordinates=(size_t) j;
1622  dash_polygon[j].primitive=UndefinedPrimitive;
1623  status&=DrawStrokePolygon(image,clone_info,dash_polygon);
1624  }
1625  n++;
1626  if (draw_info->dash_pattern[n] == 0.0)
1627  n=0;
1628  length=scale*(draw_info->dash_pattern[n]+(n == 0 ? -0.5 : 0.5));
1629  }
1630  length-=(maximum_length-total_length);
1631  if ((n & 0x01) != 0)
1632  continue;
1633  dash_polygon[j]=primitive_info[i];
1634  dash_polygon[j].coordinates=1;
1635  j++;
1636  }
1637  if ((total_length <= maximum_length) && ((n & 0x01) == 0) && (j > 1))
1638  {
1639  dash_polygon[j]=primitive_info[i-1];
1640  dash_polygon[j].point.x+=MagickEpsilon;
1641  dash_polygon[j].point.y+=MagickEpsilon;
1642  dash_polygon[j].coordinates=1;
1643  j++;
1644  dash_polygon[0].coordinates=(size_t) j;
1645  dash_polygon[j].primitive=UndefinedPrimitive;
1646  status&=DrawStrokePolygon(image,clone_info,dash_polygon);
1647  }
1648  dash_polygon=(PrimitiveInfo *) RelinquishMagickMemory(dash_polygon);
1649  clone_info=DestroyDrawInfo(clone_info);
1650  if (image->debug != MagickFalse)
1651  (void) LogMagickEvent(DrawEvent,GetMagickModule()," end draw-dash");
1652  return(status != 0 ? MagickTrue : MagickFalse);
1653 }
1654 
1655 
1656 /*
1657 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1658 % %
1659 % %
1660 % %
1661 % D r a w I m a g e %
1662 % %
1663 % %
1664 % %
1665 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1666 %
1667 % DrawImage() draws a graphic primitive on your image. The primitive
1668 % may be represented as a string or filename. Precede the filename with an
1669 % "at" sign (@) and the contents of the file are drawn on the image. You
1670 % can affect how text is drawn by setting one or more members of the draw
1671 % info structure.
1672 %
1673 % The format of the DrawImage method is:
1674 %
1675 % MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info)
1676 %
1677 % A description of each parameter follows:
1678 %
1679 % o image: the image.
1680 %
1681 % o draw_info: the draw info.
1682 %
1683 */
1684 
1685 static inline MagickBooleanType IsPoint(const char *point)
1686 {
1687  char
1688  *p;
1689 
1690  double
1691  value;
1692 
1693  value=StringToDouble(point,&p);
1694  return((value == 0.0) && (p == point) ? MagickFalse : MagickTrue);
1695 }
1696 
1697 static inline void TracePoint(PrimitiveInfo *primitive_info,
1698  const PointInfo point)
1699 {
1700  primitive_info->coordinates=1;
1701  primitive_info->point=point;
1702 }
1703 
1704 MagickExport MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info)
1705 {
1706 #define RenderImageTag "Render/Image"
1707 
1708  AffineMatrix
1709  affine,
1710  current;
1711 
1712  char
1713  key[2*MaxTextExtent],
1714  keyword[MaxTextExtent],
1715  geometry[MaxTextExtent],
1716  name[MaxTextExtent],
1717  pattern[MaxTextExtent],
1718  *primitive,
1719  *token;
1720 
1721  const char
1722  *q;
1723 
1724  double
1725  angle,
1726  factor,
1727  primitive_extent;
1728 
1729  DrawInfo
1730  **graphic_context;
1731 
1732  MagickBooleanType
1733  proceed;
1734 
1735  MagickStatusType
1736  status;
1737 
1738  PointInfo
1739  point;
1740 
1741  PixelPacket
1742  start_color;
1743 
1744  PrimitiveInfo
1745  *primitive_info;
1746 
1747  PrimitiveType
1748  primitive_type;
1749 
1750  register const char
1751  *p;
1752 
1753  register ssize_t
1754  i,
1755  x;
1756 
1757  SegmentInfo
1758  bounds;
1759 
1760  size_t
1761  length,
1762  number_points;
1763 
1764  ssize_t
1765  j,
1766  k,
1767  n;
1768 
1769  /*
1770  Ensure the annotation info is valid.
1771  */
1772  assert(image != (Image *) NULL);
1773  assert(image->signature == MagickSignature);
1774  if (image->debug != MagickFalse)
1775  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1776  assert(draw_info != (DrawInfo *) NULL);
1777  assert(draw_info->signature == MagickSignature);
1778  if (image->debug != MagickFalse)
1779  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1780  if ((draw_info->primitive == (char *) NULL) ||
1781  (*draw_info->primitive == '\0'))
1782  return(MagickFalse);
1783  if (image->debug != MagickFalse)
1784  (void) LogMagickEvent(DrawEvent,GetMagickModule(),"begin draw-image");
1785  if (*draw_info->primitive != '@')
1786  primitive=AcquireString(draw_info->primitive);
1787  else
1788  primitive=FileToString(draw_info->primitive+1,~0UL,&image->exception);
1789  if (primitive == (char *) NULL)
1790  return(MagickFalse);
1791  primitive_extent=(double) strlen(primitive);
1792  (void) SetImageArtifact(image,"MVG",primitive);
1793  n=0;
1794  /*
1795  Allocate primitive info memory.
1796  */
1797  graphic_context=(DrawInfo **) AcquireMagickMemory(
1798  sizeof(*graphic_context));
1799  if (graphic_context == (DrawInfo **) NULL)
1800  {
1801  primitive=DestroyString(primitive);
1802  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1803  image->filename);
1804  }
1805  number_points=6553;
1806  primitive_info=(PrimitiveInfo *) AcquireQuantumMemory((size_t) number_points,
1807  sizeof(*primitive_info));
1808  if (primitive_info == (PrimitiveInfo *) NULL)
1809  {
1810  primitive=DestroyString(primitive);
1811  for ( ; n >= 0; n--)
1812  graphic_context[n]=DestroyDrawInfo(graphic_context[n]);
1813  graphic_context=(DrawInfo **) RelinquishMagickMemory(graphic_context);
1814  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1815  image->filename);
1816  }
1817  graphic_context[n]=CloneDrawInfo((ImageInfo *) NULL,draw_info);
1818  graphic_context[n]->viewbox=image->page;
1819  if ((image->page.width == 0) || (image->page.height == 0))
1820  {
1821  graphic_context[n]->viewbox.width=image->columns;
1822  graphic_context[n]->viewbox.height=image->rows;
1823  }
1824  token=AcquireString(primitive);
1825  (void) QueryColorDatabase("#000000",&start_color,&image->exception);
1826  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1827  return(MagickFalse);
1828  status=MagickTrue;
1829  for (q=primitive; *q != '\0'; )
1830  {
1831  /*
1832  Interpret graphic primitive.
1833  */
1834  GetMagickToken(q,&q,keyword);
1835  if (*keyword == '\0')
1836  break;
1837  if (*keyword == '#')
1838  {
1839  /*
1840  Comment.
1841  */
1842  while ((*q != '\n') && (*q != '\0'))
1843  q++;
1844  continue;
1845  }
1846  p=q-strlen(keyword)-1;
1847  primitive_type=UndefinedPrimitive;
1848  current=graphic_context[n]->affine;
1849  GetAffineMatrix(&affine);
1850  switch (*keyword)
1851  {
1852  case ';':
1853  break;
1854  case 'a':
1855  case 'A':
1856  {
1857  if (LocaleCompare("affine",keyword) == 0)
1858  {
1859  GetMagickToken(q,&q,token);
1860  affine.sx=StringToDouble(token,(char **) NULL);
1861  GetMagickToken(q,&q,token);
1862  if (*token == ',')
1863  GetMagickToken(q,&q,token);
1864  affine.rx=StringToDouble(token,(char **) NULL);
1865  GetMagickToken(q,&q,token);
1866  if (*token == ',')
1867  GetMagickToken(q,&q,token);
1868  affine.ry=StringToDouble(token,(char **) NULL);
1869  GetMagickToken(q,&q,token);
1870  if (*token == ',')
1871  GetMagickToken(q,&q,token);
1872  affine.sy=StringToDouble(token,(char **) NULL);
1873  GetMagickToken(q,&q,token);
1874  if (*token == ',')
1875  GetMagickToken(q,&q,token);
1876  affine.tx=StringToDouble(token,(char **) NULL);
1877  GetMagickToken(q,&q,token);
1878  if (*token == ',')
1879  GetMagickToken(q,&q,token);
1880  affine.ty=StringToDouble(token,(char **) NULL);
1881  break;
1882  }
1883  if (LocaleCompare("arc",keyword) == 0)
1884  {
1885  primitive_type=ArcPrimitive;
1886  break;
1887  }
1888  status=MagickFalse;
1889  break;
1890  }
1891  case 'b':
1892  case 'B':
1893  {
1894  if (LocaleCompare("bezier",keyword) == 0)
1895  {
1896  primitive_type=BezierPrimitive;
1897  break;
1898  }
1899  if (LocaleCompare("border-color",keyword) == 0)
1900  {
1901  GetMagickToken(q,&q,token);
1902  (void) QueryColorDatabase(token,&graphic_context[n]->border_color,
1903  &image->exception);
1904  break;
1905  }
1906  status=MagickFalse;
1907  break;
1908  }
1909  case 'c':
1910  case 'C':
1911  {
1912  if (LocaleCompare("clip-path",keyword) == 0)
1913  {
1914  /*
1915  Create clip mask.
1916  */
1917  GetMagickToken(q,&q,token);
1918  (void) CloneString(&graphic_context[n]->clip_mask,token);
1919  (void) DrawClipPath(image,graphic_context[n],
1920  graphic_context[n]->clip_mask);
1921  break;
1922  }
1923  if (LocaleCompare("clip-rule",keyword) == 0)
1924  {
1925  ssize_t
1926  fill_rule;
1927 
1928  GetMagickToken(q,&q,token);
1929  fill_rule=ParseCommandOption(MagickFillRuleOptions,MagickFalse,
1930  token);
1931  if (fill_rule == -1)
1932  {
1933  status=MagickFalse;
1934  break;
1935  }
1936  graphic_context[n]->fill_rule=(FillRule) fill_rule;
1937  break;
1938  }
1939  if (LocaleCompare("clip-units",keyword) == 0)
1940  {
1941  ssize_t
1942  clip_units;
1943 
1944  GetMagickToken(q,&q,token);
1945  clip_units=ParseCommandOption(MagickClipPathOptions,MagickFalse,
1946  token);
1947  if (clip_units == -1)
1948  {
1949  status=MagickFalse;
1950  break;
1951  }
1952  graphic_context[n]->clip_units=(ClipPathUnits) clip_units;
1953  if (clip_units == ObjectBoundingBox)
1954  {
1955  GetAffineMatrix(&current);
1956  affine.sx=draw_info->bounds.x2;
1957  affine.sy=draw_info->bounds.y2;
1958  affine.tx=draw_info->bounds.x1;
1959  affine.ty=draw_info->bounds.y1;
1960  break;
1961  }
1962  break;
1963  }
1964  if (LocaleCompare("circle",keyword) == 0)
1965  {
1966  primitive_type=CirclePrimitive;
1967  break;
1968  }
1969  if (LocaleCompare("color",keyword) == 0)
1970  {
1971  primitive_type=ColorPrimitive;
1972  break;
1973  }
1974  status=MagickFalse;
1975  break;
1976  }
1977  case 'd':
1978  case 'D':
1979  {
1980  if (LocaleCompare("decorate",keyword) == 0)
1981  {
1982  ssize_t
1983  decorate;
1984 
1985  GetMagickToken(q,&q,token);
1986  decorate=ParseCommandOption(MagickDecorateOptions,MagickFalse,
1987  token);
1988  if (decorate == -1)
1989  {
1990  status=MagickFalse;
1991  break;
1992  }
1993  graphic_context[n]->decorate=(DecorationType) decorate;
1994  break;
1995  }
1996  status=MagickFalse;
1997  break;
1998  }
1999  case 'e':
2000  case 'E':
2001  {
2002  if (LocaleCompare("ellipse",keyword) == 0)
2003  {
2004  primitive_type=EllipsePrimitive;
2005  break;
2006  }
2007  if (LocaleCompare("encoding",keyword) == 0)
2008  {
2009  GetMagickToken(q,&q,token);
2010  (void) CloneString(&graphic_context[n]->encoding,token);
2011  break;
2012  }
2013  status=MagickFalse;
2014  break;
2015  }
2016  case 'f':
2017  case 'F':
2018  {
2019  if (LocaleCompare("fill",keyword) == 0)
2020  {
2021  GetMagickToken(q,&q,token);
2022  (void) FormatLocaleString(pattern,MaxTextExtent,"%s",token);
2023  if (GetImageArtifact(image,pattern) != (const char *) NULL)
2024  (void) DrawPatternPath(image,draw_info,token,
2025  &graphic_context[n]->fill_pattern);
2026  else
2027  {
2028  status&=QueryColorDatabase(token,&graphic_context[n]->fill,
2029  &image->exception);
2030  if (status == MagickFalse)
2031  {
2032  ImageInfo
2033  *pattern_info;
2034 
2035  pattern_info=AcquireImageInfo();
2036  (void) CopyMagickString(pattern_info->filename,token,
2037  MaxTextExtent);
2038  graphic_context[n]->fill_pattern=
2039  ReadImage(pattern_info,&image->exception);
2040  CatchException(&image->exception);
2041  pattern_info=DestroyImageInfo(pattern_info);
2042  }
2043  }
2044  break;
2045  }
2046  if (LocaleCompare("fill-opacity",keyword) == 0)
2047  {
2048  GetMagickToken(q,&q,token);
2049  factor=strchr(token,'%') != (char *) NULL ? 0.01 : 1.0;
2050  graphic_context[n]->fill.opacity=ClampToQuantum((MagickRealType)
2051  QuantumRange*(1.0-factor*StringToDouble(token,(char **) NULL)));
2052  break;
2053  }
2054  if (LocaleCompare("fill-rule",keyword) == 0)
2055  {
2056  ssize_t
2057  fill_rule;
2058 
2059  GetMagickToken(q,&q,token);
2060  fill_rule=ParseCommandOption(MagickFillRuleOptions,MagickFalse,
2061  token);
2062  if (fill_rule == -1)
2063  {
2064  status=MagickFalse;
2065  break;
2066  }
2067  graphic_context[n]->fill_rule=(FillRule) fill_rule;
2068  break;
2069  }
2070  if (LocaleCompare("font",keyword) == 0)
2071  {
2072  GetMagickToken(q,&q,token);
2073  (void) CloneString(&graphic_context[n]->font,token);
2074  if (LocaleCompare("none",token) == 0)
2075  graphic_context[n]->font=(char *)
2076  RelinquishMagickMemory(graphic_context[n]->font);
2077  break;
2078  }
2079  if (LocaleCompare("font-family",keyword) == 0)
2080  {
2081  GetMagickToken(q,&q,token);
2082  (void) CloneString(&graphic_context[n]->family,token);
2083  break;
2084  }
2085  if (LocaleCompare("font-size",keyword) == 0)
2086  {
2087  GetMagickToken(q,&q,token);
2088  graphic_context[n]->pointsize=StringToDouble(token,(char **) NULL);
2089  break;
2090  }
2091  if (LocaleCompare("font-stretch",keyword) == 0)
2092  {
2093  ssize_t
2094  stretch;
2095 
2096  GetMagickToken(q,&q,token);
2097  stretch=ParseCommandOption(MagickStretchOptions,MagickFalse,token);
2098  if (stretch == -1)
2099  {
2100  status=MagickFalse;
2101  break;
2102  }
2103  graphic_context[n]->stretch=(StretchType) stretch;
2104  break;
2105  }
2106  if (LocaleCompare("font-style",keyword) == 0)
2107  {
2108  ssize_t
2109  style;
2110 
2111  GetMagickToken(q,&q,token);
2112  style=ParseCommandOption(MagickStyleOptions,MagickFalse,token);
2113  if (style == -1)
2114  {
2115  status=MagickFalse;
2116  break;
2117  }
2118  graphic_context[n]->style=(StyleType) style;
2119  break;
2120  }
2121  if (LocaleCompare("font-weight",keyword) == 0)
2122  {
2123  GetMagickToken(q,&q,token);
2124  graphic_context[n]->weight=StringToUnsignedLong(token);
2125  if (LocaleCompare(token,"all") == 0)
2126  graphic_context[n]->weight=0;
2127  if (LocaleCompare(token,"bold") == 0)
2128  graphic_context[n]->weight=700;
2129  if (LocaleCompare(token,"bolder") == 0)
2130  if (graphic_context[n]->weight <= 800)
2131  graphic_context[n]->weight+=100;
2132  if (LocaleCompare(token,"lighter") == 0)
2133  if (graphic_context[n]->weight >= 100)
2134  graphic_context[n]->weight-=100;
2135  if (LocaleCompare(token,"normal") == 0)
2136  graphic_context[n]->weight=400;
2137  break;
2138  }
2139  status=MagickFalse;
2140  break;
2141  }
2142  case 'g':
2143  case 'G':
2144  {
2145  if (LocaleCompare("gradient-units",keyword) == 0)
2146  {
2147  GetMagickToken(q,&q,token);
2148  break;
2149  }
2150  if (LocaleCompare("gravity",keyword) == 0)
2151  {
2152  ssize_t
2153  gravity;
2154 
2155  GetMagickToken(q,&q,token);
2156  gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,token);
2157  if (gravity == -1)
2158  {
2159  status=MagickFalse;
2160  break;
2161  }
2162  graphic_context[n]->gravity=(GravityType) gravity;
2163  break;
2164  }
2165  status=MagickFalse;
2166  break;
2167  }
2168  case 'i':
2169  case 'I':
2170  {
2171  if (LocaleCompare("image",keyword) == 0)
2172  {
2173  ssize_t
2174  compose;
2175 
2176  primitive_type=ImagePrimitive;
2177  GetMagickToken(q,&q,token);
2178  compose=ParseCommandOption(MagickComposeOptions,MagickFalse,token);
2179  if (compose == -1)
2180  {
2181  status=MagickFalse;
2182  break;
2183  }
2184  graphic_context[n]->compose=(CompositeOperator) compose;
2185  break;
2186  }
2187  if (LocaleCompare("interline-spacing",keyword) == 0)
2188  {
2189  GetMagickToken(q,&q,token);
2190  graphic_context[n]->interline_spacing=StringToDouble(token,
2191  (char **) NULL);
2192  break;
2193  }
2194  if (LocaleCompare("interword-spacing",keyword) == 0)
2195  {
2196  GetMagickToken(q,&q,token);
2197  graphic_context[n]->interword_spacing=StringToDouble(token,
2198  (char **) NULL);
2199  break;
2200  }
2201  status=MagickFalse;
2202  break;
2203  }
2204  case 'k':
2205  case 'K':
2206  {
2207  if (LocaleCompare("kerning",keyword) == 0)
2208  {
2209  GetMagickToken(q,&q,token);
2210  graphic_context[n]->kerning=StringToDouble(token,(char **) NULL);
2211  break;
2212  }
2213  status=MagickFalse;
2214  break;
2215  }
2216  case 'l':
2217  case 'L':
2218  {
2219  if (LocaleCompare("line",keyword) == 0)
2220  {
2221  primitive_type=LinePrimitive;
2222  break;
2223  }
2224  status=MagickFalse;
2225  break;
2226  }
2227  case 'm':
2228  case 'M':
2229  {
2230  if (LocaleCompare("matte",keyword) == 0)
2231  {
2232  primitive_type=MattePrimitive;
2233  break;
2234  }
2235  status=MagickFalse;
2236  break;
2237  }
2238  case 'o':
2239  case 'O':
2240  {
2241  if (LocaleCompare("offset",keyword) == 0)
2242  {
2243  GetMagickToken(q,&q,token);
2244  break;
2245  }
2246  if (LocaleCompare("opacity",keyword) == 0)
2247  {
2248  GetMagickToken(q,&q,token);
2249  factor=strchr(token,'%') != (char *) NULL ? 0.01 : 1.0;
2250  graphic_context[n]->opacity=ClampToQuantum((MagickRealType)
2251  QuantumRange*(1.0-((1.0-QuantumScale*graphic_context[n]->opacity)*
2252  factor*StringToDouble(token,(char **) NULL))));
2253  graphic_context[n]->fill.opacity=graphic_context[n]->opacity;
2254  graphic_context[n]->stroke.opacity=graphic_context[n]->opacity;
2255  break;
2256  }
2257  status=MagickFalse;
2258  break;
2259  }
2260  case 'p':
2261  case 'P':
2262  {
2263  if (LocaleCompare("path",keyword) == 0)
2264  {
2265  primitive_type=PathPrimitive;
2266  break;
2267  }
2268  if (LocaleCompare("point",keyword) == 0)
2269  {
2270  primitive_type=PointPrimitive;
2271  break;
2272  }
2273  if (LocaleCompare("polyline",keyword) == 0)
2274  {
2275  primitive_type=PolylinePrimitive;
2276  break;
2277  }
2278  if (LocaleCompare("polygon",keyword) == 0)
2279  {
2280  primitive_type=PolygonPrimitive;
2281  break;
2282  }
2283  if (LocaleCompare("pop",keyword) == 0)
2284  {
2285  GetMagickToken(q,&q,token);
2286  if (LocaleCompare("clip-path",token) == 0)
2287  break;
2288  if (LocaleCompare("defs",token) == 0)
2289  break;
2290  if (LocaleCompare("gradient",token) == 0)
2291  break;
2292  if (LocaleCompare("graphic-context",token) == 0)
2293  {
2294  if (n <= 0)
2295  {
2296  (void) ThrowMagickException(&image->exception,
2297  GetMagickModule(),DrawError,
2298  "UnbalancedGraphicContextPushPop","`%s'",token);
2299  n=0;
2300  break;
2301  }
2302  if (graphic_context[n]->clip_mask != (char *) NULL)
2303  if (LocaleCompare(graphic_context[n]->clip_mask,
2304  graphic_context[n-1]->clip_mask) != 0)
2305  (void) SetImageClipMask(image,(Image *) NULL);
2306  graphic_context[n]=DestroyDrawInfo(graphic_context[n]);
2307  n--;
2308  break;
2309  }
2310  if (LocaleCompare("pattern",token) == 0)
2311  break;
2312  status=MagickFalse;
2313  break;
2314  }
2315  if (LocaleCompare("push",keyword) == 0)
2316  {
2317  GetMagickToken(q,&q,token);
2318  if (LocaleCompare("clip-path",token) == 0)
2319  {
2320  char
2321  name[MaxTextExtent];
2322 
2323  GetMagickToken(q,&q,token);
2324  (void) FormatLocaleString(name,MaxTextExtent,"%s",token);
2325  for (p=q; *q != '\0'; )
2326  {
2327  GetMagickToken(q,&q,token);
2328  if (LocaleCompare(token,"pop") != 0)
2329  continue;
2330  GetMagickToken(q,(const char **) NULL,token);
2331  if (LocaleCompare(token,"clip-path") != 0)
2332  continue;
2333  break;
2334  }
2335  (void) CopyMagickString(token,p,(size_t) (q-p-4+1));
2336  (void) SetImageArtifact(image,name,token);
2337  GetMagickToken(q,&q,token);
2338  break;
2339  }
2340  if (LocaleCompare("gradient",token) == 0)
2341  {
2342  char
2343  key[2*MaxTextExtent],
2344  name[MaxTextExtent],
2345  type[MaxTextExtent];
2346 
2347  SegmentInfo
2348  segment;
2349 
2350  GetMagickToken(q,&q,token);
2351  (void) CopyMagickString(name,token,MaxTextExtent);
2352  GetMagickToken(q,&q,token);
2353  (void) CopyMagickString(type,token,MaxTextExtent);
2354  GetMagickToken(q,&q,token);
2355  segment.x1=StringToDouble(token,(char **) NULL);
2356  GetMagickToken(q,&q,token);
2357  if (*token == ',')
2358  GetMagickToken(q,&q,token);
2359  segment.y1=StringToDouble(token,(char **) NULL);
2360  GetMagickToken(q,&q,token);
2361  if (*token == ',')
2362  GetMagickToken(q,&q,token);
2363  segment.x2=StringToDouble(token,(char **) NULL);
2364  GetMagickToken(q,&q,token);
2365  if (*token == ',')
2366  GetMagickToken(q,&q,token);
2367  segment.y2=StringToDouble(token,(char **) NULL);
2368  if (LocaleCompare(type,"radial") == 0)
2369  {
2370  GetMagickToken(q,&q,token);
2371  if (*token == ',')
2372  GetMagickToken(q,&q,token);
2373  }
2374  for (p=q; *q != '\0'; )
2375  {
2376  GetMagickToken(q,&q,token);
2377  if (LocaleCompare(token,"pop") != 0)
2378  continue;
2379  GetMagickToken(q,(const char **) NULL,token);
2380  if (LocaleCompare(token,"gradient") != 0)
2381  continue;
2382  break;
2383  }
2384  (void) CopyMagickString(token,p,(size_t) (q-p-4+1));
2385  bounds.x1=graphic_context[n]->affine.sx*segment.x1+
2386  graphic_context[n]->affine.ry*segment.y1+
2387  graphic_context[n]->affine.tx;
2388  bounds.y1=graphic_context[n]->affine.rx*segment.x1+
2389  graphic_context[n]->affine.sy*segment.y1+
2390  graphic_context[n]->affine.ty;
2391  bounds.x2=graphic_context[n]->affine.sx*segment.x2+
2392  graphic_context[n]->affine.ry*segment.y2+
2393  graphic_context[n]->affine.tx;
2394  bounds.y2=graphic_context[n]->affine.rx*segment.x2+
2395  graphic_context[n]->affine.sy*segment.y2+
2396  graphic_context[n]->affine.ty;
2397  (void) FormatLocaleString(key,MaxTextExtent,"%s",name);
2398  (void) SetImageArtifact(image,key,token);
2399  (void) FormatLocaleString(key,MaxTextExtent,"%s-geometry",name);
2400  (void) FormatLocaleString(geometry,MaxTextExtent,
2401  "%gx%g%+.15g%+.15g",
2402  MagickMax(fabs(bounds.x2-bounds.x1+1.0),1.0),
2403  MagickMax(fabs(bounds.y2-bounds.y1+1.0),1.0),
2404  bounds.x1,bounds.y1);
2405  (void) SetImageArtifact(image,key,geometry);
2406  GetMagickToken(q,&q,token);
2407  break;
2408  }
2409  if (LocaleCompare("pattern",token) == 0)
2410  {
2411  RectangleInfo
2412  bounds;
2413 
2414  GetMagickToken(q,&q,token);
2415  (void) CopyMagickString(name,token,MaxTextExtent);
2416  GetMagickToken(q,&q,token);
2417  bounds.x=(ssize_t) ceil(StringToDouble(token,(char **) NULL)-
2418  0.5);
2419  GetMagickToken(q,&q,token);
2420  if (*token == ',')
2421  GetMagickToken(q,&q,token);
2422  bounds.y=(ssize_t) ceil(StringToDouble(token,(char **) NULL)-
2423  0.5);
2424  GetMagickToken(q,&q,token);
2425  if (*token == ',')
2426  GetMagickToken(q,&q,token);
2427  bounds.width=(size_t) floor(StringToDouble(token,
2428  (char **) NULL)+0.5);
2429  GetMagickToken(q,&q,token);
2430  if (*token == ',')
2431  GetMagickToken(q,&q,token);
2432  bounds.height=(size_t) floor(StringToDouble(token,
2433  (char **) NULL)+0.5);
2434  for (p=q; *q != '\0'; )
2435  {
2436  GetMagickToken(q,&q,token);
2437  if (LocaleCompare(token,"pop") != 0)
2438  continue;
2439  GetMagickToken(q,(const char **) NULL,token);
2440  if (LocaleCompare(token,"pattern") != 0)
2441  continue;
2442  break;
2443  }
2444  (void) CopyMagickString(token,p,(size_t) (q-p-4+1));
2445  (void) FormatLocaleString(key,MaxTextExtent,"%s",name);
2446  (void) SetImageArtifact(image,key,token);
2447  (void) FormatLocaleString(key,MaxTextExtent,"%s-geometry",name);
2448  (void) FormatLocaleString(geometry,MaxTextExtent,
2449  "%.20gx%.20g%+.20g%+.20g",(double) bounds.width,(double)
2450  bounds.height,(double) bounds.x,(double) bounds.y);
2451  (void) SetImageArtifact(image,key,geometry);
2452  GetMagickToken(q,&q,token);
2453  break;
2454  }
2455  if (LocaleCompare("graphic-context",token) == 0)
2456  {
2457  n++;
2458  graphic_context=(DrawInfo **) ResizeQuantumMemory(
2459  graphic_context,(size_t) (n+1),sizeof(*graphic_context));
2460  if (graphic_context == (DrawInfo **) NULL)
2461  {
2462  (void) ThrowMagickException(&image->exception,
2463  GetMagickModule(),ResourceLimitError,
2464  "MemoryAllocationFailed","`%s'",image->filename);
2465  break;
2466  }
2467  graphic_context[n]=CloneDrawInfo((ImageInfo *) NULL,
2468  graphic_context[n-1]);
2469  break;
2470  }
2471  if (LocaleCompare("defs",token) == 0)
2472  break;
2473  status=MagickFalse;
2474  break;
2475  }
2476  status=MagickFalse;
2477  break;
2478  }
2479  case 'r':
2480  case 'R':
2481  {
2482  if (LocaleCompare("rectangle",keyword) == 0)
2483  {
2484  primitive_type=RectanglePrimitive;
2485  break;
2486  }
2487  if (LocaleCompare("rotate",keyword) == 0)
2488  {
2489  GetMagickToken(q,&q,token);
2490  angle=StringToDouble(token,(char **) NULL);
2491  affine.sx=cos(DegreesToRadians(fmod((double) angle,360.0)));
2492  affine.rx=sin(DegreesToRadians(fmod((double) angle,360.0)));
2493  affine.ry=(-sin(DegreesToRadians(fmod((double) angle,360.0))));
2494  affine.sy=cos(DegreesToRadians(fmod((double) angle,360.0)));
2495  break;
2496  }
2497  if (LocaleCompare("roundRectangle",keyword) == 0)
2498  {
2499  primitive_type=RoundRectanglePrimitive;
2500  break;
2501  }
2502  status=MagickFalse;
2503  break;
2504  }
2505  case 's':
2506  case 'S':
2507  {
2508  if (LocaleCompare("scale",keyword) == 0)
2509  {
2510  GetMagickToken(q,&q,token);
2511  affine.sx=StringToDouble(token,(char **) NULL);
2512  GetMagickToken(q,&q,token);
2513  if (*token == ',')
2514  GetMagickToken(q,&q,token);
2515  affine.sy=StringToDouble(token,(char **) NULL);
2516  break;
2517  }
2518  if (LocaleCompare("skewX",keyword) == 0)
2519  {
2520  GetMagickToken(q,&q,token);
2521  angle=StringToDouble(token,(char **) NULL);
2522  affine.ry=sin(DegreesToRadians(angle));
2523  break;
2524  }
2525  if (LocaleCompare("skewY",keyword) == 0)
2526  {
2527  GetMagickToken(q,&q,token);
2528  angle=StringToDouble(token,(char **) NULL);
2529  affine.rx=(-tan(DegreesToRadians(angle)/2.0));
2530  break;
2531  }
2532  if (LocaleCompare("stop-color",keyword) == 0)
2533  {
2534  PixelPacket
2535  stop_color;
2536 
2537  GetMagickToken(q,&q,token);
2538  (void) QueryColorDatabase(token,&stop_color,&image->exception);
2539  (void) GradientImage(image,LinearGradient,ReflectSpread,
2540  &start_color,&stop_color);
2541  start_color=stop_color;
2542  GetMagickToken(q,&q,token);
2543  break;
2544  }
2545  if (LocaleCompare("stroke",keyword) == 0)
2546  {
2547  GetMagickToken(q,&q,token);
2548  (void) FormatLocaleString(pattern,MaxTextExtent,"%s",token);
2549  if (GetImageArtifact(image,pattern) != (const char *) NULL)
2550  (void) DrawPatternPath(image,draw_info,token,
2551  &graphic_context[n]->stroke_pattern);
2552  else
2553  {
2554  status&=QueryColorDatabase(token,&graphic_context[n]->stroke,
2555  &image->exception);
2556  if (status == MagickFalse)
2557  {
2558  ImageInfo
2559  *pattern_info;
2560 
2561  pattern_info=AcquireImageInfo();
2562  (void) CopyMagickString(pattern_info->filename,token,
2563  MaxTextExtent);
2564  graphic_context[n]->stroke_pattern=
2565  ReadImage(pattern_info,&image->exception);
2566  CatchException(&image->exception);
2567  pattern_info=DestroyImageInfo(pattern_info);
2568  }
2569  }
2570  break;
2571  }
2572  if (LocaleCompare("stroke-antialias",keyword) == 0)
2573  {
2574  GetMagickToken(q,&q,token);
2575  graphic_context[n]->stroke_antialias=
2576  StringToLong(token) != 0 ? MagickTrue : MagickFalse;
2577  break;
2578  }
2579  if (LocaleCompare("stroke-dasharray",keyword) == 0)
2580  {
2581  if (graphic_context[n]->dash_pattern != (double *) NULL)
2582  graphic_context[n]->dash_pattern=(double *)
2583  RelinquishMagickMemory(graphic_context[n]->dash_pattern);
2584  if (IsPoint(q) != MagickFalse)
2585  {
2586  const char
2587  *p;
2588 
2589  p=q;
2590  GetMagickToken(p,&p,token);
2591  if (*token == ',')
2592  GetMagickToken(p,&p,token);
2593  for (x=0; IsPoint(token) != MagickFalse; x++)
2594  {
2595  GetMagickToken(p,&p,token);
2596  if (*token == ',')
2597  GetMagickToken(p,&p,token);
2598  }
2599  graphic_context[n]->dash_pattern=(double *)
2600  AcquireQuantumMemory((size_t) (2UL*x+1UL),
2601  sizeof(*graphic_context[n]->dash_pattern));
2602  if (graphic_context[n]->dash_pattern == (double *) NULL)
2603  {
2604  (void) ThrowMagickException(&image->exception,
2605  GetMagickModule(),ResourceLimitError,
2606  "MemoryAllocationFailed","`%s'",image->filename);
2607  break;
2608  }
2609  for (j=0; j < x; j++)
2610  {
2611  GetMagickToken(q,&q,token);
2612  if (*token == ',')
2613  GetMagickToken(q,&q,token);
2614  graphic_context[n]->dash_pattern[j]=StringToDouble(token,
2615  (char **) NULL);
2616  }
2617  if ((x & 0x01) != 0)
2618  for ( ; j < (2*x); j++)
2619  graphic_context[n]->dash_pattern[j]=
2620  graphic_context[n]->dash_pattern[j-x];
2621  graphic_context[n]->dash_pattern[j]=0.0;
2622  break;
2623  }
2624  GetMagickToken(q,&q,token);
2625  break;
2626  }
2627  if (LocaleCompare("stroke-dashoffset",keyword) == 0)
2628  {
2629  GetMagickToken(q,&q,token);
2630  graphic_context[n]->dash_offset=StringToDouble(token,
2631  (char **) NULL);
2632  break;
2633  }
2634  if (LocaleCompare("stroke-linecap",keyword) == 0)
2635  {
2636  ssize_t
2637  linecap;
2638 
2639  GetMagickToken(q,&q,token);
2640  linecap=ParseCommandOption(MagickLineCapOptions,MagickFalse,token);
2641  if (linecap == -1)
2642  {
2643  status=MagickFalse;
2644  break;
2645  }
2646  graphic_context[n]->linecap=(LineCap) linecap;
2647  break;
2648  }
2649  if (LocaleCompare("stroke-linejoin",keyword) == 0)
2650  {
2651  ssize_t
2652  linejoin;
2653 
2654  GetMagickToken(q,&q,token);
2655  linejoin=ParseCommandOption(MagickLineJoinOptions,MagickFalse,token);
2656  if (linejoin == -1)
2657  {
2658  status=MagickFalse;
2659  break;
2660  }
2661  graphic_context[n]->linejoin=(LineJoin) linejoin;
2662  break;
2663  }
2664  if (LocaleCompare("stroke-miterlimit",keyword) == 0)
2665  {
2666  GetMagickToken(q,&q,token);
2667  graphic_context[n]->miterlimit=StringToUnsignedLong(token);
2668  break;
2669  }
2670  if (LocaleCompare("stroke-opacity",keyword) == 0)
2671  {
2672  GetMagickToken(q,&q,token);
2673  factor=strchr(token,'%') != (char *) NULL ? 0.01 : 1.0;
2674  graphic_context[n]->stroke.opacity=ClampToQuantum((MagickRealType)
2675  QuantumRange*(1.0-factor*StringToDouble(token,(char **) NULL)));
2676  break;
2677  }
2678  if (LocaleCompare("stroke-width",keyword) == 0)
2679  {
2680  GetMagickToken(q,&q,token);
2681  graphic_context[n]->stroke_width=StringToDouble(token,
2682  (char **) NULL);
2683  break;
2684  }
2685  status=MagickFalse;
2686  break;
2687  }
2688  case 't':
2689  case 'T':
2690  {
2691  if (LocaleCompare("text",keyword) == 0)
2692  {
2693  primitive_type=TextPrimitive;
2694  break;
2695  }
2696  if (LocaleCompare("text-align",keyword) == 0)
2697  {
2698  ssize_t
2699  align;
2700 
2701  GetMagickToken(q,&q,token);
2702  align=ParseCommandOption(MagickAlignOptions,MagickFalse,token);
2703  if (align == -1)
2704  {
2705  status=MagickFalse;
2706  break;
2707  }
2708  graphic_context[n]->align=(AlignType) align;
2709  break;
2710  }
2711  if (LocaleCompare("text-anchor",keyword) == 0)
2712  {
2713  ssize_t
2714  align;
2715 
2716  GetMagickToken(q,&q,token);
2717  align=ParseCommandOption(MagickAlignOptions,MagickFalse,token);
2718  if (align == -1)
2719  {
2720  status=MagickFalse;
2721  break;
2722  }
2723  graphic_context[n]->align=(AlignType) align;
2724  break;
2725  }
2726  if (LocaleCompare("text-antialias",keyword) == 0)
2727  {
2728  GetMagickToken(q,&q,token);
2729  graphic_context[n]->text_antialias=
2730  StringToLong(token) != 0 ? MagickTrue : MagickFalse;
2731  break;
2732  }
2733  if (LocaleCompare("text-undercolor",keyword) == 0)
2734  {
2735  GetMagickToken(q,&q,token);
2736  (void) QueryColorDatabase(token,&graphic_context[n]->undercolor,
2737  &image->exception);
2738  break;
2739  }
2740  if (LocaleCompare("translate",keyword) == 0)
2741  {
2742  GetMagickToken(q,&q,token);
2743  affine.tx=StringToDouble(token,(char **) NULL);
2744  GetMagickToken(q,&q,token);
2745  if (*token == ',')
2746  GetMagickToken(q,&q,token);
2747  affine.ty=StringToDouble(token,(char **) NULL);
2748  break;
2749  }
2750  status=MagickFalse;
2751  break;
2752  }
2753  case 'v':
2754  case 'V':
2755  {
2756  if (LocaleCompare("viewbox",keyword) == 0)
2757  {
2758  GetMagickToken(q,&q,token);
2759  graphic_context[n]->viewbox.x=(ssize_t) ceil(StringToDouble(token,
2760  (char **) NULL)-0.5);
2761  GetMagickToken(q,&q,token);
2762  if (*token == ',')
2763  GetMagickToken(q,&q,token);
2764  graphic_context[n]->viewbox.y=(ssize_t) ceil(StringToDouble(token,
2765  (char **) NULL)-0.5);
2766  GetMagickToken(q,&q,token);
2767  if (*token == ',')
2768  GetMagickToken(q,&q,token);
2769  graphic_context[n]->viewbox.width=(size_t) floor(StringToDouble(
2770  token,(char **) NULL)+0.5);
2771  GetMagickToken(q,&q,token);
2772  if (*token == ',')
2773  GetMagickToken(q,&q,token);
2774  graphic_context[n]->viewbox.height=(size_t) floor(StringToDouble(
2775  token,(char **) NULL)+0.5);
2776  break;
2777  }
2778  status=MagickFalse;
2779  break;
2780  }
2781  default:
2782  {
2783  status=MagickFalse;
2784  break;
2785  }
2786  }
2787  if (status == MagickFalse)
2788  break;
2789  if ((affine.sx != 1.0) || (affine.rx != 0.0) || (affine.ry != 0.0) ||
2790  (affine.sy != 1.0) || (affine.tx != 0.0) || (affine.ty != 0.0))
2791  {
2792  graphic_context[n]->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
2793  graphic_context[n]->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
2794  graphic_context[n]->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
2795  graphic_context[n]->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
2796  graphic_context[n]->affine.tx=current.sx*affine.tx+current.ry*affine.ty+
2797  current.tx;
2798  graphic_context[n]->affine.ty=current.rx*affine.tx+current.sy*affine.ty+
2799  current.ty;
2800  }
2801  if (primitive_type == UndefinedPrimitive)
2802  {
2803  if (image->debug != MagickFalse)
2804  (void) LogMagickEvent(DrawEvent,GetMagickModule()," %.*s",
2805  (int) (q-p),p);
2806  continue;
2807  }
2808  /*
2809  Parse the primitive attributes.
2810  */
2811  i=0;
2812  j=0;
2813  primitive_info[0].point.x=0.0;
2814  primitive_info[0].point.y=0.0;
2815  for (x=0; *q != '\0'; x++)
2816  {
2817  /*
2818  Define points.
2819  */
2820  if (IsPoint(q) == MagickFalse)
2821  break;
2822  GetMagickToken(q,&q,token);
2823  point.x=StringToDouble(token,(char **) NULL);
2824  GetMagickToken(q,&q,token);
2825  if (*token == ',')
2826  GetMagickToken(q,&q,token);
2827  point.y=StringToDouble(token,(char **) NULL);
2828  GetMagickToken(q,(const char **) NULL,token);
2829  if (*token == ',')
2830  GetMagickToken(q,&q,token);
2831  primitive_info[i].primitive=primitive_type;
2832  primitive_info[i].point=point;
2833  primitive_info[i].coordinates=0;
2834  primitive_info[i].method=FloodfillMethod;
2835  i++;
2836  if (i < (ssize_t) number_points)
2837  continue;
2838  number_points<<=1;
2839  primitive_info=(PrimitiveInfo *) ResizeQuantumMemory(primitive_info,
2840  (size_t) number_points,sizeof(*primitive_info));
2841  if (primitive_info == (PrimitiveInfo *) NULL)
2842  {
2843  (void) ThrowMagickException(&image->exception,GetMagickModule(),
2844  ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
2845  break;
2846  }
2847  }
2848  primitive_info[j].primitive=primitive_type;
2849  primitive_info[j].coordinates=(size_t) x;
2850  primitive_info[j].method=FloodfillMethod;
2851  primitive_info[j].text=(char *) NULL;
2852  /*
2853  Circumscribe primitive within a circle.
2854  */
2855  bounds.x1=primitive_info[j].point.x;
2856  bounds.y1=primitive_info[j].point.y;
2857  bounds.x2=primitive_info[j].point.x;
2858  bounds.y2=primitive_info[j].point.y;
2859  for (k=1; k < (ssize_t) primitive_info[j].coordinates; k++)
2860  {
2861  point=primitive_info[j+k].point;
2862  if (point.x < bounds.x1)
2863  bounds.x1=point.x;
2864  if (point.y < bounds.y1)
2865  bounds.y1=point.y;
2866  if (point.x > bounds.x2)
2867  bounds.x2=point.x;
2868  if (point.y > bounds.y2)
2869  bounds.y2=point.y;
2870  }
2871  /*
2872  Speculate how many points our primitive might consume.
2873  */
2874  length=primitive_info[j].coordinates;
2875  switch (primitive_type)
2876  {
2877  case RectanglePrimitive:
2878  {
2879  length*=5;
2880  break;
2881  }
2882  case RoundRectanglePrimitive:
2883  {
2884  length*=5+8*BezierQuantum;
2885  break;
2886  }
2887  case BezierPrimitive:
2888  {
2889  if (primitive_info[j].coordinates > 107)
2890  (void) ThrowMagickException(&image->exception,GetMagickModule(),
2891  DrawError,"TooManyBezierCoordinates","`%s'",token);
2892  length=BezierQuantum*primitive_info[j].coordinates;
2893  break;
2894  }
2895  case PathPrimitive:
2896  {
2897  char
2898  *s,
2899  *t;
2900 
2901  GetMagickToken(q,&q,token);
2902  length=1;
2903  t=token;
2904  for (s=token; *s != '\0'; s=t)
2905  {
2906  double
2907  value;
2908 
2909  value=StringToDouble(s,&t);
2910  (void) value;
2911  if (s == t)
2912  {
2913  t++;
2914  continue;
2915  }
2916  length++;
2917  }
2918  length=length*BezierQuantum/2;
2919  break;
2920  }
2921  case CirclePrimitive:
2922  case ArcPrimitive:
2923  case EllipsePrimitive:
2924  {
2925  double
2926  alpha,
2927  beta,
2928  radius;
2929 
2930  alpha=bounds.x2-bounds.x1;
2931  beta=bounds.y2-bounds.y1;
2932  radius=hypot((double) alpha,(double) beta);
2933  length=2*((size_t) ceil((double) MagickPI*radius))+6*BezierQuantum+360;
2934  break;
2935  }
2936  default:
2937  break;
2938  }
2939  if ((size_t) (i+length) >= number_points)
2940  {
2941  /*
2942  Resize based on speculative points required by primitive.
2943  */
2944  number_points+=length+1;
2945  primitive_info=(PrimitiveInfo *) ResizeQuantumMemory(primitive_info,
2946  (size_t) number_points,sizeof(*primitive_info));
2947  if (primitive_info == (PrimitiveInfo *) NULL)
2948  {
2949  (void) ThrowMagickException(&image->exception,GetMagickModule(),
2950  ResourceLimitError,"MemoryAllocationFailed","`%s'",
2951  image->filename);
2952  break;
2953  }
2954  }
2955  switch (primitive_type)
2956  {
2957  case PointPrimitive:
2958  default:
2959  {
2960  if (primitive_info[j].coordinates != 1)
2961  {
2962  status=MagickFalse;
2963  break;
2964  }
2965  TracePoint(primitive_info+j,primitive_info[j].point);
2966  i=(ssize_t) (j+primitive_info[j].coordinates);
2967  break;
2968  }
2969  case LinePrimitive:
2970  {
2971  if (primitive_info[j].coordinates != 2)
2972  {
2973  status=MagickFalse;
2974  break;
2975  }
2976  TraceLine(primitive_info+j,primitive_info[j].point,
2977  primitive_info[j+1].point);
2978  i=(ssize_t) (j+primitive_info[j].coordinates);
2979  break;
2980  }
2981  case RectanglePrimitive:
2982  {
2983  if (primitive_info[j].coordinates != 2)
2984  {
2985  status=MagickFalse;
2986  break;
2987  }
2988  TraceRectangle(primitive_info+j,primitive_info[j].point,
2989  primitive_info[j+1].point);
2990  i=(ssize_t) (j+primitive_info[j].coordinates);
2991  break;
2992  }
2993  case RoundRectanglePrimitive:
2994  {
2995  if (primitive_info[j].coordinates != 3)
2996  {
2997  status=MagickFalse;
2998  break;
2999  }
3000  TraceRoundRectangle(primitive_info+j,primitive_info[j].point,
3001  primitive_info[j+1].point,primitive_info[j+2].point);
3002  i=(ssize_t) (j+primitive_info[j].coordinates);
3003  break;
3004  }
3005  case ArcPrimitive:
3006  {
3007  if (primitive_info[j].coordinates != 3)
3008  {
3009  primitive_type=UndefinedPrimitive;
3010  break;
3011  }
3012  TraceArc(primitive_info+j,primitive_info[j].point,
3013  primitive_info[j+1].point,primitive_info[j+2].point);
3014  i=(ssize_t) (j+primitive_info[j].coordinates);
3015  break;
3016  }
3017  case EllipsePrimitive:
3018  {
3019  if (primitive_info[j].coordinates != 3)
3020  {
3021  status=MagickFalse;
3022  break;
3023  }
3024  TraceEllipse(primitive_info+j,primitive_info[j].point,
3025  primitive_info[j+1].point,primitive_info[j+2].point);
3026  i=(ssize_t) (j+primitive_info[j].coordinates);
3027  break;
3028  }
3029  case CirclePrimitive:
3030  {
3031  if (primitive_info[j].coordinates != 2)
3032  {
3033  status=MagickFalse;
3034  break;
3035  }
3036  TraceCircle(primitive_info+j,primitive_info[j].point,
3037  primitive_info[j+1].point);
3038  i=(ssize_t) (j+primitive_info[j].coordinates);
3039  break;
3040  }
3041  case PolylinePrimitive:
3042  break;
3043  case PolygonPrimitive:
3044  {
3045  primitive_info[i]=primitive_info[j];
3046  primitive_info[i].coordinates=0;
3047  primitive_info[j].coordinates++;
3048  i++;
3049  break;
3050  }
3051  case BezierPrimitive:
3052  {
3053  if (primitive_info[j].coordinates < 3)
3054  {
3055  status=MagickFalse;
3056  break;
3057  }
3058  TraceBezier(primitive_info+j,primitive_info[j].coordinates);
3059  i=(ssize_t) (j+primitive_info[j].coordinates);
3060  break;
3061  }
3062  case PathPrimitive:
3063  {
3064  i=(ssize_t) (j+TracePath(primitive_info+j,token));
3065  break;
3066  }
3067  case ColorPrimitive:
3068  case MattePrimitive:
3069  {
3070  ssize_t
3071  method;
3072 
3073  if (primitive_info[j].coordinates != 1)
3074  {
3075  status=MagickFalse;
3076  break;
3077  }
3078  GetMagickToken(q,&q,token);
3079  method=ParseCommandOption(MagickMethodOptions,MagickFalse,token);
3080  if (method == -1)
3081  {
3082  status=MagickFalse;
3083  break;
3084  }
3085  primitive_info[j].method=(PaintMethod) method;
3086  break;
3087  }
3088  case TextPrimitive:
3089  {
3090  if (primitive_info[j].coordinates != 1)
3091  {
3092  status=MagickFalse;
3093  break;
3094  }
3095  if (*token != ',')
3096  GetMagickToken(q,&q,token);
3097  primitive_info[j].text=AcquireString(token);
3098  break;
3099  }
3100  case ImagePrimitive:
3101  {
3102  if (primitive_info[j].coordinates != 2)
3103  {
3104  status=MagickFalse;
3105  break;
3106  }
3107  GetMagickToken(q,&q,token);
3108  primitive_info[j].text=AcquireString(token);
3109  break;
3110  }
3111  }
3112  if (primitive_info == (PrimitiveInfo *) NULL)
3113  break;
3114  if (image->debug != MagickFalse)
3115  (void) LogMagickEvent(DrawEvent,GetMagickModule()," %.*s",(int) (q-p),p);
3116  if (status == MagickFalse)
3117  break;
3118  primitive_info[i].primitive=UndefinedPrimitive;
3119  if (i == 0)
3120  continue;
3121  /*
3122  Transform points.
3123  */
3124  for (i=0; primitive_info[i].primitive != UndefinedPrimitive; i++)
3125  {
3126  point=primitive_info[i].point;
3127  primitive_info[i].point.x=graphic_context[n]->affine.sx*point.x+
3128  graphic_context[n]->affine.ry*point.y+graphic_context[n]->affine.tx;
3129  primitive_info[i].point.y=graphic_context[n]->affine.rx*point.x+
3130  graphic_context[n]->affine.sy*point.y+graphic_context[n]->affine.ty;
3131  point=primitive_info[i].point;
3132  if (point.x < graphic_context[n]->bounds.x1)
3133  graphic_context[n]->bounds.x1=point.x;
3134  if (point.y < graphic_context[n]->bounds.y1)
3135  graphic_context[n]->bounds.y1=point.y;
3136  if (point.x > graphic_context[n]->bounds.x2)
3137  graphic_context[n]->bounds.x2=point.x;
3138  if (point.y > graphic_context[n]->bounds.y2)
3139  graphic_context[n]->bounds.y2=point.y;
3140  if (primitive_info[i].primitive == ImagePrimitive)
3141  break;
3142  if (i >= (ssize_t) number_points)
3143  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
3144  }
3145  if (graphic_context[n]->render != MagickFalse)
3146  {
3147  if ((n != 0) && (graphic_context[n]->clip_mask != (char *) NULL) &&
3148  (LocaleCompare(graphic_context[n]->clip_mask,
3149  graphic_context[n-1]->clip_mask) != 0))
3150  status&=DrawClipPath(image,graphic_context[n],
3151  graphic_context[n]->clip_mask);
3152  status&=DrawPrimitive(image,graphic_context[n],primitive_info);
3153  }
3154  if (primitive_info->text != (char *) NULL)
3155  primitive_info->text=(char *) RelinquishMagickMemory(
3156  primitive_info->text);
3157  proceed=SetImageProgress(image,RenderImageTag,q-primitive,(MagickSizeType)
3158  primitive_extent);
3159  if (proceed == MagickFalse)
3160  break;
3161  if (status == 0)
3162  break;
3163  }
3164  if (image->debug != MagickFalse)
3165  (void) LogMagickEvent(DrawEvent,GetMagickModule(),"end draw-image");
3166  /*
3167  Relinquish resources.
3168  */
3169  token=DestroyString(token);
3170  if (primitive_info != (PrimitiveInfo *) NULL)
3171  primitive_info=(PrimitiveInfo *) RelinquishMagickMemory(primitive_info);
3172  primitive=DestroyString(primitive);
3173  for ( ; n >= 0; n--)
3174  graphic_context[n]=DestroyDrawInfo(graphic_context[n]);
3175  graphic_context=(DrawInfo **) RelinquishMagickMemory(graphic_context);
3176  if (status == MagickFalse)
3177  ThrowBinaryException(DrawError,"NonconformingDrawingPrimitiveDefinition",
3178  keyword);
3179  return(status != 0 ? MagickTrue : MagickFalse);
3180 }
3181 
3182 
3183 /*
3184 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3185 % %
3186 % %
3187 % %
3188 % D r a w G r a d i e n t I m a g e %
3189 % %
3190 % %
3191 % %
3192 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3193 %
3194 % DrawGradientImage() draws a linear gradient on the image.
3195 %
3196 % The format of the DrawGradientImage method is:
3197 %
3198 % MagickBooleanType DrawGradientImage(Image *image,
3199 % const DrawInfo *draw_info)
3200 %
3201 % A description of each parameter follows:
3202 %
3203 % o image: the image.
3204 %
3205 % o _info: the draw info.
3206 %
3207 */
3208 
3209 static inline double GetStopColorOffset(const GradientInfo *gradient,
3210  const ssize_t x,const ssize_t y)
3211 {
3212  switch (gradient->type)
3213  {
3214  case UndefinedGradient:
3215  case LinearGradient:
3216  {
3217  double
3218  gamma,
3219  length,
3220  offset,
3221  scale;
3222 
3223  PointInfo
3224  p,
3225  q;
3226 
3227  const SegmentInfo
3228  *gradient_vector;
3229 
3230  gradient_vector=(&gradient->gradient_vector);
3231  p.x=gradient_vector->x2-gradient_vector->x1;
3232  p.y=gradient_vector->y2-gradient_vector->y1;
3233  q.x=(double) x-gradient_vector->x1;
3234  q.y=(double) y-gradient_vector->y1;
3235  length=sqrt(q.x*q.x+q.y*q.y);
3236  gamma=sqrt(p.x*p.x+p.y*p.y)*length;
3237  gamma=PerceptibleReciprocal(gamma);
3238  scale=p.x*q.x+p.y*q.y;
3239  offset=gamma*scale*length;
3240  return(offset);
3241  }
3242  case RadialGradient:
3243  {
3244  double
3245  length,
3246  offset;
3247 
3248  PointInfo
3249  v;
3250 
3251  v.x=(double) x-gradient->center.x;
3252  v.y=(double) y-gradient->center.y;
3253  length=sqrt(v.x*v.x+v.y*v.y);
3254  if (gradient->spread == RepeatSpread)
3255  return(length);
3256  offset=length/gradient->radius;
3257  return(offset);
3258  }
3259  }
3260  return(0.0);
3261 }
3262 
3263 MagickExport MagickBooleanType DrawGradientImage(Image *image,
3264  const DrawInfo *draw_info)
3265 {
3266  CacheView
3267  *image_view;
3268 
3269  const GradientInfo
3270  *gradient;
3271 
3272  const SegmentInfo
3273  *gradient_vector;
3274 
3275  double
3276  length;
3277 
3278  ExceptionInfo
3279  *exception;
3280 
3281  MagickBooleanType
3282  status;
3283 
3284  MagickPixelPacket
3285  zero;
3286 
3287  PointInfo
3288  point;
3289 
3290  RectangleInfo
3291  bounding_box;
3292 
3293  ssize_t
3294  y;
3295 
3296  /*
3297  Draw linear or radial gradient on image.
3298  */
3299  assert(image != (Image *) NULL);
3300  assert(image->signature == MagickSignature);
3301  if (image->debug != MagickFalse)
3302  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3303  assert(draw_info != (const DrawInfo *) NULL);
3304  gradient=(&draw_info->gradient);
3305  gradient_vector=(&gradient->gradient_vector);
3306  point.x=gradient_vector->x2-gradient_vector->x1;
3307  point.y=gradient_vector->y2-gradient_vector->y1;
3308  length=sqrt(point.x*point.x+point.y*point.y);
3309  bounding_box=gradient->bounding_box;
3310  status=MagickTrue;
3311  exception=(&image->exception);
3312  GetMagickPixelPacket(image,&zero);
3313  image_view=AcquireAuthenticCacheView(image,exception);
3314 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3315  #pragma omp parallel for schedule(static,4) shared(status) \
3316  magick_threads(image,image,1,1)
3317 #endif
3318  for (y=bounding_box.y; y < (ssize_t) bounding_box.height; y++)
3319  {
3320  double
3321  alpha,
3322  offset;
3323 
3324  MagickPixelPacket
3325  composite,
3326  pixel;
3327 
3328  register IndexPacket
3329  *restrict indexes;
3330 
3331  register ssize_t
3332  i,
3333  x;
3334 
3335  register PixelPacket
3336  *restrict q;
3337 
3338  ssize_t
3339  j;
3340 
3341  if (status == MagickFalse)
3342  continue;
3343  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3344  if (q == (PixelPacket *) NULL)
3345  {
3346  status=MagickFalse;
3347  continue;
3348  }
3349  indexes=GetCacheViewAuthenticIndexQueue(image_view);
3350  pixel=zero;
3351  composite=zero;
3352  offset=GetStopColorOffset(gradient,0,y);
3353  if (gradient->type != RadialGradient)
3354  offset/=length;
3355  for (x=bounding_box.x; x < (ssize_t) bounding_box.width; x++)
3356  {
3357  SetMagickPixelPacket(image,q,indexes+x,&pixel);
3358  switch (gradient->spread)
3359  {
3360  case UndefinedSpread:
3361  case PadSpread:
3362  {
3363  if ((x != (ssize_t) ceil(gradient_vector->x1-0.5)) ||
3364  (y != (ssize_t) ceil(gradient_vector->y1-0.5)))
3365  {
3366  offset=GetStopColorOffset(gradient,x,y);
3367  if (gradient->type != RadialGradient)
3368  offset/=length;
3369  }
3370  for (i=0; i < (ssize_t) gradient->number_stops; i++)
3371  if (offset < gradient->stops[i].offset)
3372  break;
3373  if ((offset < 0.0) || (i == 0))
3374  composite=gradient->stops[0].color;
3375  else
3376  if ((offset > 1.0) || (i == (ssize_t) gradient->number_stops))
3377  composite=gradient->stops[gradient->number_stops-1].color;
3378  else
3379  {
3380  j=i;
3381  i--;
3382  alpha=(offset-gradient->stops[i].offset)/
3383  (gradient->stops[j].offset-gradient->stops[i].offset);
3384  MagickPixelCompositeBlend(&gradient->stops[i].color,1.0-alpha,
3385  &gradient->stops[j].color,alpha,&composite);
3386  }
3387  break;
3388  }
3389  case ReflectSpread:
3390  {
3391  if ((x != (ssize_t) ceil(gradient_vector->x1-0.5)) ||
3392  (y != (ssize_t) ceil(gradient_vector->y1-0.5)))
3393  {
3394  offset=GetStopColorOffset(gradient,x,y);
3395  if (gradient->type != RadialGradient)
3396  offset/=length;
3397  }
3398  if (offset < 0.0)
3399  offset=(-offset);
3400  if ((ssize_t) fmod(offset,2.0) == 0)
3401  offset=fmod(offset,1.0);
3402  else
3403  offset=1.0-fmod(offset,1.0);
3404  for (i=0; i < (ssize_t) gradient->number_stops; i++)
3405  if (offset < gradient->stops[i].offset)
3406  break;
3407  if (i == 0)
3408  composite=gradient->stops[0].color;
3409  else
3410  if (i == (ssize_t) gradient->number_stops)
3411  composite=gradient->stops[gradient->number_stops-1].color;
3412  else
3413  {
3414  j=i;
3415  i--;
3416  alpha=(offset-gradient->stops[i].offset)/
3417  (gradient->stops[j].offset-gradient->stops[i].offset);
3418  MagickPixelCompositeBlend(&gradient->stops[i].color,1.0-alpha,
3419  &gradient->stops[j].color,alpha,&composite);
3420  }
3421  break;
3422  }
3423  case RepeatSpread:
3424  {
3425  double
3426  repeat;
3427 
3428  MagickBooleanType
3429  antialias;
3430 
3431  antialias=MagickFalse;
3432  repeat=0.0;
3433  if ((x != (ssize_t) ceil(gradient_vector->x1-0.5)) ||
3434  (y != (ssize_t) ceil(gradient_vector->y1-0.5)))
3435  {
3436  offset=GetStopColorOffset(gradient,x,y);
3437  if (gradient->type == LinearGradient)
3438  {
3439  repeat=fmod(offset,length);
3440  if (repeat < 0.0)
3441  repeat=length-fmod(-repeat,length);
3442  else
3443  repeat=fmod(offset,length);
3444  antialias=(repeat < length) && ((repeat+1.0) > length) ?
3445  MagickTrue : MagickFalse;
3446  offset=repeat/length;
3447  }
3448  else
3449  {
3450  repeat=fmod(offset,gradient->radius);
3451  if (repeat < 0.0)
3452  repeat=gradient->radius-fmod(-repeat,gradient->radius);
3453  else
3454  repeat=fmod(offset,gradient->radius);
3455  antialias=repeat+1.0 > gradient->radius ?
3456  MagickTrue : MagickFalse;
3457  offset=repeat/gradient->radius;
3458  }
3459  }
3460  for (i=0; i < (ssize_t) gradient->number_stops; i++)
3461  if (offset < gradient->stops[i].offset)
3462  break;
3463  if (i == 0)
3464  composite=gradient->stops[0].color;
3465  else
3466  if (i == (ssize_t) gradient->number_stops)
3467  composite=gradient->stops[gradient->number_stops-1].color;
3468  else
3469  {
3470  j=i;
3471  i--;
3472  alpha=(offset-gradient->stops[i].offset)/
3473  (gradient->stops[j].offset-gradient->stops[i].offset);
3474  if (antialias != MagickFalse)
3475  {
3476  if (gradient->type == LinearGradient)
3477  alpha=length-repeat;
3478  else
3479  alpha=gradient->radius-repeat;
3480  i=0;
3481  j=(ssize_t) gradient->number_stops-1L;
3482  }
3483  MagickPixelCompositeBlend(&gradient->stops[i].color,1.0-alpha,
3484  &gradient->stops[j].color,alpha,&composite);
3485  }
3486  break;
3487  }
3488  }
3489  MagickPixelCompositeOver(&composite,composite.opacity,&pixel,
3490  pixel.opacity,&pixel);
3491  SetPixelPacket(image,&pixel,q,indexes+x);
3492  q++;
3493  }
3494  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3495  status=MagickFalse;
3496  }
3497  image_view=DestroyCacheView(image_view);
3498  return(status);
3499 }
3500 
3501 
3502 /*
3503 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3504 % %
3505 % %
3506 % %
3507 % D r a w P a t t e r n P a t h %
3508 % %
3509 % %
3510 % %
3511 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3512 %
3513 % DrawPatternPath() draws a pattern.
3514 %
3515 % The format of the DrawPatternPath method is:
3516 %
3517 % MagickBooleanType DrawPatternPath(Image *image,const DrawInfo *draw_info,
3518 % const char *name,Image **pattern)
3519 %
3520 % A description of each parameter follows:
3521 %
3522 % o image: the image.
3523 %
3524 % o draw_info: the draw info.
3525 %
3526 % o name: the pattern name.
3527 %
3528 % o image: the image.
3529 %
3530 */
3531 MagickExport MagickBooleanType DrawPatternPath(Image *image,
3532  const DrawInfo *draw_info,const char *name,Image **pattern)
3533 {
3534  char
3535  property[MaxTextExtent];
3536 
3537  const char
3538  *geometry,
3539  *path;
3540 
3541  DrawInfo
3542  *clone_info;
3543 
3544  ImageInfo
3545  *image_info;
3546 
3547  MagickBooleanType
3548  status;
3549 
3550  assert(image != (Image *) NULL);
3551  assert(image->signature == MagickSignature);
3552  if (image->debug != MagickFalse)
3553  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3554  assert(draw_info != (const DrawInfo *) NULL);
3555  assert(name != (const char *) NULL);
3556  (void) FormatLocaleString(property,MaxTextExtent,"%s",name);
3557  path=GetImageArtifact(image,property);
3558  if (path == (const char *) NULL)
3559  return(MagickFalse);
3560  (void) FormatLocaleString(property,MaxTextExtent,"%s-geometry",name);
3561  geometry=GetImageArtifact(image,property);
3562  if (geometry == (const char *) NULL)
3563  return(MagickFalse);
3564  if ((*pattern) != (Image *) NULL)
3565  *pattern=DestroyImage(*pattern);
3566  image_info=AcquireImageInfo();
3567  image_info->size=AcquireString(geometry);
3568  *pattern=AcquireImage(image_info);
3569  image_info=DestroyImageInfo(image_info);
3570  (void) QueryColorDatabase("#00000000",&(*pattern)->background_color,
3571  &image->exception);
3572  (void) SetImageBackgroundColor(*pattern);
3573  if (image->debug != MagickFalse)
3574  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
3575  "begin pattern-path %s %s",name,geometry);
3576  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
3577  clone_info->fill_pattern=NewImageList();
3578  clone_info->stroke_pattern=NewImageList();
3579  (void) CloneString(&clone_info->primitive,path);
3580  status=DrawImage(*pattern,clone_info);
3581  clone_info=DestroyDrawInfo(clone_info);
3582  if (image->debug != MagickFalse)
3583  (void) LogMagickEvent(DrawEvent,GetMagickModule(),"end pattern-path");
3584  return(status);
3585 }
3586 
3587 
3588 /*
3589 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3590 % %
3591 % %
3592 % %
3593 + D r a w P o l y g o n P r i m i t i v e %
3594 % %
3595 % %
3596 % %
3597 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3598 %
3599 % DrawPolygonPrimitive() draws a polygon on the image.
3600 %
3601 % The format of the DrawPolygonPrimitive method is:
3602 %
3603 % MagickBooleanType DrawPolygonPrimitive(Image *image,
3604 % const DrawInfo *draw_info,const PrimitiveInfo *primitive_info)
3605 %
3606 % A description of each parameter follows:
3607 %
3608 % o image: the image.
3609 %
3610 % o draw_info: the draw info.
3611 %
3612 % o primitive_info: Specifies a pointer to a PrimitiveInfo structure.
3613 %
3614 */
3615 
3616 static PolygonInfo **DestroyPolygonThreadSet(PolygonInfo **polygon_info)
3617 {
3618  register ssize_t
3619  i;
3620 
3621  assert(polygon_info != (PolygonInfo **) NULL);
3622  for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
3623  if (polygon_info[i] != (PolygonInfo *) NULL)
3624  polygon_info[i]=DestroyPolygonInfo(polygon_info[i]);
3625  polygon_info=(PolygonInfo **) RelinquishMagickMemory(polygon_info);
3626  return(polygon_info);
3627 }
3628 
3629 static PolygonInfo **AcquirePolygonThreadSet(const DrawInfo *draw_info,
3630  const PrimitiveInfo *primitive_info)
3631 {
3632  PathInfo
3633  *restrict path_info;
3634 
3635  PolygonInfo
3636  **polygon_info;
3637 
3638  register ssize_t
3639  i;
3640 
3641  size_t
3642  number_threads;
3643 
3644  number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
3645  polygon_info=(PolygonInfo **) AcquireQuantumMemory(number_threads,
3646  sizeof(*polygon_info));
3647  if (polygon_info == (PolygonInfo **) NULL)
3648  return((PolygonInfo **) NULL);
3649  (void) ResetMagickMemory(polygon_info,0,(size_t)
3650  GetMagickResourceLimit(ThreadResource)*sizeof(*polygon_info));
3651  path_info=ConvertPrimitiveToPath(draw_info,primitive_info);
3652  if (path_info == (PathInfo *) NULL)
3653  return(DestroyPolygonThreadSet(polygon_info));
3654  for (i=0; i < (ssize_t) number_threads; i++)
3655  {
3656  polygon_info[i]=ConvertPathToPolygon(draw_info,path_info);
3657  if (polygon_info[i] == (PolygonInfo *) NULL)
3658  return(DestroyPolygonThreadSet(polygon_info));
3659  }
3660  path_info=(PathInfo *) RelinquishMagickMemory(path_info);
3661  return(polygon_info);
3662 }
3663 
3664 static double GetOpacityPixel(PolygonInfo *polygon_info,const double mid,
3665  const MagickBooleanType fill,const FillRule fill_rule,const ssize_t x,
3666  const ssize_t y,double *stroke_opacity)
3667 {
3668  double
3669  alpha,
3670  beta,
3671  distance,
3672  subpath_opacity;
3673 
3674  PointInfo
3675  delta;
3676 
3677  register EdgeInfo
3678  *p;
3679 
3680  register const PointInfo
3681  *q;
3682 
3683  register ssize_t
3684  i;
3685 
3686  ssize_t
3687  j,
3688  winding_number;
3689 
3690  /*
3691  Compute fill & stroke opacity for this (x,y) point.
3692  */
3693  *stroke_opacity=0.0;
3694  subpath_opacity=0.0;
3695  p=polygon_info->edges;
3696  for (j=0; j < (ssize_t) polygon_info->number_edges; j++, p++)
3697  {
3698  if ((double) y <= (p->bounds.y1-mid-0.5))
3699  break;
3700  if ((double) y > (p->bounds.y2+mid+0.5))
3701  {
3702  (void) DestroyEdge(polygon_info,(size_t) j);
3703  continue;
3704  }
3705  if (((double) x <= (p->bounds.x1-mid-0.5)) ||
3706  ((double) x > (p->bounds.x2+mid+0.5)))
3707  continue;
3708  i=(ssize_t) MagickMax((double) p->highwater,1.0);
3709  for ( ; i < (ssize_t) p->number_points; i++)
3710  {
3711  if ((double) y <= (p->points[i-1].y-mid-0.5))
3712  break;
3713  if ((double) y > (p->points[i].y+mid+0.5))
3714  continue;
3715  if (p->scanline != (double) y)
3716  {
3717  p->scanline=(double) y;
3718  p->highwater=(size_t) i;
3719  }
3720  /*
3721  Compute distance between a point and an edge.
3722  */
3723  q=p->points+i-1;
3724  delta.x=(q+1)->x-q->x;
3725  delta.y=(q+1)->y-q->y;
3726  beta=delta.x*(x-q->x)+delta.y*(y-q->y);
3727  if (beta < 0.0)
3728  {
3729  delta.x=(double) x-q->x;
3730  delta.y=(double) y-q->y;
3731  distance=delta.x*delta.x+delta.y*delta.y;
3732  }
3733  else
3734  {
3735  alpha=delta.x*delta.x+delta.y*delta.y;
3736  if (beta > alpha)
3737  {
3738  delta.x=(double) x-(q+1)->x;
3739  delta.y=(double) y-(q+1)->y;
3740  distance=delta.x*delta.x+delta.y*delta.y;
3741  }
3742  else
3743  {
3744  alpha=1.0/alpha;
3745  beta=delta.x*(y-q->y)-delta.y*(x-q->x);
3746  distance=alpha*beta*beta;
3747  }
3748  }
3749  /*
3750  Compute stroke & subpath opacity.
3751  */
3752  beta=0.0;
3753  if (p->ghostline == MagickFalse)
3754  {
3755  alpha=mid+0.5;
3756  if ((*stroke_opacity < 1.0) &&
3757  (distance <= ((alpha+0.25)*(alpha+0.25))))
3758  {
3759  alpha=mid-0.5;
3760  if (distance <= ((alpha+0.25)*(alpha+0.25)))
3761  *stroke_opacity=1.0;
3762  else
3763  {
3764  beta=1.0;
3765  if (distance != 1.0)
3766  beta=sqrt((double) distance);
3767  alpha=beta-mid-0.5;
3768  if (*stroke_opacity < ((alpha-0.25)*(alpha-0.25)))
3769  *stroke_opacity=(alpha-0.25)*(alpha-0.25);
3770  }
3771  }
3772  }
3773  if ((fill == MagickFalse) || (distance > 1.0) || (subpath_opacity >= 1.0))
3774  continue;
3775  if (distance <= 0.0)
3776  {
3777  subpath_opacity=1.0;
3778  continue;
3779  }
3780  if (distance > 1.0)
3781  continue;
3782  if (beta == 0.0)
3783  {
3784  beta=1.0;
3785  if (distance != 1.0)
3786  beta=sqrt(distance);
3787  }
3788  alpha=beta-1.0;
3789  if (subpath_opacity < (alpha*alpha))
3790  subpath_opacity=alpha*alpha;
3791  }
3792  }
3793  /*
3794  Compute fill opacity.
3795  */
3796  if (fill == MagickFalse)
3797  return(0.0);
3798  if (subpath_opacity >= 1.0)
3799  return(1.0);
3800  /*
3801  Determine winding number.
3802  */
3803  winding_number=0;
3804  p=polygon_info->edges;
3805  for (j=0; j < (ssize_t) polygon_info->number_edges; j++, p++)
3806  {
3807  if ((double) y <= p->bounds.y1)
3808  break;
3809  if (((double) y > p->bounds.y2) || ((double) x <= p->bounds.x1))
3810  continue;
3811  if ((double) x > p->bounds.x2)
3812  {
3813  winding_number+=p->direction ? 1 : -1;
3814  continue;
3815  }
3816  i=(ssize_t) MagickMax((double) p->highwater,1.0);
3817  for ( ; i < (ssize_t) p->number_points; i++)
3818  if ((double) y <= p->points[i].y)
3819  break;
3820  q=p->points+i-1;
3821  if ((((q+1)->x-q->x)*(y-q->y)) <= (((q+1)->y-q->y)*(x-q->x)))
3822  winding_number+=p->direction ? 1 : -1;
3823  }
3824  if (fill_rule != NonZeroRule)
3825  {
3826  if ((MagickAbsoluteValue(winding_number) & 0x01) != 0)
3827  return(1.0);
3828  }
3829  else
3830  if (MagickAbsoluteValue(winding_number) != 0)
3831  return(1.0);
3832  return(subpath_opacity);
3833 }
3834 
3835 static MagickBooleanType DrawPolygonPrimitive(Image *image,
3836  const DrawInfo *draw_info,const PrimitiveInfo *primitive_info)
3837 {
3838  CacheView
3839  *image_view;
3840 
3841  double
3842  mid;
3843 
3844  ExceptionInfo
3845  *exception;
3846 
3847  MagickBooleanType
3848  fill,
3849  status;
3850 
3851  PolygonInfo
3852  **restrict polygon_info;
3853 
3854  register EdgeInfo
3855  *p;
3856 
3857  register ssize_t
3858  i;
3859 
3860  SegmentInfo
3861  bounds;
3862 
3863  ssize_t
3864  start,
3865  stop,
3866  y;
3867 
3868  /*
3869  Compute bounding box.
3870  */
3871  assert(image != (Image *) NULL);
3872  assert(image->signature == MagickSignature);
3873  if (image->debug != MagickFalse)
3874  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3875  assert(draw_info != (DrawInfo *) NULL);
3876  assert(draw_info->signature == MagickSignature);
3877  assert(primitive_info != (PrimitiveInfo *) NULL);
3878  if (primitive_info->coordinates == 0)
3879  return(MagickTrue);
3880  polygon_info=AcquirePolygonThreadSet(draw_info,primitive_info);
3881  if (polygon_info == (PolygonInfo **) NULL)
3882  return(MagickFalse);
3883 DisableMSCWarning(4127)
3884  if (0)
3885  DrawBoundingRectangles(image,draw_info,polygon_info[0]);
3886 RestoreMSCWarning
3887  if (image->debug != MagickFalse)
3888  (void) LogMagickEvent(DrawEvent,GetMagickModule()," begin draw-polygon");
3889  fill=(primitive_info->method == FillToBorderMethod) ||
3890  (primitive_info->method == FloodfillMethod) ? MagickTrue : MagickFalse;
3891  mid=ExpandAffine(&draw_info->affine)*draw_info->stroke_width/2.0;
3892  bounds=polygon_info[0]->edges[0].bounds;
3893  for (i=1; i < (ssize_t) polygon_info[0]->number_edges; i++)
3894  {
3895  p=polygon_info[0]->edges+i;
3896  if (p->bounds.x1 < bounds.x1)
3897  bounds.x1=p->bounds.x1;
3898  if (p->bounds.y1 < bounds.y1)
3899  bounds.y1=p->bounds.y1;
3900  if (p->bounds.x2 > bounds.x2)
3901  bounds.x2=p->bounds.x2;
3902  if (p->bounds.y2 > bounds.y2)
3903  bounds.y2=p->bounds.y2;
3904  }
3905  bounds.x1-=(mid+1.0);
3906  bounds.x1=bounds.x1 < 0.0 ? 0.0 : (size_t) ceil(bounds.x1-0.5) >=
3907  image->columns ? (double) image->columns-1 : bounds.x1;
3908  bounds.y1-=(mid+1.0);
3909  bounds.y1=bounds.y1 < 0.0 ? 0.0 : (size_t) ceil(bounds.y1-0.5) >=
3910  image->rows ? (double) image->rows-1 : bounds.y1;
3911  bounds.x2+=(mid+1.0);
3912  bounds.x2=bounds.x2 < 0.0 ? 0.0 : (size_t) floor(bounds.x2+0.5) >=
3913  image->columns ? (double) image->columns-1 : bounds.x2;
3914  bounds.y2+=(mid+1.0);
3915  bounds.y2=bounds.y2 < 0.0 ? 0.0 : (size_t) floor(bounds.y2+0.5) >=
3916  image->rows ? (double) image->rows-1 : bounds.y2;
3917  status=MagickTrue;
3918  exception=(&image->exception);
3919  image_view=AcquireAuthenticCacheView(image,exception);
3920  if (primitive_info->coordinates == 1)
3921  {
3922  /*
3923  Draw point.
3924  */
3925  start=(ssize_t) ceil(bounds.y1-0.5);
3926  stop=(ssize_t) floor(bounds.y2+0.5);
3927 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3928  #pragma omp parallel for schedule(static,4) shared(status) \
3929  magick_threads(image,image,1,1)
3930 #endif
3931  for (y=start; y <= stop; y++)
3932  {
3933  MagickBooleanType
3934  sync;
3935 
3936  register PixelPacket
3937  *restrict q;
3938 
3939  register ssize_t
3940  x;
3941 
3942  ssize_t
3943  start,
3944  stop;
3945 
3946  if (status == MagickFalse)
3947  continue;
3948  start=(ssize_t) ceil(bounds.x1-0.5);
3949  stop=(ssize_t) floor(bounds.x2+0.5);
3950  x=start;
3951  q=GetCacheViewAuthenticPixels(image_view,x,y,(size_t) (stop-x+1),1,
3952  exception);
3953  if (q == (PixelPacket *) NULL)
3954  {
3955  status=MagickFalse;
3956  continue;
3957  }
3958  for ( ; x <= stop; x++)
3959  {
3960  if ((x == (ssize_t) ceil(primitive_info->point.x-0.5)) &&
3961  (y == (ssize_t) ceil(primitive_info->point.y-0.5)))
3962  (void) GetStrokeColor(draw_info,x,y,q);
3963  q++;
3964  }
3965  sync=SyncCacheViewAuthenticPixels(image_view,exception);
3966  if (sync == MagickFalse)
3967  status=MagickFalse;
3968  }
3969  image_view=DestroyCacheView(image_view);
3970  polygon_info=DestroyPolygonThreadSet(polygon_info);
3971  if (image->debug != MagickFalse)
3972  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
3973  " end draw-polygon");
3974  return(status);
3975  }
3976  /*
3977  Draw polygon or line.
3978  */
3979  if (image->matte == MagickFalse)
3980  (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
3981  start=(ssize_t) ceil(bounds.y1-0.5);
3982  stop=(ssize_t) floor(bounds.y2+0.5);
3983 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3984  #pragma omp parallel for schedule(static,4) shared(status) \
3985  magick_threads(image,image,1,1)
3986 #endif
3987  for (y=start; y <= stop; y++)
3988  {
3989  const int
3990  id = GetOpenMPThreadId();
3991 
3992  double
3993  fill_opacity,
3994  stroke_opacity;
3995 
3996  PixelPacket
3997  fill_color,
3998  stroke_color;
3999 
4000  register PixelPacket
4001  *restrict q;
4002 
4003  register ssize_t
4004  x;
4005 
4006  ssize_t
4007  start,
4008  stop;
4009 
4010  if (status == MagickFalse)
4011  continue;
4012  start=(ssize_t) ceil(bounds.x1-0.5);
4013  stop=(ssize_t) floor(bounds.x2+0.5);
4014  q=GetCacheViewAuthenticPixels(image_view,start,y,(size_t) (stop-start+1),1,
4015  exception);
4016  if (q == (PixelPacket *) NULL)
4017  {
4018  status=MagickFalse;
4019  continue;
4020  }
4021  for (x=start; x <= stop; x++)
4022  {
4023  /*
4024  Fill and/or stroke.
4025  */
4026  fill_opacity=GetOpacityPixel(polygon_info[id],mid,fill,
4027  draw_info->fill_rule,x,y,&stroke_opacity);
4028  if (draw_info->stroke_antialias == MagickFalse)
4029  {
4030  fill_opacity=fill_opacity > 0.25 ? 1.0 : 0.0;
4031  stroke_opacity=stroke_opacity > 0.25 ? 1.0 : 0.0;
4032  }
4033  (void) GetFillColor(draw_info,x,y,&fill_color);
4034  fill_opacity=(double) (QuantumRange-fill_opacity*(QuantumRange-
4035  fill_color.opacity));
4036  MagickCompositeOver(&fill_color,(MagickRealType) fill_opacity,q,
4037  (MagickRealType) q->opacity,q);
4038  (void) GetStrokeColor(draw_info,x,y,&stroke_color);
4039  stroke_opacity=(double) (QuantumRange-stroke_opacity*(QuantumRange-
4040  stroke_color.opacity));
4041  MagickCompositeOver(&stroke_color,(MagickRealType) stroke_opacity,q,
4042  (MagickRealType) q->opacity,q);
4043  q++;
4044  }
4045  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
4046  status=MagickFalse;
4047  }
4048  image_view=DestroyCacheView(image_view);
4049  polygon_info=DestroyPolygonThreadSet(polygon_info);
4050  if (image->debug != MagickFalse)
4051  (void) LogMagickEvent(DrawEvent,GetMagickModule()," end draw-polygon");
4052  return(status);
4053 }
4054 
4055 
4056 /*
4057 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4058 % %
4059 % %
4060 % %
4061 % D r a w P r i m i t i v e %
4062 % %
4063 % %
4064 % %
4065 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4066 %
4067 % DrawPrimitive() draws a primitive (line, rectangle, ellipse) on the image.
4068 %
4069 % The format of the DrawPrimitive method is:
4070 %
4071 % MagickBooleanType DrawPrimitive(Image *image,const DrawInfo *draw_info,
4072 % PrimitiveInfo *primitive_info)
4073 %
4074 % A description of each parameter follows:
4075 %
4076 % o image: the image.
4077 %
4078 % o draw_info: the draw info.
4079 %
4080 % o primitive_info: Specifies a pointer to a PrimitiveInfo structure.
4081 %
4082 */
4083 
4084 static void LogPrimitiveInfo(const PrimitiveInfo *primitive_info)
4085 {
4086  const char
4087  *methods[] =
4088  {
4089  "point",
4090  "replace",
4091  "floodfill",
4092  "filltoborder",
4093  "reset",
4094  "?"
4095  };
4096 
4097  PointInfo
4098  p,
4099  q,
4100  point;
4101 
4102  register ssize_t
4103  i,
4104  x;
4105 
4106  ssize_t
4107  coordinates,
4108  y;
4109 
4110  x=(ssize_t) ceil(primitive_info->point.x-0.5);
4111  y=(ssize_t) ceil(primitive_info->point.y-0.5);
4112  switch (primitive_info->primitive)
4113  {
4114  case PointPrimitive:
4115  {
4116  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4117  "PointPrimitive %.20g,%.20g %s",(double) x,(double) y,
4118  methods[primitive_info->method]);
4119  return;
4120  }
4121  case ColorPrimitive:
4122  {
4123  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4124  "ColorPrimitive %.20g,%.20g %s",(double) x,(double) y,
4125  methods[primitive_info->method]);
4126  return;
4127  }
4128  case MattePrimitive:
4129  {
4130  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4131  "MattePrimitive %.20g,%.20g %s",(double) x,(double) y,
4132  methods[primitive_info->method]);
4133  return;
4134  }
4135  case TextPrimitive:
4136  {
4137  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4138  "TextPrimitive %.20g,%.20g",(double) x,(double) y);
4139  return;
4140  }
4141  case ImagePrimitive:
4142  {
4143  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4144  "ImagePrimitive %.20g,%.20g",(double) x,(double) y);
4145  return;
4146  }
4147  default:
4148  break;
4149  }
4150  coordinates=0;
4151  p=primitive_info[0].point;
4152  q.x=(-1.0);
4153  q.y=(-1.0);
4154  for (i=0; primitive_info[i].primitive != UndefinedPrimitive; i++)
4155  {
4156  point=primitive_info[i].point;
4157  if (coordinates <= 0)
4158  {
4159  coordinates=(ssize_t) primitive_info[i].coordinates;
4160  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4161  " begin open (%.20g)",(double) coordinates);
4162  p=point;
4163  }
4164  point=primitive_info[i].point;
4165  if ((fabs(q.x-point.x) >= MagickEpsilon) ||
4166  (fabs(q.y-point.y) >= MagickEpsilon))
4167  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4168  " %.20g: %.18g,%.18g",(double) coordinates,point.x,point.y);
4169  else
4170  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4171  " %.20g: %g %g (duplicate)",(double) coordinates,point.x,point.y);
4172  q=point;
4173  coordinates--;
4174  if (coordinates > 0)
4175  continue;
4176  if ((fabs(p.x-point.x) >= MagickEpsilon) ||
4177  (fabs(p.y-point.y) >= MagickEpsilon))
4178  (void) LogMagickEvent(DrawEvent,GetMagickModule()," end last (%.20g)",
4179  (double) coordinates);
4180  else
4181  (void) LogMagickEvent(DrawEvent,GetMagickModule()," end open (%.20g)",
4182  (double) coordinates);
4183  }
4184 }
4185 
4186 MagickExport MagickBooleanType DrawPrimitive(Image *image,
4187  const DrawInfo *draw_info,const PrimitiveInfo *primitive_info)
4188 {
4189  CacheView
4190  *image_view;
4191 
4192  ExceptionInfo
4193  *exception;
4194 
4195  MagickStatusType
4196  status;
4197 
4198  register ssize_t
4199  i,
4200  x;
4201 
4202  ssize_t
4203  y;
4204 
4205  if (image->debug != MagickFalse)
4206  {
4207  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4208  " begin draw-primitive");
4209  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4210  " affine: %g %g %g %g %g %g",draw_info->affine.sx,
4211  draw_info->affine.rx,draw_info->affine.ry,draw_info->affine.sy,
4212  draw_info->affine.tx,draw_info->affine.ty);
4213  }
4214  if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
4215  ((IsPixelGray(&draw_info->fill) == MagickFalse) ||
4216  (IsPixelGray(&draw_info->stroke) == MagickFalse)))
4217  (void) SetImageColorspace(image,sRGBColorspace);
4218  status=MagickTrue;
4219  exception=(&image->exception);
4220  x=(ssize_t) ceil(primitive_info->point.x-0.5);
4221  y=(ssize_t) ceil(primitive_info->point.y-0.5);
4222  image_view=AcquireAuthenticCacheView(image,exception);
4223  switch (primitive_info->primitive)
4224  {
4225  case PointPrimitive:
4226  {
4227  PixelPacket
4228  fill_color;
4229 
4230  PixelPacket
4231  *q;
4232 
4233  if ((y < 0) || (y >= (ssize_t) image->rows))
4234  break;
4235  if ((x < 0) || (x >= (ssize_t) image->columns))
4236  break;
4237  q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
4238  if (q == (PixelPacket *) NULL)
4239  break;
4240  (void) GetFillColor(draw_info,x,y,&fill_color);
4241  MagickCompositeOver(&fill_color,(MagickRealType) fill_color.opacity,q,
4242  (MagickRealType) q->opacity,q);
4243  status&=SyncCacheViewAuthenticPixels(image_view,exception);
4244  break;
4245  }
4246  case ColorPrimitive:
4247  {
4248  switch (primitive_info->method)
4249  {
4250  case PointMethod:
4251  default:
4252  {
4253  PixelPacket
4254  *q;
4255 
4256  q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
4257  if (q == (PixelPacket *) NULL)
4258  break;
4259  (void) GetFillColor(draw_info,x,y,q);
4260  status&=SyncCacheViewAuthenticPixels(image_view,exception);
4261  break;
4262  }
4263  case ReplaceMethod:
4264  {
4265  MagickBooleanType
4266  sync;
4267 
4268  PixelPacket
4269  target;
4270 
4271  status&=GetOneCacheViewVirtualPixel(image_view,x,y,&target,exception);
4272  for (y=0; y < (ssize_t) image->rows; y++)
4273  {
4274  register PixelPacket
4275  *restrict q;
4276 
4277  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
4278  exception);
4279  if (q == (PixelPacket *) NULL)
4280  break;
4281  for (x=0; x < (ssize_t) image->columns; x++)
4282  {
4283  if (IsColorSimilar(image,q,&target) == MagickFalse)
4284  {
4285  q++;
4286  continue;
4287  }
4288  (void) GetFillColor(draw_info,x,y,q);
4289  q++;
4290  }
4291  sync=SyncCacheViewAuthenticPixels(image_view,exception);
4292  if (sync == MagickFalse)
4293  break;
4294  }
4295  break;
4296  }
4297  case FloodfillMethod:
4298  case FillToBorderMethod:
4299  {
4300  MagickPixelPacket
4301  target;
4302 
4303  (void) GetOneVirtualMagickPixel(image,x,y,&target,exception);
4304  if (primitive_info->method == FillToBorderMethod)
4305  {
4306  target.red=(MagickRealType) draw_info->border_color.red;
4307  target.green=(MagickRealType) draw_info->border_color.green;
4308  target.blue=(MagickRealType) draw_info->border_color.blue;
4309  }
4310  status&=FloodfillPaintImage(image,DefaultChannels,draw_info,&target,x,
4311  y,primitive_info->method == FloodfillMethod ? MagickFalse :
4312  MagickTrue);
4313  break;
4314  }
4315  case ResetMethod:
4316  {
4317  MagickBooleanType
4318  sync;
4319 
4320  for (y=0; y < (ssize_t) image->rows; y++)
4321  {
4322  register PixelPacket
4323  *restrict q;
4324 
4325  register ssize_t
4326  x;
4327 
4328  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
4329  exception);
4330  if (q == (PixelPacket *) NULL)
4331  break;
4332  for (x=0; x < (ssize_t) image->columns; x++)
4333  {
4334  (void) GetFillColor(draw_info,x,y,q);
4335  q++;
4336  }
4337  sync=SyncCacheViewAuthenticPixels(image_view,exception);
4338  if (sync == MagickFalse)
4339  break;
4340  }
4341  break;
4342  }
4343  }
4344  break;
4345  }
4346  case MattePrimitive:
4347  {
4348  if (image->matte == MagickFalse)
4349  (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
4350  switch (primitive_info->method)
4351  {
4352  case PointMethod:
4353  default:
4354  {
4355  PixelPacket
4356  pixel;
4357 
4358  PixelPacket
4359  *q;
4360 
4361  q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
4362  if (q == (PixelPacket *) NULL)
4363  break;
4364  (void) GetFillColor(draw_info,x,y,&pixel);
4365  SetPixelOpacity(q,pixel.opacity);
4366  status&=SyncCacheViewAuthenticPixels(image_view,exception);
4367  break;
4368  }
4369  case ReplaceMethod:
4370  {
4371  MagickBooleanType
4372  sync;
4373 
4374  PixelPacket
4375  pixel,
4376  target;
4377 
4378  status&=GetOneCacheViewVirtualPixel(image_view,x,y,&target,exception);
4379  for (y=0; y < (ssize_t) image->rows; y++)
4380  {
4381  register PixelPacket
4382  *restrict q;
4383 
4384  register ssize_t
4385  x;
4386 
4387  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
4388  exception);
4389  if (q == (PixelPacket *) NULL)
4390  break;
4391  for (x=0; x < (ssize_t) image->columns; x++)
4392  {
4393  if (IsColorSimilar(image,q,&target) == MagickFalse)
4394  {
4395  q++;
4396  continue;
4397  }
4398  (void) GetFillColor(draw_info,x,y,&pixel);
4399  SetPixelOpacity(q,pixel.opacity);
4400  q++;
4401  }
4402  sync=SyncCacheViewAuthenticPixels(image_view,exception);
4403  if (sync == MagickFalse)
4404  break;
4405  }
4406  break;
4407  }
4408  case FloodfillMethod:
4409  case FillToBorderMethod:
4410  {
4411  MagickPixelPacket
4412  target;
4413 
4414  (void) GetOneVirtualMagickPixel(image,x,y,&target,exception);
4415  if (primitive_info->method == FillToBorderMethod)
4416  {
4417  target.red=(MagickRealType) draw_info->border_color.red;
4418  target.green=(MagickRealType) draw_info->border_color.green;
4419  target.blue=(MagickRealType) draw_info->border_color.blue;
4420  }
4421  status&=FloodfillPaintImage(image,OpacityChannel,draw_info,&target,x,
4422  y,primitive_info->method == FloodfillMethod ? MagickFalse :
4423  MagickTrue);
4424  break;
4425  }
4426  case ResetMethod:
4427  {
4428  MagickBooleanType
4429  sync;
4430 
4431  PixelPacket
4432  pixel;
4433 
4434  for (y=0; y < (ssize_t) image->rows; y++)
4435  {
4436  register PixelPacket
4437  *restrict q;
4438 
4439  register ssize_t
4440  x;
4441 
4442  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
4443  exception);
4444  if (q == (PixelPacket *) NULL)
4445  break;
4446  for (x=0; x < (ssize_t) image->columns; x++)
4447  {
4448  (void) GetFillColor(draw_info,x,y,&pixel);
4449  SetPixelOpacity(q,pixel.opacity);
4450  q++;
4451  }
4452  sync=SyncCacheViewAuthenticPixels(image_view,exception);
4453  if (sync == MagickFalse)
4454  break;
4455  }
4456  break;
4457  }
4458  }
4459  break;
4460  }
4461  case TextPrimitive:
4462  {
4463  char
4464  geometry[MaxTextExtent];
4465 
4466  DrawInfo
4467  *clone_info;
4468 
4469  if (primitive_info->text == (char *) NULL)
4470  break;
4471  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
4472  (void) CloneString(&clone_info->text,primitive_info->text);
4473  (void) FormatLocaleString(geometry,MaxTextExtent,"%+f%+f",
4474  primitive_info->point.x,primitive_info->point.y);
4475  (void) CloneString(&clone_info->geometry,geometry);
4476  status&=AnnotateImage(image,clone_info);
4477  clone_info=DestroyDrawInfo(clone_info);
4478  break;
4479  }
4480  case ImagePrimitive:
4481  {
4482  AffineMatrix
4483  affine;
4484 
4485  char
4486  composite_geometry[MaxTextExtent];
4487 
4488  Image
4489  *composite_image;
4490 
4491  ImageInfo
4492  *clone_info;
4493 
4494  RectangleInfo
4495  geometry;
4496 
4497  ssize_t
4498  x1,
4499  y1;
4500 
4501  if (primitive_info->text == (char *) NULL)
4502  break;
4503  clone_info=AcquireImageInfo();
4504  if (LocaleNCompare(primitive_info->text,"data:",5) == 0)
4505  composite_image=ReadInlineImage(clone_info,primitive_info->text,
4506  &image->exception);
4507  else
4508  {
4509  (void) CopyMagickString(clone_info->filename,primitive_info->text,
4510  MaxTextExtent);
4511  composite_image=ReadImage(clone_info,&image->exception);
4512  }
4513  clone_info=DestroyImageInfo(clone_info);
4514  if (composite_image == (Image *) NULL)
4515  break;
4516  (void) SetImageProgressMonitor(composite_image,(MagickProgressMonitor)
4517  NULL,(void *) NULL);
4518  x1=(ssize_t) ceil(primitive_info[1].point.x-0.5);
4519  y1=(ssize_t) ceil(primitive_info[1].point.y-0.5);
4520  if (((x1 != 0L) && (x1 != (ssize_t) composite_image->columns)) ||
4521  ((y1 != 0L) && (y1 != (ssize_t) composite_image->rows)))
4522  {
4523  char
4524  geometry[MaxTextExtent];
4525 
4526  /*
4527  Resize image.
4528  */
4529  (void) FormatLocaleString(geometry,MaxTextExtent,"%gx%g!",
4530  primitive_info[1].point.x,primitive_info[1].point.y);
4531  composite_image->filter=image->filter;
4532  (void) TransformImage(&composite_image,(char *) NULL,geometry);
4533  }
4534  if (composite_image->matte == MagickFalse)
4535  (void) SetImageAlphaChannel(composite_image,OpaqueAlphaChannel);
4536  if (draw_info->opacity != OpaqueOpacity)
4537  (void) SetImageOpacity(composite_image,draw_info->opacity);
4538  SetGeometry(image,&geometry);
4539  image->gravity=draw_info->gravity;
4540  geometry.x=x;
4541  geometry.y=y;
4542  (void) FormatLocaleString(composite_geometry,MaxTextExtent,
4543  "%.20gx%.20g%+.20g%+.20g",(double) composite_image->columns,(double)
4544  composite_image->rows,(double) geometry.x,(double) geometry.y);
4545  (void) ParseGravityGeometry(image,composite_geometry,&geometry,
4546  &image->exception);
4547  affine=draw_info->affine;
4548  affine.tx=(double) geometry.x;
4549  affine.ty=(double) geometry.y;
4550  composite_image->interpolate=image->interpolate;
4551  if (draw_info->compose == OverCompositeOp)
4552  (void) DrawAffineImage(image,composite_image,&affine);
4553  else
4554  (void) CompositeImage(image,draw_info->compose,composite_image,
4555  geometry.x,geometry.y);
4556  composite_image=DestroyImage(composite_image);
4557  break;
4558  }
4559  default:
4560  {
4561  double
4562  mid,
4563  scale;
4564 
4565  DrawInfo
4566  *clone_info;
4567 
4568  if (IsEventLogging() != MagickFalse)
4569  LogPrimitiveInfo(primitive_info);
4570  scale=ExpandAffine(&draw_info->affine);
4571  if ((draw_info->dash_pattern != (double *) NULL) &&
4572  (draw_info->dash_pattern[0] != 0.0) &&
4573  ((scale*draw_info->stroke_width) >= MagickEpsilon) &&
4574  (draw_info->stroke.opacity != (Quantum) TransparentOpacity))
4575  {
4576  /*
4577  Draw dash polygon.
4578  */
4579  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
4580  clone_info->stroke_width=0.0;
4581  clone_info->stroke.opacity=(Quantum) TransparentOpacity;
4582  status&=DrawPolygonPrimitive(image,clone_info,primitive_info);
4583  clone_info=DestroyDrawInfo(clone_info);
4584  (void) DrawDashPolygon(draw_info,primitive_info,image);
4585  break;
4586  }
4587  mid=ExpandAffine(&draw_info->affine)*draw_info->stroke_width/2.0;
4588  if ((mid > 1.0) &&
4589  (draw_info->stroke.opacity != (Quantum) TransparentOpacity))
4590  {
4591  MagickBooleanType
4592  closed_path;
4593 
4594  /*
4595  Draw strokes while respecting line cap/join attributes.
4596  */
4597  for (i=0; primitive_info[i].primitive != UndefinedPrimitive; i++) ;
4598  closed_path=
4599  (primitive_info[i-1].point.x == primitive_info[0].point.x) &&
4600  (primitive_info[i-1].point.y == primitive_info[0].point.y) ?
4601  MagickTrue : MagickFalse;
4602  i=(ssize_t) primitive_info[0].coordinates;
4603  if ((((draw_info->linecap == RoundCap) ||
4604  (closed_path != MagickFalse)) &&
4605  (draw_info->linejoin == RoundJoin)) ||
4606  (primitive_info[i].primitive != UndefinedPrimitive))
4607  {
4608  (void) DrawPolygonPrimitive(image,draw_info,primitive_info);
4609  break;
4610  }
4611  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
4612  clone_info->stroke_width=0.0;
4613  clone_info->stroke.opacity=(Quantum) TransparentOpacity;
4614  status&=DrawPolygonPrimitive(image,clone_info,primitive_info);
4615  clone_info=DestroyDrawInfo(clone_info);
4616  status&=DrawStrokePolygon(image,draw_info,primitive_info);
4617  break;
4618  }
4619  status&=DrawPolygonPrimitive(image,draw_info,primitive_info);
4620  break;
4621  }
4622  }
4623  image_view=DestroyCacheView(image_view);
4624  if (image->debug != MagickFalse)
4625  (void) LogMagickEvent(DrawEvent,GetMagickModule()," end draw-primitive");
4626  return(status != 0 ? MagickTrue : MagickFalse);
4627 }
4628 
4629 
4630 /*
4631 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4632 % %
4633 % %
4634 % %
4635 + D r a w S t r o k e P o l y g o n %
4636 % %
4637 % %
4638 % %
4639 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4640 %
4641 % DrawStrokePolygon() draws a stroked polygon (line, rectangle, ellipse) on
4642 % the image while respecting the line cap and join attributes.
4643 %
4644 % The format of the DrawStrokePolygon method is:
4645 %
4646 % MagickBooleanType DrawStrokePolygon(Image *image,
4647 % const DrawInfo *draw_info,const PrimitiveInfo *primitive_info)
4648 %
4649 % A description of each parameter follows:
4650 %
4651 % o image: the image.
4652 %
4653 % o draw_info: the draw info.
4654 %
4655 % o primitive_info: Specifies a pointer to a PrimitiveInfo structure.
4656 %
4657 %
4658 */
4659 
4660 static void DrawRoundLinecap(Image *image,const DrawInfo *draw_info,
4661  const PrimitiveInfo *primitive_info)
4662 {
4663  PrimitiveInfo
4664  linecap[5];
4665 
4666  register ssize_t
4667  i;
4668 
4669  for (i=0; i < 4; i++)
4670  linecap[i]=(*primitive_info);
4671  linecap[0].coordinates=4;
4672  linecap[1].point.x+=(double) (10.0*MagickEpsilon);
4673  linecap[2].point.x+=(double) (10.0*MagickEpsilon);
4674  linecap[2].point.y+=(double) (10.0*MagickEpsilon);
4675  linecap[3].point.y+=(double) (10.0*MagickEpsilon);
4676  linecap[4].primitive=UndefinedPrimitive;
4677  (void) DrawPolygonPrimitive(image,draw_info,linecap);
4678 }
4679 
4680 static MagickBooleanType DrawStrokePolygon(Image *image,
4681  const DrawInfo *draw_info,const PrimitiveInfo *primitive_info)
4682 {
4683  DrawInfo
4684  *clone_info;
4685 
4686  MagickBooleanType
4687  closed_path;
4688 
4689  MagickStatusType
4690  status;
4691 
4692  PrimitiveInfo
4693  *stroke_polygon;
4694 
4695  register const PrimitiveInfo
4696  *p,
4697  *q;
4698 
4699  /*
4700  Draw stroked polygon.
4701  */
4702  if (image->debug != MagickFalse)
4703  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4704  " begin draw-stroke-polygon");
4705  clone_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
4706  clone_info->fill=draw_info->stroke;
4707  if (clone_info->fill_pattern != (Image *) NULL)
4708  clone_info->fill_pattern=DestroyImage(clone_info->fill_pattern);
4709  if (clone_info->stroke_pattern != (Image *) NULL)
4710  clone_info->fill_pattern=CloneImage(clone_info->stroke_pattern,0,0,
4711  MagickTrue,&clone_info->stroke_pattern->exception);
4712  clone_info->stroke.opacity=(Quantum) TransparentOpacity;
4713  clone_info->stroke_width=0.0;
4714  clone_info->fill_rule=NonZeroRule;
4715  status=MagickTrue;
4716  for (p=primitive_info; p->primitive != UndefinedPrimitive; p+=p->coordinates)
4717  {
4718  stroke_polygon=TraceStrokePolygon(draw_info,p);
4719  status&=DrawPolygonPrimitive(image,clone_info,stroke_polygon);
4720  if (status == 0)
4721  break;
4722  stroke_polygon=(PrimitiveInfo *) RelinquishMagickMemory(stroke_polygon);
4723  q=p+p->coordinates-1;
4724  closed_path=(q->point.x == p->point.x) && (q->point.y == p->point.y) ?
4725  MagickTrue : MagickFalse;
4726  if ((draw_info->linecap == RoundCap) && (closed_path == MagickFalse))
4727  {
4728  DrawRoundLinecap(image,draw_info,p);
4729  DrawRoundLinecap(image,draw_info,q);
4730  }
4731  }
4732  clone_info=DestroyDrawInfo(clone_info);
4733  if (image->debug != MagickFalse)
4734  (void) LogMagickEvent(DrawEvent,GetMagickModule(),
4735  " end draw-stroke-polygon");
4736  return(status != 0 ? MagickTrue : MagickFalse);
4737 }
4738 
4739 
4740 /*
4741 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4742 % %
4743 % %
4744 % %
4745 % G e t A f f i n e M a t r i x %
4746 % %
4747 % %
4748 % %
4749 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4750 %
4751 % GetAffineMatrix() returns an AffineMatrix initialized to the identity
4752 % matrix.
4753 %
4754 % The format of the GetAffineMatrix method is:
4755 %
4756 % void GetAffineMatrix(AffineMatrix *affine_matrix)
4757 %
4758 % A description of each parameter follows:
4759 %
4760 % o affine_matrix: the affine matrix.
4761 %
4762 */
4763 MagickExport void GetAffineMatrix(AffineMatrix *affine_matrix)
4764 {
4765  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
4766  assert(affine_matrix != (AffineMatrix *) NULL);
4767  (void) ResetMagickMemory(affine_matrix,0,sizeof(*affine_matrix));
4768  affine_matrix->sx=1.0;
4769  affine_matrix->sy=1.0;
4770 }
4771 
4772 
4773 /*
4774 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4775 % %
4776 % %
4777 % %
4778 + G e t D r a w I n f o %
4779 % %
4780 % %
4781 % %
4782 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4783 %
4784 % GetDrawInfo() initializes draw_info to default values from image_info.
4785 %
4786 % The format of the GetDrawInfo method is:
4787 %
4788 % void GetDrawInfo(const ImageInfo *image_info,DrawInfo *draw_info)
4789 %
4790 % A description of each parameter follows:
4791 %
4792 % o image_info: the image info..
4793 %
4794 % o draw_info: the draw info.
4795 %
4796 */
4797 MagickExport void GetDrawInfo(const ImageInfo *image_info,DrawInfo *draw_info)
4798 {
4799  const char
4800  *option;
4801 
4802  ExceptionInfo
4803  *exception;
4804 
4805  ImageInfo
4806  *clone_info;
4807 
4808  /*
4809  Initialize draw attributes.
4810  */
4811  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
4812  assert(draw_info != (DrawInfo *) NULL);
4813  (void) ResetMagickMemory(draw_info,0,sizeof(*draw_info));
4814  clone_info=CloneImageInfo(image_info);
4815  GetAffineMatrix(&draw_info->affine);
4816  exception=AcquireExceptionInfo();
4817  (void) QueryColorDatabase("#000F",&draw_info->fill,exception);
4818  (void) QueryColorDatabase("#FFF0",&draw_info->stroke,exception);
4819  draw_info->stroke_antialias=clone_info->antialias;
4820  draw_info->stroke_width=1.0;
4821  draw_info->opacity=OpaqueOpacity;
4822  draw_info->fill_rule=EvenOddRule;
4823  draw_info->linecap=ButtCap;
4824  draw_info->linejoin=MiterJoin;
4825  draw_info->miterlimit=10;
4826  draw_info->decorate=NoDecoration;
4827  if (clone_info->font != (char *) NULL)
4828  draw_info->font=AcquireString(clone_info->font);
4829  if (clone_info->density != (char *) NULL)
4830  draw_info->density=AcquireString(clone_info->density);
4831  draw_info->text_antialias=clone_info->antialias;
4832  draw_info->pointsize=12.0;
4833  if (clone_info->pointsize != 0.0)
4834  draw_info->pointsize=clone_info->pointsize;
4835  draw_info->undercolor.opacity=(Quantum) TransparentOpacity;
4836  draw_info->border_color=clone_info->border_color;
4837  draw_info->compose=OverCompositeOp;
4838  if (clone_info->server_name != (char *) NULL)
4839  draw_info->server_name=AcquireString(clone_info->server_name);
4840  draw_info->render=MagickTrue;
4841  draw_info->debug=IsEventLogging();
4842  option=GetImageOption(clone_info,"encoding");
4843  if (option != (const char *) NULL)
4844  (void) CloneString(&draw_info->encoding,option);
4845  option=GetImageOption(clone_info,"kerning");
4846  if (option != (const char *) NULL)
4847  draw_info->kerning=StringToDouble(option,(char **) NULL);
4848  option=GetImageOption(clone_info,"interline-spacing");
4849  if (option != (const char *) NULL)
4850  draw_info->interline_spacing=StringToDouble(option,(char **) NULL);
4851  draw_info->direction=UndefinedDirection;
4852  option=GetImageOption(clone_info,"interword-spacing");
4853  if (option != (const char *) NULL)
4854  draw_info->interword_spacing=StringToDouble(option,(char **) NULL);
4855  option=GetImageOption(clone_info,"direction");
4856  if (option != (const char *) NULL)
4857  draw_info->direction=(DirectionType) ParseCommandOption(
4858  MagickDirectionOptions,MagickFalse,option);
4859  option=GetImageOption(clone_info,"fill");
4860  if (option != (const char *) NULL)
4861  (void) QueryColorDatabase(option,&draw_info->fill,exception);
4862  option=GetImageOption(clone_info,"stroke");
4863  if (option != (const char *) NULL)
4864  (void) QueryColorDatabase(option,&draw_info->stroke,exception);
4865  option=GetImageOption(clone_info,"strokewidth");
4866  if (option != (const char *) NULL)
4867  draw_info->stroke_width=StringToDouble(option,(char **) NULL);
4868  option=GetImageOption(clone_info,"undercolor");
4869  if (option != (const char *) NULL)
4870  (void) QueryColorDatabase(option,&draw_info->undercolor,exception);
4871  option=GetImageOption(clone_info,"gravity");
4872  if (option != (const char *) NULL)
4873  draw_info->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
4874  MagickFalse,option);
4875  exception=DestroyExceptionInfo(exception);
4876  draw_info->signature=MagickSignature;
4877  clone_info=DestroyImageInfo(clone_info);
4878 }
4879 
4880 
4881 /*
4882 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4883 % %
4884 % %
4885 % %
4886 + P e r m u t a t e %
4887 % %
4888 % %
4889 % %
4890 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4891 %
4892 % Permutate() returns the permuation of the (n,k).
4893 %
4894 % The format of the Permutate method is:
4895 %
4896 % void Permutate(ssize_t n,ssize_t k)
4897 %
4898 % A description of each parameter follows:
4899 %
4900 % o n:
4901 %
4902 % o k:
4903 %
4904 %
4905 */
4906 static inline double Permutate(const ssize_t n,const ssize_t k)
4907 {
4908  double
4909  r;
4910 
4911  register ssize_t
4912  i;
4913 
4914  r=1.0;
4915  for (i=k+1; i <= n; i++)
4916  r*=i;
4917  for (i=1; i <= (n-k); i++)
4918  r/=i;
4919  return(r);
4920 }
4921 
4922 
4923 /*
4924 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4925 % %
4926 % %
4927 % %
4928 + T r a c e P r i m i t i v e %
4929 % %
4930 % %
4931 % %
4932 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4933 %
4934 % TracePrimitive is a collection of methods for generating graphic
4935 % primitives such as arcs, ellipses, paths, etc.
4936 %
4937 */
4938 
4939 static void TraceArc(PrimitiveInfo *primitive_info,const PointInfo start,
4940  const PointInfo end,const PointInfo degrees)
4941 {
4942  PointInfo
4943  center,
4944  radii;
4945 
4946  center.x=0.5*(end.x+start.x);
4947  center.y=0.5*(end.y+start.y);
4948  radii.x=fabs(center.x-start.x);
4949  radii.y=fabs(center.y-start.y);
4950  TraceEllipse(primitive_info,center,radii,degrees);
4951 }
4952 
4953 static void TraceArcPath(PrimitiveInfo *primitive_info,const PointInfo start,
4954  const PointInfo end,const PointInfo arc,const double angle,
4955  const MagickBooleanType large_arc,const MagickBooleanType sweep)
4956 {
4957  double
4958  alpha,
4959  beta,
4960  delta,
4961  factor,
4962  gamma,
4963  theta;
4964 
4965  PointInfo
4966  center,
4967  points[3],
4968  radii;
4969 
4970  register double
4971  cosine,
4972  sine;
4973 
4974  register PrimitiveInfo
4975  *p;
4976 
4977  register ssize_t
4978  i;
4979 
4980  size_t
4981  arc_segments;
4982 
4983  if ((start.x == end.x) && (start.y == end.y))
4984  {
4985  TracePoint(primitive_info,end);
4986  return;
4987  }
4988  radii.x=fabs(arc.x);
4989  radii.y=fabs(arc.y);
4990  if ((radii.x == 0.0) || (radii.y == 0.0))
4991  {
4992  TraceLine(primitive_info,start,end);
4993  return;
4994  }
4995  cosine=cos(DegreesToRadians(fmod((double) angle,360.0)));
4996  sine=sin(DegreesToRadians(fmod((double) angle,360.0)));
4997  center.x=(double) (cosine*(end.x-start.x)/2+sine*(end.y-start.y)/2);
4998  center.y=(double) (cosine*(end.y-start.y)/2-sine*(end.x-start.x)/2);
4999  delta=(center.x*center.x)/(radii.x*radii.x)+(center.y*center.y)/
5000  (radii.y*radii.y);
5001  if (delta < MagickEpsilon)
5002  {
5003  TraceLine(primitive_info,start,end);
5004  return;
5005  }
5006  if (delta > 1.0)
5007  {
5008  radii.x*=sqrt((double) delta);
5009  radii.y*=sqrt((double) delta);
5010  }
5011  points[0].x=(double) (cosine*start.x/radii.x+sine*start.y/radii.x);
5012  points[0].y=(double) (cosine*start.y/radii.y-sine*start.x/radii.y);
5013  points[1].x=(double) (cosine*end.x/radii.x+sine*end.y/radii.x);
5014  points[1].y=(double) (cosine*end.y/radii.y-sine*end.x/radii.y);
5015  alpha=points[1].x-points[0].x;
5016  beta=points[1].y-points[0].y;
5017  factor=PerceptibleReciprocal(alpha*alpha+beta*beta)-0.25;
5018  if (factor <= 0.0)
5019  factor=0.0;
5020  else
5021  {
5022  factor=sqrt((double) factor);
5023  if (sweep == large_arc)
5024  factor=(-factor);
5025  }
5026  center.x=(double) ((points[0].x+points[1].x)/2-factor*beta);
5027  center.y=(double) ((points[0].y+points[1].y)/2+factor*alpha);
5028  alpha=atan2(points[0].y-center.y,points[0].x-center.x);
5029  theta=atan2(points[1].y-center.y,points[1].x-center.x)-alpha;
5030  if ((theta < 0.0) && (sweep != MagickFalse))
5031  theta+=2.0*MagickPI;
5032  else
5033  if ((theta > 0.0) && (sweep == MagickFalse))
5034  theta-=2.0*MagickPI;
5035  arc_segments=(size_t) ceil(fabs((double) (theta/(0.5*MagickPI+
5036  MagickEpsilon))));
5037  p=primitive_info;
5038  for (i=0; i < (ssize_t) arc_segments; i++)
5039  {
5040  beta=0.5*((alpha+(i+1)*theta/arc_segments)-(alpha+i*theta/arc_segments));
5041  gamma=(8.0/3.0)*sin(fmod((double) (0.5*beta),DegreesToRadians(360.0)))*
5042  sin(fmod((double) (0.5*beta),DegreesToRadians(360.0)))/
5043  sin(fmod((double) beta,DegreesToRadians(360.0)));
5044  points[0].x=(double) (center.x+cos(fmod((double) (alpha+(double) i*theta/
5045  arc_segments),DegreesToRadians(360.0)))-gamma*sin(fmod((double) (alpha+
5046  (double) i*theta/arc_segments),DegreesToRadians(360.0))));
5047  points[0].y=(double) (center.y+sin(fmod((double) (alpha+(double) i*theta/
5048  arc_segments),DegreesToRadians(360.0)))+gamma*cos(fmod((double) (alpha+
5049  (double) i*theta/arc_segments),DegreesToRadians(360.0))));
5050  points[2].x=(double) (center.x+cos(fmod((double) (alpha+(double) (i+1)*
5051  theta/arc_segments),DegreesToRadians(360.0))));
5052  points[2].y=(double) (center.y+sin(fmod((double) (alpha+(double) (i+1)*
5053  theta/arc_segments),DegreesToRadians(360.0))));
5054  points[1].x=(double) (points[2].x+gamma*sin(fmod((double) (alpha+(double)
5055  (i+1)*theta/arc_segments),DegreesToRadians(360.0))));
5056  points[1].y=(double) (points[2].y-gamma*cos(fmod((double) (alpha+(double)
5057  (i+1)*theta/arc_segments),DegreesToRadians(360.0))));
5058  p->point.x=(p == primitive_info) ? start.x : (p-1)->point.x;
5059  p->point.y=(p == primitive_info) ? start.y : (p-1)->point.y;
5060  (p+1)->point.x=(double) (cosine*radii.x*points[0].x-sine*radii.y*
5061  points[0].y);
5062  (p+1)->point.y=(double) (sine*radii.x*points[0].x+cosine*radii.y*
5063  points[0].y);
5064  (p+2)->point.x=(double) (cosine*radii.x*points[1].x-sine*radii.y*
5065  points[1].y);
5066  (p+2)->point.y=(double) (sine*radii.x*points[1].x+cosine*radii.y*
5067  points[1].y);
5068  (p+3)->point.x=(double) (cosine*radii.x*points[2].x-sine*radii.y*
5069  points[2].y);
5070  (p+3)->point.y=(double) (sine*radii.x*points[2].x+cosine*radii.y*
5071  points[2].y);
5072  if (i == (ssize_t) (arc_segments-1))
5073  (p+3)->point=end;
5074  TraceBezier(p,4);
5075  p+=p->coordinates;
5076  }
5077  primitive_info->coordinates=(size_t) (p-primitive_info);
5078  for (i=0; i < (ssize_t) primitive_info->coordinates; i++)
5079  {
5080  p->primitive=primitive_info->primitive;
5081  p--;
5082  }
5083 }
5084 
5085 static void TraceBezier(PrimitiveInfo *primitive_info,
5086  const size_t number_coordinates)
5087 {
5088  double
5089  alpha,
5090  *coefficients,
5091  weight;
5092 
5093  PointInfo
5094  end,
5095  point,
5096  *points;
5097 
5098  register PrimitiveInfo
5099  *p;
5100 
5101  register ssize_t
5102  i,
5103  j;
5104 
5105  size_t
5106  control_points,
5107  quantum;
5108 
5109  /*
5110  Allocate coeficients.
5111  */
5112  quantum=number_coordinates;
5113  for (i=0; i < (ssize_t) number_coordinates; i++)
5114  {
5115  for (j=i+1; j < (ssize_t) number_coordinates; j++)
5116  {
5117  alpha=fabs(primitive_info[j].point.x-primitive_info[i].point.x);
5118  if (alpha > (double) quantum)
5119  quantum=(size_t) alpha;
5120  alpha=fabs(primitive_info[j].point.y-primitive_info[i].point.y);
5121  if (alpha > (double) quantum)
5122  quantum=(size_t) alpha;
5123  }
5124  }
5125  quantum=(size_t) MagickMin((double) quantum/number_coordinates,
5126  (double) BezierQuantum);
5127  control_points=quantum*number_coordinates;
5128  coefficients=(double *) AcquireQuantumMemory((size_t)
5129  number_coordinates,sizeof(*coefficients));
5130  points=(PointInfo *) AcquireQuantumMemory((size_t) control_points,
5131  sizeof(*points));
5132  if ((coefficients == (double *) NULL) || (points == (PointInfo *) NULL))
5133  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
5134  /*
5135  Compute bezier points.
5136  */
5137  end=primitive_info[number_coordinates-1].point;
5138  for (i=0; i < (ssize_t) number_coordinates; i++)
5139  coefficients[i]=Permutate((ssize_t) number_coordinates-1,i);
5140  weight=0.0;
5141  for (i=0; i < (ssize_t) control_points; i++)
5142  {
5143  p=primitive_info;
5144  point.x=0.0;
5145  point.y=0.0;
5146  alpha=pow((double) (1.0-weight),(double) number_coordinates-1.0);
5147  for (j=0; j < (ssize_t) number_coordinates; j++)
5148  {
5149  point.x+=alpha*coefficients[j]*p->point.x;
5150  point.y+=alpha*coefficients[j]*p->point.y;
5151  alpha*=weight/(1.0-weight);
5152  p++;
5153  }
5154  points[i]=point;
5155  weight+=1.0/control_points;
5156  }
5157  /*
5158  Bezier curves are just short segmented polys.
5159  */
5160  p=primitive_info;
5161  for (i=0; i < (ssize_t) control_points; i++)
5162  {
5163  TracePoint(p,points[i]);
5164  p+=p->coordinates;
5165  }
5166  TracePoint(p,end);
5167  p+=p->coordinates;
5168  primitive_info->coordinates=(size_t) (p-primitive_info);
5169  for (i=0; i < (ssize_t) primitive_info->coordinates; i++)
5170  {
5171  p->primitive=primitive_info->primitive;
5172  p--;
5173  }
5174  points=(PointInfo *) RelinquishMagickMemory(points);
5175  coefficients=(double *) RelinquishMagickMemory(coefficients);
5176 }
5177 
5178 static void TraceCircle(PrimitiveInfo *primitive_info,const PointInfo start,
5179  const PointInfo end)
5180 {
5181  double
5182  alpha,
5183  beta,
5184  radius;
5185 
5186  PointInfo
5187  offset,
5188  degrees;
5189 
5190  alpha=end.x-start.x;
5191  beta=end.y-start.y;
5192  radius=hypot((double) alpha,(double) beta);
5193  offset.x=(double) radius;
5194  offset.y=(double) radius;
5195  degrees.x=0.0;
5196  degrees.y=360.0;
5197  TraceEllipse(primitive_info,start,offset,degrees);
5198 }
5199 
5200 static void TraceEllipse(PrimitiveInfo *primitive_info,const PointInfo start,
5201  const PointInfo stop,const PointInfo degrees)
5202 {
5203  double
5204  delta,
5205  step,
5206  y;
5207 
5208  PointInfo
5209  angle,
5210  point;
5211 
5212  register PrimitiveInfo
5213  *p;
5214 
5215  register ssize_t
5216  i;
5217 
5218  /*
5219  Ellipses are just short segmented polys.
5220  */
5221  if ((stop.x == 0.0) && (stop.y == 0.0))
5222  {
5223  TracePoint(primitive_info,start);
5224  return;
5225  }
5226  delta=2.0/MagickMax(stop.x,stop.y);
5227  step=MagickPI/8.0;
5228  if ((delta >= 0.0) && (delta < (MagickPI/8.0)))
5229  step=MagickPI/(4*(MagickPI/delta/2+0.5));
5230  angle.x=DegreesToRadians(degrees.x);
5231  y=degrees.y;
5232  while (y < degrees.x)
5233  y+=360.0;
5234  angle.y=(double) (DegreesToRadians(y)-MagickEpsilon);
5235  for (p=primitive_info; angle.x < angle.y; angle.x+=step)
5236  {
5237  point.x=cos(fmod(angle.x,DegreesToRadians(360.0)))*stop.x+start.x;
5238  point.y=sin(fmod(angle.x,DegreesToRadians(360.0)))*stop.y+start.y;
5239  TracePoint(p,point);
5240  p+=p->coordinates;
5241  }
5242  point.x=cos(fmod(angle.y,DegreesToRadians(360.0)))*stop.x+start.x;
5243  point.y=sin(fmod(angle.y,DegreesToRadians(360.0)))*stop.y+start.y;
5244  TracePoint(p,point);
5245  p+=p->coordinates;
5246  primitive_info->coordinates=(size_t) (p-primitive_info);
5247  for (i=0; i < (ssize_t) primitive_info->coordinates; i++)
5248  {
5249  p->primitive=primitive_info->primitive;
5250  p--;
5251  }
5252 }
5253 
5254 static void TraceLine(PrimitiveInfo *primitive_info,const PointInfo start,
5255  const PointInfo end)
5256 {
5257  TracePoint(primitive_info,start);
5258  if ((fabs(start.x-end.x) < MagickEpsilon) &&
5259  (fabs(start.y-end.y) < MagickEpsilon))
5260  {
5261  primitive_info->primitive=PointPrimitive;
5262  primitive_info->coordinates=1;
5263  return;
5264  }
5265  TracePoint(primitive_info+1,end);
5266  (primitive_info+1)->primitive=primitive_info->primitive;
5267  primitive_info->coordinates=2;
5268 }
5269 
5270 static size_t TracePath(PrimitiveInfo *primitive_info,const char *path)
5271 {
5272  char
5273  token[MaxTextExtent];
5274 
5275  const char
5276  *p;
5277 
5278  double
5279  x,
5280  y;
5281 
5282  int
5283  attribute,
5284  last_attribute;
5285 
5286  PointInfo
5287  end,
5288  points[4],
5289  point,
5290  start;
5291 
5292  PrimitiveType
5293  primitive_type;
5294 
5295  register PrimitiveInfo
5296  *q;
5297 
5298  register ssize_t
5299  i;
5300 
5301  size_t
5302  number_coordinates,
5303  z_count;
5304 
5305  attribute=0;
5306  end.x=0.0;
5307  end.y=0.0;
5308  point.x=0.0;
5309  point.y=0.0;
5310  start.x=0.0;
5311  start.y=0.0;
5312  number_coordinates=0;
5313  z_count=0;
5314  primitive_type=primitive_info->primitive;
5315  q=primitive_info;
5316  for (p=path; *p != '\0'; )
5317  {
5318  while (isspace((int) ((unsigned char) *p)) != 0)
5319  p++;
5320  if (*p == '\0')
5321  break;
5322  last_attribute=attribute;
5323  attribute=(int) (*p++);
5324  switch (attribute)
5325  {
5326  case 'a':
5327  case 'A':
5328  {
5329  double
5330  angle;
5331 
5332  MagickBooleanType
5333  large_arc,
5334  sweep;
5335 
5336  PointInfo
5337  arc;
5338 
5339  /*
5340  Compute arc points.
5341  */
5342  do
5343  {
5344  GetMagickToken(p,&p,token);
5345  if (*token == ',')
5346  GetMagickToken(p,&p,token);
5347  arc.x=StringToDouble(token,(char **) NULL);
5348  GetMagickToken(p,&p,token);
5349  if (*token == ',')
5350  GetMagickToken(p,&p,token);
5351  arc.y=StringToDouble(token,(char **) NULL);
5352  GetMagickToken(p,&p,token);
5353  if (*token == ',')
5354  GetMagickToken(p,&p,token);
5355  angle=StringToDouble(token,(char **) NULL);
5356  GetMagickToken(p,&p,token);
5357  if (*token == ',')
5358  GetMagickToken(p,&p,token);
5359  large_arc=StringToLong(token) != 0 ? MagickTrue : MagickFalse;
5360  GetMagickToken(p,&p,token);
5361  if (*token == ',')
5362  GetMagickToken(p,&p,token);
5363  sweep=StringToLong(token) != 0 ? MagickTrue : MagickFalse;
5364  GetMagickToken(p,&p,token);
5365  if (*token == ',')
5366  GetMagickToken(p,&p,token);
5367  x=StringToDouble(token,(char **) NULL);
5368  GetMagickToken(p,&p,token);
5369  if (*token == ',')
5370  GetMagickToken(p,&p,token);
5371  y=StringToDouble(token,(char **) NULL);
5372  end.x=(double) (attribute == (int) 'A' ? x : point.x+x);
5373  end.y=(double) (attribute == (int) 'A' ? y : point.y+y);
5374  TraceArcPath(q,point,end,arc,angle,large_arc,sweep);
5375  q+=q->coordinates;
5376  point=end;
5377  while (isspace((int) ((unsigned char) *p)) != 0)
5378  p++;
5379  if (*p == ',')
5380  p++;
5381  } while (IsPoint(p) != MagickFalse);
5382  break;
5383  }
5384  case 'c':
5385  case 'C':
5386  {
5387  /*
5388  Compute bezier points.
5389  */
5390  do
5391  {
5392  points[0]=point;
5393  for (i=1; i < 4; i++)
5394  {
5395  GetMagickToken(p,&p,token);
5396  if (*token == ',')
5397  GetMagickToken(p,&p,token);
5398  x=StringToDouble(token,(char **) NULL);
5399  GetMagickToken(p,&p,token);
5400  if (*token == ',')
5401  GetMagickToken(p,&p,token);
5402  y=StringToDouble(token,(char **) NULL);
5403  end.x=(double) (attribute == (int) 'C' ? x : point.x+x);
5404  end.y=(double) (attribute == (int) 'C' ? y : point.y+y);
5405  points[i]=end;
5406  }
5407  for (i=0; i < 4; i++)
5408  (q+i)->point=points[i];
5409  TraceBezier(q,4);
5410  q+=q->coordinates;
5411  point=end;
5412  } while (IsPoint(p) != MagickFalse);
5413  break;
5414  }
5415  case 'H':
5416  case 'h':
5417  {
5418  do
5419  {
5420  GetMagickToken(p,&p,token);
5421  if (*token == ',')
5422  GetMagickToken(p,&p,token);
5423  x=StringToDouble(token,(char **) NULL);
5424  point.x=(double) (attribute == (int) 'H' ? x: point.x+x);
5425  TracePoint(q,point);
5426  q+=q->coordinates;
5427  } while (IsPoint(p) != MagickFalse);
5428  break;
5429  }
5430  case 'l':
5431  case 'L':
5432  {
5433  do
5434  {
5435  GetMagickToken(p,&p,token);
5436  if (*token == ',')
5437  GetMagickToken(p,&p,token);
5438  x=StringToDouble(token,(char **) NULL);
5439