MagickCore 7.1.2
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
composite.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% CCCC OOO M M PPPP OOO SSSSS IIIII TTTTT EEEEE %
7% C O O MM MM P P O O SS I T E %
8% C O O M M M PPPP O O SSS I T EEE %
9% C O O M M P O O SS I T E %
10% CCCC OOO M M P OOO SSSSS IIIII T EEEEE %
11% %
12% %
13% MagickCore Image Composite Methods %
14% %
15% Software Design %
16% Cristy %
17% July 1992 %
18% %
19% %
20% Copyright @ 1999 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/license/ %
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/*
41 Include declarations.
42*/
43#include "MagickCore/studio.h"
44#include "MagickCore/artifact.h"
45#include "MagickCore/cache.h"
46#include "MagickCore/cache-private.h"
47#include "MagickCore/cache-view.h"
48#include "MagickCore/channel.h"
49#include "MagickCore/client.h"
50#include "MagickCore/color.h"
51#include "MagickCore/color-private.h"
52#include "MagickCore/colorspace.h"
53#include "MagickCore/colorspace-private.h"
54#include "MagickCore/composite.h"
55#include "MagickCore/composite-private.h"
56#include "MagickCore/constitute.h"
57#include "MagickCore/draw.h"
58#include "MagickCore/exception-private.h"
59#include "MagickCore/fx.h"
60#include "MagickCore/gem.h"
61#include "MagickCore/geometry.h"
62#include "MagickCore/image.h"
63#include "MagickCore/image-private.h"
64#include "MagickCore/list.h"
65#include "MagickCore/log.h"
66#include "MagickCore/memory_.h"
67#include "MagickCore/monitor.h"
68#include "MagickCore/monitor-private.h"
69#include "MagickCore/morphology.h"
70#include "MagickCore/option.h"
71#include "MagickCore/pixel-accessor.h"
72#include "MagickCore/property.h"
73#include "MagickCore/quantum.h"
74#include "MagickCore/resample.h"
75#include "MagickCore/resource_.h"
76#include "MagickCore/string_.h"
77#include "MagickCore/string-private.h"
78#include "MagickCore/thread-private.h"
79#include "MagickCore/threshold.h"
80#include "MagickCore/token.h"
81#include "MagickCore/transform.h"
82#include "MagickCore/utility.h"
83#include "MagickCore/utility-private.h"
84#include "MagickCore/version.h"
85␌
86/*
87%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
88% %
89% %
90% %
91% C o m p o s i t e I m a g e %
92% %
93% %
94% %
95%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
96%
97% CompositeImage() returns the second image composited onto the first
98% at the specified offset, using the specified composite method.
99%
100% The format of the CompositeImage method is:
101%
102% MagickBooleanType CompositeImage(Image *image,
103% const Image *source_image,const CompositeOperator compose,
104% const MagickBooleanType clip_to_self,const ssize_t x_offset,
105% const ssize_t y_offset,ExceptionInfo *exception)
106%
107% A description of each parameter follows:
108%
109% o image: the canvas image, modified by he composition
110%
111% o source_image: the source image.
112%
113% o compose: This operator affects how the composite is applied to
114% the image. The operators and how they are utilized are listed here
115% http://www.w3.org/TR/SVG12/#compositing.
116%
117% o clip_to_self: set to MagickTrue to limit composition to area composed.
118%
119% o x_offset: the column offset of the composited image.
120%
121% o y_offset: the row offset of the composited image.
122%
123% Extra Controls from Image meta-data in 'image' (artifacts)
124%
125% o "compose:args"
126% A string containing extra numerical arguments for specific compose
127% methods, generally expressed as a 'geometry' or a comma separated list
128% of numbers.
129%
130% Compose methods needing such arguments include "BlendCompositeOp" and
131% "DisplaceCompositeOp".
132%
133% o exception: return any errors or warnings in this structure.
134%
135*/
136
137/*
138 Composition based on the SVG specification:
139
140 A Composition is defined by...
141 Color Function : f(Sc,Dc) where Sc and Dc are the normalized colors
142 Blending areas : X = 1 for area of overlap, ie: f(Sc,Dc)
143 Y = 1 for source preserved
144 Z = 1 for canvas preserved
145
146 Conversion to transparency (then optimized)
147 Dca' = f(Sc, Dc)*Sa*Da + Y*Sca*(1-Da) + Z*Dca*(1-Sa)
148 Da' = X*Sa*Da + Y*Sa*(1-Da) + Z*Da*(1-Sa)
149
150 Where...
151 Sca = Sc*Sa normalized Source color divided by Source alpha
152 Dca = Dc*Da normalized Dest color divided by Dest alpha
153 Dc' = Dca'/Da' the desired color value for this channel.
154
155 Da' in in the follow formula as 'gamma' The resulting alpha value.
156
157 Most functions use a blending mode of over (X=1,Y=1,Z=1) this results in
158 the following optimizations...
159 gamma = Sa+Da-Sa*Da;
160 gamma = 1 - QuantumScale*alpha * QuantumScale*beta;
161 opacity = QuantumScale*alpha*beta; // over blend, optimized 1-Gamma
162
163 The above SVG definitions also define that Mathematical Composition
164 methods should use a 'Over' blending mode for Alpha Channel.
165 It however was not applied for composition modes of 'Plus', 'Minus',
166 the modulus versions of 'Add' and 'Subtract'.
167
168 Mathematical operator changes to be applied from IM v6.7...
169
170 1) Modulus modes 'Add' and 'Subtract' are obsoleted and renamed
171 'ModulusAdd' and 'ModulusSubtract' for clarity.
172
173 2) All mathematical compositions work as per the SVG specification
174 with regard to blending. This now includes 'ModulusAdd' and
175 'ModulusSubtract'.
176
177 3) When the special channel flag 'sync' (synchronize channel updates)
178 is turned off (enabled by default) then mathematical compositions are
179 only performed on the channels specified, and are applied
180 independently of each other. In other words the mathematics is
181 performed as 'pure' mathematical operations, rather than as image
182 operations.
183*/
184
185static Image *BlendConvolveImage(const Image *image,const char *kernel,
186 ExceptionInfo *exception)
187{
188 Image
189 *clone_image,
190 *convolve_image;
191
192 KernelInfo
193 *kernel_info;
194
195 /*
196 Convolve image with a kernel.
197 */
198 kernel_info=AcquireKernelInfo(kernel,exception);
199 if (kernel_info == (KernelInfo *) NULL)
200 return((Image *) NULL);
201 clone_image=CloneImage(image,0,0,MagickTrue,exception);
202 if (clone_image == (Image *) NULL)
203 {
204 kernel_info=DestroyKernelInfo(kernel_info);
205 return((Image *) NULL);
206 }
207 (void) SetImageAlphaChannel(clone_image,OffAlphaChannel,exception);
208 convolve_image=ConvolveImage(clone_image,kernel_info,exception);
209 kernel_info=DestroyKernelInfo(kernel_info);
210 clone_image=DestroyImage(clone_image);
211 return(convolve_image);
212}
213
214static Image *BlendMagnitudeImage(const Image *dx_image,const Image *dy_image,
215 ExceptionInfo *exception)
216{
217 CacheView
218 *dx_view,
219 *dy_view,
220 *magnitude_view;
221
222 Image
223 *magnitude_image;
224
225 MagickBooleanType
226 status = MagickTrue;
227
228 ssize_t
229 y;
230
231 /*
232 Generate the magnitude between two images.
233 */
234 magnitude_image=CloneImage(dx_image,0,0,MagickTrue,exception);
235 if (magnitude_image == (Image *) NULL)
236 return(magnitude_image);
237 dx_view=AcquireVirtualCacheView(dx_image,exception);
238 dy_view=AcquireVirtualCacheView(dy_image,exception);
239 magnitude_view=AcquireAuthenticCacheView(magnitude_image,exception);
240#if defined(MAGICKCORE_OPENMP_SUPPORT)
241 #pragma omp parallel for schedule(static) shared(status) \
242 magick_number_threads(dx_image,magnitude_image,dx_image->rows,1)
243#endif
244 for (y=0; y < (ssize_t) dx_image->rows; y++)
245 {
246 const Quantum
247 *magick_restrict p,
248 *magick_restrict q;
249
250 Quantum
251 *magick_restrict r;
252
253 ssize_t
254 x;
255
256 if (status == MagickFalse)
257 continue;
258 p=GetCacheViewVirtualPixels(dx_view,0,y,dx_image->columns,1,exception);
259 q=GetCacheViewVirtualPixels(dy_view,0,y,dx_image->columns,1,exception);
260 r=GetCacheViewAuthenticPixels(magnitude_view,0,y,dx_image->columns,1,
261 exception);
262 if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL) ||
263 (r == (Quantum *) NULL))
264 {
265 status=MagickFalse;
266 continue;
267 }
268 for (x=0; x < (ssize_t) dx_image->columns; x++)
269 {
270 ssize_t
271 i;
272
273 for (i=0; i < (ssize_t) GetPixelChannels(dx_image); i++)
274 {
275 PixelChannel channel = GetPixelChannelChannel(dx_image,i);
276 PixelTrait traits = GetPixelChannelTraits(dx_image,channel);
277 PixelTrait dy_traits = GetPixelChannelTraits(dy_image,channel);
278 if ((traits == UndefinedPixelTrait) ||
279 (dy_traits == UndefinedPixelTrait) ||
280 ((dy_traits & UpdatePixelTrait) == 0))
281 continue;
282 r[i]=ClampToQuantum(hypot((double) p[i],(double)
283 GetPixelChannel(dy_image,channel,q)));
284 }
285 p+=(ptrdiff_t) GetPixelChannels(dx_image);
286 q+=(ptrdiff_t) GetPixelChannels(dy_image);
287 r+=(ptrdiff_t) GetPixelChannels(magnitude_image);
288 }
289 if (SyncCacheViewAuthenticPixels(magnitude_view,exception) == MagickFalse)
290 status=MagickFalse;
291 }
292 magnitude_view=DestroyCacheView(magnitude_view);
293 dy_view=DestroyCacheView(dy_view);
294 dx_view=DestroyCacheView(dx_view);
295 if (status == MagickFalse)
296 magnitude_image=DestroyImage(magnitude_image);
297 return(magnitude_image);
298}
299
300static Image *BlendMaxMagnitudeImage(const Image *alpha_image,
301 const Image *beta_image,const Image *dx_image,const Image *dy_image,
302 ExceptionInfo *exception)
303{
304 CacheView
305 *alpha_view,
306 *beta_view,
307 *dx_view,
308 *dy_view,
309 *magnitude_view;
310
311 Image
312 *magnitude_image;
313
314 MagickBooleanType
315 status = MagickTrue;
316
317 ssize_t
318 y;
319
320 /*
321 Select the larger of two magnitudes.
322 */
323 magnitude_image=CloneImage(alpha_image,0,0,MagickTrue,exception);
324 if (magnitude_image == (Image *) NULL)
325 return(magnitude_image);
326 alpha_view=AcquireVirtualCacheView(alpha_image,exception);
327 beta_view=AcquireVirtualCacheView(beta_image,exception);
328 dx_view=AcquireVirtualCacheView(dx_image,exception);
329 dy_view=AcquireVirtualCacheView(dy_image,exception);
330 magnitude_view=AcquireAuthenticCacheView(magnitude_image,exception);
331#if defined(MAGICKCORE_OPENMP_SUPPORT)
332 #pragma omp parallel for schedule(static) shared(status) \
333 magick_number_threads(alpha_image,magnitude_image,alpha_image->rows,1)
334#endif
335 for (y=0; y < (ssize_t) alpha_image->rows; y++)
336 {
337 const Quantum
338 *magick_restrict p,
339 *magick_restrict q,
340 *magick_restrict r,
341 *magick_restrict s;
342
343 Quantum
344 *magick_restrict t;
345
346 ssize_t
347 x;
348
349 if (status == MagickFalse)
350 continue;
351 p=GetCacheViewVirtualPixels(alpha_view,0,y,alpha_image->columns,1,
352 exception);
353 q=GetCacheViewVirtualPixels(beta_view,0,y,alpha_image->columns,1,exception);
354 r=GetCacheViewVirtualPixels(dx_view,0,y,alpha_image->columns,1,exception);
355 s=GetCacheViewVirtualPixels(dy_view,0,y,alpha_image->columns,1,exception);
356 t=GetCacheViewAuthenticPixels(magnitude_view,0,y,alpha_image->columns,1,
357 exception);
358 if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL) ||
359 (r == (const Quantum *) NULL) || (s == (const Quantum *) NULL) ||
360 (t == (Quantum *) NULL))
361 {
362 status=MagickFalse;
363 continue;
364 }
365 for (x=0; x < (ssize_t) alpha_image->columns; x++)
366 {
367 ssize_t
368 i;
369
370 for (i=0; i < (ssize_t) GetPixelChannels(alpha_image); i++)
371 {
372 PixelChannel channel = GetPixelChannelChannel(alpha_image,i);
373 PixelTrait traits = GetPixelChannelTraits(alpha_image,channel);
374 PixelTrait beta_traits = GetPixelChannelTraits(beta_image,channel);
375 if ((traits == UndefinedPixelTrait) ||
376 (beta_traits == UndefinedPixelTrait) ||
377 ((beta_traits & UpdatePixelTrait) == 0))
378 continue;
379 if (p[i] > GetPixelChannel(beta_image,channel,q))
380 t[i]=GetPixelChannel(dx_image,channel,r);
381 else
382 t[i]=GetPixelChannel(dy_image,channel,s);
383 }
384 p+=(ptrdiff_t) GetPixelChannels(alpha_image);
385 q+=(ptrdiff_t) GetPixelChannels(beta_image);
386 r+=(ptrdiff_t) GetPixelChannels(dx_image);
387 s+=(ptrdiff_t) GetPixelChannels(dy_image);
388 t+=(ptrdiff_t) GetPixelChannels(magnitude_image);
389 }
390 if (SyncCacheViewAuthenticPixels(magnitude_view,exception) == MagickFalse)
391 status=MagickFalse;
392 }
393 magnitude_view=DestroyCacheView(magnitude_view);
394 dy_view=DestroyCacheView(dy_view);
395 dx_view=DestroyCacheView(dx_view);
396 beta_view=DestroyCacheView(beta_view);
397 alpha_view=DestroyCacheView(alpha_view);
398 if (status == MagickFalse)
399 magnitude_image=DestroyImage(magnitude_image);
400 return(magnitude_image);
401}
402
403static Image *BlendSumImage(const Image *alpha_image,const Image *beta_image,
404 const double attenuate,const double sign,ExceptionInfo *exception)
405{
406 CacheView
407 *alpha_view,
408 *beta_view,
409 *sum_view;
410
411 Image
412 *sum_image;
413
414 MagickBooleanType
415 status = MagickTrue;
416
417 ssize_t
418 y;
419
420 /*
421 Add or subtract and optionally attenuate two images.
422 */
423 sum_image=CloneImage(alpha_image,0,0,MagickTrue,exception);
424 if (sum_image == (Image *) NULL)
425 return(sum_image);
426 alpha_view=AcquireVirtualCacheView(alpha_image,exception);
427 beta_view=AcquireVirtualCacheView(beta_image,exception);
428 sum_view=AcquireAuthenticCacheView(sum_image,exception);
429#if defined(MAGICKCORE_OPENMP_SUPPORT)
430 #pragma omp parallel for schedule(static) shared(status) \
431 magick_number_threads(alpha_image,sum_image,alpha_image->rows,1)
432#endif
433 for (y=0; y < (ssize_t) alpha_image->rows; y++)
434 {
435 const Quantum
436 *magick_restrict p,
437 *magick_restrict q;
438
439 Quantum
440 *magick_restrict r;
441
442 ssize_t
443 x;
444
445 if (status == MagickFalse)
446 continue;
447 p=GetCacheViewVirtualPixels(alpha_view,0,y,alpha_image->columns,1,
448 exception);
449 q=GetCacheViewVirtualPixels(beta_view,0,y,alpha_image->columns,1,exception);
450 r=GetCacheViewAuthenticPixels(sum_view,0,y,alpha_image->columns,1,
451 exception);
452 if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL) ||
453 (r == (Quantum *) NULL))
454 {
455 status=MagickFalse;
456 continue;
457 }
458 for (x=0; x < (ssize_t) alpha_image->columns; x++)
459 {
460 ssize_t
461 i;
462
463 for (i=0; i < (ssize_t) GetPixelChannels(alpha_image); i++)
464 {
465 PixelChannel channel = GetPixelChannelChannel(alpha_image,i);
466 PixelTrait traits = GetPixelChannelTraits(alpha_image,channel);
467 PixelTrait beta_traits = GetPixelChannelTraits(beta_image,channel);
468 if ((traits == UndefinedPixelTrait) ||
469 (beta_traits == UndefinedPixelTrait) ||
470 ((beta_traits & UpdatePixelTrait) == 0))
471 continue;
472 r[i]=ClampToQuantum(attenuate*((double) p[i]+sign*
473 (double) GetPixelChannel(beta_image,channel,q)));
474 }
475 p+=(ptrdiff_t) GetPixelChannels(alpha_image);
476 q+=(ptrdiff_t) GetPixelChannels(beta_image);
477 r+=(ptrdiff_t) GetPixelChannels(sum_image);
478 }
479 if (SyncCacheViewAuthenticPixels(sum_view,exception) == MagickFalse)
480 status=MagickFalse;
481 }
482 sum_view=DestroyCacheView(sum_view);
483 beta_view=DestroyCacheView(beta_view);
484 alpha_view=DestroyCacheView(alpha_view);
485 if (status == MagickFalse)
486 sum_image=DestroyImage(sum_image);
487 return(sum_image);
488}
489
490static Image *BlendDivergentImage(const Image *alpha_image,
491 const Image *beta_image,ExceptionInfo *exception)
492{
493#define FreeDivergentResources() \
494{ \
495 if (dy_image != (Image *) NULL) \
496 dy_image=DestroyImage(dy_image); \
497 if (dx_image != (Image *) NULL) \
498 dx_image=DestroyImage(dx_image); \
499 if (magnitude_beta != (Image *) NULL) \
500 magnitude_beta=DestroyImage(magnitude_beta); \
501 if (dy_beta != (Image *) NULL) \
502 dy_beta=DestroyImage(dy_beta); \
503 if (dx_beta != (Image *) NULL) \
504 dx_beta=DestroyImage(dx_beta); \
505 if (magnitude_alpha != (Image *) NULL) \
506 magnitude_alpha=DestroyImage(magnitude_alpha); \
507 if (dy_alpha != (Image *) NULL) \
508 dy_alpha=DestroyImage(dy_alpha); \
509 if (dx_alpha != (Image *) NULL) \
510 dx_alpha=DestroyImage(dx_alpha); \
511}
512
513 Image
514 *divergent_image = (Image *) NULL,
515 *dx_alpha = (Image *) NULL,
516 *dx_beta = (Image *) NULL,
517 *dx_divergent = (Image *) NULL,
518 *dx_image = (Image *) NULL,
519 *dy_alpha = (Image *) NULL,
520 *dy_beta = (Image *) NULL,
521 *dy_divergent = (Image *) NULL,
522 *dy_image = (Image *) NULL,
523 *magnitude_alpha = (Image *) NULL,
524 *magnitude_beta = (Image *) NULL;
525
526 /*
527 Create X and Y gradient images for alpha image and the magnitude.
528 */
529 dx_alpha=BlendConvolveImage(alpha_image,"3x1:-0.5,0.0,0.5",exception);
530 if (dx_alpha == (Image *) NULL)
531 {
532 FreeDivergentResources();
533 return((Image *) NULL);
534 }
535 dy_alpha=BlendConvolveImage(alpha_image,"1x3:-0.5,0.0,0.5",exception);
536 if (dy_alpha == (Image *) NULL)
537 {
538 FreeDivergentResources();
539 return((Image *) NULL);
540 }
541 magnitude_alpha=BlendMagnitudeImage(dx_alpha,dy_alpha,exception);
542 if (magnitude_alpha == (Image *) NULL)
543 {
544 FreeDivergentResources();
545 return((Image *) NULL);
546 }
547 /*
548 Create X and Y gradient images for beta and the magnitude.
549 */
550 dx_beta=BlendConvolveImage(beta_image,"3x1:-0.5,0.0,0.5",exception);
551 if (dx_beta == (Image *) NULL)
552 {
553 FreeDivergentResources();
554 return((Image *) NULL);
555 }
556 dy_beta=BlendConvolveImage(beta_image,"1x3:-0.5,0.0,0.5",exception);
557 if (dy_beta == (Image *) NULL)
558 {
559 FreeDivergentResources();
560 return((Image *) NULL);
561 }
562 magnitude_beta=BlendMagnitudeImage(dx_beta,dy_beta,exception);
563 if (magnitude_beta == (Image *) NULL)
564 {
565 FreeDivergentResources();
566 return((Image *) NULL);
567 }
568 /*
569 Select alpha or beta gradient for larger of two magnitudes.
570 */
571 dx_image=BlendMaxMagnitudeImage(magnitude_alpha,magnitude_beta,dx_alpha,
572 dx_beta,exception);
573 if (dx_image == (Image *) NULL)
574 {
575 FreeDivergentResources();
576 return((Image *) NULL);
577 }
578 dy_image=BlendMaxMagnitudeImage(magnitude_alpha,magnitude_beta,dy_alpha,
579 dy_beta,exception);
580 if (dy_image == (Image *) NULL)
581 {
582 FreeDivergentResources();
583 return((Image *) NULL);
584 }
585 dx_beta=DestroyImage(dx_beta);
586 dx_alpha=DestroyImage(dx_alpha);
587 magnitude_beta=DestroyImage(magnitude_beta);
588 magnitude_alpha=DestroyImage(magnitude_alpha);
589 /*
590 Create divergence of gradients dx and dy and divide by 4 as guide image.
591 */
592 dx_divergent=BlendConvolveImage(dx_image,"3x1:-0.5,0.0,0.5",exception);
593 if (dx_divergent == (Image *) NULL)
594 {
595 FreeDivergentResources();
596 return((Image *) NULL);
597 }
598 dy_divergent=BlendConvolveImage(dy_image,"1x3:-0.5,0.0,0.5",exception);
599 if (dy_divergent == (Image *) NULL)
600 {
601 FreeDivergentResources();
602 return((Image *) NULL);
603 }
604 divergent_image=BlendSumImage(dx_divergent,dy_divergent,0.25,1.0,exception);
605 dy_divergent=DestroyImage(dy_divergent);
606 dx_divergent=DestroyImage(dx_divergent);
607 if (divergent_image == (Image *) NULL)
608 {
609 FreeDivergentResources();
610 return((Image *) NULL);
611 }
612 FreeDivergentResources();
613 return(divergent_image);
614}
615
616static MagickBooleanType BlendMaskAlphaChannel(Image *image,
617 const Image *mask_image,ExceptionInfo *exception)
618{
619 CacheView
620 *image_view,
621 *mask_view;
622
623 MagickBooleanType
624 status = MagickTrue;
625
626 ssize_t
627 y;
628
629 /*
630 Threshold the alpha channel.
631 */
632 if (SetImageAlpha(image,OpaqueAlpha,exception) == MagickFalse)
633 return(MagickFalse);
634 image_view=AcquireAuthenticCacheView(image,exception);
635 mask_view=AcquireVirtualCacheView(mask_image,exception);
636#if defined(MAGICKCORE_OPENMP_SUPPORT)
637 #pragma omp parallel for schedule(static) shared(status) \
638 magick_number_threads(image,image,image->rows,2)
639#endif
640 for (y=0; y < (ssize_t) image->rows; y++)
641 {
642 const Quantum
643 *magick_restrict p;
644
645 Quantum
646 *magick_restrict q;
647
648 ssize_t
649 x;
650
651 if (status == MagickFalse)
652 continue;
653 p=GetCacheViewVirtualPixels(mask_view,0,y,image->columns,1,exception);
654 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
655 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
656 {
657 status=MagickFalse;
658 continue;
659 }
660 for (x=0; x < (ssize_t) image->columns; x++)
661 {
662 Quantum
663 alpha = GetPixelAlpha(mask_image,p);
664
665 ssize_t
666 i = GetPixelChannelOffset(image,AlphaPixelChannel);
667
668 if (fabs((double) alpha) >= MagickEpsilon)
669 q[i]=(Quantum) 0;
670 p+=(ptrdiff_t) GetPixelChannels(mask_image);
671 q+=(ptrdiff_t) GetPixelChannels(image);
672 }
673 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
674 status=MagickFalse;
675 }
676 mask_view=DestroyCacheView(mask_view);
677 image_view=DestroyCacheView(image_view);
678 return(status);
679}
680
681static Image *BlendMeanImage(Image *image,const Image *mask_image,
682 ExceptionInfo *exception)
683{
684 CacheView
685 *alpha_view,
686 *mask_view,
687 *mean_view;
688
689 double
690 mean[MaxPixelChannels];
691
692 Image
693 *mean_image;
694
695 MagickBooleanType
696 status = MagickTrue;
697
698 ssize_t
699 j,
700 y;
701
702 /*
703 Compute the mean of the image.
704 */
705 (void) memset(mean,0,MaxPixelChannels*sizeof(*mean));
706 alpha_view=AcquireVirtualCacheView(image,exception);
707 for (y=0; y < (ssize_t) image->rows; y++)
708 {
709 const Quantum
710 *magick_restrict p;
711
712 ssize_t
713 x;
714
715 p=GetCacheViewVirtualPixels(alpha_view,0,y,image->columns,1,
716 exception);
717 if (p == (const Quantum *) NULL)
718 break;
719 for (x=0; x < (ssize_t) image->columns; x++)
720 {
721 ssize_t
722 i;
723
724 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
725 {
726 PixelChannel channel = GetPixelChannelChannel(image,i);
727 PixelTrait traits = GetPixelChannelTraits(image,channel);
728 if (traits == UndefinedPixelTrait)
729 continue;
730 mean[i]+=QuantumScale*(double) p[i];
731 }
732 p+=(ptrdiff_t) GetPixelChannels(image);
733 }
734 }
735 alpha_view=DestroyCacheView(alpha_view);
736 if (y < (ssize_t) image->rows)
737 return((Image *) NULL);
738 for (j=0; j < (ssize_t) GetPixelChannels(image); j++)
739 mean[j]=(double) QuantumRange*mean[j]/image->columns/
740 image->rows;
741 /*
742 Replace any unmasked pixels with the mean pixel.
743 */
744 mean_image=CloneImage(image,0,0,MagickTrue,exception);
745 if (mean_image == (Image *) NULL)
746 return(mean_image);
747 mask_view=AcquireVirtualCacheView(mask_image,exception);
748 mean_view=AcquireAuthenticCacheView(mean_image,exception);
749#if defined(MAGICKCORE_OPENMP_SUPPORT)
750 #pragma omp parallel for schedule(static) shared(status) \
751 magick_number_threads(mask_image,mean_image,mean_image->rows,4)
752#endif
753 for (y=0; y < (ssize_t) mean_image->rows; y++)
754 {
755 const Quantum
756 *magick_restrict p;
757
758 Quantum
759 *magick_restrict q;
760
761 ssize_t
762 x;
763
764 if (status == MagickFalse)
765 continue;
766 p=GetCacheViewVirtualPixels(mask_view,0,y,mean_image->columns,1,exception);
767 q=GetCacheViewAuthenticPixels(mean_view,0,y,mean_image->columns,1,
768 exception);
769 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
770 {
771 status=MagickFalse;
772 continue;
773 }
774 for (x=0; x < (ssize_t) mean_image->columns; x++)
775 {
776 Quantum
777 alpha = GetPixelAlpha(mask_image,p),
778 mask = GetPixelReadMask(mask_image,p);
779
780 ssize_t
781 i;
782
783 for (i=0; i < (ssize_t) GetPixelChannels(mean_image); i++)
784 {
785 PixelChannel channel = GetPixelChannelChannel(mean_image,i);
786 PixelTrait traits = GetPixelChannelTraits(mean_image,channel);
787 if (traits == UndefinedPixelTrait)
788 continue;
789 if (mask <= (QuantumRange/2))
790 q[i]=(Quantum) 0;
791 else
792 if (fabs((double) alpha) >= MagickEpsilon)
793 q[i]=ClampToQuantum(mean[i]);
794 }
795 p+=(ptrdiff_t) GetPixelChannels(mask_image);
796 q+=(ptrdiff_t) GetPixelChannels(mean_image);
797 }
798 if (SyncCacheViewAuthenticPixels(mean_view,exception) == MagickFalse)
799 status=MagickFalse;
800 }
801 mask_view=DestroyCacheView(mask_view);
802 mean_view=DestroyCacheView(mean_view);
803 if (status == MagickFalse)
804 mean_image=DestroyImage(mean_image);
805 return(mean_image);
806}
807
808static MagickBooleanType BlendRMSEResidual(const Image *alpha_image,
809 const Image *beta_image,double *residual,ExceptionInfo *exception)
810{
811 CacheView
812 *alpha_view,
813 *beta_view;
814
815 double
816 area = 0.0,
817 channel_residual = 0.0;
818
819 MagickBooleanType
820 status = MagickTrue;
821
822 size_t
823 columns = MagickMax(alpha_image->columns,beta_image->columns),
824 rows = MagickMax(alpha_image->rows,beta_image->rows);
825
826 ssize_t
827 y;
828
829 alpha_view=AcquireVirtualCacheView(alpha_image,exception);
830 beta_view=AcquireVirtualCacheView(beta_image,exception);
831#if defined(MAGICKCORE_OPENMP_SUPPORT)
832 #pragma omp parallel for schedule(static) shared(status) \
833 reduction(+:area) reduction(+:channel_residual) \
834 magick_number_threads(alpha_image,alpha_image,rows,1)
835#endif
836 for (y=0; y < (ssize_t) rows; y++)
837 {
838 const Quantum
839 *magick_restrict p,
840 *magick_restrict q;
841
842 ssize_t
843 x;
844
845 if (status == MagickFalse)
846 continue;
847 p=GetCacheViewVirtualPixels(alpha_view,0,y,columns,1,exception);
848 q=GetCacheViewVirtualPixels(beta_view,0,y,columns,1,exception);
849 if ((p == (const Quantum *) NULL) || (q == (const Quantum *) NULL))
850 {
851 status=MagickFalse;
852 continue;
853 }
854 channel_residual=0.0;
855 for (x=0; x < (ssize_t) columns; x++)
856 {
857 double
858 Da,
859 Sa;
860
861 ssize_t
862 i;
863
864 if ((GetPixelReadMask(alpha_image,p) <= (QuantumRange/2)) ||
865 (GetPixelReadMask(beta_image,q) <= (QuantumRange/2)))
866 {
867 p+=(ptrdiff_t) GetPixelChannels(alpha_image);
868 q+=(ptrdiff_t) GetPixelChannels(beta_image);
869 continue;
870 }
871 Sa=QuantumScale*(double) GetPixelAlpha(alpha_image,p);
872 Da=QuantumScale*(double) GetPixelAlpha(beta_image,q);
873 for (i=0; i < (ssize_t) GetPixelChannels(alpha_image); i++)
874 {
875 double
876 distance;
877
878 PixelChannel channel = GetPixelChannelChannel(alpha_image,i);
879 PixelTrait traits = GetPixelChannelTraits(alpha_image,channel);
880 PixelTrait beta_traits = GetPixelChannelTraits(beta_image,channel);
881 if ((traits == UndefinedPixelTrait) ||
882 (beta_traits == UndefinedPixelTrait) ||
883 ((beta_traits & UpdatePixelTrait) == 0))
884 continue;
885 if (channel == AlphaPixelChannel)
886 distance=QuantumScale*((double) p[i]-(double) GetPixelChannel(
887 beta_image,channel,q));
888 else
889 distance=QuantumScale*(Sa*(double) p[i]-Da*(double) GetPixelChannel(
890 beta_image,channel,q));
891 channel_residual+=distance*distance;
892 }
893 area++;
894 p+=(ptrdiff_t) GetPixelChannels(alpha_image);
895 q+=(ptrdiff_t) GetPixelChannels(beta_image);
896 }
897 }
898 beta_view=DestroyCacheView(beta_view);
899 alpha_view=DestroyCacheView(alpha_view);
900 area=MagickSafeReciprocal(area);
901 *residual=sqrt(area*channel_residual/(double) GetImageChannels(alpha_image));
902 return(status);
903}
904
905static MagickBooleanType CompositeOverImage(Image *image,
906 const Image *source_image,const MagickBooleanType clip_to_self,
907 const ssize_t x_offset,const ssize_t y_offset,ExceptionInfo *exception)
908{
909#define CompositeImageTag "Composite/Image"
910
911 CacheView
912 *image_view,
913 *source_view;
914
915 const char
916 *value;
917
918 MagickBooleanType
919 clamp,
920 status;
921
922 MagickOffsetType
923 progress;
924
925 ssize_t
926 y;
927
928 /*
929 Composite image.
930 */
931 status=MagickTrue;
932 progress=0;
933 clamp=MagickTrue;
934 value=GetImageArtifact(image,"compose:clamp");
935 if (value != (const char *) NULL)
936 clamp=IsStringTrue(value);
937 status=MagickTrue;
938 progress=0;
939 source_view=AcquireVirtualCacheView(source_image,exception);
940 image_view=AcquireAuthenticCacheView(image,exception);
941#if defined(MAGICKCORE_OPENMP_SUPPORT)
942 #pragma omp parallel for schedule(static) shared(progress,status) \
943 magick_number_threads(source_image,image,image->rows,1)
944#endif
945 for (y=0; y < (ssize_t) image->rows; y++)
946 {
947 const Quantum
948 *pixels;
949
950 PixelInfo
951 canvas_pixel,
952 source_pixel;
953
954 const Quantum
955 *magick_restrict p;
956
957 Quantum
958 *magick_restrict q;
959
960 ssize_t
961 x;
962
963 if (status == MagickFalse)
964 continue;
965 if (clip_to_self != MagickFalse)
966 {
967 if (y < y_offset)
968 continue;
969 if ((y-y_offset) >= (ssize_t) source_image->rows)
970 continue;
971 }
972 /*
973 If pixels is NULL, y is outside overlay region.
974 */
975 pixels=(Quantum *) NULL;
976 p=(Quantum *) NULL;
977 if ((y >= y_offset) &&
978 ((y-y_offset) < (ssize_t) source_image->rows))
979 {
980 p=GetCacheViewVirtualPixels(source_view,0,CastDoubleToSsizeT((double) y-
981 y_offset),source_image->columns,1,exception);
982 if (p == (const Quantum *) NULL)
983 {
984 status=MagickFalse;
985 continue;
986 }
987 pixels=p;
988 if (x_offset < 0)
989 p-=(ptrdiff_t) CastDoubleToSsizeT((double) x_offset*
990 GetPixelChannels(source_image));
991 }
992 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
993 if (q == (Quantum *) NULL)
994 {
995 status=MagickFalse;
996 continue;
997 }
998 GetPixelInfo(image,&canvas_pixel);
999 GetPixelInfo(source_image,&source_pixel);
1000 for (x=0; x < (ssize_t) image->columns; x++)
1001 {
1002 double
1003 gamma;
1004
1005 MagickRealType
1006 alpha,
1007 Da,
1008 Dc,
1009 Dca,
1010 Sa,
1011 Sc,
1012 Sca;
1013
1014 ssize_t
1015 i;
1016
1017 size_t
1018 channels;
1019
1020 if (clip_to_self != MagickFalse)
1021 {
1022 if (x < x_offset)
1023 {
1024 q+=(ptrdiff_t) GetPixelChannels(image);
1025 continue;
1026 }
1027 if ((x-x_offset) >= (ssize_t) source_image->columns)
1028 break;
1029 }
1030 if ((pixels == (Quantum *) NULL) || (x < x_offset) ||
1031 ((x-x_offset) >= (ssize_t) source_image->columns))
1032 {
1033 Quantum
1034 source[MaxPixelChannels];
1035
1036 /*
1037 Virtual composite:
1038 Sc: source color.
1039 Dc: canvas color.
1040 */
1041 (void) GetOneVirtualPixel(source_image,
1042 CastDoubleToSsizeT((double) x-x_offset),
1043 CastDoubleToSsizeT((double) y-y_offset),source,exception);
1044 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1045 {
1046 MagickRealType
1047 pixel;
1048
1049 PixelChannel channel = GetPixelChannelChannel(image,i);
1050 PixelTrait traits = GetPixelChannelTraits(image,channel);
1051 PixelTrait source_traits=GetPixelChannelTraits(source_image,
1052 channel);
1053 if ((traits == UndefinedPixelTrait) ||
1054 (source_traits == UndefinedPixelTrait))
1055 continue;
1056 if (channel == AlphaPixelChannel)
1057 pixel=(MagickRealType) TransparentAlpha;
1058 else
1059 pixel=(MagickRealType) q[i];
1060 q[i]=clamp != MagickFalse ? ClampPixel(pixel) :
1061 ClampToQuantum(pixel);
1062 }
1063 q+=(ptrdiff_t) GetPixelChannels(image);
1064 continue;
1065 }
1066 /*
1067 Authentic composite:
1068 Sa: normalized source alpha.
1069 Da: normalized canvas alpha.
1070 */
1071 Sa=QuantumScale*(double) GetPixelAlpha(source_image,p);
1072 Da=QuantumScale*(double) GetPixelAlpha(image,q);
1073 alpha=Sa+Da-Sa*Da;
1074 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1075 {
1076 MagickRealType
1077 pixel;
1078
1079 PixelChannel channel = GetPixelChannelChannel(image,i);
1080 PixelTrait traits = GetPixelChannelTraits(image,channel);
1081 PixelTrait source_traits=GetPixelChannelTraits(source_image,channel);
1082 if (traits == UndefinedPixelTrait)
1083 continue;
1084 if ((source_traits == UndefinedPixelTrait) &&
1085 (channel != AlphaPixelChannel))
1086 continue;
1087 if (channel == AlphaPixelChannel)
1088 {
1089 /*
1090 Set alpha channel.
1091 */
1092 pixel=(double) QuantumRange*alpha;
1093 q[i]=clamp != MagickFalse ? ClampPixel(pixel) :
1094 ClampToQuantum(pixel);
1095 continue;
1096 }
1097 /*
1098 Sc: source color.
1099 Dc: canvas color.
1100 */
1101 Sc=(MagickRealType) GetPixelChannel(source_image,channel,p);
1102 Dc=(MagickRealType) q[i];
1103 if ((traits & CopyPixelTrait) != 0)
1104 {
1105 /*
1106 Copy channel.
1107 */
1108 q[i]=ClampToQuantum(Sc);
1109 continue;
1110 }
1111 /*
1112 Porter-Duff compositions:
1113 Sca: source normalized color multiplied by alpha.
1114 Dca: normalized canvas color multiplied by alpha.
1115 */
1116 Sca=QuantumScale*Sa*Sc;
1117 Dca=QuantumScale*Da*Dc;
1118 gamma=MagickSafeReciprocal(alpha);
1119 pixel=(double) QuantumRange*gamma*(Sca+Dca*(1.0-Sa));
1120 q[i]=clamp != MagickFalse ? ClampPixel(pixel) : ClampToQuantum(pixel);
1121 }
1122 p+=(ptrdiff_t) GetPixelChannels(source_image);
1123 channels=GetPixelChannels(source_image);
1124 if (p >= (pixels+channels*source_image->columns))
1125 p=pixels;
1126 q+=(ptrdiff_t) GetPixelChannels(image);
1127 }
1128 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1129 status=MagickFalse;
1130 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1131 {
1132 MagickBooleanType
1133 proceed;
1134
1135#if defined(MAGICKCORE_OPENMP_SUPPORT)
1136 #pragma omp atomic
1137#endif
1138 progress++;
1139 proceed=SetImageProgress(image,CompositeImageTag,progress,image->rows);
1140 if (proceed == MagickFalse)
1141 status=MagickFalse;
1142 }
1143 }
1144 source_view=DestroyCacheView(source_view);
1145 image_view=DestroyCacheView(image_view);
1146 return(status);
1147}
1148
1149static MagickBooleanType SaliencyBlendImage(Image *image,
1150 const Image *source_image,const ssize_t x_offset,const ssize_t y_offset,
1151 const double iterations,const double residual_threshold,const size_t tick,
1152 ExceptionInfo *exception)
1153{
1154 Image
1155 *crop_image,
1156 *divergent_image,
1157 *relax_image,
1158 *residual_image = (Image *) NULL;
1159
1160 KernelInfo
1161 *kernel_info;
1162
1163 MagickBooleanType
1164 status = MagickTrue,
1165 verbose = MagickFalse;
1166
1167 RectangleInfo
1168 crop_info = {
1169 source_image->columns,
1170 source_image->rows,
1171 x_offset,
1172 y_offset
1173 };
1174
1175 ssize_t
1176 i;
1177
1178 /*
1179 Saliency blend composite operator.
1180 */
1181 crop_image=CropImage(image,&crop_info,exception);
1182 if (crop_image == (Image *) NULL)
1183 return(MagickFalse);
1184 DisableCompositeClampUnlessSpecified(crop_image);
1185 divergent_image=BlendDivergentImage(crop_image,source_image,exception);
1186 if (divergent_image == (Image *) NULL)
1187 {
1188 crop_image=DestroyImage(crop_image);
1189 return(MagickFalse);
1190 }
1191 (void) ResetImagePage(crop_image,"0x0+0+0");
1192 relax_image=BlendMeanImage(crop_image,source_image,exception);
1193 if (relax_image == (Image *) NULL)
1194 {
1195 crop_image=DestroyImage(crop_image);
1196 divergent_image=DestroyImage(divergent_image);
1197 return(MagickFalse);
1198 }
1199 status=BlendMaskAlphaChannel(crop_image,source_image,exception);
1200 if (status == MagickFalse)
1201 {
1202 crop_image=DestroyImage(crop_image);
1203 divergent_image=DestroyImage(divergent_image);
1204 return(MagickFalse);
1205 }
1206 residual_image=CloneImage(relax_image,0,0,MagickTrue,exception);
1207 if (residual_image == (Image *) NULL)
1208 {
1209 crop_image=DestroyImage(crop_image);
1210 relax_image=DestroyImage(relax_image);
1211 return(MagickFalse);
1212 }
1213 /*
1214 Convolve relaxed image and blur area of interest.
1215 */
1216 kernel_info=AcquireKernelInfo("3x3:0,0.25,0,0.25,0,0.25,0,0.25,0",exception);
1217 if (kernel_info == (KernelInfo *) NULL)
1218 {
1219 crop_image=DestroyImage(crop_image);
1220 residual_image=DestroyImage(residual_image);
1221 relax_image=DestroyImage(relax_image);
1222 return(MagickFalse);
1223 }
1224 verbose=IsStringTrue(GetImageArtifact(image,"verbose"));
1225 if (verbose != MagickFalse)
1226 (void) FormatLocaleFile(stderr,"saliency blending:\n");
1227 for (i=0; i < (ssize_t) iterations; i++)
1228 {
1229 double
1230 residual = 1.0;
1231
1232 Image
1233 *convolve_image,
1234 *sum_image;
1235
1236 convolve_image=ConvolveImage(relax_image,kernel_info,exception);
1237 if (convolve_image == (Image *) NULL)
1238 break;
1239 relax_image=DestroyImage(relax_image);
1240 relax_image=convolve_image;
1241 sum_image=BlendSumImage(relax_image,divergent_image,1.0,-1.0,exception);
1242 if (sum_image == (Image *) NULL)
1243 break;
1244 relax_image=DestroyImage(relax_image);
1245 relax_image=sum_image;
1246 status=CompositeOverImage(relax_image,crop_image,MagickTrue,0,0,exception);
1247 if (status == MagickFalse)
1248 break;
1249 status=BlendRMSEResidual(relax_image,residual_image,&residual,exception);
1250 if (status == MagickFalse)
1251 break;
1252 if ((verbose != MagickFalse) && ((i % MagickMax(tick,1)) == 0))
1253 (void) FormatLocaleFile(stderr," %g: %g\n",(double) i,(double) residual);
1254 if (residual < residual_threshold)
1255 {
1256 if (verbose != MagickFalse)
1257 (void) FormatLocaleFile(stderr," %g: %g\n",(double) i,(double)
1258 residual);
1259 break;
1260 }
1261 residual_image=DestroyImage(residual_image);
1262 residual_image=CloneImage(relax_image,0,0,MagickTrue,exception);
1263 if (residual_image == (Image *) NULL)
1264 break;
1265 }
1266 kernel_info=DestroyKernelInfo(kernel_info);
1267 crop_image=DestroyImage(crop_image);
1268 divergent_image=DestroyImage(divergent_image);
1269 residual_image=DestroyImage(residual_image);
1270 /*
1271 Composite relaxed over the background image.
1272 */
1273 status=CompositeOverImage(image,relax_image,MagickTrue,x_offset,y_offset,
1274 exception);
1275 relax_image=DestroyImage(relax_image);
1276 return(status);
1277}
1278
1279static MagickBooleanType SeamlessBlendImage(Image *image,
1280 const Image *source_image,const ssize_t x_offset,const ssize_t y_offset,
1281 const double iterations,const double residual_threshold,const size_t tick,
1282 ExceptionInfo *exception)
1283{
1284 Image
1285 *crop_image,
1286 *foreground_image,
1287 *mean_image,
1288 *relax_image,
1289 *residual_image,
1290 *sum_image;
1291
1292 KernelInfo
1293 *kernel_info;
1294
1295 MagickBooleanType
1296 status = MagickTrue,
1297 verbose = MagickFalse;
1298
1299 RectangleInfo
1300 crop_info = {
1301 source_image->columns,
1302 source_image->rows,
1303 x_offset,
1304 y_offset
1305 };
1306
1307 ssize_t
1308 i;
1309
1310 /*
1311 Seamless blend composite operator.
1312 */
1313 crop_image=CropImage(image,&crop_info,exception);
1314 if (crop_image == (Image *) NULL)
1315 return(MagickFalse);
1316 DisableCompositeClampUnlessSpecified(crop_image);
1317 (void) ResetImagePage(crop_image,"0x0+0+0");
1318 sum_image=BlendSumImage(crop_image,source_image,1.0,-1.0,exception);
1319 crop_image=DestroyImage(crop_image);
1320 if (sum_image == (Image *) NULL)
1321 return(MagickFalse);
1322 mean_image=BlendMeanImage(sum_image,source_image,exception);
1323 sum_image=DestroyImage(sum_image);
1324 if (mean_image == (Image *) NULL)
1325 return(MagickFalse);
1326 relax_image=CloneImage(mean_image,0,0,MagickTrue,exception);
1327 if (relax_image == (Image *) NULL)
1328 {
1329 mean_image=DestroyImage(mean_image);
1330 return(MagickFalse);
1331 }
1332 status=BlendMaskAlphaChannel(mean_image,source_image,exception);
1333 if (status == MagickFalse)
1334 {
1335 relax_image=DestroyImage(relax_image);
1336 mean_image=DestroyImage(mean_image);
1337 return(MagickFalse);
1338 }
1339 residual_image=CloneImage(relax_image,0,0,MagickTrue,exception);
1340 if (residual_image == (Image *) NULL)
1341 {
1342 relax_image=DestroyImage(relax_image);
1343 mean_image=DestroyImage(mean_image);
1344 return(MagickFalse);
1345 }
1346 /*
1347 Convolve relaxed image and blur area of interest.
1348 */
1349 kernel_info=AcquireKernelInfo("3x3:0,0.25,0,0.25,0,0.25,0,0.25,0",exception);
1350 if (kernel_info == (KernelInfo *) NULL)
1351 {
1352 residual_image=DestroyImage(residual_image);
1353 relax_image=DestroyImage(relax_image);
1354 mean_image=DestroyImage(mean_image);
1355 return(MagickFalse);
1356 }
1357 verbose=IsStringTrue(GetImageArtifact(image,"verbose"));
1358 if (verbose != MagickFalse)
1359 (void) FormatLocaleFile(stderr,"seamless blending:\n");
1360 for (i=0; i < (ssize_t) iterations; i++)
1361 {
1362 double
1363 residual = 1.0;
1364
1365 Image
1366 *convolve_image;
1367
1368 convolve_image=ConvolveImage(relax_image,kernel_info,exception);
1369 if (convolve_image == (Image *) NULL)
1370 break;
1371 relax_image=DestroyImage(relax_image);
1372 relax_image=convolve_image;
1373 status=CompositeOverImage(relax_image,mean_image,MagickTrue,0,0,exception);
1374 if (status == MagickFalse)
1375 break;
1376 status=BlendRMSEResidual(relax_image,residual_image,&residual,exception);
1377 if (status == MagickFalse)
1378 break;
1379 if ((verbose != MagickFalse) && ((i % MagickMax(tick,1)) == 0))
1380 (void) FormatLocaleFile(stderr," %g: %g\n",(double) i,(double) residual);
1381 if (residual < residual_threshold)
1382 {
1383 if (verbose != MagickFalse)
1384 (void) FormatLocaleFile(stderr," %g: %g\n",(double) i,(double)
1385 residual);
1386 break;
1387 }
1388 if (residual_image != (Image *) NULL)
1389 residual_image=DestroyImage(residual_image);
1390 residual_image=CloneImage(relax_image,0,0,MagickTrue,exception);
1391 if (residual_image == (Image *) NULL)
1392 break;
1393 }
1394 kernel_info=DestroyKernelInfo(kernel_info);
1395 mean_image=DestroyImage(mean_image);
1396 residual_image=DestroyImage(residual_image);
1397 /*
1398 Composite the foreground image over the background image.
1399 */
1400 foreground_image=BlendSumImage(source_image,relax_image,1.0,1.0,exception);
1401 relax_image=DestroyImage(relax_image);
1402 if (foreground_image == (Image *) NULL)
1403 return(MagickFalse);
1404 (void) SetImageMask(foreground_image,ReadPixelMask,(const Image *) NULL,
1405 exception);
1406 status=CompositeOverImage(image,foreground_image,MagickTrue,x_offset,y_offset,
1407 exception);
1408 foreground_image=DestroyImage(foreground_image);
1409 return(status);
1410}
1411
1412MagickExport MagickBooleanType CompositeImage(Image *image,
1413 const Image *composite,const CompositeOperator compose,
1414 const MagickBooleanType clip_to_self,const ssize_t x_offset,
1415 const ssize_t y_offset,ExceptionInfo *exception)
1416{
1417#define CompositeImageTag "Composite/Image"
1418
1419 CacheView
1420 *source_view,
1421 *image_view;
1422
1423 ColorspaceType
1424 colorspace = HCLColorspace;
1425
1426 const char
1427 *artifact;
1428
1429 double
1430 white_luminance = 10000.0;
1431
1432 GeometryInfo
1433 geometry_info;
1434
1435 IlluminantType
1436 illuminant = D65Illuminant;
1437
1438 Image
1439 *canvas_image,
1440 *source_image;
1441
1442 MagickBooleanType
1443 clamp,
1444 compose_sync,
1445 status;
1446
1447 MagickOffsetType
1448 progress;
1449
1450 MagickRealType
1451 amount,
1452 canvas_dissolve,
1453 midpoint,
1454 percent_luma,
1455 percent_chroma,
1456 source_dissolve,
1457 threshold;
1458
1459 MagickStatusType
1460 flags;
1461
1462 ssize_t
1463 y;
1464
1465 assert(image != (Image *) NULL);
1466 assert(image->signature == MagickCoreSignature);
1467 assert(composite != (Image *) NULL);
1468 assert(composite->signature == MagickCoreSignature);
1469 if (IsEventLogging() != MagickFalse)
1470 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1471 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1472 return(MagickFalse);
1473 source_image=CloneImage(composite,0,0,MagickTrue,exception);
1474 if (source_image == (const Image *) NULL)
1475 return(MagickFalse);
1476 (void) SetImageColorspace(source_image,image->colorspace,exception);
1477 if ((compose == OverCompositeOp) || (compose == SrcOverCompositeOp))
1478 {
1479 status=CompositeOverImage(image,source_image,clip_to_self,x_offset,
1480 y_offset,exception);
1481 source_image=DestroyImage(source_image);
1482 return(status);
1483 }
1484 amount=0.5;
1485 canvas_image=(Image *) NULL;
1486 canvas_dissolve=1.0;
1487 white_luminance=10000.0;
1488 artifact=GetImageArtifact(image,"compose:white-luminance");
1489 if (artifact != (const char *) NULL)
1490 white_luminance=StringToDouble(artifact,(char **) NULL);
1491 artifact=GetImageArtifact(image,"compose:illuminant");
1492 if (artifact != (const char *) NULL)
1493 {
1494 ssize_t
1495 illuminant_type;
1496
1497 illuminant_type=ParseCommandOption(MagickIlluminantOptions,MagickFalse,
1498 artifact);
1499 if (illuminant_type < 0)
1500 illuminant=UndefinedIlluminant;
1501 else
1502 illuminant=(IlluminantType) illuminant_type;
1503 }
1504 artifact=GetImageArtifact(image,"compose:colorspace");
1505 if (artifact != (const char *) NULL)
1506 {
1507 ssize_t
1508 colorspace_type;
1509
1510 colorspace_type=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
1511 artifact);
1512 if (colorspace_type < 0)
1513 colorspace=UndefinedColorspace;
1514 else
1515 colorspace=(ColorspaceType) colorspace_type;
1516 }
1517 clamp=MagickTrue;
1518 artifact=GetImageArtifact(image,"compose:clamp");
1519 if (artifact != (const char *) NULL)
1520 clamp=IsStringTrue(artifact);
1521 compose_sync=MagickTrue;
1522 artifact=GetImageArtifact(image,"compose:sync");
1523 if (artifact != (const char *) NULL)
1524 compose_sync=IsStringTrue(artifact);
1525 SetGeometryInfo(&geometry_info);
1526 percent_luma=100.0;
1527 percent_chroma=100.0;
1528 source_dissolve=1.0;
1529 threshold=0.05f;
1530 switch (compose)
1531 {
1532 case CopyCompositeOp:
1533 {
1534 if ((x_offset < 0) || (y_offset < 0))
1535 break;
1536 if ((x_offset+(ssize_t) source_image->columns) > (ssize_t) image->columns)
1537 break;
1538 if ((y_offset+(ssize_t) source_image->rows) > (ssize_t) image->rows)
1539 break;
1540 if ((source_image->alpha_trait == UndefinedPixelTrait) &&
1541 (image->alpha_trait != UndefinedPixelTrait))
1542 (void) SetImageAlphaChannel(source_image,OpaqueAlphaChannel,exception);
1543 status=MagickTrue;
1544 source_view=AcquireVirtualCacheView(source_image,exception);
1545 image_view=AcquireAuthenticCacheView(image,exception);
1546#if defined(MAGICKCORE_OPENMP_SUPPORT)
1547 #pragma omp parallel for schedule(static) shared(status) \
1548 magick_number_threads(source_image,image,source_image->rows,4)
1549#endif
1550 for (y=0; y < (ssize_t) source_image->rows; y++)
1551 {
1552 MagickBooleanType
1553 sync;
1554
1555 const Quantum
1556 *p;
1557
1558 Quantum
1559 *q;
1560
1561 ssize_t
1562 x;
1563
1564 if (status == MagickFalse)
1565 continue;
1566 p=GetCacheViewVirtualPixels(source_view,0,y,source_image->columns,1,
1567 exception);
1568 q=GetCacheViewAuthenticPixels(image_view,x_offset,y+y_offset,
1569 source_image->columns,1,exception);
1570 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1571 {
1572 status=MagickFalse;
1573 continue;
1574 }
1575 for (x=0; x < (ssize_t) source_image->columns; x++)
1576 {
1577 ssize_t
1578 i;
1579
1580 if (GetPixelReadMask(source_image,p) <= (QuantumRange/2))
1581 {
1582 p+=(ptrdiff_t) GetPixelChannels(source_image);
1583 q+=(ptrdiff_t) GetPixelChannels(image);
1584 continue;
1585 }
1586 for (i=0; i < (ssize_t) GetPixelChannels(source_image); i++)
1587 {
1588 PixelChannel channel = GetPixelChannelChannel(source_image,i);
1589 PixelTrait source_traits = GetPixelChannelTraits(source_image,
1590 channel);
1591 PixelTrait traits = GetPixelChannelTraits(image,channel);
1592 if ((source_traits == UndefinedPixelTrait) ||
1593 (traits == UndefinedPixelTrait))
1594 continue;
1595 SetPixelChannel(image,channel,p[i],q);
1596 }
1597 p+=(ptrdiff_t) GetPixelChannels(source_image);
1598 q+=(ptrdiff_t) GetPixelChannels(image);
1599 }
1600 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1601 if (sync == MagickFalse)
1602 status=MagickFalse;
1603 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1604 {
1605 MagickBooleanType
1606 proceed;
1607
1608 proceed=SetImageProgress(image,CompositeImageTag,(MagickOffsetType)
1609 y,image->rows);
1610 if (proceed == MagickFalse)
1611 status=MagickFalse;
1612 }
1613 }
1614 source_view=DestroyCacheView(source_view);
1615 image_view=DestroyCacheView(image_view);
1616 source_image=DestroyImage(source_image);
1617 return(status);
1618 }
1619 case IntensityCompositeOp:
1620 {
1621 if ((x_offset < 0) || (y_offset < 0))
1622 break;
1623 if ((x_offset+(ssize_t) source_image->columns) > (ssize_t) image->columns)
1624 break;
1625 if ((y_offset+(ssize_t) source_image->rows) > (ssize_t) image->rows)
1626 break;
1627 status=MagickTrue;
1628 source_view=AcquireVirtualCacheView(source_image,exception);
1629 image_view=AcquireAuthenticCacheView(image,exception);
1630#if defined(MAGICKCORE_OPENMP_SUPPORT)
1631 #pragma omp parallel for schedule(static) shared(status) \
1632 magick_number_threads(source_image,image,source_image->rows,4)
1633#endif
1634 for (y=0; y < (ssize_t) source_image->rows; y++)
1635 {
1636 MagickBooleanType
1637 sync;
1638
1639 const Quantum
1640 *p;
1641
1642 Quantum
1643 *q;
1644
1645 ssize_t
1646 x;
1647
1648 if (status == MagickFalse)
1649 continue;
1650 p=GetCacheViewVirtualPixels(source_view,0,y,source_image->columns,1,
1651 exception);
1652 q=GetCacheViewAuthenticPixels(image_view,x_offset,y+y_offset,
1653 source_image->columns,1,exception);
1654 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1655 {
1656 status=MagickFalse;
1657 continue;
1658 }
1659 for (x=0; x < (ssize_t) source_image->columns; x++)
1660 {
1661 if (GetPixelReadMask(source_image,p) <= (QuantumRange/2))
1662 {
1663 p+=(ptrdiff_t) GetPixelChannels(source_image);
1664 q+=(ptrdiff_t) GetPixelChannels(image);
1665 continue;
1666 }
1667 SetPixelAlpha(image,clamp != MagickFalse ?
1668 ClampPixel(GetPixelIntensity(source_image,p)) :
1669 ClampToQuantum(GetPixelIntensity(source_image,p)),q);
1670 p+=(ptrdiff_t) GetPixelChannels(source_image);
1671 q+=(ptrdiff_t) GetPixelChannels(image);
1672 }
1673 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1674 if (sync == MagickFalse)
1675 status=MagickFalse;
1676 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1677 {
1678 MagickBooleanType
1679 proceed;
1680
1681 proceed=SetImageProgress(image,CompositeImageTag,(MagickOffsetType)
1682 y,image->rows);
1683 if (proceed == MagickFalse)
1684 status=MagickFalse;
1685 }
1686 }
1687 source_view=DestroyCacheView(source_view);
1688 image_view=DestroyCacheView(image_view);
1689 source_image=DestroyImage(source_image);
1690 return(status);
1691 }
1692 case CopyAlphaCompositeOp:
1693 case ChangeMaskCompositeOp:
1694 {
1695 /*
1696 Modify canvas outside the overlaid region and require an alpha
1697 channel to exist, to add transparency.
1698 */
1699 if ((image->alpha_trait & BlendPixelTrait) == 0)
1700 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1701 break;
1702 }
1703 case BlurCompositeOp:
1704 {
1705 CacheView
1706 *canvas_view;
1707
1708 double
1709 angle_range,
1710 angle_start,
1711 height,
1712 width;
1713
1714 PixelInfo
1715 pixel;
1716
1717 ResampleFilter
1718 *resample_filter;
1719
1720 SegmentInfo
1721 blur;
1722
1723 /*
1724 Blur Image by resampling dictated by an overlay gradient map:
1725 X = red_channel; Y = green_channel; compose:args =
1726 x_scale[,y_scale[,angle]].
1727 */
1728 canvas_image=CloneImage(image,0,0,MagickTrue,exception);
1729 if (canvas_image == (Image *) NULL)
1730 {
1731 source_image=DestroyImage(source_image);
1732 return(MagickFalse);
1733 }
1734 /*
1735 Gather the maximum blur sigma values from user.
1736 */
1737 flags=NoValue;
1738 artifact=GetImageArtifact(image,"compose:args");
1739 if (artifact != (const char *) NULL)
1740 flags=ParseGeometry(artifact,&geometry_info);
1741 if ((flags & WidthValue) == 0)
1742 {
1743 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
1744 "InvalidSetting","'%s' '%s'","compose:args",artifact);
1745 source_image=DestroyImage(source_image);
1746 canvas_image=DestroyImage(canvas_image);
1747 return(MagickFalse);
1748 }
1749 /*
1750 Users input sigma now needs to be converted to the EWA ellipse size.
1751 The filter defaults to a sigma of 0.5 so to make this match the users
1752 input the ellipse size needs to be doubled.
1753 */
1754 width=2.0*geometry_info.rho;
1755 height=width;
1756 if ((flags & HeightValue) != 0)
1757 height=2.0*geometry_info.sigma;
1758 /*
1759 Default the unrotated ellipse width and height axis vectors.
1760 */
1761 blur.x1=width;
1762 blur.x2=0.0;
1763 blur.y1=0.0;
1764 blur.y2=height;
1765 if ((flags & XValue) != 0 )
1766 {
1767 MagickRealType
1768 angle;
1769
1770 /*
1771 Rotate vectors if a rotation angle is given.
1772 */
1773 angle=DegreesToRadians(geometry_info.xi);
1774 blur.x1=width*cos(angle);
1775 blur.x2=width*sin(angle);
1776 blur.y1=(-height*sin(angle));
1777 blur.y2=height*cos(angle);
1778 }
1779 angle_start=0.0;
1780 angle_range=0.0;
1781 if ((flags & YValue) != 0 )
1782 {
1783 /*
1784 Lets set a angle range and calculate in the loop.
1785 */
1786 angle_start=DegreesToRadians(geometry_info.xi);
1787 angle_range=DegreesToRadians(geometry_info.psi)-angle_start;
1788 }
1789 /*
1790 Set up a gaussian cylindrical filter for EWA Blurring.
1791
1792 As the minimum ellipse radius of support*1.0 the EWA algorithm
1793 can only produce a minimum blur of 0.5 for Gaussian (support=2.0)
1794 This means that even 'No Blur' will be still a little blurry! The
1795 solution (as well as the problem of preventing any user expert filter
1796 settings, is to set our own user settings, restore them afterwards.
1797 */
1798 resample_filter=AcquireResampleFilter(image,exception);
1799 SetResampleFilter(resample_filter,GaussianFilter);
1800 /*
1801 Perform the variable blurring of each pixel in image.
1802 */
1803 GetPixelInfo(image,&pixel);
1804 source_view=AcquireVirtualCacheView(source_image,exception);
1805 canvas_view=AcquireAuthenticCacheView(canvas_image,exception);
1806 for (y=0; y < (ssize_t) source_image->rows; y++)
1807 {
1808 MagickBooleanType
1809 sync;
1810
1811 const Quantum
1812 *magick_restrict p;
1813
1814 Quantum
1815 *magick_restrict q;
1816
1817 ssize_t
1818 x;
1819
1820 if (((y+y_offset) < 0) || ((y+y_offset) >= (ssize_t) image->rows))
1821 continue;
1822 p=GetCacheViewVirtualPixels(source_view,0,y,source_image->columns,1,
1823 exception);
1824 q=QueueCacheViewAuthenticPixels(canvas_view,0,y,canvas_image->columns,1,
1825 exception);
1826 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1827 break;
1828 for (x=0; x < (ssize_t) source_image->columns; x++)
1829 {
1830 if (((x_offset+x) < 0) || ((x_offset+x) >= (ssize_t) image->columns))
1831 {
1832 p+=(ptrdiff_t) GetPixelChannels(source_image);
1833 continue;
1834 }
1835 if (fabs(angle_range) > MagickEpsilon)
1836 {
1837 MagickRealType
1838 angle;
1839
1840 angle=angle_start+angle_range*QuantumScale*(double)
1841 GetPixelBlue(source_image,p);
1842 blur.x1=width*cos(angle);
1843 blur.x2=width*sin(angle);
1844 blur.y1=(-height*sin(angle));
1845 blur.y2=height*cos(angle);
1846 }
1847 ScaleResampleFilter(resample_filter,
1848 blur.x1*QuantumScale*(double) GetPixelRed(source_image,p),
1849 blur.y1*QuantumScale*(double) GetPixelGreen(source_image,p),
1850 blur.x2*QuantumScale*(double) GetPixelRed(source_image,p),
1851 blur.y2*QuantumScale*(double) GetPixelGreen(source_image,p) );
1852 (void) ResamplePixelColor(resample_filter,(double) x_offset+x,
1853 (double) y_offset+y,&pixel,exception);
1854 SetPixelViaPixelInfo(canvas_image,&pixel,q);
1855 p+=(ptrdiff_t) GetPixelChannels(source_image);
1856 q+=(ptrdiff_t) GetPixelChannels(canvas_image);
1857 }
1858 sync=SyncCacheViewAuthenticPixels(canvas_view,exception);
1859 if (sync == MagickFalse)
1860 break;
1861 }
1862 resample_filter=DestroyResampleFilter(resample_filter);
1863 source_view=DestroyCacheView(source_view);
1864 canvas_view=DestroyCacheView(canvas_view);
1865 source_image=DestroyImage(source_image);
1866 source_image=canvas_image;
1867 break;
1868 }
1869 case DisplaceCompositeOp:
1870 case DistortCompositeOp:
1871 {
1872 CacheView
1873 *canvas_view;
1874
1875 MagickRealType
1876 horizontal_scale,
1877 vertical_scale;
1878
1879 PixelInfo
1880 pixel;
1881
1882 PointInfo
1883 center,
1884 offset;
1885
1886 /*
1887 Displace/Distort based on overlay gradient map:
1888 X = red_channel; Y = green_channel;
1889 compose:args = x_scale[,y_scale[,center.x,center.y]]
1890 */
1891 canvas_image=CloneImage(image,0,0,MagickTrue,exception);
1892 if (canvas_image == (Image *) NULL)
1893 {
1894 source_image=DestroyImage(source_image);
1895 return(MagickFalse);
1896 }
1897 SetGeometryInfo(&geometry_info);
1898 flags=NoValue;
1899 artifact=GetImageArtifact(image,"compose:args");
1900 if (artifact != (char *) NULL)
1901 flags=ParseGeometry(artifact,&geometry_info);
1902 if ((flags & (WidthValue | HeightValue)) == 0 )
1903 {
1904 if ((flags & AspectValue) == 0)
1905 {
1906 horizontal_scale=(MagickRealType) (source_image->columns-1)/2.0;
1907 vertical_scale=(MagickRealType) (source_image->rows-1)/2.0;
1908 }
1909 else
1910 {
1911 horizontal_scale=(MagickRealType) (image->columns-1)/2.0;
1912 vertical_scale=(MagickRealType) (image->rows-1)/2.0;
1913 }
1914 }
1915 else
1916 {
1917 horizontal_scale=geometry_info.rho;
1918 vertical_scale=geometry_info.sigma;
1919 if ((flags & PercentValue) != 0)
1920 {
1921 if ((flags & AspectValue) == 0)
1922 {
1923 horizontal_scale*=(source_image->columns-1)/200.0;
1924 vertical_scale*=(source_image->rows-1)/200.0;
1925 }
1926 else
1927 {
1928 horizontal_scale*=(image->columns-1)/200.0;
1929 vertical_scale*=(image->rows-1)/200.0;
1930 }
1931 }
1932 if ((flags & HeightValue) == 0)
1933 vertical_scale=horizontal_scale;
1934 }
1935 /*
1936 Determine fixed center point for absolute distortion map
1937 Absolute distort ==
1938 Displace offset relative to a fixed absolute point
1939 Select that point according to +X+Y user inputs.
1940 default = center of overlay image
1941 arg flag '!' = locations/percentage relative to background image
1942 */
1943 center.x=(MagickRealType) x_offset;
1944 center.y=(MagickRealType) y_offset;
1945 if (compose == DistortCompositeOp)
1946 {
1947 if ((flags & XValue) == 0)
1948 if ((flags & AspectValue) != 0)
1949 center.x=(MagickRealType) ((image->columns-1)/2.0);
1950 else
1951 center.x=(MagickRealType) (x_offset+(source_image->columns-1)/
1952 2.0);
1953 else
1954 if ((flags & AspectValue) != 0)
1955 center.x=geometry_info.xi;
1956 else
1957 center.x=(MagickRealType) (x_offset+geometry_info.xi);
1958 if ((flags & YValue) == 0)
1959 if ((flags & AspectValue) != 0)
1960 center.y=(MagickRealType) ((image->rows-1)/2.0);
1961 else
1962 center.y=(MagickRealType) (y_offset+(source_image->rows-1)/2.0);
1963 else
1964 if ((flags & AspectValue) != 0)
1965 center.y=geometry_info.psi;
1966 else
1967 center.y=(MagickRealType) (y_offset+geometry_info.psi);
1968 }
1969 /*
1970 Shift the pixel offset point as defined by the provided,
1971 displacement/distortion map. -- Like a lens...
1972 */
1973 GetPixelInfo(image,&pixel);
1974 image_view=AcquireVirtualCacheView(image,exception);
1975 source_view=AcquireVirtualCacheView(source_image,exception);
1976 canvas_view=AcquireAuthenticCacheView(canvas_image,exception);
1977 for (y=0; y < (ssize_t) source_image->rows; y++)
1978 {
1979 MagickBooleanType
1980 sync;
1981
1982 const Quantum
1983 *magick_restrict p;
1984
1985 Quantum
1986 *magick_restrict q;
1987
1988 ssize_t
1989 x;
1990
1991 if (((y+y_offset) < 0) || ((y+y_offset) >= (ssize_t) image->rows))
1992 continue;
1993 p=GetCacheViewVirtualPixels(source_view,0,y,source_image->columns,1,
1994 exception);
1995 q=QueueCacheViewAuthenticPixels(canvas_view,0,y,canvas_image->columns,1,
1996 exception);
1997 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1998 break;
1999 for (x=0; x < (ssize_t) source_image->columns; x++)
2000 {
2001 if (((x_offset+x) < 0) || ((x_offset+x) >= (ssize_t) image->columns))
2002 {
2003 p+=(ptrdiff_t) GetPixelChannels(source_image);
2004 continue;
2005 }
2006 /*
2007 Displace the offset.
2008 */
2009 offset.x=(double) (horizontal_scale*((double) GetPixelRed(
2010 source_image,p)-(((MagickRealType) QuantumRange+1.0)/2.0)))/
2011 (((MagickRealType) QuantumRange+1.0)/2.0)+center.x+
2012 ((compose == DisplaceCompositeOp) ? x : 0);
2013 offset.y=(double) (vertical_scale*((double) GetPixelGreen(
2014 source_image,p)-(((MagickRealType) QuantumRange+1.0)/2.0)))/
2015 (((MagickRealType) QuantumRange+1.0)/2.0)+center.y+
2016 ((compose == DisplaceCompositeOp) ? y : 0);
2017 status=InterpolatePixelInfo(image,image_view,
2018 UndefinedInterpolatePixel,(double) offset.x,(double) offset.y,
2019 &pixel,exception);
2020 if (status == MagickFalse)
2021 break;
2022 /*
2023 Mask with the 'invalid pixel mask' in alpha channel.
2024 */
2025 pixel.alpha=(MagickRealType) QuantumRange*(QuantumScale*pixel.alpha)*
2026 (QuantumScale*(double) GetPixelAlpha(source_image,p));
2027 SetPixelViaPixelInfo(canvas_image,&pixel,q);
2028 p+=(ptrdiff_t) GetPixelChannels(source_image);
2029 q+=(ptrdiff_t) GetPixelChannels(canvas_image);
2030 }
2031 if (x < (ssize_t) source_image->columns)
2032 break;
2033 sync=SyncCacheViewAuthenticPixels(canvas_view,exception);
2034 if (sync == MagickFalse)
2035 break;
2036 }
2037 canvas_view=DestroyCacheView(canvas_view);
2038 source_view=DestroyCacheView(source_view);
2039 image_view=DestroyCacheView(image_view);
2040 source_image=DestroyImage(source_image);
2041 source_image=canvas_image;
2042 break;
2043 }
2044 case DissolveCompositeOp:
2045 {
2046 /*
2047 Geometry arguments to dissolve factors.
2048 */
2049 artifact=GetImageArtifact(image,"compose:args");
2050 if (artifact != (char *) NULL)
2051 {
2052 flags=ParseGeometry(artifact,&geometry_info);
2053 source_dissolve=geometry_info.rho/100.0;
2054 canvas_dissolve=1.0;
2055 if ((source_dissolve-MagickEpsilon) < 0.0)
2056 source_dissolve=0.0;
2057 if ((source_dissolve+MagickEpsilon) > 1.0)
2058 {
2059 canvas_dissolve=2.0-source_dissolve;
2060 source_dissolve=1.0;
2061 }
2062 if ((flags & SigmaValue) != 0)
2063 canvas_dissolve=geometry_info.sigma/100.0;
2064 if ((canvas_dissolve-MagickEpsilon) < 0.0)
2065 canvas_dissolve=0.0;
2066 if ((canvas_dissolve+MagickEpsilon) > 1.0)
2067 canvas_dissolve=1.0;
2068 }
2069 break;
2070 }
2071 case BlendCompositeOp:
2072 {
2073 artifact=GetImageArtifact(image,"compose:args");
2074 if (artifact != (char *) NULL)
2075 {
2076 flags=ParseGeometry(artifact,&geometry_info);
2077 source_dissolve=geometry_info.rho/100.0;
2078 canvas_dissolve=1.0-source_dissolve;
2079 if ((flags & SigmaValue) != 0)
2080 canvas_dissolve=geometry_info.sigma/100.0;
2081 }
2082 break;
2083 }
2084 case SaliencyBlendCompositeOp:
2085 {
2086 double
2087 residual_threshold = 0.0002,
2088 iterations = 400.0;
2089
2090 size_t
2091 tick = 100;
2092
2093 artifact=GetImageArtifact(image,"compose:args");
2094 if (artifact != (char *) NULL)
2095 {
2096 flags=ParseGeometry(artifact,&geometry_info);
2097 iterations=geometry_info.rho;
2098 if ((flags & SigmaValue) != 0)
2099 residual_threshold=geometry_info.sigma;
2100 if ((flags & XiValue) != 0)
2101 tick=(size_t) geometry_info.xi;
2102 }
2103 status=SaliencyBlendImage(image,composite,x_offset,y_offset,iterations,
2104 residual_threshold,tick,exception);
2105 source_image=DestroyImage(source_image);
2106 return(status);
2107 }
2108 case SeamlessBlendCompositeOp:
2109 {
2110 double
2111 residual_threshold = 0.0002,
2112 iterations = 400.0;
2113
2114 size_t
2115 tick = 100;
2116
2117 artifact=GetImageArtifact(image,"compose:args");
2118 if (artifact != (char *) NULL)
2119 {
2120 flags=ParseGeometry(artifact,&geometry_info);
2121 iterations=geometry_info.rho;
2122 if ((flags & SigmaValue) != 0)
2123 residual_threshold=geometry_info.sigma;
2124 if ((flags & XiValue) != 0)
2125 tick=(size_t) geometry_info.xi;
2126 }
2127 status=SeamlessBlendImage(image,composite,x_offset,y_offset,iterations,
2128 residual_threshold,tick,exception);
2129 source_image=DestroyImage(source_image);
2130 return(status);
2131 }
2132 case MathematicsCompositeOp:
2133 {
2134 /*
2135 Just collect the values from "compose:args", setting.
2136 Unused values are set to zero automagically.
2137
2138 Arguments are normally a comma separated list, so this probably should
2139 be changed to some 'general comma list' parser, (with a minimum
2140 number of values)
2141 */
2142 SetGeometryInfo(&geometry_info);
2143 artifact=GetImageArtifact(image,"compose:args");
2144 if (artifact != (char *) NULL)
2145 {
2146 flags=ParseGeometry(artifact,&geometry_info);
2147 if (flags == NoValue)
2148 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2149 "InvalidGeometry","`%s'",artifact);
2150 }
2151 break;
2152 }
2153 case ModulateCompositeOp:
2154 {
2155 /*
2156 Determine the luma and chroma scale.
2157 */
2158 artifact=GetImageArtifact(image,"compose:args");
2159 if (artifact != (char *) NULL)
2160 {
2161 flags=ParseGeometry(artifact,&geometry_info);
2162 percent_luma=geometry_info.rho;
2163 if ((flags & SigmaValue) != 0)
2164 percent_chroma=geometry_info.sigma;
2165 }
2166 break;
2167 }
2168 case ThresholdCompositeOp:
2169 {
2170 /*
2171 Determine the amount and threshold.
2172 */
2173 artifact=GetImageArtifact(image,"compose:args");
2174 if (artifact != (char *) NULL)
2175 {
2176 flags=ParseGeometry(artifact,&geometry_info);
2177 amount=geometry_info.rho;
2178 threshold=geometry_info.sigma;
2179 if ((flags & SigmaValue) == 0)
2180 threshold=0.05f;
2181 }
2182 threshold*=(double) QuantumRange;
2183 break;
2184 }
2185 default:
2186 break;
2187 }
2188 /*
2189 Composite image.
2190 */
2191 status=MagickTrue;
2192 progress=0;
2193 midpoint=((MagickRealType) QuantumRange+1.0)/2;
2194 source_view=AcquireVirtualCacheView(source_image,exception);
2195 image_view=AcquireAuthenticCacheView(image,exception);
2196#if defined(MAGICKCORE_OPENMP_SUPPORT)
2197 #pragma omp parallel for schedule(static) shared(progress,status) \
2198 magick_number_threads(source_image,image,image->rows,1)
2199#endif
2200 for (y=0; y < (ssize_t) image->rows; y++)
2201 {
2202 const Quantum
2203 *magick_restrict p,
2204 *pixels;
2205
2206 MagickRealType
2207 blue = 0.0,
2208 chroma = 0.0,
2209 green = 0.0,
2210 hue = 0.0,
2211 luma = 0.0,
2212 red = 0.0;
2213
2214 PixelInfo
2215 canvas_pixel,
2216 source_pixel;
2217
2218 Quantum
2219 *magick_restrict q;
2220
2221 ssize_t
2222 x;
2223
2224 if (status == MagickFalse)
2225 continue;
2226 if (clip_to_self != MagickFalse)
2227 {
2228 if (y < y_offset)
2229 continue;
2230 if ((y-y_offset) >= (ssize_t) source_image->rows)
2231 continue;
2232 }
2233 /*
2234 If pixels is NULL, y is outside overlay region.
2235 */
2236 pixels=(Quantum *) NULL;
2237 p=(Quantum *) NULL;
2238 if ((y >= y_offset) &&
2239 ((y-y_offset) < (ssize_t) source_image->rows))
2240 {
2241 p=GetCacheViewVirtualPixels(source_view,0,
2242 CastDoubleToSsizeT((double) y-y_offset),source_image->columns,1,
2243 exception);
2244 if (p == (const Quantum *) NULL)
2245 {
2246 status=MagickFalse;
2247 continue;
2248 }
2249 pixels=p;
2250 if (x_offset < 0)
2251 p-=(ptrdiff_t) CastDoubleToSsizeT((double) x_offset*
2252 GetPixelChannels(source_image));
2253 }
2254 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2255 if (q == (Quantum *) NULL)
2256 {
2257 status=MagickFalse;
2258 continue;
2259 }
2260 GetPixelInfo(image,&canvas_pixel);
2261 GetPixelInfo(source_image,&source_pixel);
2262 for (x=0; x < (ssize_t) image->columns; x++)
2263 {
2264 double
2265 gamma = 0.0;
2266
2267 MagickRealType
2268 alpha = 0.0,
2269 blend = 0.0,
2270 D = 0.0,
2271 Da = 0.0,
2272 Dc = 0.0,
2273 Dca = 0.0,
2274 Di = 0.0,
2275 S = 0.0,
2276 Sa = 0.0,
2277 Sc = 0.0,
2278 Sca = 0.0,
2279 Si = 0.0;
2280
2281 size_t
2282 channels;
2283
2284 ssize_t
2285 i;
2286
2287 if (clip_to_self != MagickFalse)
2288 {
2289 if (x < x_offset)
2290 {
2291 q+=(ptrdiff_t) GetPixelChannels(image);
2292 continue;
2293 }
2294 if ((x-x_offset) >= (ssize_t) source_image->columns)
2295 break;
2296 }
2297 if ((pixels == (Quantum *) NULL) || (x < x_offset) ||
2298 ((x-x_offset) >= (ssize_t) source_image->columns))
2299 {
2300 Quantum
2301 source[MaxPixelChannels];
2302
2303 /*
2304 Virtual composite:
2305 Sc: source color.
2306 Dc: canvas color.
2307 */
2308 (void) GetOneVirtualPixel(source_image,
2309 CastDoubleToSsizeT((double) x-x_offset),
2310 CastDoubleToSsizeT((double) y-y_offset),source,exception);
2311 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2312 {
2313 MagickRealType
2314 pixel = 0.0;
2315
2316 PixelChannel channel = GetPixelChannelChannel(image,i);
2317 PixelTrait traits = GetPixelChannelTraits(image,channel);
2318 PixelTrait source_traits = GetPixelChannelTraits(source_image,
2319 channel);
2320 if ((traits == UndefinedPixelTrait) ||
2321 (source_traits == UndefinedPixelTrait))
2322 continue;
2323 switch (compose)
2324 {
2325 case AlphaCompositeOp:
2326 case ChangeMaskCompositeOp:
2327 case CopyAlphaCompositeOp:
2328 case DstAtopCompositeOp:
2329 case DstInCompositeOp:
2330 case InCompositeOp:
2331 case OutCompositeOp:
2332 case SrcInCompositeOp:
2333 case SrcOutCompositeOp:
2334 {
2335 if (channel == AlphaPixelChannel)
2336 pixel=(MagickRealType) TransparentAlpha;
2337 else
2338 pixel=(MagickRealType) q[i];
2339 break;
2340 }
2341 case ClearCompositeOp:
2342 case CopyCompositeOp:
2343 case ReplaceCompositeOp:
2344 {
2345 if (channel == AlphaPixelChannel)
2346 pixel=(MagickRealType) TransparentAlpha;
2347 else
2348 pixel=0.0;
2349 break;
2350 }
2351 case BlendCompositeOp:
2352 case DissolveCompositeOp:
2353 {
2354 if (channel == AlphaPixelChannel)
2355 pixel=canvas_dissolve*(double) GetPixelAlpha(source_image,
2356 source);
2357 else
2358 pixel=(MagickRealType) source[channel];
2359 break;
2360 }
2361 default:
2362 {
2363 pixel=(MagickRealType) source[channel];
2364 break;
2365 }
2366 }
2367 q[i]=clamp != MagickFalse ? ClampPixel(pixel) :
2368 ClampToQuantum(pixel);
2369 }
2370 q+=(ptrdiff_t) GetPixelChannels(image);
2371 continue;
2372 }
2373 /*
2374 Authentic composite:
2375 Sa: normalized source alpha.
2376 Da: normalized canvas alpha.
2377 */
2378 Sa=QuantumScale*(double) GetPixelAlpha(source_image,p);
2379 Da=QuantumScale*(double) GetPixelAlpha(image,q);
2380 switch (compose)
2381 {
2382 case BumpmapCompositeOp:
2383 case ColorBurnCompositeOp:
2384 case ColorDodgeCompositeOp:
2385 case DarkenCompositeOp:
2386 case DifferenceCompositeOp:
2387 case DivideDstCompositeOp:
2388 case DivideSrcCompositeOp:
2389 case ExclusionCompositeOp:
2390 case FreezeCompositeOp:
2391 case HardLightCompositeOp:
2392 case HardMixCompositeOp:
2393 case InterpolateCompositeOp:
2394 case LightenCompositeOp:
2395 case LinearBurnCompositeOp:
2396 case LinearDodgeCompositeOp:
2397 case LinearLightCompositeOp:
2398 case MathematicsCompositeOp:
2399 case MinusDstCompositeOp:
2400 case MinusSrcCompositeOp:
2401 case MultiplyCompositeOp:
2402 case NegateCompositeOp:
2403 case OverlayCompositeOp:
2404 case PegtopLightCompositeOp:
2405 case PinLightCompositeOp:
2406 case ReflectCompositeOp:
2407 case ScreenCompositeOp:
2408 case SoftBurnCompositeOp:
2409 case SoftDodgeCompositeOp:
2410 case SoftLightCompositeOp:
2411 case StampCompositeOp:
2412 case VividLightCompositeOp:
2413 {
2414 alpha=RoundToUnity(Sa+Da-Sa*Da);
2415 break;
2416 }
2417 case DstAtopCompositeOp:
2418 case DstInCompositeOp:
2419 case InCompositeOp:
2420 case SrcInCompositeOp:
2421 {
2422 alpha=Sa*Da;
2423 break;
2424 }
2425 case DissolveCompositeOp:
2426 {
2427 alpha=source_dissolve*Sa*(-canvas_dissolve*Da)+source_dissolve*Sa+
2428 canvas_dissolve*Da;
2429 break;
2430 }
2431 case DstOverCompositeOp:
2432 case OverCompositeOp:
2433 case SrcOverCompositeOp:
2434 {
2435 alpha=Sa+Da-Sa*Da;
2436 break;
2437 }
2438 case DstOutCompositeOp:
2439 {
2440 alpha=Da*(1.0-Sa);
2441 break;
2442 }
2443 case OutCompositeOp:
2444 case SrcOutCompositeOp:
2445 {
2446 alpha=Sa*(1.0-Da);
2447 break;
2448 }
2449 case BlendCompositeOp:
2450 case PlusCompositeOp:
2451 {
2452 alpha=RoundToUnity(source_dissolve*Sa+canvas_dissolve*Da);
2453 break;
2454 }
2455 case XorCompositeOp:
2456 {
2457 alpha=Sa+Da-2.0*Sa*Da;
2458 break;
2459 }
2460 case ModulusAddCompositeOp:
2461 {
2462 if ((Sa+Da) <= 1.0)
2463 {
2464 alpha=(Sa+Da);
2465 break;
2466 }
2467 alpha=((Sa+Da)-1.0);
2468 break;
2469 }
2470 case ModulusSubtractCompositeOp:
2471 {
2472 if ((Sa-Da) >= 0.0)
2473 {
2474 alpha=(Sa-Da);
2475 break;
2476 }
2477 alpha=((Sa-Da)+1.0);
2478 break;
2479 }
2480 default:
2481 {
2482 alpha=1.0;
2483 break;
2484 }
2485 }
2486 switch (compose)
2487 {
2488 case ColorizeCompositeOp:
2489 case HueCompositeOp:
2490 case LuminizeCompositeOp:
2491 case ModulateCompositeOp:
2492 case RMSECompositeOp:
2493 case SaturateCompositeOp:
2494 {
2495 Si=GetPixelIntensity(source_image,p);
2496 GetPixelInfoPixel(source_image,p,&source_pixel);
2497 GetPixelInfoPixel(image,q,&canvas_pixel);
2498 break;
2499 }
2500 case BumpmapCompositeOp:
2501 case CopyAlphaCompositeOp:
2502 case DarkenIntensityCompositeOp:
2503 case LightenIntensityCompositeOp:
2504 {
2505 Si=GetPixelIntensity(source_image,p);
2506 Di=GetPixelIntensity(image,q);
2507 break;
2508 }
2509 default:
2510 break;
2511 }
2512 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2513 {
2514 MagickRealType
2515 pixel = 0.0,
2516 sans = 0.0;
2517
2518 PixelChannel channel = GetPixelChannelChannel(image,i);
2519 PixelTrait traits = GetPixelChannelTraits(image,channel);
2520 PixelTrait source_traits = GetPixelChannelTraits(source_image,channel);
2521 if (traits == UndefinedPixelTrait)
2522 continue;
2523 if ((channel == AlphaPixelChannel) &&
2524 ((traits & UpdatePixelTrait) != 0))
2525 {
2526 /*
2527 Set alpha channel.
2528 */
2529 switch (compose)
2530 {
2531 case AlphaCompositeOp:
2532 {
2533 pixel=(double) QuantumRange*Sa;
2534 break;
2535 }
2536 case AtopCompositeOp:
2537 case CopyBlackCompositeOp:
2538 case CopyBlueCompositeOp:
2539 case CopyCyanCompositeOp:
2540 case CopyGreenCompositeOp:
2541 case CopyMagentaCompositeOp:
2542 case CopyRedCompositeOp:
2543 case CopyYellowCompositeOp:
2544 case SrcAtopCompositeOp:
2545 case DstCompositeOp:
2546 case NoCompositeOp:
2547 {
2548 pixel=(double) QuantumRange*Da;
2549 break;
2550 }
2551 case BumpmapCompositeOp:
2552 {
2553 pixel=Si*Da;
2554 break;
2555 }
2556 case ChangeMaskCompositeOp:
2557 {
2558 if (IsFuzzyEquivalencePixel(source_image,p,image,q) != MagickFalse)
2559 pixel=(MagickRealType) TransparentAlpha;
2560 else
2561 pixel=(double) QuantumRange*Da;
2562 break;
2563 }
2564 case ClearCompositeOp:
2565 {
2566 pixel=(MagickRealType) TransparentAlpha;
2567 break;
2568 }
2569 case ColorizeCompositeOp:
2570 case HueCompositeOp:
2571 case LuminizeCompositeOp:
2572 case RMSECompositeOp:
2573 case SaturateCompositeOp:
2574 {
2575 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
2576 {
2577 pixel=(double) QuantumRange*Da;
2578 break;
2579 }
2580 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
2581 {
2582 pixel=(double) QuantumRange*Sa;
2583 break;
2584 }
2585 if (Sa < Da)
2586 {
2587 pixel=(double) QuantumRange*Da;
2588 break;
2589 }
2590 pixel=(double) QuantumRange*Sa;
2591 break;
2592 }
2593 case CopyAlphaCompositeOp:
2594 {
2595 pixel=Si;
2596 break;
2597 }
2598 case BlurCompositeOp:
2599 case CopyCompositeOp:
2600 case DisplaceCompositeOp:
2601 case DistortCompositeOp:
2602 case DstAtopCompositeOp:
2603 case ReplaceCompositeOp:
2604 case SrcCompositeOp:
2605 {
2606 pixel=(double) QuantumRange*Sa;
2607 break;
2608 }
2609 case DarkenIntensityCompositeOp:
2610 {
2611 if (compose_sync == MagickFalse)
2612 {
2613 pixel=Si < Di ? Sa : Da;
2614 break;
2615 }
2616 pixel=Sa*Si < Da*Di ? Sa : Da;
2617 break;
2618 }
2619 case DifferenceCompositeOp:
2620 {
2621 pixel=(double) QuantumRange*fabs((double) (Sa-Da));
2622 break;
2623 }
2624 case FreezeCompositeOp:
2625 {
2626 pixel=(double) QuantumRange*(1.0-(1.0-Sa)*(1.0-Sa)*
2627 MagickSafeReciprocal(Da));
2628 if (pixel < 0.0)
2629 pixel=0.0;
2630 break;
2631 }
2632 case InterpolateCompositeOp:
2633 {
2634 pixel=(double) QuantumRange*(0.5-0.25*cos(MagickPI*Sa)-0.25*
2635 cos(MagickPI*Da));
2636 break;
2637 }
2638 case LightenIntensityCompositeOp:
2639 {
2640 if (compose_sync == MagickFalse)
2641 {
2642 pixel=Si > Di ? Sa : Da;
2643 break;
2644 }
2645 pixel=Sa*Si > Da*Di ? Sa : Da;
2646 break;
2647 }
2648 case ModulateCompositeOp:
2649 {
2650 pixel=(double) QuantumRange*Da;
2651 break;
2652 }
2653 case MultiplyCompositeOp:
2654 {
2655 if (compose_sync == MagickFalse)
2656 {
2657 pixel=(double) QuantumRange*Sa*Da;
2658 break;
2659 }
2660 pixel=(double) QuantumRange*alpha;
2661 break;
2662 }
2663 case NegateCompositeOp:
2664 {
2665 pixel=(double) QuantumRange*((1.0-Sa-Da));
2666 break;
2667 }
2668 case ReflectCompositeOp:
2669 {
2670 pixel=(double) QuantumRange*(Sa*Sa*
2671 MagickSafeReciprocal(1.0-Da));
2672 if (pixel > (double) QuantumRange)
2673 pixel=(double) QuantumRange;
2674 break;
2675 }
2676 case StampCompositeOp:
2677 {
2678 pixel=(double) QuantumRange*(Sa+Da*Da-1.0);
2679 break;
2680 }
2681 case StereoCompositeOp:
2682 {
2683 pixel=(double) QuantumRange*(Sa+Da)/2;
2684 break;
2685 }
2686 default:
2687 {
2688 pixel=(double) QuantumRange*alpha;
2689 break;
2690 }
2691 }
2692 q[i]=clamp != MagickFalse ? ClampPixel(pixel) :
2693 ClampToQuantum(pixel);
2694 continue;
2695 }
2696 if (source_traits == UndefinedPixelTrait)
2697 continue;
2698 /*
2699 Sc: source color.
2700 Dc: canvas color.
2701 */
2702 Sc=(MagickRealType) GetPixelChannel(source_image,channel,p);
2703 Dc=(MagickRealType) q[i];
2704 if ((traits & CopyPixelTrait) != 0)
2705 {
2706 /*
2707 Copy channel.
2708 */
2709 q[i]=ClampToQuantum(Dc);
2710 continue;
2711 }
2712 /*
2713 Porter-Duff compositions:
2714 Sca: source normalized color multiplied by alpha.
2715 Dca: normalized canvas color multiplied by alpha.
2716 */
2717 Sca=QuantumScale*Sa*Sc;
2718 Dca=QuantumScale*Da*Dc;
2719 switch (compose)
2720 {
2721 case DarkenCompositeOp:
2722 case LightenCompositeOp:
2723 case ModulusSubtractCompositeOp:
2724 {
2725 gamma=MagickSafeReciprocal(1.0-alpha);
2726 break;
2727 }
2728 default:
2729 {
2730 gamma=MagickSafeReciprocal(alpha);
2731 break;
2732 }
2733 }
2734 pixel=Dc;
2735 switch (compose)
2736 {
2737 case AlphaCompositeOp:
2738 {
2739 pixel=(double) QuantumRange*Sa;
2740 break;
2741 }
2742 case AtopCompositeOp:
2743 case SrcAtopCompositeOp:
2744 {
2745 pixel=(double) QuantumRange*(Sca*Da+Dca*(1.0-Sa));
2746 break;
2747 }
2748 case BlendCompositeOp:
2749 {
2750 pixel=gamma*(source_dissolve*Sa*Sc+canvas_dissolve*Da*Dc);
2751 break;
2752 }
2753 case CopyCompositeOp:
2754 case ReplaceCompositeOp:
2755 {
2756 pixel=(double) QuantumRange*Sca;
2757 break;
2758 }
2759 case BlurCompositeOp:
2760 case DisplaceCompositeOp:
2761 case DistortCompositeOp:
2762 case SrcCompositeOp:
2763 {
2764 pixel=Sc;
2765 break;
2766 }
2767 case BumpmapCompositeOp:
2768 {
2769 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
2770 {
2771 pixel=Dc;
2772 break;
2773 }
2774 pixel=(QuantumScale*Si)*Dc;
2775 break;
2776 }
2777 case ChangeMaskCompositeOp:
2778 {
2779 pixel=Dc;
2780 break;
2781 }
2782 case ClearCompositeOp:
2783 {
2784 pixel=0.0;
2785 break;
2786 }
2787 case ColorBurnCompositeOp:
2788 {
2789 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
2790 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
2791 if (S <= 0.0)
2792 blend=0.0;
2793 else
2794 blend=1.0-(1.0-D)/S;
2795 pixel=(double) QuantumRange*gamma*RoundToUnity(Sa*Da*
2796 RoundToUnity(blend)+Sa*(1.0-Da)*S+Da*(1.0-Sa)*D);
2797 break;
2798 }
2799 case ColorDodgeCompositeOp:
2800 {
2801 if (Sa > 0.0)
2802 S=RoundToUnity(Sca/Sa);
2803 else
2804 S=0.0;
2805 if (Da > 0.0)
2806 D=RoundToUnity(Dca/Da);
2807 else
2808 D=0.0;
2809 if (S >= 1.0)
2810 blend=1.0;
2811 else
2812 if (D <= 0.0)
2813 blend=0.0;
2814 else
2815 {
2816 if ((1.0-S) <= 0.0)
2817 blend=1.0;
2818 else
2819 blend=MagickMin(1.0,D/(1.0-S));
2820 }
2821 pixel=(double) QuantumRange*gamma*(Sa*Da*blend+Sca*(1.0-Da)+Dca*
2822 (1.0-Sa));
2823 break;
2824 }
2825 case ColorizeCompositeOp:
2826 {
2827 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
2828 {
2829 pixel=Dc;
2830 break;
2831 }
2832 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
2833 {
2834 pixel=Sc;
2835 break;
2836 }
2837 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
2838 (double) canvas_pixel.green,(double) canvas_pixel.blue,
2839 white_luminance,illuminant,&sans,&sans,&luma);
2840 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
2841 (double) source_pixel.green,(double) source_pixel.blue,
2842 white_luminance,illuminant,&hue,&chroma,&sans);
2843 ConvertGenericToRGB(colorspace,hue,chroma,luma,
2844 white_luminance,illuminant,&red,&green,&blue);
2845 switch (channel)
2846 {
2847 case RedPixelChannel: pixel=red; break;
2848 case GreenPixelChannel: pixel=green; break;
2849 case BluePixelChannel: pixel=blue; break;
2850 default: pixel=Dc; break;
2851 }
2852 break;
2853 }
2854 case CopyAlphaCompositeOp:
2855 case DstCompositeOp:
2856 {
2857 pixel=Dc;
2858 break;
2859 }
2860 case CopyBlackCompositeOp:
2861 {
2862 if (channel == BlackPixelChannel)
2863 pixel=(MagickRealType) GetPixelBlack(source_image,p);
2864 break;
2865 }
2866 case CopyBlueCompositeOp:
2867 case CopyYellowCompositeOp:
2868 {
2869 if (channel == BluePixelChannel)
2870 pixel=(MagickRealType) GetPixelBlue(source_image,p);
2871 break;
2872 }
2873 case CopyGreenCompositeOp:
2874 case CopyMagentaCompositeOp:
2875 {
2876 if (channel == GreenPixelChannel)
2877 pixel=(MagickRealType) GetPixelGreen(source_image,p);
2878 break;
2879 }
2880 case CopyRedCompositeOp:
2881 case CopyCyanCompositeOp:
2882 {
2883 if (channel == RedPixelChannel)
2884 pixel=(MagickRealType) GetPixelRed(source_image,p);
2885 break;
2886 }
2887 case DarkenCompositeOp:
2888 {
2889 if (compose_sync == MagickFalse)
2890 {
2891 pixel=RoundToUnity(MagickMin(Sca,Dca)+Sca*(1.0-Da)+Dca*
2892 (1.0-Sa));
2893 break;
2894 }
2895 pixel=(double) QuantumRange*RoundToUnity(MagickMin(Sca,Dca)+Sca*
2896 (1.0-Da)+Dca*(1.0-Sa));
2897 break;
2898 }
2899 case DarkenIntensityCompositeOp:
2900 {
2901 if (compose_sync == MagickFalse)
2902 {
2903 pixel=RoundToUnity(MagickMin(Sca,Dca)+Sca*(1.0-Di)+Dca*
2904 (1.0-Si));
2905 break;
2906 }
2907 pixel=(double) QuantumRange*RoundToUnity(MagickMin(Sca,Dca)+Sca*
2908 (1.0-Di)+Dca*(1.0-Si));
2909 break;
2910 }
2911 case DifferenceCompositeOp:
2912 {
2913 if (compose_sync == MagickFalse)
2914 {
2915 pixel=(double) QuantumRange*RoundToUnity(fabs((double) Sc-
2916 (double) Dc));
2917 break;
2918 }
2919 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
2920 D=(Da > 0.0) ? (Dca/Da) : 0.0;
2921 pixel=(double) QuantumRange*RoundToUnity(fabs(S-D));
2922 break;
2923 }
2924 case DissolveCompositeOp:
2925 {
2926 pixel=gamma*(source_dissolve*Sa*Sc-source_dissolve*Sa*
2927 canvas_dissolve*Da*Dc+canvas_dissolve*Da*Dc);
2928 break;
2929 }
2930 case DivideDstCompositeOp:
2931 {
2932 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
2933 D=(Da > 0.0) ? (Dca/Da) : 0.0;
2934 if (S <= 0.0)
2935 blend=1.0;
2936 else
2937 blend=MagickMin(1.0,D/S);
2938 pixel=(double) QuantumRange*RoundToUnity(Sca*(1.0-Da)+Dca*(1.0-Sa)+
2939 Sa*Da*blend);
2940 break;
2941 }
2942 case DivideSrcCompositeOp:
2943 {
2944 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
2945 D=(Da > 0.0) ? (Dca/Da) : 0.0;
2946 if (D <= 0.0)
2947 blend=1.0;
2948 else
2949 blend=MagickMin(1.0,S/D);
2950 pixel=(double) QuantumRange*RoundToUnity(Sca*(1.0-Da)+Dca*(1.0-Sa)+
2951 Sa*Da*blend);
2952 break;
2953 }
2954 case DstAtopCompositeOp:
2955 {
2956 pixel=(double) QuantumRange*(Dca*Sa+Sca*(1.0-Da));
2957 break;
2958 }
2959 case DstInCompositeOp:
2960 {
2961 pixel=(double) QuantumRange*gamma*(Dca*Sa);
2962 break;
2963 }
2964 case DstOutCompositeOp:
2965 {
2966 pixel=(double) QuantumRange*gamma*(Dca*(1.0-Sa));
2967 break;
2968 }
2969 case DstOverCompositeOp:
2970 {
2971 pixel=(double) QuantumRange*gamma*(Dca+Sca*(1.0-Da));
2972 break;
2973 }
2974 case ExclusionCompositeOp:
2975 {
2976 S=(Sa > 0.0) ? Sca/Sa : 0.0;
2977 D=(Da > 0.0) ? Dca/Da : 0.0;
2978 blend=RoundToUnity(S+D-2.0*S*D);
2979 pixel=(double) QuantumRange*RoundToUnity((blend*Sa+D*(1.0-Sa))*
2980 (Sa+Da-Sa*Da));
2981 break;
2982 }
2983 case FreezeCompositeOp:
2984 {
2985 if (Dca != 0.0)
2986 blend=1.0-(1.0-Sca)*(1.0-Sca)/Dca;
2987 else
2988 blend=0.0;
2989 pixel=(double) QuantumRange*gamma*RoundToUnity(blend);
2990 break;
2991 }
2992 case HardLightCompositeOp:
2993 {
2994 D=(Da > 0.0) ? (Dca/Da) : 0.0;
2995 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
2996 if (S <= 0.5)
2997 blend=2.0*S*D;
2998 else
2999 blend=1.0-2.0*(1.0-S)*(1.0-D);
3000 pixel=(double) QuantumRange*gamma*RoundToUnity((1.0-Da)*Sca+
3001 (1.0-Sa)*Dca+blend*Sa*Da);
3002 break;
3003 }
3004 case HardMixCompositeOp:
3005 {
3006 if (Sca < 0.5)
3007 {
3008 if ((2.0*Sca) == 0.0)
3009 blend=0.0;
3010 else
3011 blend=1.0-(1.0-Dca)/(2.0*Sca);
3012 }
3013 else
3014 {
3015 if ((1.0-((2.0*Sca)-1.0)) == 0.0)
3016 blend=1.0;
3017 else
3018 blend=Dca/(1.0-(2.0*Sca-1.0));
3019 }
3020 pixel=gamma*((blend < 0.5) ? 0.0 : (double) QuantumRange);
3021 break;
3022 }
3023 case HueCompositeOp:
3024 {
3025 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3026 {
3027 pixel=Dc;
3028 break;
3029 }
3030 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3031 {
3032 pixel=Sc;
3033 break;
3034 }
3035 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3036 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3037 white_luminance,illuminant,&hue,&chroma,&luma);
3038 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
3039 (double) source_pixel.green,(double) source_pixel.blue,
3040 white_luminance,illuminant,&hue,&sans,&sans);
3041 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3042 white_luminance,illuminant,&red,&green,&blue);
3043 switch (channel)
3044 {
3045 case RedPixelChannel: pixel=red; break;
3046 case GreenPixelChannel: pixel=green; break;
3047 case BluePixelChannel: pixel=blue; break;
3048 default: pixel=Dc; break;
3049 }
3050 break;
3051 }
3052 case InCompositeOp:
3053 case SrcInCompositeOp:
3054 {
3055 pixel=(double) QuantumRange*(Sca*Da);
3056 break;
3057 }
3058 case InterpolateCompositeOp:
3059 {
3060 pixel=(double) QuantumRange*(0.5-0.25*cos(MagickPI*Sca)-0.25*
3061 cos(MagickPI*Dca));
3062 break;
3063 }
3064 case LinearBurnCompositeOp:
3065 {
3066 /*
3067 LinearBurn: as defined by Abode Photoshop, according to
3068 http://www.simplefilter.de/en/basics/mixmods.html is:
3069
3070 f(Sc,Dc) = Sc + Dc - 1
3071 */
3072 pixel=(double) QuantumRange*(Sca+Dca-Sa*Da);
3073 break;
3074 }
3075 case LinearDodgeCompositeOp:
3076 {
3077 pixel=gamma*(Sa*Sc+Da*Dc);
3078 break;
3079 }
3080 case LinearLightCompositeOp:
3081 {
3082 /*
3083 Linear Light (Adobe standard):
3084 f(Sc, Dc) = Dc + 2*Sc - 1
3085 Applied in linear (HDRI) space with clamping.
3086 */
3087 D=(Da > 0.0) ? Dca/Da : 0.0,
3088 S=(Sa > 0.0) ? Sca/Sa : 0.0;
3089 pixel=(double) QuantumRange*gamma*(RoundToUnity(D+2.0*S-1.0)*Da);
3090 break;
3091 }
3092 case LightenCompositeOp:
3093 {
3094 if (compose_sync == MagickFalse)
3095 {
3096 pixel=MagickMax(Sc,Dc);
3097 break;
3098 }
3099 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
3100 D=(Da > 0.0) ? (Dca/Da) : 0.0;
3101 pixel=(double) QuantumRange*RoundToUnity(Sca*(1.0-Da)+Dca*(1.0-Sa)+
3102 MagickMax(S,D)*Sa*Da);
3103 break;
3104 }
3105 case LightenIntensityCompositeOp:
3106 {
3107 pixel=Si > Di ? Sc : Dc;
3108 break;
3109 }
3110 case LuminizeCompositeOp:
3111 {
3112 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3113 {
3114 pixel=Dc;
3115 break;
3116 }
3117 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3118 {
3119 pixel=Sc;
3120 break;
3121 }
3122 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3123 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3124 white_luminance,illuminant,&hue,&chroma,&luma);
3125 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
3126 (double) source_pixel.green,(double) source_pixel.blue,
3127 white_luminance,illuminant,&sans,&sans,&luma);
3128 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3129 white_luminance,illuminant,&red,&green,&blue);
3130 switch (channel)
3131 {
3132 case RedPixelChannel: pixel=red; break;
3133 case GreenPixelChannel: pixel=green; break;
3134 case BluePixelChannel: pixel=blue; break;
3135 default: pixel=Dc; break;
3136 }
3137 break;
3138 }
3139 case MathematicsCompositeOp:
3140 {
3141 /*
3142 'Mathematics' a free form user control mathematical composition
3143 is defined as...
3144
3145 f(Sc,Dc) = A*Sc*Dc + B*Sc + C*Dc + D
3146
3147 Where the arguments A,B,C,D are (currently) passed to composite
3148 as a command separated 'geometry' string in "compose:args" image
3149 artifact.
3150
3151 A = a->rho, B = a->sigma, C = a->xi, D = a->psi
3152
3153 Applying the SVG transparency formula (see above), we get...
3154
3155 Dca' = Sa*Da*f(Sc,Dc) + Sca*(1.0-Da) + Dca*(1.0-Sa)
3156
3157 Dca' = A*Sca*Dca + B*Sca*Da + C*Dca*Sa + D*Sa*Da + Sca*(1.0-Da) +
3158 Dca*(1.0-Sa)
3159 */
3160 if (compose_sync == MagickFalse)
3161 {
3162 pixel=geometry_info.rho*Sc*Dc+geometry_info.sigma*Sc+
3163 geometry_info.xi*Dc+geometry_info.psi;
3164 break;
3165 }
3166 pixel=(double) QuantumRange*gamma*(geometry_info.rho*Sca*Dca+
3167 geometry_info.sigma*Sca*Da+geometry_info.xi*Dca*Sa+
3168 geometry_info.psi*Sa*Da+Sca*(1.0-Da)+Dca*(1.0-Sa));
3169 break;
3170 }
3171 case MinusDstCompositeOp:
3172 {
3173 if (compose_sync == MagickFalse)
3174 {
3175 pixel=Dc-Sc;
3176 break;
3177 }
3178 pixel=gamma*(Sa*Sc+Da*Dc-2.0*Da*Dc*Sa);
3179 break;
3180 }
3181 case MinusSrcCompositeOp:
3182 {
3183 if (compose_sync == MagickFalse)
3184 {
3185 pixel=Sc-Dc;
3186 break;
3187 }
3188 pixel=gamma*(Da*Dc+Sa*Sc-2.0*Sa*Sc*Da);
3189 break;
3190 }
3191 case ModulateCompositeOp:
3192 {
3193 ssize_t
3194 offset;
3195
3196 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3197 {
3198 pixel=Dc;
3199 break;
3200 }
3201 offset=(ssize_t) (Si-midpoint);
3202 if (offset == 0)
3203 {
3204 pixel=Dc;
3205 break;
3206 }
3207 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3208 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3209 white_luminance,illuminant,&hue,&chroma,&luma);
3210 luma+=(0.01*percent_luma*offset)/midpoint;
3211 chroma*=0.01*percent_chroma;
3212 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3213 white_luminance,illuminant,&red,&green,&blue);
3214 switch (channel)
3215 {
3216 case RedPixelChannel: pixel=red; break;
3217 case GreenPixelChannel: pixel=green; break;
3218 case BluePixelChannel: pixel=blue; break;
3219 default: pixel=Dc; break;
3220 }
3221 break;
3222 }
3223 case ModulusAddCompositeOp:
3224 {
3225 if (compose_sync == MagickFalse)
3226 {
3227 pixel=(Quantum) QuantumRange*((Sc+Dc)-floor(Sc+Dc));
3228 break;
3229 }
3230 pixel=(Quantum) QuantumRange*((Sca+Dca)-floor(Sca+Dca));
3231 break;
3232 }
3233 case ModulusSubtractCompositeOp:
3234 {
3235 if (compose_sync == MagickFalse)
3236 {
3237 pixel=(Quantum) QuantumRange*((Sc-Dc)-floor(Sc-Dc));
3238 break;
3239 }
3240 pixel=(Quantum) QuantumRange*((Sca-Dca)-floor(Sca-Dca));
3241 break;
3242 }
3243 case MultiplyCompositeOp:
3244 {
3245 if (compose_sync == MagickFalse)
3246 {
3247 pixel=(double) QuantumRange*Sc*Dc;
3248 break;
3249 }
3250 pixel=(double) QuantumRange*(Sca*Dca+Sca*(1.0-Da)+Dca*(1.0-Sa));
3251 break;
3252 }
3253 case NegateCompositeOp:
3254 {
3255 D=(Da > 0.0) ? Dca/Da : 0.0;
3256 S=(Sa > 0.0) ? Sca/Sa : 0.0;
3257 pixel=(double) QuantumRange*((1.0-fabs(1.0-S-D))*Da);
3258 break;
3259 }
3260 case NoCompositeOp:
3261 {
3262 pixel=(double) QuantumRange*Dca;
3263 break;
3264 }
3265 case OutCompositeOp:
3266 case SrcOutCompositeOp:
3267 {
3268 pixel=(double) QuantumRange*(Sca*(1.0-Da));
3269 break;
3270 }
3271 case OverCompositeOp:
3272 case SrcOverCompositeOp:
3273 {
3274 if ((Sa+Da*(1.0-Sa)) <= MagickEpsilon)
3275 pixel=0.0;
3276 else
3277 pixel=(double) QuantumRange*gamma*((Sca+Dca*(1.0-Sa))/
3278 (Sa+Da*(1.0-Sa)));
3279 break;
3280 }
3281 case OverlayCompositeOp:
3282 {
3283 if ((2.0*Dca) < Da)
3284 {
3285 pixel=(double) QuantumRange*gamma*(2.0*Dca*Sca+Dca*(1.0-Sa)+
3286 Sca*(1.0-Da));
3287 break;
3288 }
3289 pixel=(double) QuantumRange*gamma*(Da*Sa-2.0*(Sa-Sca)*(Da-Dca)+Dca*
3290 (1.0-Sa)+Sca*(1.0-Da));
3291 break;
3292 }
3293 case PegtopLightCompositeOp:
3294 {
3295 if (fabs((double) Da) < MagickEpsilon)
3296 {
3297 pixel=(double) QuantumRange*gamma*Sca;
3298 break;
3299 }
3300 if (RoundToUnity(Sca) <= 0.5)
3301 blend=RoundToUnity(Dca/Da)-(1.0-2.0*RoundToUnity(Sca))*
3302 RoundToUnity(Dca/Da)*(1.0-RoundToUnity(Dca/Da));
3303 else
3304 {
3305 if (RoundToUnity(Dca/Da) <= 0.25)
3306 blend=((16.0*RoundToUnity(Dca/Da)-12.0)*RoundToUnity(Dca/Da)+
3307 4.0)*RoundToUnity(Dca/Da);
3308 else
3309 blend=sqrt(RoundToUnity(Dca/Da));
3310 blend=RoundToUnity(Dca/Da)+(2.0*RoundToUnity(Sca)-1.0)*
3311 (blend-RoundToUnity(Dca/Da));
3312 }
3313 pixel=(double) QuantumRange*gamma*(RoundToUnity(blend)*Da*Sa+Dca*
3314 (1.0-Sa));
3315 break;
3316 }
3317 case PinLightCompositeOp:
3318 {
3319 /*
3320 Adobe Pin Light (colors in [0,1]):
3321
3322 if (Cs <= 0.5)
3323 f = min(Cd, 2*Cs);
3324 else
3325 f = max(Cd, 2*Cs - 1);
3326 */
3327 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3328 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3329 if (S <= 0.5)
3330 blend=MagickMin(D,2.0*S);
3331 else
3332 blend=MagickMax(D,2.0*S-1.0);
3333 pixel=(double) QuantumRange*gamma*(blend*RoundToUnity(Sa+Da-Sa*Da));
3334 break;
3335 }
3336 case PlusCompositeOp:
3337 {
3338 D=(Da > 0.0) ? Dca/Da : 0.0;
3339 S=(Sa > 0.0) ? Sca/Sa : 0.0;
3340 pixel=(double) QuantumRange*(RoundToUnity(Sa+Da-Sa*Da)*
3341 RoundToUnity(S+D));
3342 break;
3343 }
3344 case ReflectCompositeOp:
3345 {
3346 if (compose_sync == MagickFalse)
3347 {
3348 if (Dc < 1.0)
3349 blend=(Sc*Sc)/(1.0-Dc);
3350 else
3351 blend=1.0;
3352 pixel=(double) QuantumRange*RoundToUnity(blend);
3353 break;
3354 }
3355 if (Sa > 0.0)
3356 S=Sca/Sa;
3357 else
3358 S=0.0;
3359 if (Da > 0.0)
3360 D=Dca/Da;
3361 else
3362 D=0.0;
3363 if (D < 1.0)
3364 blend=(S*S)/(1.0-D);
3365 else
3366 blend=1.0;
3367 pixel=(double) QuantumRange*RoundToUnity((Sa+Da-Sa*Da)*blend);
3368 break;
3369 }
3370 case RMSECompositeOp:
3371 {
3372 double
3373 gray;
3374
3375 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3376 {
3377 pixel=Dc;
3378 break;
3379 }
3380 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3381 {
3382 pixel=Sc;
3383 break;
3384 }
3385 gray=sqrt(
3386 (canvas_pixel.red-source_pixel.red)*
3387 (canvas_pixel.red-source_pixel.red)+
3388 (canvas_pixel.green-source_pixel.green)*
3389 (canvas_pixel.green-source_pixel.green)+
3390 (canvas_pixel.blue-source_pixel.blue)*
3391 (canvas_pixel.blue-source_pixel.blue)/3.0);
3392 switch (channel)
3393 {
3394 case RedPixelChannel: pixel=gray; break;
3395 case GreenPixelChannel: pixel=gray; break;
3396 case BluePixelChannel: pixel=gray; break;
3397 default: pixel=Dc; break;
3398 }
3399 break;
3400 }
3401 case SaturateCompositeOp:
3402 {
3403 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3404 {
3405 pixel=Dc;
3406 break;
3407 }
3408 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3409 {
3410 pixel=Sc;
3411 break;
3412 }
3413 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3414 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3415 white_luminance,illuminant,&hue,&chroma,&luma);
3416 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
3417 (double) source_pixel.green,(double) source_pixel.blue,
3418 white_luminance,illuminant,&sans,&chroma,&sans);
3419 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3420 white_luminance,illuminant,&red,&green,&blue);
3421 switch (channel)
3422 {
3423 case RedPixelChannel: pixel=red; break;
3424 case GreenPixelChannel: pixel=green; break;
3425 case BluePixelChannel: pixel=blue; break;
3426 default: pixel=Dc; break;
3427 }
3428 break;
3429 }
3430 case ScreenCompositeOp:
3431 {
3432 if (compose_sync == MagickFalse)
3433 {
3434 pixel=(double) QuantumRange*RoundToUnity(Sc+Dc-Sc*Dc);
3435 break;
3436 }
3437 if (Sa > 0.0)
3438 S=Sca/Sa;
3439 else
3440 S=0.0;
3441 if (Da > 0.0)
3442 D=Dca/Da;
3443 else
3444 D=0.0;
3445 if ((Sa+Da-Sa*Da) > 0.0)
3446 pixel=(double) QuantumRange*RoundToUnity((Sa+Da-Sa*Da)*(S+D-S*D));
3447 else
3448 pixel=0.0;
3449 break;
3450 }
3451 case SoftBurnCompositeOp:
3452 {
3453 if (RoundToUnity(Dca) <= 0.0)
3454 blend = 0.0;
3455 else
3456 if (RoundToUnity(Sca) >= 1.0)
3457 blend = 1.0;
3458 else
3459 blend=1.0-MagickMin(1.0,(1.0-RoundToUnity(Dca))/
3460 RoundToUnity(Sca));
3461 pixel=(double) QuantumRange*gamma*RoundToUnity(blend);
3462 break;
3463 }
3464 case SoftDodgeCompositeOp:
3465 {
3466 if (RoundToUnity(Sca) <= 0.0)
3467 blend=RoundToUnity(Dca);
3468 else
3469 if (RoundToUnity(Dca) >= 1.0)
3470 blend=1.0;
3471 else
3472 blend=MagickMin(1.0,RoundToUnity(Dca)/(1.0-RoundToUnity(Sca)));
3473 pixel=(double) QuantumRange*gamma*RoundToUnity(blend);
3474 break;
3475 }
3476 case SoftLightCompositeOp:
3477 {
3478 if (RoundToUnity(Sca) <= 0.5)
3479 {
3480 pixel=(double) QuantumRange*gamma*(RoundToUnity(Dca)*Sa+Da*
3481 (RoundToUnity(Dca)-(1.0-2.0*RoundToUnity(Sca))*
3482 RoundToUnity(Dca)*(1.0-RoundToUnity(Dca)))+RoundToUnity(Sca)*
3483 (1.0-Da)+RoundToUnity(Dca)*(1.0-Sa));
3484 break;
3485 }
3486 if (RoundToUnity(Dca) > 0.25)
3487 blend=sqrt(RoundToUnity(Dca));
3488 else
3489 blend=((16.0*RoundToUnity(Dca)-12.0)*RoundToUnity(Dca)+4.0)*
3490 RoundToUnity(Dca);
3491 pixel=(double) QuantumRange*gamma*(RoundToUnity(Dca)*Sa+Da*
3492 (RoundToUnity(Dca)+(2.0*RoundToUnity(Sca)-1.0)*
3493 (RoundToUnity(blend)-RoundToUnity(Dca)))+RoundToUnity(Sca)*
3494 (1.0-Da)+RoundToUnity(Dca)*(1.0-Sa));
3495 break;
3496 }
3497 case StampCompositeOp:
3498 {
3499 pixel=(double) QuantumRange*RoundToUnity(Sca+Dca-1.0);
3500 break;
3501 }
3502 case StereoCompositeOp:
3503 {
3504 if (channel == RedPixelChannel)
3505 pixel=(MagickRealType) GetPixelRed(source_image,p);
3506 break;
3507 }
3508 case ThresholdCompositeOp:
3509 {
3510 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
3511 D=(Da > 0.0) ? (Dca/Da) : 0.0;
3512 if (fabs(2.0*(S-D)) < threshold)
3513 blend=D;
3514 else
3515 blend=D+(S-D)*amount;
3516 pixel=(double) QuantumRange*(Sa*Da*RoundToUnity(blend)+Sca*
3517 (1.0-Da)+Dca*(1.0-Sa));
3518 break;
3519 }
3520 case VividLightCompositeOp:
3521 {
3522 if ((fabs((double) Sa) < MagickEpsilon) ||
3523 (fabs((double) Da) < MagickEpsilon))
3524 {
3525 pixel=(double) QuantumRange*gamma*(Sa*Da+Sca*(1.0-Da)+Dca*
3526 (1.0-Sa));
3527 break;
3528 }
3529 if (RoundToUnity(Sca/Sa) <= 0.0)
3530 blend=0.0;
3531 else
3532 if (RoundToUnity(Sca/Sa) < 0.5)
3533 blend=1.0-(1.0-RoundToUnity(Dca/Da))/(2.0*RoundToUnity(Sca/Sa));
3534 else
3535 if (RoundToUnity(Sca/Sa) < 1.0)
3536 blend=RoundToUnity(Dca/Da)/(2.0*(1.0-RoundToUnity(Sca/Sa)));
3537 else
3538 blend=1.0;
3539 pixel=(double) QuantumRange*gamma*(Sa*Da*RoundToUnity(blend)+Sca*
3540 (1.0-Da)+Dca*(1.0-Sa));
3541 break;
3542 }
3543 case XorCompositeOp:
3544 {
3545 pixel=(double) QuantumRange*(Sca*(1.0-Da)+Dca*(1.0-Sa));
3546 break;
3547 }
3548 default:
3549 {
3550 pixel=Sc;
3551 break;
3552 }
3553 }
3554 q[i]=clamp != MagickFalse ? ClampPixel(pixel) : ClampToQuantum(pixel);
3555 }
3556 p+=(ptrdiff_t) GetPixelChannels(source_image);
3557 channels=GetPixelChannels(source_image);
3558 if (p >= (pixels+channels*source_image->columns))
3559 p=pixels;
3560 q+=(ptrdiff_t) GetPixelChannels(image);
3561 }
3562 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3563 status=MagickFalse;
3564 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3565 {
3566 MagickBooleanType
3567 proceed;
3568
3569#if defined(MAGICKCORE_OPENMP_SUPPORT)
3570 #pragma omp atomic
3571#endif
3572 progress++;
3573 proceed=SetImageProgress(image,CompositeImageTag,progress,image->rows);
3574 if (proceed == MagickFalse)
3575 status=MagickFalse;
3576 }
3577 }
3578 source_view=DestroyCacheView(source_view);
3579 image_view=DestroyCacheView(image_view);
3580 if (canvas_image != (Image * ) NULL)
3581 canvas_image=DestroyImage(canvas_image);
3582 else
3583 source_image=DestroyImage(source_image);
3584 return(status);
3585}
3586␌
3587/*
3588%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3589% %
3590% %
3591% %
3592% T e x t u r e I m a g e %
3593% %
3594% %
3595% %
3596%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3597%
3598% TextureImage() repeatedly tiles the texture image across and down the image
3599% canvas.
3600%
3601% The format of the TextureImage method is:
3602%
3603% MagickBooleanType TextureImage(Image *image,const Image *texture,
3604% ExceptionInfo *exception)
3605%
3606% A description of each parameter follows:
3607%
3608% o image: the image.
3609%
3610% o texture_image: This image is the texture to layer on the background.
3611%
3612*/
3613MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
3614 ExceptionInfo *exception)
3615{
3616#define TextureImageTag "Texture/Image"
3617
3618 CacheView
3619 *image_view,
3620 *texture_view;
3621
3622 Image
3623 *texture_image;
3624
3625 MagickBooleanType
3626 status;
3627
3628 ssize_t
3629 y;
3630
3631 assert(image != (Image *) NULL);
3632 assert(image->signature == MagickCoreSignature);
3633 if (IsEventLogging() != MagickFalse)
3634 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3635 if (texture == (const Image *) NULL)
3636 return(MagickFalse);
3637 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
3638 return(MagickFalse);
3639 texture_image=CloneImage(texture,0,0,MagickTrue,exception);
3640 if (texture_image == (const Image *) NULL)
3641 return(MagickFalse);
3642 (void) TransformImageColorspace(texture_image,image->colorspace,exception);
3643 (void) SetImageVirtualPixelMethod(texture_image,TileVirtualPixelMethod,
3644 exception);
3645 status=MagickTrue;
3646 if ((image->compose != CopyCompositeOp) &&
3647 ((image->compose != OverCompositeOp) ||
3648 (image->alpha_trait != UndefinedPixelTrait) ||
3649 (texture_image->alpha_trait != UndefinedPixelTrait)))
3650 {
3651 /*
3652 Tile texture onto the image background.
3653 */
3654 for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) texture_image->rows)
3655 {
3656 ssize_t
3657 x;
3658
3659 if (status == MagickFalse)
3660 continue;
3661 for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) texture_image->columns)
3662 {
3663 MagickBooleanType
3664 thread_status;
3665
3666 thread_status=CompositeImage(image,texture_image,image->compose,
3667 MagickTrue,x+texture_image->tile_offset.x,y+
3668 texture_image->tile_offset.y,exception);
3669 if (thread_status == MagickFalse)
3670 {
3671 status=thread_status;
3672 break;
3673 }
3674 }
3675 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3676 {
3677 MagickBooleanType
3678 proceed;
3679
3680 proceed=SetImageProgress(image,TextureImageTag,(MagickOffsetType) y,
3681 image->rows);
3682 if (proceed == MagickFalse)
3683 status=MagickFalse;
3684 }
3685 }
3686 (void) SetImageProgress(image,TextureImageTag,(MagickOffsetType)
3687 image->rows,image->rows);
3688 texture_image=DestroyImage(texture_image);
3689 return(status);
3690 }
3691 /*
3692 Tile texture onto the image background (optimized).
3693 */
3694 status=MagickTrue;
3695 texture_view=AcquireVirtualCacheView(texture_image,exception);
3696 image_view=AcquireAuthenticCacheView(image,exception);
3697#if defined(MAGICKCORE_OPENMP_SUPPORT)
3698 #pragma omp parallel for schedule(static) shared(status) \
3699 magick_number_threads(texture_image,image,image->rows,2)
3700#endif
3701 for (y=0; y < (ssize_t) image->rows; y++)
3702 {
3703 MagickBooleanType
3704 sync;
3705
3706 const Quantum
3707 *p,
3708 *pixels;
3709
3710 ssize_t
3711 x;
3712
3713 Quantum
3714 *q;
3715
3716 size_t
3717 width;
3718
3719 if (status == MagickFalse)
3720 continue;
3721 pixels=GetCacheViewVirtualPixels(texture_view,texture_image->tile_offset.x,
3722 (y+texture_image->tile_offset.y) % (ssize_t) texture_image->rows,
3723 texture_image->columns,1,exception);
3724 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3725 if ((pixels == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3726 {
3727 status=MagickFalse;
3728 continue;
3729 }
3730 for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) texture_image->columns)
3731 {
3732 ssize_t
3733 j;
3734
3735 p=pixels;
3736 width=texture_image->columns;
3737 if ((x+(ssize_t) width) > (ssize_t) image->columns)
3738 width=image->columns-(size_t) x;
3739 for (j=0; j < (ssize_t) width; j++)
3740 {
3741 ssize_t
3742 i;
3743
3744 for (i=0; i < (ssize_t) GetPixelChannels(texture_image); i++)
3745 {
3746 PixelChannel channel = GetPixelChannelChannel(texture_image,i);
3747 PixelTrait traits = GetPixelChannelTraits(image,channel);
3748 PixelTrait texture_traits=GetPixelChannelTraits(texture_image,
3749 channel);
3750 if ((traits == UndefinedPixelTrait) ||
3751 (texture_traits == UndefinedPixelTrait))
3752 continue;
3753 SetPixelChannel(image,channel,p[i],q);
3754 }
3755 p+=(ptrdiff_t) GetPixelChannels(texture_image);
3756 q+=(ptrdiff_t) GetPixelChannels(image);
3757 }
3758 }
3759 sync=SyncCacheViewAuthenticPixels(image_view,exception);
3760 if (sync == MagickFalse)
3761 status=MagickFalse;
3762 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3763 {
3764 MagickBooleanType
3765 proceed;
3766
3767 proceed=SetImageProgress(image,TextureImageTag,(MagickOffsetType) y,
3768 image->rows);
3769 if (proceed == MagickFalse)
3770 status=MagickFalse;
3771 }
3772 }
3773 texture_view=DestroyCacheView(texture_view);
3774 image_view=DestroyCacheView(image_view);
3775 texture_image=DestroyImage(texture_image);
3776 return(status);
3777}