MagickCore 7.1.2-28
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 if (source_image->alpha_trait == UndefinedPixelTrait)
2596 pixel=Si;
2597 else
2598 pixel=(double) QuantumRange*Sa;
2599 break;
2600 }
2601 case BlurCompositeOp:
2602 case CopyCompositeOp:
2603 case DisplaceCompositeOp:
2604 case DistortCompositeOp:
2605 case DstAtopCompositeOp:
2606 case ReplaceCompositeOp:
2607 case SrcCompositeOp:
2608 {
2609 pixel=(double) QuantumRange*Sa;
2610 break;
2611 }
2612 case DarkenIntensityCompositeOp:
2613 {
2614 if (compose_sync == MagickFalse)
2615 {
2616 pixel=Si < Di ? Sa : Da;
2617 break;
2618 }
2619 pixel=Sa*Si < Da*Di ? Sa : Da;
2620 break;
2621 }
2622 case DifferenceCompositeOp:
2623 {
2624 pixel=(double) QuantumRange*fabs((double) (Sa-Da));
2625 break;
2626 }
2627 case FreezeCompositeOp:
2628 {
2629 pixel=(double) QuantumRange*(1.0-(1.0-Sa)*(1.0-Sa)*
2630 MagickSafeReciprocal(Da));
2631 if (pixel < 0.0)
2632 pixel=0.0;
2633 break;
2634 }
2635 case InterpolateCompositeOp:
2636 {
2637 pixel=(double) QuantumRange*(0.5-0.25*cos(MagickPI*Sa)-0.25*
2638 cos(MagickPI*Da));
2639 break;
2640 }
2641 case LightenIntensityCompositeOp:
2642 {
2643 if (compose_sync == MagickFalse)
2644 {
2645 pixel=Si > Di ? Sa : Da;
2646 break;
2647 }
2648 pixel=Sa*Si > Da*Di ? Sa : Da;
2649 break;
2650 }
2651 case ModulateCompositeOp:
2652 {
2653 pixel=(double) QuantumRange*Da;
2654 break;
2655 }
2656 case MultiplyCompositeOp:
2657 {
2658 if (compose_sync == MagickFalse)
2659 {
2660 pixel=(double) QuantumRange*Sa*Da;
2661 break;
2662 }
2663 pixel=(double) QuantumRange*alpha;
2664 break;
2665 }
2666 case NegateCompositeOp:
2667 {
2668 pixel=(double) QuantumRange*((1.0-Sa-Da));
2669 break;
2670 }
2671 case ReflectCompositeOp:
2672 {
2673 pixel=(double) QuantumRange*(Sa*Sa*
2674 MagickSafeReciprocal(1.0-Da));
2675 if (pixel > (double) QuantumRange)
2676 pixel=(double) QuantumRange;
2677 break;
2678 }
2679 case StampCompositeOp:
2680 {
2681 pixel=(double) QuantumRange*(Sa+Da*Da-1.0);
2682 break;
2683 }
2684 case StereoCompositeOp:
2685 {
2686 pixel=(double) QuantumRange*(Sa+Da)/2;
2687 break;
2688 }
2689 default:
2690 {
2691 pixel=(double) QuantumRange*alpha;
2692 break;
2693 }
2694 }
2695 q[i]=clamp != MagickFalse ? ClampPixel(pixel) :
2696 ClampToQuantum(pixel);
2697 continue;
2698 }
2699 if (source_traits == UndefinedPixelTrait)
2700 continue;
2701 /*
2702 Sc: source color.
2703 Dc: canvas color.
2704 */
2705 Sc=(MagickRealType) GetPixelChannel(source_image,channel,p);
2706 Dc=(MagickRealType) q[i];
2707 if ((traits & CopyPixelTrait) != 0)
2708 {
2709 /*
2710 Copy channel.
2711 */
2712 q[i]=ClampToQuantum(Dc);
2713 continue;
2714 }
2715 /*
2716 Porter-Duff compositions:
2717 Sca: source normalized color multiplied by alpha.
2718 Dca: normalized canvas color multiplied by alpha.
2719 */
2720 Sca=QuantumScale*Sa*Sc;
2721 Dca=QuantumScale*Da*Dc;
2722 switch (compose)
2723 {
2724 case DarkenCompositeOp:
2725 case LightenCompositeOp:
2726 case ModulusSubtractCompositeOp:
2727 {
2728 gamma=MagickSafeReciprocal(1.0-alpha);
2729 break;
2730 }
2731 default:
2732 {
2733 gamma=MagickSafeReciprocal(alpha);
2734 break;
2735 }
2736 }
2737 pixel=Dc;
2738 switch (compose)
2739 {
2740 case AlphaCompositeOp:
2741 {
2742 pixel=(double) QuantumRange*Sa;
2743 break;
2744 }
2745 case AtopCompositeOp:
2746 case SrcAtopCompositeOp:
2747 {
2748 pixel=(double) QuantumRange*(Sca*Da+Dca*(1.0-Sa));
2749 break;
2750 }
2751 case BlendCompositeOp:
2752 {
2753 pixel=gamma*(source_dissolve*Sa*Sc+canvas_dissolve*Da*Dc);
2754 break;
2755 }
2756 case CopyCompositeOp:
2757 case ReplaceCompositeOp:
2758 {
2759 pixel=(double) QuantumRange*Sca;
2760 break;
2761 }
2762 case BlurCompositeOp:
2763 case DisplaceCompositeOp:
2764 case DistortCompositeOp:
2765 case SrcCompositeOp:
2766 {
2767 pixel=Sc;
2768 break;
2769 }
2770 case BumpmapCompositeOp:
2771 {
2772 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
2773 {
2774 pixel=Dc;
2775 break;
2776 }
2777 pixel=(QuantumScale*Si)*Dc;
2778 break;
2779 }
2780 case ChangeMaskCompositeOp:
2781 {
2782 pixel=Dc;
2783 break;
2784 }
2785 case ClearCompositeOp:
2786 {
2787 pixel=0.0;
2788 break;
2789 }
2790 case ColorBurnCompositeOp:
2791 {
2792 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
2793 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
2794 if (fabs(S) < MagickEpsilon)
2795 blend=0.0;
2796 else
2797 blend=MagickMin(1.0,MagickMax(0.0,1.0-(1.0-D)/S));
2798 pixel=(double) QuantumRange*gamma*RoundToUnity(Sa*Da*blend+Sa*
2799 (1.0-Da)*S+Da*(1.0-Sa)*D);
2800 break;
2801 }
2802 case ColorDodgeCompositeOp:
2803 {
2804 if (Sa > 0.0)
2805 S=RoundToUnity(Sca/Sa);
2806 else
2807 S=0.0;
2808 if (Da > 0.0)
2809 D=RoundToUnity(Dca/Da);
2810 else
2811 D=0.0;
2812 if (S >= 1.0)
2813 blend=1.0;
2814 else
2815 if (D <= 0.0)
2816 blend=0.0;
2817 else
2818 {
2819 if ((1.0-S) <= 0.0)
2820 blend=1.0;
2821 else
2822 blend=MagickMin(1.0,D/(1.0-S));
2823 }
2824 pixel=(double) QuantumRange*gamma*(Sa*Da*blend+Sca*(1.0-Da)+Dca*
2825 (1.0-Sa));
2826 break;
2827 }
2828 case ColorizeCompositeOp:
2829 {
2830 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
2831 {
2832 pixel=Dc;
2833 break;
2834 }
2835 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
2836 {
2837 pixel=Sc;
2838 break;
2839 }
2840 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
2841 (double) canvas_pixel.green,(double) canvas_pixel.blue,
2842 white_luminance,illuminant,&sans,&sans,&luma);
2843 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
2844 (double) source_pixel.green,(double) source_pixel.blue,
2845 white_luminance,illuminant,&hue,&chroma,&sans);
2846 ConvertGenericToRGB(colorspace,hue,chroma,luma,
2847 white_luminance,illuminant,&red,&green,&blue);
2848 switch (channel)
2849 {
2850 case RedPixelChannel: pixel=red; break;
2851 case GreenPixelChannel: pixel=green; break;
2852 case BluePixelChannel: pixel=blue; break;
2853 default: pixel=Dc; break;
2854 }
2855 break;
2856 }
2857 case CopyAlphaCompositeOp:
2858 case DstCompositeOp:
2859 {
2860 pixel=Dc;
2861 break;
2862 }
2863 case CopyBlackCompositeOp:
2864 {
2865 if (channel == BlackPixelChannel)
2866 pixel=(MagickRealType) GetPixelBlack(source_image,p);
2867 break;
2868 }
2869 case CopyBlueCompositeOp:
2870 case CopyYellowCompositeOp:
2871 {
2872 if (channel == BluePixelChannel)
2873 pixel=(MagickRealType) GetPixelBlue(source_image,p);
2874 break;
2875 }
2876 case CopyGreenCompositeOp:
2877 case CopyMagentaCompositeOp:
2878 {
2879 if (channel == GreenPixelChannel)
2880 pixel=(MagickRealType) GetPixelGreen(source_image,p);
2881 break;
2882 }
2883 case CopyRedCompositeOp:
2884 case CopyCyanCompositeOp:
2885 {
2886 if (channel == RedPixelChannel)
2887 pixel=(MagickRealType) GetPixelRed(source_image,p);
2888 break;
2889 }
2890 case DarkenCompositeOp:
2891 {
2892 if (compose_sync == MagickFalse)
2893 {
2894 pixel=RoundToUnity(MagickMin(Sca,Dca)+Sca*(1.0-Da)+Dca*
2895 (1.0-Sa));
2896 break;
2897 }
2898 pixel=(double) QuantumRange*RoundToUnity(MagickMin(Sca,Dca)+Sca*
2899 (1.0-Da)+Dca*(1.0-Sa));
2900 break;
2901 }
2902 case DarkenIntensityCompositeOp:
2903 {
2904 if (compose_sync == MagickFalse)
2905 {
2906 pixel=RoundToUnity(MagickMin(Sca,Dca)+Sca*(1.0-Di)+Dca*
2907 (1.0-Si));
2908 break;
2909 }
2910 pixel=(double) QuantumRange*RoundToUnity(MagickMin(Sca,Dca)+Sca*
2911 (1.0-Di)+Dca*(1.0-Si));
2912 break;
2913 }
2914 case DifferenceCompositeOp:
2915 {
2916 if (compose_sync == MagickFalse)
2917 {
2918 pixel=(double) QuantumRange*RoundToUnity(fabs((double) Sc-
2919 (double) Dc));
2920 break;
2921 }
2922 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
2923 D=(Da > 0.0) ? (Dca/Da) : 0.0;
2924 pixel=(double) QuantumRange*RoundToUnity(fabs(S-D));
2925 break;
2926 }
2927 case DissolveCompositeOp:
2928 {
2929 pixel=gamma*(source_dissolve*Sa*Sc-source_dissolve*Sa*
2930 canvas_dissolve*Da*Dc+canvas_dissolve*Da*Dc);
2931 break;
2932 }
2933 case DivideDstCompositeOp:
2934 {
2935 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
2936 D=(Da > 0.0) ? (Dca/Da) : 0.0;
2937 if (fabs(S) < MagickEpsilon)
2938 blend=1.0;
2939 else
2940 blend=RoundToUnity(D/S);
2941 pixel=(double) QuantumRange*RoundToUnity(Sca*(1.0-Da)+Dca*(1.0-Sa)+
2942 Sa*Da*blend);
2943 break;
2944 }
2945 case DivideSrcCompositeOp:
2946 {
2947 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
2948 D=(Da > 0.0) ? (Dca/Da) : 0.0;
2949 if (fabs(D) < MagickEpsilon)
2950 blend=1.0;
2951 else
2952 blend=RoundToUnity(S/D);
2953 pixel=(double) QuantumRange*RoundToUnity(Sca*(1.0-Da)+Dca*(1.0-Sa)+
2954 Sa*Da*blend);
2955 break;
2956 }
2957 case DstAtopCompositeOp:
2958 {
2959 pixel=(double) QuantumRange*(Dca*Sa+Sca*(1.0-Da));
2960 break;
2961 }
2962 case DstInCompositeOp:
2963 {
2964 pixel=(double) QuantumRange*gamma*(Dca*Sa);
2965 break;
2966 }
2967 case DstOutCompositeOp:
2968 {
2969 pixel=(double) QuantumRange*gamma*(Dca*(1.0-Sa));
2970 break;
2971 }
2972 case DstOverCompositeOp:
2973 {
2974 pixel=(double) QuantumRange*gamma*(Dca+Sca*(1.0-Da));
2975 break;
2976 }
2977 case ExclusionCompositeOp:
2978 {
2979 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
2980 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
2981 blend=RoundToUnity(S+D-2.0*S*D);
2982 pixel=(double) QuantumRange*RoundToUnity((blend*Sa+D*(1.0-Sa))*
2983 (Sa+Da-Sa*Da));
2984 break;
2985 }
2986 case FreezeCompositeOp:
2987 {
2988 if (Dca != 0.0)
2989 blend=1.0-(1.0-Sca)*(1.0-Sca)/Dca;
2990 else
2991 blend=0.0;
2992 pixel=(double) QuantumRange*gamma*RoundToUnity(blend);
2993 break;
2994 }
2995 case HardLightCompositeOp:
2996 {
2997 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
2998 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
2999 if (S <= 0.5)
3000 blend=2.0*S*D;
3001 else
3002 blend=1.0-2.0*(1.0-S)*(1.0-D);
3003 pixel=(double) QuantumRange*gamma*RoundToUnity((1.0-Da)*Sca+
3004 (1.0-Sa)*Dca+blend*Sa*Da);
3005 break;
3006 }
3007 case HardMixCompositeOp:
3008 {
3009 double
3010 hardmix,
3011 vivid;
3012
3013 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3014 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3015 if (S <= 0.5)
3016 {
3017 if (S <= MagickEpsilon)
3018 vivid=0.0;
3019 else
3020 vivid=1.0-(1.0-D)/(2.0*S);
3021 }
3022 else
3023 {
3024 if ((1.0-(2.0*S-1.0)) <= MagickEpsilon)
3025 vivid=1.0;
3026 else
3027 vivid=D/(1.0-(2.0*S-1.0));
3028 }
3029 hardmix=(vivid < 0.5) ? 0.0 : 1.0;
3030 pixel=(double) QuantumRange*gamma*RoundToUnity(Sa*Da*hardmix+Sca*
3031 (1.0-Da)+Dca*(1.0-Sa));
3032 break;
3033 }
3034 case HueCompositeOp:
3035 {
3036 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3037 {
3038 pixel=Dc;
3039 break;
3040 }
3041 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3042 {
3043 pixel=Sc;
3044 break;
3045 }
3046 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3047 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3048 white_luminance,illuminant,&hue,&chroma,&luma);
3049 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
3050 (double) source_pixel.green,(double) source_pixel.blue,
3051 white_luminance,illuminant,&hue,&sans,&sans);
3052 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3053 white_luminance,illuminant,&red,&green,&blue);
3054 switch (channel)
3055 {
3056 case RedPixelChannel: pixel=red; break;
3057 case GreenPixelChannel: pixel=green; break;
3058 case BluePixelChannel: pixel=blue; break;
3059 default: pixel=Dc; break;
3060 }
3061 break;
3062 }
3063 case InCompositeOp:
3064 case SrcInCompositeOp:
3065 {
3066 pixel=(double) QuantumRange*(Sca*Da);
3067 break;
3068 }
3069 case InterpolateCompositeOp:
3070 {
3071 pixel=(double) QuantumRange*(0.5-0.25*cos(MagickPI*Sca)-0.25*
3072 cos(MagickPI*Dca));
3073 break;
3074 }
3075 case LinearBurnCompositeOp:
3076 {
3077 /*
3078 LinearBurn: as defined by Abode Photoshop, according to
3079 http://www.simplefilter.de/en/basics/mixmods.html is:
3080
3081 f(Sc,Dc) = Sc + Dc - 1
3082 */
3083 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3084 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3085 blend=RoundToUnity(S+D-1.0);
3086 pixel=(double) QuantumRange*RoundToUnity(Sa*Da*blend+Sca*(1.0-Da)+
3087 Dca*(1.0-Sa));
3088 break;
3089 }
3090 case LinearDodgeCompositeOp:
3091 {
3092 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3093 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3094 blend=RoundToUnity(S+D);
3095 pixel=(double) QuantumRange*gamma*RoundToUnity(Sa*Da*blend+
3096 Sca*(1.0-Da)+Dca*(1.0-Sa));
3097 break;
3098 }
3099 case LinearLightCompositeOp:
3100 {
3101 /*
3102 Linear Light (Adobe standard):
3103 f(Sc, Dc) = Dc + 2*Sc - 1
3104 Applied in linear (HDRI) space with clamping.
3105 */
3106 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3107 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3108 blend=RoundToUnity(D+2.0*S-1.0);
3109 pixel=(double) QuantumRange*gamma*RoundToUnity(Sa*Da*blend+Sca*
3110 (1.0-Da)+Dca*(1.0-Sa));
3111 break;
3112 }
3113 case LightenCompositeOp:
3114 {
3115 if (compose_sync == MagickFalse)
3116 {
3117 pixel=MagickMax(Sc,Dc);
3118 break;
3119 }
3120 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3121 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3122 pixel=(double) QuantumRange*RoundToUnity(Sca*(1.0-Da)+Dca*(1.0-Sa)+
3123 MagickMax(S,D)*Sa*Da);
3124 break;
3125 }
3126 case LightenIntensityCompositeOp:
3127 {
3128 pixel=Si > Di ? Sc : Dc;
3129 break;
3130 }
3131 case LuminizeCompositeOp:
3132 {
3133 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3134 {
3135 pixel=Dc;
3136 break;
3137 }
3138 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3139 {
3140 pixel=Sc;
3141 break;
3142 }
3143 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3144 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3145 white_luminance,illuminant,&hue,&chroma,&luma);
3146 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
3147 (double) source_pixel.green,(double) source_pixel.blue,
3148 white_luminance,illuminant,&sans,&sans,&luma);
3149 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3150 white_luminance,illuminant,&red,&green,&blue);
3151 switch (channel)
3152 {
3153 case RedPixelChannel: pixel=red; break;
3154 case GreenPixelChannel: pixel=green; break;
3155 case BluePixelChannel: pixel=blue; break;
3156 default: pixel=Dc; break;
3157 }
3158 break;
3159 }
3160 case MathematicsCompositeOp:
3161 {
3162 /*
3163 'Mathematics' a free form user control mathematical composition
3164 is defined as...
3165
3166 f(Sc,Dc) = A*Sc*Dc + B*Sc + C*Dc + D
3167
3168 Where the arguments A,B,C,D are (currently) passed to composite
3169 as a command separated 'geometry' string in "compose:args" image
3170 artifact.
3171
3172 A = a->rho, B = a->sigma, C = a->xi, D = a->psi
3173
3174 Applying the SVG transparency formula (see above), we get...
3175
3176 Dca' = Sa*Da*f(Sc,Dc) + Sca*(1.0-Da) + Dca*(1.0-Sa)
3177
3178 Dca' = A*Sca*Dca + B*Sca*Da + C*Dca*Sa + D*Sa*Da + Sca*(1.0-Da) +
3179 Dca*(1.0-Sa)
3180 */
3181 if (compose_sync == MagickFalse)
3182 {
3183 pixel=geometry_info.rho*Sc*Dc+geometry_info.sigma*Sc+
3184 geometry_info.xi*Dc+geometry_info.psi;
3185 break;
3186 }
3187 pixel=(double) QuantumRange*gamma*(geometry_info.rho*Sca*Dca+
3188 geometry_info.sigma*Sca*Da+geometry_info.xi*Dca*Sa+
3189 geometry_info.psi*Sa*Da+Sca*(1.0-Da)+Dca*(1.0-Sa));
3190 break;
3191 }
3192 case MinusDstCompositeOp:
3193 {
3194 if (compose_sync == MagickFalse)
3195 {
3196 pixel=Dc-Sc;
3197 break;
3198 }
3199 pixel=gamma*(Sa*Sc+Da*Dc-2.0*Da*Dc*Sa);
3200 break;
3201 }
3202 case MinusSrcCompositeOp:
3203 {
3204 if (compose_sync == MagickFalse)
3205 {
3206 pixel=Sc-Dc;
3207 break;
3208 }
3209 pixel=gamma*(Da*Dc+Sa*Sc-2.0*Sa*Sc*Da);
3210 break;
3211 }
3212 case ModulateCompositeOp:
3213 {
3214 ssize_t
3215 offset;
3216
3217 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3218 {
3219 pixel=Dc;
3220 break;
3221 }
3222 offset=(ssize_t) (Si-midpoint);
3223 if (offset == 0)
3224 {
3225 pixel=Dc;
3226 break;
3227 }
3228 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3229 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3230 white_luminance,illuminant,&hue,&chroma,&luma);
3231 luma+=(0.01*percent_luma*offset)/midpoint;
3232 chroma*=0.01*percent_chroma;
3233 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3234 white_luminance,illuminant,&red,&green,&blue);
3235 switch (channel)
3236 {
3237 case RedPixelChannel: pixel=red; break;
3238 case GreenPixelChannel: pixel=green; break;
3239 case BluePixelChannel: pixel=blue; break;
3240 default: pixel=Dc; break;
3241 }
3242 break;
3243 }
3244 case ModulusAddCompositeOp:
3245 {
3246 if (compose_sync == MagickFalse)
3247 {
3248 pixel=(Quantum) QuantumRange*((Sc+Dc)-floor(Sc+Dc));
3249 break;
3250 }
3251 pixel=(Quantum) QuantumRange*((Sca+Dca)-floor(Sca+Dca));
3252 break;
3253 }
3254 case ModulusSubtractCompositeOp:
3255 {
3256 if (compose_sync == MagickFalse)
3257 {
3258 pixel=(Quantum) QuantumRange*((Sc-Dc)-floor(Sc-Dc));
3259 break;
3260 }
3261 pixel=(Quantum) QuantumRange*((Sca-Dca)-floor(Sca-Dca));
3262 break;
3263 }
3264 case MultiplyCompositeOp:
3265 {
3266 if (compose_sync == MagickFalse)
3267 {
3268 pixel=(double) QuantumRange*Sc*Dc;
3269 break;
3270 }
3271 pixel=(double) QuantumRange*(Sca*Dca+Sca*(1.0-Da)+Dca*(1.0-Sa));
3272 break;
3273 }
3274 case NegateCompositeOp:
3275 {
3276 D=(Da > 0.0) ? Dca/Da : 0.0;
3277 S=(Sa > 0.0) ? Sca/Sa : 0.0;
3278 pixel=(double) QuantumRange*((1.0-fabs(1.0-S-D))*Da);
3279 break;
3280 }
3281 case NoCompositeOp:
3282 {
3283 pixel=(double) QuantumRange*Dca;
3284 break;
3285 }
3286 case OutCompositeOp:
3287 case SrcOutCompositeOp:
3288 {
3289 pixel=(double) QuantumRange*(Sca*(1.0-Da));
3290 break;
3291 }
3292 case OverCompositeOp:
3293 case SrcOverCompositeOp:
3294 {
3295 if ((Sa+Da*(1.0-Sa)) <= MagickEpsilon)
3296 pixel=0.0;
3297 else
3298 pixel=(double) QuantumRange*gamma*((Sca+Dca*(1.0-Sa))/
3299 (Sa+Da*(1.0-Sa)));
3300 break;
3301 }
3302 case OverlayCompositeOp:
3303 {
3304 if ((2.0*Dca) < Da)
3305 {
3306 pixel=(double) QuantumRange*gamma*(2.0*Dca*Sca+Dca*(1.0-Sa)+
3307 Sca*(1.0-Da));
3308 break;
3309 }
3310 pixel=(double) QuantumRange*gamma*(Da*Sa-2.0*(Sa-Sca)*(Da-Dca)+Dca*
3311 (1.0-Sa)+Sca*(1.0-Da));
3312 break;
3313 }
3314 case PegtopLightCompositeOp:
3315 {
3316 if (fabs((double) Da) < MagickEpsilon)
3317 {
3318 pixel=(double) QuantumRange*gamma*Sca;
3319 break;
3320 }
3321 if (RoundToUnity(Sca) <= 0.5)
3322 blend=RoundToUnity(Dca/Da)-(1.0-2.0*RoundToUnity(Sca))*
3323 RoundToUnity(Dca/Da)*(1.0-RoundToUnity(Dca/Da));
3324 else
3325 {
3326 if (RoundToUnity(Dca/Da) <= 0.25)
3327 blend=((16.0*RoundToUnity(Dca/Da)-12.0)*RoundToUnity(Dca/Da)+
3328 4.0)*RoundToUnity(Dca/Da);
3329 else
3330 blend=sqrt(RoundToUnity(Dca/Da));
3331 blend=RoundToUnity(Dca/Da)+(2.0*RoundToUnity(Sca)-1.0)*
3332 (blend-RoundToUnity(Dca/Da));
3333 }
3334 pixel=(double) QuantumRange*gamma*(RoundToUnity(blend)*Da*Sa+Dca*
3335 (1.0-Sa));
3336 break;
3337 }
3338 case PinLightCompositeOp:
3339 {
3340 /*
3341 Adobe Pin Light (colors in [0,1]):
3342
3343 if (Cs <= 0.5)
3344 f = min(Cd, 2*Cs);
3345 else
3346 f = max(Cd, 2*Cs - 1);
3347 */
3348 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3349 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3350 if (S <= 0.5)
3351 blend=MagickMin(D,2.0*S);
3352 else
3353 blend=MagickMax(D,2.0*S-1.0);
3354 pixel=(double) QuantumRange*gamma*RoundToUnity(Sa*Da*blend+Sca*
3355 (1.0-Da)+Dca*(1.0-Sa));
3356 break;
3357 }
3358 case PlusCompositeOp:
3359 {
3360 D=(Da > 0.0) ? Dca/Da : 0.0;
3361 S=(Sa > 0.0) ? Sca/Sa : 0.0;
3362 pixel=(double) QuantumRange*(RoundToUnity(Sa+Da-Sa*Da)*
3363 RoundToUnity(S+D));
3364 break;
3365 }
3366 case ReflectCompositeOp:
3367 {
3368 if (compose_sync == MagickFalse)
3369 {
3370 if (Dc < 1.0)
3371 blend=(Sc*Sc)/(1.0-Dc);
3372 else
3373 blend=1.0;
3374 pixel=(double) QuantumRange*RoundToUnity(blend);
3375 break;
3376 }
3377 if (Sa > 0.0)
3378 S=Sca/Sa;
3379 else
3380 S=0.0;
3381 if (Da > 0.0)
3382 D=Dca/Da;
3383 else
3384 D=0.0;
3385 if (D < 1.0)
3386 blend=(S*S)/(1.0-D);
3387 else
3388 blend=1.0;
3389 pixel=(double) QuantumRange*RoundToUnity((Sa+Da-Sa*Da)*blend);
3390 break;
3391 }
3392 case RMSECompositeOp:
3393 {
3394 double
3395 gray;
3396
3397 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3398 {
3399 pixel=Dc;
3400 break;
3401 }
3402 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3403 {
3404 pixel=Sc;
3405 break;
3406 }
3407 gray=sqrt(
3408 (canvas_pixel.red-source_pixel.red)*
3409 (canvas_pixel.red-source_pixel.red)+
3410 (canvas_pixel.green-source_pixel.green)*
3411 (canvas_pixel.green-source_pixel.green)+
3412 (canvas_pixel.blue-source_pixel.blue)*
3413 (canvas_pixel.blue-source_pixel.blue)/3.0);
3414 switch (channel)
3415 {
3416 case RedPixelChannel: pixel=gray; break;
3417 case GreenPixelChannel: pixel=gray; break;
3418 case BluePixelChannel: pixel=gray; break;
3419 default: pixel=Dc; break;
3420 }
3421 break;
3422 }
3423 case SaturateCompositeOp:
3424 {
3425 if (fabs((double) QuantumRange*Sa-(double) TransparentAlpha) < MagickEpsilon)
3426 {
3427 pixel=Dc;
3428 break;
3429 }
3430 if (fabs((double) QuantumRange*Da-(double) TransparentAlpha) < MagickEpsilon)
3431 {
3432 pixel=Sc;
3433 break;
3434 }
3435 ConvertRGBToGeneric(colorspace,(double) canvas_pixel.red,
3436 (double) canvas_pixel.green,(double) canvas_pixel.blue,
3437 white_luminance,illuminant,&hue,&chroma,&luma);
3438 ConvertRGBToGeneric(colorspace,(double) source_pixel.red,
3439 (double) source_pixel.green,(double) source_pixel.blue,
3440 white_luminance,illuminant,&sans,&chroma,&sans);
3441 ConvertGenericToRGB(colorspace,hue,chroma,luma,
3442 white_luminance,illuminant,&red,&green,&blue);
3443 switch (channel)
3444 {
3445 case RedPixelChannel: pixel=red; break;
3446 case GreenPixelChannel: pixel=green; break;
3447 case BluePixelChannel: pixel=blue; break;
3448 default: pixel=Dc; break;
3449 }
3450 break;
3451 }
3452 case ScreenCompositeOp:
3453 {
3454 if (compose_sync == MagickFalse)
3455 {
3456 pixel=(double) QuantumRange*RoundToUnity(Sc+Dc-Sc*Dc);
3457 break;
3458 }
3459 S=(Sa > 0.0) ? RoundToUnity(Sca/Sa) : 0.0;
3460 D=(Da > 0.0) ? RoundToUnity(Dca/Da) : 0.0;
3461 blend=RoundToUnity(S+D-S*D);
3462 pixel=(double) QuantumRange*RoundToUnity(Sa*Da*blend+Sca*(1.0-Da)+
3463 Dca*(1.0-Sa));
3464 break;
3465 }
3466 case SoftBurnCompositeOp:
3467 {
3468 if (RoundToUnity(Dca) <= 0.0)
3469 blend = 0.0;
3470 else
3471 if (RoundToUnity(Sca) >= 1.0)
3472 blend = 1.0;
3473 else
3474 blend=1.0-MagickMin(1.0,(1.0-RoundToUnity(Dca))/
3475 RoundToUnity(Sca));
3476 pixel=(double) QuantumRange*gamma*RoundToUnity(blend);
3477 break;
3478 }
3479 case SoftDodgeCompositeOp:
3480 {
3481 if (RoundToUnity(Sca) <= 0.0)
3482 blend=RoundToUnity(Dca);
3483 else
3484 if (RoundToUnity(Dca) >= 1.0)
3485 blend=1.0;
3486 else
3487 blend=MagickMin(1.0,RoundToUnity(Dca)/(1.0-RoundToUnity(Sca)));
3488 pixel=(double) QuantumRange*gamma*RoundToUnity(blend);
3489 break;
3490 }
3491 case SoftLightCompositeOp:
3492 {
3493 if (RoundToUnity(Sca) <= 0.5)
3494 {
3495 pixel=(double) QuantumRange*gamma*(RoundToUnity(Dca)*Sa+Da*
3496 (RoundToUnity(Dca)-(1.0-2.0*RoundToUnity(Sca))*
3497 RoundToUnity(Dca)*(1.0-RoundToUnity(Dca)))+RoundToUnity(Sca)*
3498 (1.0-Da)+RoundToUnity(Dca)*(1.0-Sa));
3499 break;
3500 }
3501 if (RoundToUnity(Dca) > 0.25)
3502 blend=sqrt(RoundToUnity(Dca));
3503 else
3504 blend=((16.0*RoundToUnity(Dca)-12.0)*RoundToUnity(Dca)+4.0)*
3505 RoundToUnity(Dca);
3506 pixel=(double) QuantumRange*gamma*(RoundToUnity(Dca)*Sa+Da*
3507 (RoundToUnity(Dca)+(2.0*RoundToUnity(Sca)-1.0)*
3508 (RoundToUnity(blend)-RoundToUnity(Dca)))+RoundToUnity(Sca)*
3509 (1.0-Da)+RoundToUnity(Dca)*(1.0-Sa));
3510 break;
3511 }
3512 case StampCompositeOp:
3513 {
3514 pixel=(double) QuantumRange*RoundToUnity(Sca+Dca-1.0);
3515 break;
3516 }
3517 case StereoCompositeOp:
3518 {
3519 if (channel == RedPixelChannel)
3520 pixel=(MagickRealType) GetPixelRed(source_image,p);
3521 break;
3522 }
3523 case ThresholdCompositeOp:
3524 {
3525 S=(Sa > 0.0) ? (Sca/Sa) : 0.0;
3526 D=(Da > 0.0) ? (Dca/Da) : 0.0;
3527 if (fabs(2.0*(S-D)) < threshold)
3528 blend=D;
3529 else
3530 blend=D+(S-D)*amount;
3531 pixel=(double) QuantumRange*(Sa*Da*RoundToUnity(blend)+Sca*
3532 (1.0-Da)+Dca*(1.0-Sa));
3533 break;
3534 }
3535 case VividLightCompositeOp:
3536 {
3537 if ((fabs((double) Sa) < MagickEpsilon) ||
3538 (fabs((double) Da) < MagickEpsilon))
3539 {
3540 pixel=(double) QuantumRange*gamma*(Sa*Da+Sca*(1.0-Da)+Dca*
3541 (1.0-Sa));
3542 break;
3543 }
3544 if (RoundToUnity(Sca/Sa) <= 0.0)
3545 blend=0.0;
3546 else
3547 if (RoundToUnity(Sca/Sa) < 0.5)
3548 blend=1.0-(1.0-RoundToUnity(Dca/Da))/(2.0*RoundToUnity(Sca/Sa));
3549 else
3550 if (RoundToUnity(Sca/Sa) < 1.0)
3551 blend=RoundToUnity(Dca/Da)/(2.0*(1.0-RoundToUnity(Sca/Sa)));
3552 else
3553 blend=1.0;
3554 pixel=(double) QuantumRange*gamma*(Sa*Da*RoundToUnity(blend)+Sca*
3555 (1.0-Da)+Dca*(1.0-Sa));
3556 break;
3557 }
3558 case XorCompositeOp:
3559 {
3560 pixel=(double) QuantumRange*(Sca*(1.0-Da)+Dca*(1.0-Sa));
3561 break;
3562 }
3563 default:
3564 {
3565 pixel=Sc;
3566 break;
3567 }
3568 }
3569 q[i]=clamp != MagickFalse ? ClampPixel(pixel) : ClampToQuantum(pixel);
3570 }
3571 p+=(ptrdiff_t) GetPixelChannels(source_image);
3572 channels=GetPixelChannels(source_image);
3573 if (p >= (pixels+channels*source_image->columns))
3574 p=pixels;
3575 q+=(ptrdiff_t) GetPixelChannels(image);
3576 }
3577 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3578 status=MagickFalse;
3579 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3580 {
3581 MagickBooleanType
3582 proceed;
3583
3584#if defined(MAGICKCORE_OPENMP_SUPPORT)
3585 #pragma omp atomic
3586#endif
3587 progress++;
3588 proceed=SetImageProgress(image,CompositeImageTag,progress,image->rows);
3589 if (proceed == MagickFalse)
3590 status=MagickFalse;
3591 }
3592 }
3593 source_view=DestroyCacheView(source_view);
3594 image_view=DestroyCacheView(image_view);
3595 if (canvas_image != (Image * ) NULL)
3596 canvas_image=DestroyImage(canvas_image);
3597 else
3598 source_image=DestroyImage(source_image);
3599 return(status);
3600}
3601␌
3602/*
3603%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3604% %
3605% %
3606% %
3607% T e x t u r e I m a g e %
3608% %
3609% %
3610% %
3611%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3612%
3613% TextureImage() repeatedly tiles the texture image across and down the image
3614% canvas.
3615%
3616% The format of the TextureImage method is:
3617%
3618% MagickBooleanType TextureImage(Image *image,const Image *texture,
3619% ExceptionInfo *exception)
3620%
3621% A description of each parameter follows:
3622%
3623% o image: the image.
3624%
3625% o texture_image: This image is the texture to layer on the background.
3626%
3627*/
3628MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
3629 ExceptionInfo *exception)
3630{
3631#define TextureImageTag "Texture/Image"
3632
3633 CacheView
3634 *image_view,
3635 *texture_view;
3636
3637 Image
3638 *texture_image;
3639
3640 MagickBooleanType
3641 status;
3642
3643 ssize_t
3644 y;
3645
3646 assert(image != (Image *) NULL);
3647 assert(image->signature == MagickCoreSignature);
3648 if (IsEventLogging() != MagickFalse)
3649 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3650 if (texture == (const Image *) NULL)
3651 return(MagickFalse);
3652 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
3653 return(MagickFalse);
3654 texture_image=CloneImage(texture,0,0,MagickTrue,exception);
3655 if (texture_image == (const Image *) NULL)
3656 return(MagickFalse);
3657 (void) TransformImageColorspace(texture_image,image->colorspace,exception);
3658 (void) SetImageVirtualPixelMethod(texture_image,TileVirtualPixelMethod,
3659 exception);
3660 status=MagickTrue;
3661 if ((image->compose != CopyCompositeOp) &&
3662 ((image->compose != OverCompositeOp) ||
3663 (image->alpha_trait != UndefinedPixelTrait) ||
3664 (texture_image->alpha_trait != UndefinedPixelTrait)))
3665 {
3666 /*
3667 Tile texture onto the image background.
3668 */
3669 for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) texture_image->rows)
3670 {
3671 ssize_t
3672 x;
3673
3674 if (status == MagickFalse)
3675 continue;
3676 for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) texture_image->columns)
3677 {
3678 MagickBooleanType
3679 thread_status;
3680
3681 thread_status=CompositeImage(image,texture_image,image->compose,
3682 MagickTrue,x+texture_image->tile_offset.x,y+
3683 texture_image->tile_offset.y,exception);
3684 if (thread_status == MagickFalse)
3685 {
3686 status=thread_status;
3687 break;
3688 }
3689 }
3690 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3691 {
3692 MagickBooleanType
3693 proceed;
3694
3695 proceed=SetImageProgress(image,TextureImageTag,(MagickOffsetType) y,
3696 image->rows);
3697 if (proceed == MagickFalse)
3698 status=MagickFalse;
3699 }
3700 }
3701 (void) SetImageProgress(image,TextureImageTag,(MagickOffsetType)
3702 image->rows,image->rows);
3703 texture_image=DestroyImage(texture_image);
3704 return(status);
3705 }
3706 /*
3707 Tile texture onto the image background (optimized).
3708 */
3709 status=MagickTrue;
3710 texture_view=AcquireVirtualCacheView(texture_image,exception);
3711 image_view=AcquireAuthenticCacheView(image,exception);
3712#if defined(MAGICKCORE_OPENMP_SUPPORT)
3713 #pragma omp parallel for schedule(static) shared(status) \
3714 magick_number_threads(texture_image,image,image->rows,2)
3715#endif
3716 for (y=0; y < (ssize_t) image->rows; y++)
3717 {
3718 MagickBooleanType
3719 sync;
3720
3721 const Quantum
3722 *p,
3723 *pixels;
3724
3725 ssize_t
3726 x;
3727
3728 Quantum
3729 *q;
3730
3731 size_t
3732 width;
3733
3734 if (status == MagickFalse)
3735 continue;
3736 pixels=GetCacheViewVirtualPixels(texture_view,texture_image->tile_offset.x,
3737 (y+texture_image->tile_offset.y) % (ssize_t) texture_image->rows,
3738 texture_image->columns,1,exception);
3739 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3740 if ((pixels == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3741 {
3742 status=MagickFalse;
3743 continue;
3744 }
3745 for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) texture_image->columns)
3746 {
3747 ssize_t
3748 j;
3749
3750 p=pixels;
3751 width=texture_image->columns;
3752 if ((x+(ssize_t) width) > (ssize_t) image->columns)
3753 width=image->columns-(size_t) x;
3754 for (j=0; j < (ssize_t) width; j++)
3755 {
3756 ssize_t
3757 i;
3758
3759 for (i=0; i < (ssize_t) GetPixelChannels(texture_image); i++)
3760 {
3761 PixelChannel channel = GetPixelChannelChannel(texture_image,i);
3762 PixelTrait traits = GetPixelChannelTraits(image,channel);
3763 PixelTrait texture_traits=GetPixelChannelTraits(texture_image,
3764 channel);
3765 if ((traits == UndefinedPixelTrait) ||
3766 (texture_traits == UndefinedPixelTrait))
3767 continue;
3768 SetPixelChannel(image,channel,p[i],q);
3769 }
3770 p+=(ptrdiff_t) GetPixelChannels(texture_image);
3771 q+=(ptrdiff_t) GetPixelChannels(image);
3772 }
3773 }
3774 sync=SyncCacheViewAuthenticPixels(image_view,exception);
3775 if (sync == MagickFalse)
3776 status=MagickFalse;
3777 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3778 {
3779 MagickBooleanType
3780 proceed;
3781
3782 proceed=SetImageProgress(image,TextureImageTag,(MagickOffsetType) y,
3783 image->rows);
3784 if (proceed == MagickFalse)
3785 status=MagickFalse;
3786 }
3787 }
3788 texture_view=DestroyCacheView(texture_view);
3789 image_view=DestroyCacheView(image_view);
3790 texture_image=DestroyImage(texture_image);
3791 return(status);
3792}