1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % PPPP AAA IIIII N N TTTTT %
7 % P P A A I NN N T %
8 % PPPP AAAAA I N N N T %
9 % P A A I N NN T %
10 % P A A IIIII N N T %
11 % %
12 % %
13 % Methods to Paint on an Image %
14 % %
15 % Software Design %
16 % Cristy %
17 % July 1998 %
18 % %
19 % %
20 % Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
22 % %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
25 % %
26 % https://imagemagick.org/script/license.php %
27 % %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
33 % %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 */
38
39 /*
40 Include declarations.
41 */
42 #include "MagickCore/studio.h"
43 #include "MagickCore/artifact.h"
44 #include "MagickCore/channel.h"
45 #include "MagickCore/color.h"
46 #include "MagickCore/color-private.h"
47 #include "MagickCore/colorspace-private.h"
48 #include "MagickCore/composite.h"
49 #include "MagickCore/composite-private.h"
50 #include "MagickCore/draw.h"
51 #include "MagickCore/draw-private.h"
52 #include "MagickCore/exception.h"
53 #include "MagickCore/exception-private.h"
54 #include "MagickCore/gem.h"
55 #include "MagickCore/gem-private.h"
56 #include "MagickCore/monitor.h"
57 #include "MagickCore/monitor-private.h"
58 #include "MagickCore/option.h"
59 #include "MagickCore/paint.h"
60 #include "MagickCore/pixel-accessor.h"
61 #include "MagickCore/resource_.h"
62 #include "MagickCore/statistic.h"
63 #include "MagickCore/string_.h"
64 #include "MagickCore/string-private.h"
65 #include "MagickCore/thread-private.h"
66
67 /*
68 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
69 % %
70 % %
71 % %
72 % F l o o d f i l l P a i n t I m a g e %
73 % %
74 % %
75 % %
76 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
77 %
78 % FloodfillPaintImage() changes the color value of any pixel that matches
79 % target and is an immediate neighbor. If the method FillToBorderMethod is
80 % specified, the color value is changed for any neighbor pixel that does not
81 % match the bordercolor member of image.
82 %
83 % By default target must match a particular pixel color exactly. However,
84 % in many cases two colors may differ by a small amount. The fuzz member of
85 % image defines how much tolerance is acceptable to consider two colors as
86 % the same. For example, set fuzz to 10 and the color red at intensities of
87 % 100 and 102 respectively are now interpreted as the same color for the
88 % purposes of the floodfill.
89 %
90 % The format of the FloodfillPaintImage method is:
91 %
92 % MagickBooleanType FloodfillPaintImage(Image *image,
93 % const DrawInfo *draw_info,const PixelInfo target,
94 % const ssize_t x_offset,const ssize_t y_offset,
95 % const MagickBooleanType invert,ExceptionInfo *exception)
96 %
97 % A description of each parameter follows:
98 %
99 % o image: the image.
100 %
101 % o draw_info: the draw info.
102 %
103 % o target: the RGB value of the target color.
104 %
105 % o x_offset,y_offset: the starting location of the operation.
106 %
107 % o invert: paint any pixel that does not match the target color.
108 %
109 % o exception: return any errors or warnings in this structure.
110 %
111 */
FloodfillPaintImage(Image * image,const DrawInfo * draw_info,const PixelInfo * target,const ssize_t x_offset,const ssize_t y_offset,const MagickBooleanType invert,ExceptionInfo * exception)112 MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
113 const DrawInfo *draw_info,const PixelInfo *target,const ssize_t x_offset,
114 const ssize_t y_offset,const MagickBooleanType invert,
115 ExceptionInfo *exception)
116 {
117 #define MaxStacksize 524288UL
118 #define PushSegmentStack(up,left,right,delta) \
119 { \
120 if (s >= (segment_stack+MaxStacksize)) \
121 ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
122 else \
123 { \
124 if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (ssize_t) image->rows)) \
125 { \
126 s->x1=(double) (left); \
127 s->y1=(double) (up); \
128 s->x2=(double) (right); \
129 s->y2=(double) (delta); \
130 s++; \
131 } \
132 } \
133 }
134
135 CacheView
136 *floodplane_view,
137 *image_view;
138
139 Image
140 *floodplane_image;
141
142 MagickBooleanType
143 skip,
144 status;
145
146 MemoryInfo
147 *segment_info;
148
149 PixelInfo
150 fill_color,
151 pixel;
152
153 register SegmentInfo
154 *s;
155
156 SegmentInfo
157 *segment_stack;
158
159 ssize_t
160 offset,
161 start,
162 x1,
163 x2,
164 y;
165
166 /*
167 Check boundary conditions.
168 */
169 assert(image != (Image *) NULL);
170 assert(image->signature == MagickCoreSignature);
171 if (image->debug != MagickFalse)
172 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
173 assert(draw_info != (DrawInfo *) NULL);
174 assert(draw_info->signature == MagickCoreSignature);
175 if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
176 return(MagickFalse);
177 if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
178 return(MagickFalse);
179 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
180 return(MagickFalse);
181 if (IsGrayColorspace(image->colorspace) != MagickFalse)
182 (void) SetImageColorspace(image,sRGBColorspace,exception);
183 if ((image->alpha_trait == UndefinedPixelTrait) &&
184 (draw_info->fill.alpha_trait != UndefinedPixelTrait))
185 (void) SetImageAlpha(image,OpaqueAlpha,exception);
186 /*
187 Set floodfill state.
188 */
189 floodplane_image=CloneImage(image,0,0,MagickTrue,
190 exception);
191 if (floodplane_image == (Image *) NULL)
192 return(MagickFalse);
193 floodplane_image->alpha_trait=UndefinedPixelTrait;
194 floodplane_image->colorspace=GRAYColorspace;
195 (void) QueryColorCompliance("#000",AllCompliance,
196 &floodplane_image->background_color,exception);
197 (void) SetImageBackgroundColor(floodplane_image,exception);
198 segment_info=AcquireVirtualMemory(MaxStacksize,sizeof(*segment_stack));
199 if (segment_info == (MemoryInfo *) NULL)
200 {
201 floodplane_image=DestroyImage(floodplane_image);
202 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
203 image->filename);
204 }
205 segment_stack=(SegmentInfo *) GetVirtualMemoryBlob(segment_info);
206 /*
207 Push initial segment on stack.
208 */
209 status=MagickTrue;
210 start=0;
211 s=segment_stack;
212 PushSegmentStack(y_offset,x_offset,x_offset,1);
213 PushSegmentStack(y_offset+1,x_offset,x_offset,-1);
214 GetPixelInfo(image,&pixel);
215 image_view=AcquireVirtualCacheView(image,exception);
216 floodplane_view=AcquireAuthenticCacheView(floodplane_image,exception);
217 while (s > segment_stack)
218 {
219 register const Quantum
220 *magick_restrict p;
221
222 register Quantum
223 *magick_restrict q;
224
225 register ssize_t
226 x;
227
228 /*
229 Pop segment off stack.
230 */
231 s--;
232 x1=(ssize_t) s->x1;
233 x2=(ssize_t) s->x2;
234 offset=(ssize_t) s->y2;
235 y=(ssize_t) s->y1+offset;
236 /*
237 Recolor neighboring pixels.
238 */
239 p=GetCacheViewVirtualPixels(image_view,0,y,(size_t) (x1+1),1,exception);
240 q=GetCacheViewAuthenticPixels(floodplane_view,0,y,(size_t) (x1+1),1,
241 exception);
242 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
243 break;
244 p+=x1*GetPixelChannels(image);
245 q+=x1*GetPixelChannels(floodplane_image);
246 for (x=x1; x >= 0; x--)
247 {
248 if (GetPixelGray(floodplane_image,q) != 0)
249 break;
250 GetPixelInfoPixel(image,p,&pixel);
251 if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
252 break;
253 SetPixelGray(floodplane_image,QuantumRange,q);
254 p-=GetPixelChannels(image);
255 q-=GetPixelChannels(floodplane_image);
256 }
257 if (SyncCacheViewAuthenticPixels(floodplane_view,exception) == MagickFalse)
258 break;
259 skip=x >= x1 ? MagickTrue : MagickFalse;
260 if (skip == MagickFalse)
261 {
262 start=x+1;
263 if (start < x1)
264 PushSegmentStack(y,start,x1-1,-offset);
265 x=x1+1;
266 }
267 do
268 {
269 if (skip == MagickFalse)
270 {
271 if (x < (ssize_t) image->columns)
272 {
273 p=GetCacheViewVirtualPixels(image_view,x,y,image->columns-x,1,
274 exception);
275 q=GetCacheViewAuthenticPixels(floodplane_view,x,y,image->columns-
276 x,1,exception);
277 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
278 break;
279 for ( ; x < (ssize_t) image->columns; x++)
280 {
281 if (GetPixelGray(floodplane_image,q) != 0)
282 break;
283 GetPixelInfoPixel(image,p,&pixel);
284 if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
285 break;
286 SetPixelGray(floodplane_image,QuantumRange,q);
287 p+=GetPixelChannels(image);
288 q+=GetPixelChannels(floodplane_image);
289 }
290 status=SyncCacheViewAuthenticPixels(floodplane_view,exception);
291 if (status == MagickFalse)
292 break;
293 }
294 PushSegmentStack(y,start,x-1,offset);
295 if (x > (x2+1))
296 PushSegmentStack(y,x2+1,x-1,-offset);
297 }
298 skip=MagickFalse;
299 x++;
300 if (x <= x2)
301 {
302 p=GetCacheViewVirtualPixels(image_view,x,y,(size_t) (x2-x+1),1,
303 exception);
304 q=GetCacheViewAuthenticPixels(floodplane_view,x,y,(size_t) (x2-x+1),1,
305 exception);
306 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
307 break;
308 for ( ; x <= x2; x++)
309 {
310 if (GetPixelGray(floodplane_image,q) != 0)
311 break;
312 GetPixelInfoPixel(image,p,&pixel);
313 if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
314 break;
315 p+=GetPixelChannels(image);
316 q+=GetPixelChannels(floodplane_image);
317 }
318 }
319 start=x;
320 } while (x <= x2);
321 }
322 status=MagickTrue;
323 for (y=0; y < (ssize_t) image->rows; y++)
324 {
325 register const Quantum
326 *magick_restrict p;
327
328 register Quantum
329 *magick_restrict q;
330
331 register ssize_t
332 x;
333
334 /*
335 Tile fill color onto floodplane.
336 */
337 if (status == MagickFalse)
338 continue;
339 p=GetCacheViewVirtualPixels(floodplane_view,0,y,image->columns,1,exception);
340 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
341 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
342 {
343 status=MagickFalse;
344 continue;
345 }
346 for (x=0; x < (ssize_t) image->columns; x++)
347 {
348 if (GetPixelGray(floodplane_image,p) != 0)
349 {
350 GetFillColor(draw_info,x,y,&fill_color,exception);
351 SetPixelViaPixelInfo(image,&fill_color,q);
352 }
353 p+=GetPixelChannels(floodplane_image);
354 q+=GetPixelChannels(image);
355 }
356 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
357 status=MagickFalse;
358 }
359 floodplane_view=DestroyCacheView(floodplane_view);
360 image_view=DestroyCacheView(image_view);
361 segment_info=RelinquishVirtualMemory(segment_info);
362 floodplane_image=DestroyImage(floodplane_image);
363 return(status);
364 }
365
366 /*
367 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
368 % %
369 % %
370 % %
371 + G r a d i e n t I m a g e %
372 % %
373 % %
374 % %
375 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
376 %
377 % GradientImage() applies a continuously smooth color transitions along a
378 % vector from one color to another.
379 %
380 % Note, the interface of this method will change in the future to support
381 % more than one transistion.
382 %
383 % The format of the GradientImage method is:
384 %
385 % MagickBooleanType GradientImage(Image *image,const GradientType type,
386 % const SpreadMethod method,const PixelInfo *start_color,
387 % const PixelInfo *stop_color,ExceptionInfo *exception)
388 %
389 % A description of each parameter follows:
390 %
391 % o image: the image.
392 %
393 % o type: the gradient type: linear or radial.
394 %
395 % o spread: the gradient spread meathod: pad, reflect, or repeat.
396 %
397 % o start_color: the start color.
398 %
399 % o stop_color: the stop color.
400 %
401 % o exception: return any errors or warnings in this structure.
402 %
403 */
GradientImage(Image * image,const GradientType type,const SpreadMethod method,const StopInfo * stops,const size_t number_stops,ExceptionInfo * exception)404 MagickExport MagickBooleanType GradientImage(Image *image,
405 const GradientType type,const SpreadMethod method,const StopInfo *stops,
406 const size_t number_stops,ExceptionInfo *exception)
407 {
408 const char
409 *artifact;
410
411 DrawInfo
412 *draw_info;
413
414 GradientInfo
415 *gradient;
416
417 MagickBooleanType
418 status;
419
420 /*
421 Set gradient start-stop end points.
422 */
423 assert(image != (const Image *) NULL);
424 assert(image->signature == MagickCoreSignature);
425 if (image->debug != MagickFalse)
426 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
427 assert(stops != (const StopInfo *) NULL);
428 assert(number_stops > 0);
429 draw_info=AcquireDrawInfo();
430 gradient=(&draw_info->gradient);
431 gradient->type=type;
432 gradient->bounding_box.width=image->columns;
433 gradient->bounding_box.height=image->rows;
434 artifact=GetImageArtifact(image,"gradient:bounding-box");
435 if (artifact != (const char *) NULL)
436 (void) ParseAbsoluteGeometry(artifact,&gradient->bounding_box);
437 gradient->gradient_vector.x2=(double) image->columns-1;
438 gradient->gradient_vector.y2=(double) image->rows-1;
439 artifact=GetImageArtifact(image,"gradient:direction");
440 if (artifact != (const char *) NULL)
441 {
442 GravityType
443 direction;
444
445 direction=(GravityType) ParseCommandOption(MagickGravityOptions,
446 MagickFalse,artifact);
447 switch (direction)
448 {
449 case NorthWestGravity:
450 {
451 gradient->gradient_vector.x1=(double) image->columns-1;
452 gradient->gradient_vector.y1=(double) image->rows-1;
453 gradient->gradient_vector.x2=0.0;
454 gradient->gradient_vector.y2=0.0;
455 break;
456 }
457 case NorthGravity:
458 {
459 gradient->gradient_vector.x1=0.0;
460 gradient->gradient_vector.y1=(double) image->rows-1;
461 gradient->gradient_vector.x2=0.0;
462 gradient->gradient_vector.y2=0.0;
463 break;
464 }
465 case NorthEastGravity:
466 {
467 gradient->gradient_vector.x1=0.0;
468 gradient->gradient_vector.y1=(double) image->rows-1;
469 gradient->gradient_vector.x2=(double) image->columns-1;
470 gradient->gradient_vector.y2=0.0;
471 break;
472 }
473 case WestGravity:
474 {
475 gradient->gradient_vector.x1=(double) image->columns-1;
476 gradient->gradient_vector.y1=0.0;
477 gradient->gradient_vector.x2=0.0;
478 gradient->gradient_vector.y2=0.0;
479 break;
480 }
481 case EastGravity:
482 {
483 gradient->gradient_vector.x1=0.0;
484 gradient->gradient_vector.y1=0.0;
485 gradient->gradient_vector.x2=(double) image->columns-1;
486 gradient->gradient_vector.y2=0.0;
487 break;
488 }
489 case SouthWestGravity:
490 {
491 gradient->gradient_vector.x1=(double) image->columns-1;
492 gradient->gradient_vector.y1=0.0;
493 gradient->gradient_vector.x2=0.0;
494 gradient->gradient_vector.y2=(double) image->rows-1;
495 break;
496 }
497 case SouthGravity:
498 {
499 gradient->gradient_vector.x1=0.0;
500 gradient->gradient_vector.y1=0.0;
501 gradient->gradient_vector.x2=0.0;
502 gradient->gradient_vector.y2=(double) image->columns-1;
503 break;
504 }
505 case SouthEastGravity:
506 {
507 gradient->gradient_vector.x1=0.0;
508 gradient->gradient_vector.y1=0.0;
509 gradient->gradient_vector.x2=(double) image->columns-1;
510 gradient->gradient_vector.y2=(double) image->rows-1;
511 break;
512 }
513 default:
514 break;
515 }
516 }
517 artifact=GetImageArtifact(image,"gradient:angle");
518 if (artifact != (const char *) NULL)
519 gradient->angle=StringToDouble(artifact,(char **) NULL);
520 artifact=GetImageArtifact(image,"gradient:vector");
521 if (artifact != (const char *) NULL)
522 (void) sscanf(artifact,"%lf%*[ ,]%lf%*[ ,]%lf%*[ ,]%lf",
523 &gradient->gradient_vector.x1,&gradient->gradient_vector.y1,
524 &gradient->gradient_vector.x2,&gradient->gradient_vector.y2);
525 if ((GetImageArtifact(image,"gradient:angle") == (const char *) NULL) &&
526 (GetImageArtifact(image,"gradient:direction") == (const char *) NULL) &&
527 (GetImageArtifact(image,"gradient:extent") == (const char *) NULL) &&
528 (GetImageArtifact(image,"gradient:vector") == (const char *) NULL))
529 if ((type == LinearGradient) && (gradient->gradient_vector.y2 != 0.0))
530 gradient->gradient_vector.x2=0.0;
531 gradient->center.x=(double) gradient->gradient_vector.x2/2.0;
532 gradient->center.y=(double) gradient->gradient_vector.y2/2.0;
533 artifact=GetImageArtifact(image,"gradient:center");
534 if (artifact != (const char *) NULL)
535 (void) sscanf(artifact,"%lf%*[ ,]%lf",&gradient->center.x,
536 &gradient->center.y);
537 artifact=GetImageArtifact(image,"gradient:angle");
538 if ((type == LinearGradient) && (artifact != (const char *) NULL))
539 {
540 double
541 sine,
542 cosine,
543 distance;
544
545 /*
546 Reference https://drafts.csswg.org/css-images-3/#linear-gradients.
547 */
548 sine=sin((double) DegreesToRadians(gradient->angle-90.0));
549 cosine=cos((double) DegreesToRadians(gradient->angle-90.0));
550 distance=fabs((double) (image->columns-1.0)*cosine)+
551 fabs((double) (image->rows-1.0)*sine);
552 gradient->gradient_vector.x1=0.5*((image->columns-1.0)-distance*cosine);
553 gradient->gradient_vector.y1=0.5*((image->rows-1.0)-distance*sine);
554 gradient->gradient_vector.x2=0.5*((image->columns-1.0)+distance*cosine);
555 gradient->gradient_vector.y2=0.5*((image->rows-1.0)+distance*sine);
556 }
557 gradient->radii.x=(double) MagickMax((image->columns-1.0),(image->rows-1.0))/
558 2.0;
559 gradient->radii.y=gradient->radii.x;
560 artifact=GetImageArtifact(image,"gradient:extent");
561 if (artifact != (const char *) NULL)
562 {
563 if (LocaleCompare(artifact,"Circle") == 0)
564 {
565 gradient->radii.x=(double) MagickMax((image->columns-1.0),
566 (image->rows-1.0))/2.0;
567 gradient->radii.y=gradient->radii.x;
568 }
569 if (LocaleCompare(artifact,"Diagonal") == 0)
570 {
571 gradient->radii.x=(double) (sqrt((double) (image->columns-1.0)*
572 (image->columns-1.0)+(image->rows-1.0)*(image->rows-1.0)))/2.0;
573 gradient->radii.y=gradient->radii.x;
574 }
575 if (LocaleCompare(artifact,"Ellipse") == 0)
576 {
577 gradient->radii.x=(double) (image->columns-1.0)/2.0;
578 gradient->radii.y=(double) (image->rows-1.0)/2.0;
579 }
580 if (LocaleCompare(artifact,"Maximum") == 0)
581 {
582 gradient->radii.x=(double) MagickMax((image->columns-1.0),
583 (image->rows-1.0))/2.0;
584 gradient->radii.y=gradient->radii.x;
585 }
586 if (LocaleCompare(artifact,"Minimum") == 0)
587 {
588 gradient->radii.x=(double) (MagickMin((image->columns-1.0),
589 (image->rows-1.0)))/2.0;
590 gradient->radii.y=gradient->radii.x;
591 }
592 }
593 artifact=GetImageArtifact(image,"gradient:radii");
594 if (artifact != (const char *) NULL)
595 (void) sscanf(artifact,"%lf%*[ ,]%lf",&gradient->radii.x,
596 &gradient->radii.y);
597 gradient->radius=MagickMax(gradient->radii.x,gradient->radii.y);
598 gradient->spread=method;
599 /*
600 Define the gradient to fill between the stops.
601 */
602 gradient->number_stops=number_stops;
603 gradient->stops=(StopInfo *) AcquireQuantumMemory(gradient->number_stops,
604 sizeof(*gradient->stops));
605 if (gradient->stops == (StopInfo *) NULL)
606 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
607 image->filename);
608 (void) memcpy(gradient->stops,stops,(size_t) number_stops*
609 sizeof(*stops));
610 /*
611 Draw a gradient on the image.
612 */
613 status=DrawGradientImage(image,draw_info,exception);
614 draw_info=DestroyDrawInfo(draw_info);
615 return(status);
616 }
617
618 /*
619 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
620 % %
621 % %
622 % %
623 % O i l P a i n t I m a g e %
624 % %
625 % %
626 % %
627 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
628 %
629 % OilPaintImage() applies a special effect filter that simulates an oil
630 % painting. Each pixel is replaced by the most frequent color occurring
631 % in a circular region defined by radius.
632 %
633 % The format of the OilPaintImage method is:
634 %
635 % Image *OilPaintImage(const Image *image,const double radius,
636 % const double sigma,ExceptionInfo *exception)
637 %
638 % A description of each parameter follows:
639 %
640 % o image: the image.
641 %
642 % o radius: the radius of the circular neighborhood.
643 %
644 % o sigma: the standard deviation of the Gaussian, in pixels.
645 %
646 % o exception: return any errors or warnings in this structure.
647 %
648 */
649
DestroyHistogramThreadSet(size_t ** histogram)650 static size_t **DestroyHistogramThreadSet(size_t **histogram)
651 {
652 register ssize_t
653 i;
654
655 assert(histogram != (size_t **) NULL);
656 for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
657 if (histogram[i] != (size_t *) NULL)
658 histogram[i]=(size_t *) RelinquishMagickMemory(histogram[i]);
659 histogram=(size_t **) RelinquishMagickMemory(histogram);
660 return(histogram);
661 }
662
AcquireHistogramThreadSet(const size_t count)663 static size_t **AcquireHistogramThreadSet(const size_t count)
664 {
665 register ssize_t
666 i;
667
668 size_t
669 **histogram,
670 number_threads;
671
672 number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
673 histogram=(size_t **) AcquireQuantumMemory(number_threads,sizeof(*histogram));
674 if (histogram == (size_t **) NULL)
675 return((size_t **) NULL);
676 (void) memset(histogram,0,number_threads*sizeof(*histogram));
677 for (i=0; i < (ssize_t) number_threads; i++)
678 {
679 histogram[i]=(size_t *) AcquireQuantumMemory(count,sizeof(**histogram));
680 if (histogram[i] == (size_t *) NULL)
681 return(DestroyHistogramThreadSet(histogram));
682 }
683 return(histogram);
684 }
685
OilPaintImage(const Image * image,const double radius,const double sigma,ExceptionInfo * exception)686 MagickExport Image *OilPaintImage(const Image *image,const double radius,
687 const double sigma,ExceptionInfo *exception)
688 {
689 #define NumberPaintBins 256
690 #define OilPaintImageTag "OilPaint/Image"
691
692 CacheView
693 *image_view,
694 *paint_view;
695
696 Image
697 *linear_image,
698 *paint_image;
699
700 MagickBooleanType
701 status;
702
703 MagickOffsetType
704 progress;
705
706 size_t
707 **histograms,
708 width;
709
710 ssize_t
711 center,
712 y;
713
714 /*
715 Initialize painted image attributes.
716 */
717 assert(image != (const Image *) NULL);
718 assert(image->signature == MagickCoreSignature);
719 if (image->debug != MagickFalse)
720 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
721 assert(exception != (ExceptionInfo *) NULL);
722 assert(exception->signature == MagickCoreSignature);
723 width=GetOptimalKernelWidth2D(radius,sigma);
724 linear_image=CloneImage(image,0,0,MagickTrue,exception);
725 paint_image=CloneImage(image,0,0,MagickTrue,exception);
726 if ((linear_image == (Image *) NULL) || (paint_image == (Image *) NULL))
727 {
728 if (linear_image != (Image *) NULL)
729 linear_image=DestroyImage(linear_image);
730 if (paint_image != (Image *) NULL)
731 linear_image=DestroyImage(paint_image);
732 return((Image *) NULL);
733 }
734 if (SetImageStorageClass(paint_image,DirectClass,exception) == MagickFalse)
735 {
736 linear_image=DestroyImage(linear_image);
737 paint_image=DestroyImage(paint_image);
738 return((Image *) NULL);
739 }
740 histograms=AcquireHistogramThreadSet(NumberPaintBins);
741 if (histograms == (size_t **) NULL)
742 {
743 linear_image=DestroyImage(linear_image);
744 paint_image=DestroyImage(paint_image);
745 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
746 }
747 /*
748 Oil paint image.
749 */
750 status=MagickTrue;
751 progress=0;
752 center=(ssize_t) GetPixelChannels(linear_image)*(linear_image->columns+width)*
753 (width/2L)+GetPixelChannels(linear_image)*(width/2L);
754 image_view=AcquireVirtualCacheView(linear_image,exception);
755 paint_view=AcquireAuthenticCacheView(paint_image,exception);
756 #if defined(MAGICKCORE_OPENMP_SUPPORT)
757 #pragma omp parallel for schedule(static) shared(progress,status) \
758 magick_number_threads(linear_image,paint_image,linear_image->rows,1)
759 #endif
760 for (y=0; y < (ssize_t) linear_image->rows; y++)
761 {
762 register const Quantum
763 *magick_restrict p;
764
765 register Quantum
766 *magick_restrict q;
767
768 register size_t
769 *histogram;
770
771 register ssize_t
772 x;
773
774 if (status == MagickFalse)
775 continue;
776 p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)
777 (width/2L),linear_image->columns+width,width,exception);
778 q=QueueCacheViewAuthenticPixels(paint_view,0,y,paint_image->columns,1,
779 exception);
780 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
781 {
782 status=MagickFalse;
783 continue;
784 }
785 histogram=histograms[GetOpenMPThreadId()];
786 for (x=0; x < (ssize_t) linear_image->columns; x++)
787 {
788 register ssize_t
789 i,
790 u;
791
792 size_t
793 count;
794
795 ssize_t
796 j,
797 k,
798 n,
799 v;
800
801 /*
802 Assign most frequent color.
803 */
804 k=0;
805 j=0;
806 count=0;
807 (void) memset(histogram,0,NumberPaintBins* sizeof(*histogram));
808 for (v=0; v < (ssize_t) width; v++)
809 {
810 for (u=0; u < (ssize_t) width; u++)
811 {
812 n=(ssize_t) ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(
813 linear_image,p+GetPixelChannels(linear_image)*(u+k))));
814 histogram[n]++;
815 if (histogram[n] > count)
816 {
817 j=k+u;
818 count=histogram[n];
819 }
820 }
821 k+=(ssize_t) (linear_image->columns+width);
822 }
823 for (i=0; i < (ssize_t) GetPixelChannels(linear_image); i++)
824 {
825 PixelChannel channel = GetPixelChannelChannel(linear_image,i);
826 PixelTrait traits = GetPixelChannelTraits(linear_image,channel);
827 PixelTrait paint_traits=GetPixelChannelTraits(paint_image,channel);
828 if ((traits == UndefinedPixelTrait) ||
829 (paint_traits == UndefinedPixelTrait))
830 continue;
831 if ((paint_traits & CopyPixelTrait) != 0)
832 {
833 SetPixelChannel(paint_image,channel,p[center+i],q);
834 continue;
835 }
836 SetPixelChannel(paint_image,channel,p[j*GetPixelChannels(linear_image)+
837 i],q);
838 }
839 p+=GetPixelChannels(linear_image);
840 q+=GetPixelChannels(paint_image);
841 }
842 if (SyncCacheViewAuthenticPixels(paint_view,exception) == MagickFalse)
843 status=MagickFalse;
844 if (linear_image->progress_monitor != (MagickProgressMonitor) NULL)
845 {
846 MagickBooleanType
847 proceed;
848
849 #if defined(MAGICKCORE_OPENMP_SUPPORT)
850 #pragma omp atomic
851 #endif
852 progress++;
853 proceed=SetImageProgress(linear_image,OilPaintImageTag,progress,
854 linear_image->rows);
855 if (proceed == MagickFalse)
856 status=MagickFalse;
857 }
858 }
859 paint_view=DestroyCacheView(paint_view);
860 image_view=DestroyCacheView(image_view);
861 histograms=DestroyHistogramThreadSet(histograms);
862 linear_image=DestroyImage(linear_image);
863 if (status == MagickFalse)
864 paint_image=DestroyImage(paint_image);
865 return(paint_image);
866 }
867
868 /*
869 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
870 % %
871 % %
872 % %
873 % O p a q u e P a i n t I m a g e %
874 % %
875 % %
876 % %
877 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
878 %
879 % OpaquePaintImage() changes any pixel that matches color with the color
880 % defined by fill argument.
881 %
882 % By default color must match a particular pixel color exactly. However, in
883 % many cases two colors may differ by a small amount. Fuzz defines how much
884 % tolerance is acceptable to consider two colors as the same. For example,
885 % set fuzz to 10 and the color red at intensities of 100 and 102 respectively
886 % are now interpreted as the same color.
887 %
888 % The format of the OpaquePaintImage method is:
889 %
890 % MagickBooleanType OpaquePaintImage(Image *image,const PixelInfo *target,
891 % const PixelInfo *fill,const MagickBooleanType invert,
892 % ExceptionInfo *exception)
893 %
894 % A description of each parameter follows:
895 %
896 % o image: the image.
897 %
898 % o target: the RGB value of the target color.
899 %
900 % o fill: the replacement color.
901 %
902 % o invert: paint any pixel that does not match the target color.
903 %
904 % o exception: return any errors or warnings in this structure.
905 %
906 */
OpaquePaintImage(Image * image,const PixelInfo * target,const PixelInfo * fill,const MagickBooleanType invert,ExceptionInfo * exception)907 MagickExport MagickBooleanType OpaquePaintImage(Image *image,
908 const PixelInfo *target,const PixelInfo *fill,const MagickBooleanType invert,
909 ExceptionInfo *exception)
910 {
911 #define OpaquePaintImageTag "Opaque/Image"
912
913 CacheView
914 *image_view;
915
916 MagickBooleanType
917 status;
918
919 MagickOffsetType
920 progress;
921
922 PixelInfo
923 conform_fill,
924 conform_target,
925 zero;
926
927 ssize_t
928 y;
929
930 assert(image != (Image *) NULL);
931 assert(image->signature == MagickCoreSignature);
932 assert(target != (PixelInfo *) NULL);
933 assert(fill != (PixelInfo *) NULL);
934 if (image->debug != MagickFalse)
935 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
936 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
937 return(MagickFalse);
938 ConformPixelInfo(image,fill,&conform_fill,exception);
939 ConformPixelInfo(image,target,&conform_target,exception);
940 /*
941 Make image color opaque.
942 */
943 status=MagickTrue;
944 progress=0;
945 GetPixelInfo(image,&zero);
946 image_view=AcquireAuthenticCacheView(image,exception);
947 #if defined(MAGICKCORE_OPENMP_SUPPORT)
948 #pragma omp parallel for schedule(static) shared(progress,status) \
949 magick_number_threads(image,image,image->rows,1)
950 #endif
951 for (y=0; y < (ssize_t) image->rows; y++)
952 {
953 PixelInfo
954 pixel;
955
956 register Quantum
957 *magick_restrict q;
958
959 register ssize_t
960 x;
961
962 if (status == MagickFalse)
963 continue;
964 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
965 if (q == (Quantum *) NULL)
966 {
967 status=MagickFalse;
968 continue;
969 }
970 pixel=zero;
971 for (x=0; x < (ssize_t) image->columns; x++)
972 {
973 GetPixelInfoPixel(image,q,&pixel);
974 if (IsFuzzyEquivalencePixelInfo(&pixel,&conform_target) != invert)
975 {
976 PixelTrait
977 traits;
978
979 traits=GetPixelChannelTraits(image,RedPixelChannel);
980 if ((traits & UpdatePixelTrait) != 0)
981 SetPixelRed(image,(Quantum) conform_fill.red,q);
982 traits=GetPixelChannelTraits(image,GreenPixelChannel);
983 if ((traits & UpdatePixelTrait) != 0)
984 SetPixelGreen(image,(Quantum) conform_fill.green,q);
985 traits=GetPixelChannelTraits(image,BluePixelChannel);
986 if ((traits & UpdatePixelTrait) != 0)
987 SetPixelBlue(image,(Quantum) conform_fill.blue,q);
988 traits=GetPixelChannelTraits(image,BlackPixelChannel);
989 if ((traits & UpdatePixelTrait) != 0)
990 SetPixelBlack(image,(Quantum) conform_fill.black,q);
991 traits=GetPixelChannelTraits(image,AlphaPixelChannel);
992 if ((traits & UpdatePixelTrait) != 0)
993 SetPixelAlpha(image,(Quantum) conform_fill.alpha,q);
994 }
995 q+=GetPixelChannels(image);
996 }
997 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
998 status=MagickFalse;
999 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1000 {
1001 MagickBooleanType
1002 proceed;
1003
1004 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1005 #pragma omp atomic
1006 #endif
1007 progress++;
1008 proceed=SetImageProgress(image,OpaquePaintImageTag,progress,
1009 image->rows);
1010 if (proceed == MagickFalse)
1011 status=MagickFalse;
1012 }
1013 }
1014 image_view=DestroyCacheView(image_view);
1015 return(status);
1016 }
1017
1018 /*
1019 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1020 % %
1021 % %
1022 % %
1023 % T r a n s p a r e n t P a i n t I m a g e %
1024 % %
1025 % %
1026 % %
1027 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1028 %
1029 % TransparentPaintImage() changes the opacity value associated with any pixel
1030 % that matches color to the value defined by opacity.
1031 %
1032 % By default color must match a particular pixel color exactly. However, in
1033 % many cases two colors may differ by a small amount. Fuzz defines how much
1034 % tolerance is acceptable to consider two colors as the same. For example,
1035 % set fuzz to 10 and the color red at intensities of 100 and 102 respectively
1036 % are now interpreted as the same color.
1037 %
1038 % The format of the TransparentPaintImage method is:
1039 %
1040 % MagickBooleanType TransparentPaintImage(Image *image,
1041 % const PixelInfo *target,const Quantum opacity,
1042 % const MagickBooleanType invert,ExceptionInfo *exception)
1043 %
1044 % A description of each parameter follows:
1045 %
1046 % o image: the image.
1047 %
1048 % o target: the target color.
1049 %
1050 % o opacity: the replacement opacity value.
1051 %
1052 % o invert: paint any pixel that does not match the target color.
1053 %
1054 % o exception: return any errors or warnings in this structure.
1055 %
1056 */
TransparentPaintImage(Image * image,const PixelInfo * target,const Quantum opacity,const MagickBooleanType invert,ExceptionInfo * exception)1057 MagickExport MagickBooleanType TransparentPaintImage(Image *image,
1058 const PixelInfo *target,const Quantum opacity,const MagickBooleanType invert,
1059 ExceptionInfo *exception)
1060 {
1061 #define TransparentPaintImageTag "Transparent/Image"
1062
1063 CacheView
1064 *image_view;
1065
1066 MagickBooleanType
1067 status;
1068
1069 MagickOffsetType
1070 progress;
1071
1072 PixelInfo
1073 zero;
1074
1075 ssize_t
1076 y;
1077
1078 assert(image != (Image *) NULL);
1079 assert(image->signature == MagickCoreSignature);
1080 assert(target != (PixelInfo *) NULL);
1081 if (image->debug != MagickFalse)
1082 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1083 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1084 return(MagickFalse);
1085 if (image->alpha_trait == UndefinedPixelTrait)
1086 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1087 /*
1088 Make image color transparent.
1089 */
1090 status=MagickTrue;
1091 progress=0;
1092 GetPixelInfo(image,&zero);
1093 image_view=AcquireAuthenticCacheView(image,exception);
1094 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1095 #pragma omp parallel for schedule(static) shared(progress,status) \
1096 magick_number_threads(image,image,image->rows,1)
1097 #endif
1098 for (y=0; y < (ssize_t) image->rows; y++)
1099 {
1100 PixelInfo
1101 pixel;
1102
1103 register ssize_t
1104 x;
1105
1106 register Quantum
1107 *magick_restrict q;
1108
1109 if (status == MagickFalse)
1110 continue;
1111 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1112 if (q == (Quantum *) NULL)
1113 {
1114 status=MagickFalse;
1115 continue;
1116 }
1117 pixel=zero;
1118 for (x=0; x < (ssize_t) image->columns; x++)
1119 {
1120 GetPixelInfoPixel(image,q,&pixel);
1121 if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
1122 SetPixelAlpha(image,opacity,q);
1123 q+=GetPixelChannels(image);
1124 }
1125 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1126 status=MagickFalse;
1127 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1128 {
1129 MagickBooleanType
1130 proceed;
1131
1132 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1133 #pragma omp atomic
1134 #endif
1135 progress++;
1136 proceed=SetImageProgress(image,TransparentPaintImageTag,progress,
1137 image->rows);
1138 if (proceed == MagickFalse)
1139 status=MagickFalse;
1140 }
1141 }
1142 image_view=DestroyCacheView(image_view);
1143 return(status);
1144 }
1145
1146 /*
1147 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1148 % %
1149 % %
1150 % %
1151 % T r a n s p a r e n t P a i n t I m a g e C h r o m a %
1152 % %
1153 % %
1154 % %
1155 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1156 %
1157 % TransparentPaintImageChroma() changes the opacity value associated with any
1158 % pixel that matches color to the value defined by opacity.
1159 %
1160 % As there is one fuzz value for the all the channels, TransparentPaintImage()
1161 % is not suitable for the operations like chroma, where the tolerance for
1162 % similarity of two color component (RGB) can be different. Thus we define
1163 % this method to take two target pixels (one low and one high) and all the
1164 % pixels of an image which are lying between these two pixels are made
1165 % transparent.
1166 %
1167 % The format of the TransparentPaintImageChroma method is:
1168 %
1169 % MagickBooleanType TransparentPaintImageChroma(Image *image,
1170 % const PixelInfo *low,const PixelInfo *high,const Quantum opacity,
1171 % const MagickBooleanType invert,ExceptionInfo *exception)
1172 %
1173 % A description of each parameter follows:
1174 %
1175 % o image: the image.
1176 %
1177 % o low: the low target color.
1178 %
1179 % o high: the high target color.
1180 %
1181 % o opacity: the replacement opacity value.
1182 %
1183 % o invert: paint any pixel that does not match the target color.
1184 %
1185 % o exception: return any errors or warnings in this structure.
1186 %
1187 */
TransparentPaintImageChroma(Image * image,const PixelInfo * low,const PixelInfo * high,const Quantum opacity,const MagickBooleanType invert,ExceptionInfo * exception)1188 MagickExport MagickBooleanType TransparentPaintImageChroma(Image *image,
1189 const PixelInfo *low,const PixelInfo *high,const Quantum opacity,
1190 const MagickBooleanType invert,ExceptionInfo *exception)
1191 {
1192 #define TransparentPaintImageTag "Transparent/Image"
1193
1194 CacheView
1195 *image_view;
1196
1197 MagickBooleanType
1198 status;
1199
1200 MagickOffsetType
1201 progress;
1202
1203 ssize_t
1204 y;
1205
1206 assert(image != (Image *) NULL);
1207 assert(image->signature == MagickCoreSignature);
1208 assert(high != (PixelInfo *) NULL);
1209 assert(low != (PixelInfo *) NULL);
1210 if (image->debug != MagickFalse)
1211 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1212 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1213 return(MagickFalse);
1214 if (image->alpha_trait == UndefinedPixelTrait)
1215 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1216 /*
1217 Make image color transparent.
1218 */
1219 status=MagickTrue;
1220 progress=0;
1221 image_view=AcquireAuthenticCacheView(image,exception);
1222 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1223 #pragma omp parallel for schedule(static) shared(progress,status) \
1224 magick_number_threads(image,image,image->rows,1)
1225 #endif
1226 for (y=0; y < (ssize_t) image->rows; y++)
1227 {
1228 MagickBooleanType
1229 match;
1230
1231 PixelInfo
1232 pixel;
1233
1234 register Quantum
1235 *magick_restrict q;
1236
1237 register ssize_t
1238 x;
1239
1240 if (status == MagickFalse)
1241 continue;
1242 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1243 if (q == (Quantum *) NULL)
1244 {
1245 status=MagickFalse;
1246 continue;
1247 }
1248 GetPixelInfo(image,&pixel);
1249 for (x=0; x < (ssize_t) image->columns; x++)
1250 {
1251 GetPixelInfoPixel(image,q,&pixel);
1252 match=((pixel.red >= low->red) && (pixel.red <= high->red) &&
1253 (pixel.green >= low->green) && (pixel.green <= high->green) &&
1254 (pixel.blue >= low->blue) && (pixel.blue <= high->blue)) ? MagickTrue :
1255 MagickFalse;
1256 if (match != invert)
1257 SetPixelAlpha(image,opacity,q);
1258 q+=GetPixelChannels(image);
1259 }
1260 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1261 status=MagickFalse;
1262 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1263 {
1264 MagickBooleanType
1265 proceed;
1266
1267 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1268 #pragma omp atomic
1269 #endif
1270 progress++;
1271 proceed=SetImageProgress(image,TransparentPaintImageTag,progress,
1272 image->rows);
1273 if (proceed == MagickFalse)
1274 status=MagickFalse;
1275 }
1276 }
1277 image_view=DestroyCacheView(image_view);
1278 return(status);
1279 }
1280