(no commit message)

diff --git a/Magick++/lib/Image.cpp b/Magick++/lib/Image.cpp
index bdce045d35716b2baa9c143946fc9a841ef0548a..e63f4ca730879227cd6305eaf7026b6152ac2d8e 100644 (file)
--- a/Magick++/lib/Image.cpp
+++ b/Magick++/lib/Image.cpp
@@ -683,8 +683,8 @@ void Magick::Image::composite ( const Image &compositeImage_,
   ExceptionInfo exceptionInfo;
   GetExceptionInfo( &exceptionInfo );
   CompositeImage( image(),
-                 compose_,
                  compositeImage_.constImage(),
+                 compose_, MagickFalse,
                  xOffset_,
                   yOffset_, &exceptionInfo );
   throwException( exceptionInfo );
@@ -708,8 +708,8 @@ void Magick::Image::composite ( const Image &compositeImage_,
   ExceptionInfo exceptionInfo;
   GetExceptionInfo( &exceptionInfo );
   CompositeImage( image(),
-                 compose_,
                  compositeImage_.constImage(),
+                 compose_, MagickFalse,
                  x, y, &exceptionInfo );
   throwException( exceptionInfo );
   (void) DestroyExceptionInfo( &exceptionInfo );
@@ -728,8 +728,8 @@ void Magick::Image::composite ( const Image &compositeImage_,
   ExceptionInfo exceptionInfo;
   GetExceptionInfo( &exceptionInfo );
   CompositeImage( image(),
-                 compose_,
                  compositeImage_.constImage(),
+                 compose_, MagickFalse,
                  geometry.x, geometry.y, &exceptionInfo );
   throwException( exceptionInfo );
   (void) DestroyExceptionInfo( &exceptionInfo );
@@ -1617,8 +1617,8 @@ void Magick::Image::quantumOperator ( const ssize_t x_,const ssize_t y_,
   ChannelType channel_mask = SetPixelChannelMask( image(), channel_);
   EvaluateImage( crop_image, operator_, rvalue_, &exceptionInfo );
   (void) SetPixelChannelMapMask( image(), channel_mask );
-  (void) CompositeImage( image(), image()->matte != MagickFalse ?
-    OverCompositeOp : CopyCompositeOp, crop_image, geometry.x, geometry.y,
+  (void) CompositeImage( image(), crop_image, image()->matte != MagickFalse ?
+    OverCompositeOp : CopyCompositeOp, MagickFalse, geometry.x, geometry.y,
     &exceptionInfo );
   crop_image = DestroyImageList(crop_image);
   throwException( exceptionInfo );

diff --git a/MagickCore/annotate.c b/MagickCore/annotate.c
index 84dbb9e944b1c278fc904a14b96b0b434106c780..15f5b2717dcfc4ca3c375c518d9eb61fbbedd75d 100644 (file)
--- a/MagickCore/annotate.c
+++ b/MagickCore/annotate.c
@@ -1844,7 +1844,7 @@ static MagickBooleanType RenderPostscript(Image *image,
           break;
       }
       annotate_view=DestroyCacheView(annotate_view);
-      (void) CompositeImage(image,OverCompositeOp,annotate_image,
+      (void) CompositeImage(image,annotate_image,OverCompositeOp,MagickFalse,
         (ssize_t) ceil(offset->x-0.5),(ssize_t) ceil(offset->y-(metrics->ascent+
         metrics->descent)-0.5),exception);
     }

diff --git a/MagickCore/compare.c b/MagickCore/compare.c
index 029e9f0393f28949a138e198424f7fea5ff27128..1f5b74c522068fcbc8aec1c3e7fbb7c773d4cc86 100644 (file)
--- a/MagickCore/compare.c
+++ b/MagickCore/compare.c
@@ -263,8 +263,8 @@ MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image,
   highlight_view=DestroyCacheView(highlight_view);
   reconstruct_view=DestroyCacheView(reconstruct_view);
   image_view=DestroyCacheView(image_view);
-  (void) CompositeImage(difference_image,image->compose,highlight_image,0,0,
-    exception);
+  (void) CompositeImage(difference_image,highlight_image,image->compose,
+    MagickFalse,0,0,exception);
   highlight_image=DestroyImage(highlight_image);
   if (status == MagickFalse)
     difference_image=DestroyImage(difference_image);

diff --git a/MagickCore/composite.c b/MagickCore/composite.c
index 9771485c62960465711684e1c8fc6531cffdd85e..3eb605c567727ad7fcf58a17ba2205cfe6df616f 100644 (file)
--- a/MagickCore/composite.c
+++ b/MagickCore/composite.c
@@ -94,18 +94,21 @@
 %  The format of the CompositeImage method is:
 %
 %      MagickBooleanType CompositeImage(Image *image,
-%        const CompositeOperator compose,Image *composite_image,
-%        const ssize_t x_offset,const ssize_t y_offset,ExceptionInfo *exception)
+%        const Image *composite_image,const CompositeOperator compose,
+%        const MagickBooleanType clip_to_self,const ssize_t x_offset,
+%        const ssize_t y_offset,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
 %    o image: the destination image, modified by he composition
 %
+%    o composite_image: the composite (source) image.
+%
 %    o compose: This operator affects how the composite is applied to
 %      the image.  The operators and how they are utilized are listed here
 %      http://www.w3.org/TR/SVG12/#compositing.
 %
-%    o composite_image: the composite (source) image.
+%    o clip_to_self: set to MagickTrue to limit composition to area composed.
 %
 %    o x_offset: the column offset of the composited image.
 %
@@ -270,8 +273,8 @@ static inline double MagickMax(const double x,const double y)
 }
 
 static MagickBooleanType CompositeOverImage(Image *image,
-  const Image *composite_image,const ssize_t x_offset,const ssize_t y_offset,
-  ExceptionInfo *exception)
+  const Image *composite_image,const MagickBooleanType clip_to_self,
+  const ssize_t x_offset,const ssize_t y_offset,ExceptionInfo *exception)
 {
 #define CompositeImageTag  "Composite/Image"
 
@@ -279,11 +282,7 @@ static MagickBooleanType CompositeOverImage(Image *image,
     *composite_view,
     *image_view;
 
-  const char
-    *value;
-
   MagickBooleanType
-    clip_to_self,
     status;
 
   MagickOffsetType
@@ -292,13 +291,6 @@ static MagickBooleanType CompositeOverImage(Image *image,
   ssize_t
     y;
 
-  /*
-    Prepare composite image.
-  */
-  clip_to_self=MagickTrue;
-  value=GetImageArtifact(composite_image,"compose:outside-overlay");
-  if (value != (const char *) NULL)
-    clip_to_self=IsMagickTrue(value) == MagickFalse ? MagickTrue : MagickFalse;
   /*
     Composite image.
   */
@@ -328,7 +320,7 @@ static MagickBooleanType CompositeOverImage(Image *image,
 
     if (status == MagickFalse)
       continue;
-    if (clip_to_self == MagickTrue)
+    if (clip_to_self != MagickFalse)
       {
         if (y < y_offset)
           continue;
@@ -372,7 +364,7 @@ static MagickBooleanType CompositeOverImage(Image *image,
       register ssize_t
         i;
 
-      if (clip_to_self == MagickTrue)
+      if (clip_to_self != MagickFalse)
         {
           if (x < x_offset)
             {
@@ -505,8 +497,8 @@ static MagickBooleanType CompositeOverImage(Image *image,
 }
 
 MagickExport MagickBooleanType CompositeImage(Image *image,
-  const CompositeOperator compose,const Image *composite_image,
-  const ssize_t x_offset,const ssize_t y_offset,ExceptionInfo *exception)
+  const Image *composite_image,const CompositeOperator compose,
+  const MagickBooleanType clip_to_self,const ssize_t x_offset,const ssize_t y_offset,ExceptionInfo *exception)
 {
 #define CompositeImageTag  "Composite/Image"
 
@@ -514,9 +506,6 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     *composite_view,
     *image_view;
 
-  const char
-    *value;
-
   GeometryInfo
     geometry_info;
 
@@ -524,7 +513,6 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     *destination_image;
 
   MagickBooleanType
-    clip_to_self,
     status;
 
   MagickOffsetType
@@ -602,35 +590,19 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     return(MagickFalse);
   if ((compose == OverCompositeOp) || (compose == SrcOverCompositeOp))
     {
-      status=CompositeOverImage(image,composite_image,x_offset,y_offset,
-        exception);
+      status=CompositeOverImage(image,composite_image,clip_to_self,x_offset,
+        y_offset,exception);
       return(status);
     }
   destination_image=(Image *) NULL;
   amount=0.5;
   destination_dissolve=1.0;
-  clip_to_self=MagickFalse;
   percent_brightness=100.0;
   percent_saturation=100.0;
   source_dissolve=1.0;
   threshold=0.05f;
   switch (compose)
   {
-    case ClearCompositeOp:
-    case DstAtopCompositeOp:
-    case DstInCompositeOp:
-    case InCompositeOp:
-    case OutCompositeOp:
-    case SrcCompositeOp:
-    case SrcInCompositeOp:
-    case SrcOutCompositeOp:
-    {
-      /*
-        Modify destination outside the overlaid region.
-      */
-      clip_to_self=MagickTrue;
-      break;
-    }
     case CopyCompositeOp:
     {
       if ((x_offset < 0) || (y_offset < 0))
@@ -732,7 +704,6 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
       */
       if (image->matte == MagickFalse)
         (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
-      clip_to_self=MagickTrue;
       break;
     }
     case BlurCompositeOp:
@@ -741,6 +712,9 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
         *composite_view,
         *destination_view;
 
+      const char
+        *value;
+
       PixelInfo
         pixel;
 
@@ -883,6 +857,9 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
         *destination_view,
         *image_view;
 
+      const char
+        *value;
+
       PixelInfo
         pixel;
 
@@ -1048,6 +1025,9 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     }
     case DissolveCompositeOp:
     {
+      const char
+        *value;
+
       /*
         Geometry arguments to dissolve factors.
       */
@@ -1068,17 +1048,14 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
             destination_dissolve=geometry_info.sigma/100.0;
           if ((destination_dissolve-MagickEpsilon) < 0.0)
             destination_dissolve=0.0;
-          clip_to_self=MagickTrue;
-          if ((destination_dissolve+MagickEpsilon) > 1.0 )
-            {
-              destination_dissolve=1.0;
-              clip_to_self=MagickFalse;
-            }
         }
       break;
     }
     case BlendCompositeOp:
     {
+      const char
+        *value;
+
       value=GetImageArtifact(composite_image,"compose:args");
       if (value != (char *) NULL)
         {
@@ -1087,14 +1064,14 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
           destination_dissolve=1.0-source_dissolve;
           if ((flags & SigmaValue) != 0)
             destination_dissolve=geometry_info.sigma/100.0;
-          clip_to_self=MagickTrue;
-          if ((destination_dissolve+MagickEpsilon) > 1.0)
-            clip_to_self=MagickFalse;
         }
       break;
     }
     case MathematicsCompositeOp:
     {
+      const char
+        *value;
+
       /*
         Just collect the values from "compose:args", setting.
         Unused values are set to zero automagically.
@@ -1111,6 +1088,9 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     }
     case ModulateCompositeOp:
     {
+      const char
+        *value;
+
       /*
         Determine the brightness and saturation scale.
       */
@@ -1126,6 +1106,9 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     }
     case ThresholdCompositeOp:
     {
+      const char
+        *value;
+
       /*
         Determine the amount and threshold.
       */
@@ -1144,9 +1127,6 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     default:
       break;
   }
-  value=GetImageArtifact(composite_image,"compose:outside-overlay");
-  if (value != (const char *) NULL)
-    clip_to_self=IsMagickTrue(value);
   /*
     Composite image.
   */
@@ -1182,7 +1162,7 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
 
     if (status == MagickFalse)
       continue;
-    if (clip_to_self == MagickFalse)
+    if (clip_to_self != MagickFalse)
       {
         if (y < y_offset)
           continue;
@@ -1234,7 +1214,7 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
       size_t
         channels;
 
-      if (clip_to_self == MagickFalse)
+      if (clip_to_self != MagickFalse)
         {
           if (x < x_offset)
             {
@@ -2351,9 +2331,9 @@ MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
           MagickBooleanType
             thread_status;
 
-          thread_status=CompositeImage(image,image->compose,texture_image,x+
-            texture_image->tile_offset.x,y+texture_image->tile_offset.y,
-            exception);
+          thread_status=CompositeImage(image,texture_image,image->compose,
+            MagickFalse,x+texture_image->tile_offset.x,y+
+            texture_image->tile_offset.y,exception);
           if (thread_status == MagickFalse)
             {
               status=thread_status;

diff --git a/MagickCore/composite.h b/MagickCore/composite.h
index b0b88ca4e72a6509ca8bba6ed17c09ed88668d80..7b3d394f18e5ddd6882a191bc67fb6bace5b5d9b 100644 (file)
--- a/MagickCore/composite.h
+++ b/MagickCore/composite.h
@@ -97,8 +97,8 @@ typedef enum
 } CompositeOperator;
 
 extern MagickExport MagickBooleanType
-  CompositeImage(Image *,const CompositeOperator,const Image *,const ssize_t,
-    const ssize_t,ExceptionInfo *),
+  CompositeImage(Image *,const Image *,const CompositeOperator,
+    const MagickBooleanType,const ssize_t,const ssize_t,ExceptionInfo *),
   TextureImage(Image *,const Image *,ExceptionInfo *);
 
 #if defined(__cplusplus) || defined(c_plusplus)

diff --git a/MagickCore/decorate.c b/MagickCore/decorate.c
index 40c687b91ce6abd28a2e14e9b4e45a42b01b5360..ceabced6f5479669835b964f78f9893769b08aba 100644 (file)
--- a/MagickCore/decorate.c
+++ b/MagickCore/decorate.c
@@ -593,7 +593,8 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
         frame_info->inner_bevel);
       y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
         frame_info->inner_bevel);
-      (void) CompositeImage(frame_image,compose,image,x,y,exception);
+      (void) CompositeImage(frame_image,image,compose,MagickFalse,x,y,
+        exception);
     }
   return(frame_image);
 }

diff --git a/MagickCore/display.c b/MagickCore/display.c
index 5e8b021c3c45f475f69e4e6f8cc058b976c6ce9b..12067cfc9141aba3ea8558a4c244ad55337361c0 100644 (file)
--- a/MagickCore/display.c
+++ b/MagickCore/display.c
@@ -4355,8 +4355,8 @@ static MagickBooleanType XCompositeImage(Display *display,
   /*
     Composite image with X Image window.
   */
-  (void) CompositeImage(image,compose,composite_image,composite_info.x,
-    composite_info.y,exception);
+  (void) CompositeImage(image,composite_image,compose,MagickFalse,
+    composite_info.x,composite_info.y,exception);
   composite_image=DestroyImage(composite_image);
   XSetCursorState(display,windows,MagickFalse);
   /*
@@ -10928,8 +10928,8 @@ static MagickBooleanType XPasteImage(Display *display,
   /*
     Paste image with X Image window.
   */
-  (void) CompositeImage(image,compose,paste_image,paste_info.x,paste_info.y,
-    exception);
+  (void) CompositeImage(image,paste_image,compose,MagickFalse,paste_info.x,
+    paste_info.y,exception);
   paste_image=DestroyImage(paste_image);
   XSetCursorState(display,windows,MagickFalse);
   /*
@@ -11662,8 +11662,8 @@ static MagickBooleanType XROIImage(Display *display,
               (void) XMagickCommand(display,resource_info,windows,
                 SaveToUndoBufferCommand,image,exception);
               windows->image.orphan=MagickFalse;
-              (void) CompositeImage(*image,CopyCompositeOp,roi_image,
-                crop_info.x,crop_info.y,exception);
+              (void) CompositeImage(*image,roi_image,CopyCompositeOp,
+                MagickFalse,crop_info.x,crop_info.y,exception);
               roi_image=DestroyImage(roi_image);
               (void) SetImageProgressMonitor(*image,progress_monitor,
                 (*image)->client_data);

diff --git a/MagickCore/distort.c b/MagickCore/distort.c
index d6cf65470572826950ca1d13f753f49eb4bdd208..0e6c0a5035a985d65d2f8bf3e1aad617180dce31 100644 (file)
--- a/MagickCore/distort.c
+++ b/MagickCore/distort.c
@@ -1556,8 +1556,8 @@ MagickExport Image *DistortResizeImage(const Image *image,
         exception);
       (void) SetImageAlphaChannel(resize_alpha,DeactivateAlphaChannel,
         exception);
-      (void) CompositeImage(resize_image,CopyAlphaCompositeOp,resize_alpha,
-        0,0,exception);
+      (void) CompositeImage(resize_image,resize_alpha,CopyAlphaCompositeOp,
+        MagickFalse,0,0,exception);
       resize_alpha=DestroyImage(resize_alpha);
     }
   (void) SetImageVirtualPixelMethod(resize_image,vp_save,exception);

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index ecdc9d6eb79060e847292667ec7c80a602277c4f..5285fefb427f17e5ac18e4bc6ff02f71f7933fc2 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -4497,8 +4497,8 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
       if (draw_info->compose == OverCompositeOp)
         (void) DrawAffineImage(image,composite_image,&affine,exception);
       else
-        (void) CompositeImage(image,draw_info->compose,composite_image,
-          geometry.x,geometry.y,exception);
+        (void) CompositeImage(image,composite_image,draw_info->compose,
+          MagickFalse,geometry.x,geometry.y,exception);
       composite_image=DestroyImage(composite_image);
       break;
     }

diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index db4167335d4aedfc8171df6517f80cc6e0145761..4fe4354707d7883f50c66dd83f881f5bca9505f5 100644 (file)
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -4018,12 +4018,12 @@ MagickExport Image *PolaroidImage(const Image *image,const DrawInfo *draw_info,
     }
   picture_image->background_color=image->border_color;
   (void) SetImageBackgroundColor(picture_image,exception);
-  (void) CompositeImage(picture_image,OverCompositeOp,image,quantum,quantum,
-    exception);
+  (void) CompositeImage(picture_image,image,OverCompositeOp,MagickFalse,quantum,
+    quantum,exception);
   if (caption_image != (Image *) NULL)
     {
-      (void) CompositeImage(picture_image,OverCompositeOp,caption_image,quantum,
-        (ssize_t) (image->rows+3*quantum/2),exception);
+      (void) CompositeImage(picture_image,caption_image,OverCompositeOp,
+        MagickFalse,quantum,(ssize_t) (image->rows+3*quantum/2),exception);
       caption_image=DestroyImage(caption_image);
     }
   (void) QueryColorCompliance("none",AllCompliance,
@@ -4061,8 +4061,8 @@ MagickExport Image *PolaroidImage(const Image *image,const DrawInfo *draw_info,
       return(picture_image);
     }
   polaroid_image=flop_image;
-  (void) CompositeImage(polaroid_image,OverCompositeOp,picture_image,(ssize_t)
-    (-0.01*picture_image->columns/2.0),0L,exception);
+  (void) CompositeImage(polaroid_image,picture_image,OverCompositeOp,
+    MagickFalse,(ssize_t) (-0.01*picture_image->columns/2.0),0L,exception);
   picture_image=DestroyImage(picture_image);
   (void) QueryColorCompliance("none",AllCompliance,
     &polaroid_image->background_color,exception);
@@ -4518,8 +4518,8 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
       dodge_image=DestroyImage(dodge_image);
       return((Image *) NULL);
     }
-  (void) CompositeImage(sketch_image,ColorDodgeCompositeOp,dodge_image,0,0,
-    exception);
+  (void) CompositeImage(sketch_image,dodge_image,ColorDodgeCompositeOp,
+    MagickFalse,0,0,exception);
   dodge_image=DestroyImage(dodge_image);
   blend_image=CloneImage(image,0,0,MagickTrue,exception);
   if (blend_image == (Image *) NULL)
@@ -4528,8 +4528,8 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
       return((Image *) NULL);
     }
   (void) SetImageArtifact(blend_image,"compose:args","20x80");
-  (void) CompositeImage(sketch_image,BlendCompositeOp,blend_image,0,0,
-    exception);
+  (void) CompositeImage(sketch_image,blend_image,BlendCompositeOp,MagickFalse,
+    0,0,exception);
   blend_image=DestroyImage(blend_image);
   return(sketch_image);
 }
@@ -5522,8 +5522,8 @@ MagickExport Image *VignetteImage(const Image *image,const double radius,
       return((Image *) NULL);
     }
   blur_image->matte=MagickFalse;
-  (void) CompositeImage(canvas_image,IntensityCompositeOp,blur_image,0,0,
-    exception);
+  (void) CompositeImage(canvas_image,blur_image,IntensityCompositeOp,
+    MagickFalse,0,0,exception);
   blur_image=DestroyImage(blur_image);
   vignette_image=MergeImageLayers(canvas_image,FlattenLayer,exception);
   canvas_image=DestroyImage(canvas_image);

diff --git a/MagickCore/image.c b/MagickCore/image.c
index e1e71c26338556a01e03a18bf056933d68774557..8072a17ae4bc50cf9b6e5b8c9b39f83a4630d768 100644 (file)
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -2200,7 +2200,8 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
       /*
         Copy pixel intensity to the alpha channel.
       */
-      status=CompositeImage(image,IntensityCompositeOp,image,0,0,exception);
+      status=CompositeImage(image,image,IntensityCompositeOp,MagickFalse,0,0,
+        exception);
       if (alpha_type == ShapeAlphaChannel)
         (void) LevelImageColors(image,&image->background_color,
           &image->background_color,MagickTrue,exception);
@@ -2213,7 +2214,8 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
     }
     case ExtractAlphaChannel:
     {
-      status=CompositeImage(image,AlphaCompositeOp,image,0,0,exception);
+      status=CompositeImage(image,image,AlphaCompositeOp,MagickFalse,0,0,
+        exception);
       image->matte=MagickFalse;
       break;
     }
@@ -3610,8 +3612,8 @@ MagickExport Image *SmushImages(const Image *images,
         x_offset-=SmushXGap(smush_image,image,offset,exception);
         y_offset-=geometry.y;
       }
-    status=CompositeImage(smush_image,OverCompositeOp,image,x_offset,y_offset,
-      exception);
+    status=CompositeImage(smush_image,image,OverCompositeOp,MagickFalse,
+      x_offset,y_offset,exception);
     proceed=SetImageProgress(image,SmushImageTag,n,number_images);
     if (proceed == MagickFalse)
       break;

diff --git a/MagickCore/layer.c b/MagickCore/layer.c
index 8386273b4cf0f186afcc588980f4633f44b46008..defd88d855aa188e333f64c8172092bc3c7b3472 100644 (file)
--- a/MagickCore/layer.c
+++ b/MagickCore/layer.c
@@ -276,8 +276,8 @@ MagickExport Image *CoalesceImages(const Image *image,ExceptionInfo *exception)
     Coalesce rest of the images.
   */
   dispose_image=CloneImage(coalesce_image,0,0,MagickTrue,exception);
-  (void) CompositeImage(coalesce_image,CopyCompositeOp,next,next->page.x,
-    next->page.y,exception);
+  (void) CompositeImage(coalesce_image,next,CopyCompositeOp,MagickFalse,
+    next->page.x,next->page.y,exception);
   next=GetNextImageInList(next);
   for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
   {
@@ -327,8 +327,8 @@ MagickExport Image *CoalesceImages(const Image *image,ExceptionInfo *exception)
     coalesce_image->next->previous=coalesce_image;
     previous=coalesce_image;
     coalesce_image=GetNextImageInList(coalesce_image);
-    (void) CompositeImage(coalesce_image,next->matte != MagickFalse ?
-      OverCompositeOp : CopyCompositeOp,next,next->page.x,next->page.y,
+    (void) CompositeImage(coalesce_image,next,next->matte != MagickFalse ?
+      OverCompositeOp : CopyCompositeOp,MagickFalse,next->page.x,next->page.y,
       exception);
     (void) CloneImageProfiles(coalesce_image,next);
     (void) CloneImageProperties(coalesce_image,next);
@@ -368,19 +368,20 @@ MagickExport Image *CoalesceImages(const Image *image,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
-%    o image: the image sequence.
+%    o images: the image sequence.
 %
 %    o exception: return any errors or warnings in this structure.
 %
 */
-MagickExport Image *DisposeImages(const Image *image,ExceptionInfo *exception)
+MagickExport Image *DisposeImages(const Image *images,ExceptionInfo *exception)
 {
   Image
     *dispose_image,
     *dispose_images;
 
   register Image
-    *curr;
+    *image,
+    *next;
 
   RectangleInfo
     bounds;
@@ -388,25 +389,25 @@ MagickExport Image *DisposeImages(const Image *image,ExceptionInfo *exception)
   /*
     Run the image through the animation sequence
   */
-  assert(image != (Image *) NULL);
-  assert(image->signature == MagickSignature);
-  if (image->debug != MagickFalse)
-    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  assert(images != (Image *) NULL);
+  assert(images->signature == MagickSignature);
+  if (images->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  curr=GetFirstImageInList(image);
-  dispose_image=CloneImage(curr,curr->page.width,curr->page.height,MagickTrue,
-    exception);
+  image=GetFirstImageInList(images);
+  dispose_image=CloneImage(image,image->page.width,image->page.height,
+    MagickTrue,exception);
   if (dispose_image == (Image *) NULL)
     return((Image *) NULL);
-  dispose_image->page=curr->page;
+  dispose_image->page=image->page;
   dispose_image->page.x=0;
   dispose_image->page.y=0;
   dispose_image->dispose=NoneDispose;
   dispose_image->background_color.alpha=(Quantum) TransparentAlpha;
   (void) SetImageBackgroundColor(dispose_image,exception);
   dispose_images=NewImageList();
-  for ( ; curr != (Image *) NULL; curr=GetNextImageInList(curr))
+  for (next=image; image != (Image *) NULL; image=GetNextImageInList(image))
   {
     Image
       *current_image;
@@ -421,17 +422,17 @@ MagickExport Image *DisposeImages(const Image *image,ExceptionInfo *exception)
         dispose_image=DestroyImage(dispose_image);
         return((Image *) NULL);
       }
-    (void) CompositeImage(current_image,curr->matte != MagickFalse ?
-      OverCompositeOp : CopyCompositeOp,curr,curr->page.x,curr->page.y,
+    (void) CompositeImage(current_image,next,next->matte != MagickFalse ?
+      OverCompositeOp : CopyCompositeOp,MagickFalse,next->page.x,next->page.y,
       exception);
     /*
       Handle Background dispose: image is displayed for the delay period.
     */
-    if (curr->dispose == BackgroundDispose)
+    if (next->dispose == BackgroundDispose)
       {
-        bounds=curr->page;
-        bounds.width=curr->columns;
-        bounds.height=curr->rows;
+        bounds=next->page;
+        bounds.width=next->columns;
+        bounds.height=next->rows;
         if (bounds.x < 0)
           {
             bounds.width+=bounds.x;
@@ -451,7 +452,7 @@ MagickExport Image *DisposeImages(const Image *image,ExceptionInfo *exception)
     /*
       Select the appropriate previous/disposed image.
     */
-    if (curr->dispose == PreviousDispose)
+    if (next->dispose == PreviousDispose)
       current_image=DestroyImage(current_image);
     else
       {
@@ -473,12 +474,12 @@ MagickExport Image *DisposeImages(const Image *image,ExceptionInfo *exception)
           dispose_image=DestroyImage(dispose_image);
           return((Image *) NULL);
         }
-      (void) CloneImageProfiles(dispose,curr);
-      (void) CloneImageProperties(dispose,curr);
-      (void) CloneImageArtifacts(dispose,curr);
+      (void) CloneImageProfiles(dispose,next);
+      (void) CloneImageProperties(dispose,next);
+      (void) CloneImageArtifacts(dispose,next);
       dispose->page.x=0;
       dispose->page.y=0;
-      dispose->dispose=curr->dispose;
+      dispose->dispose=next->dispose;
       AppendImageToList(&dispose_images,dispose);
     }
   }
@@ -793,8 +794,8 @@ MagickExport Image *CompareImagesLayers(const Image *image,
   image_a->page=next->page;
   image_a->page.x=0;
   image_a->page.y=0;
-  (void) CompositeImage(image_a,CopyCompositeOp,next,next->page.x,next->page.y,
-    exception);
+  (void) CompositeImage(image_a,next,CopyCompositeOp,MagickFalse,next->page.x,
+    next->page.y,exception);
   /*
     Compute the bounding box of changes for the later images
   */
@@ -809,7 +810,7 @@ MagickExport Image *CompareImagesLayers(const Image *image,
         bounds=(RectangleInfo *) RelinquishMagickMemory(bounds);
         return((Image *) NULL);
       }
-    (void) CompositeImage(image_a,CopyCompositeOp,next,next->page.x,
+    (void) CompositeImage(image_a,next,CopyCompositeOp,MagickFalse,next->page.x,
       next->page.y,exception);
     bounds[i]=CompareImagesBounds(image_b,image_a,method,exception);
 
@@ -1497,8 +1498,8 @@ MagickExport void OptimizeImageTransparency(const Image *image,
         dispose_image=DestroyImage(dispose_image);
         return;
       }
-    (void) CompositeImage(current_image,next->matte != MagickFalse ?
-      OverCompositeOp : CopyCompositeOp, next,next->page.x,next->page.y,
+    (void) CompositeImage(current_image,next,next->matte != MagickFalse ?
+      OverCompositeOp : CopyCompositeOp,MagickFalse,next->page.x,next->page.y,
       exception);
     /*
       At this point the image would be displayed, for the delay period
@@ -1540,9 +1541,9 @@ MagickExport void OptimizeImageTransparency(const Image *image,
       Optimize Transparency of the next frame (if present)
     */
     next=GetNextImageInList(next);
-    if ( next != (Image *) NULL ) {
-      (void) CompositeImage(next, ChangeMaskCompositeOp,
-        dispose_image, -(next->page.x), -(next->page.y), exception );
+    if (next != (Image *) NULL) {
+      (void) CompositeImage(next,dispose_image,ChangeMaskCompositeOp,
+        MagickFalse,-(next->page.x),-(next->page.y),exception);
     }
   }
   dispose_image=DestroyImage(dispose_image);
@@ -1757,8 +1758,8 @@ static inline void CompositeCanvas(Image *destination,
 {
   x_offset+=source->page.x-destination->page.x;
   y_offset+=source->page.y-destination->page.y;
-  (void) CompositeImage(destination,compose,source,x_offset,y_offset,
-    exception);
+  (void) CompositeImage(destination,source,compose,MagickFalse,x_offset,
+    y_offset,exception);
 }
 
 MagickExport void CompositeLayers(Image *destination,
@@ -2031,7 +2032,7 @@ MagickExport Image *MergeImageLayers(Image *image,const ImageLayerMethod method,
   number_images=GetImageListLength(image);
   for (scene=0; scene < (ssize_t) number_images; scene++)
   {
-    (void) CompositeImage(canvas,image->compose,image,image->page.x-
+    (void) CompositeImage(canvas,image,image->compose,MagickFalse,image->page.x-
       canvas->page.x,image->page.y-canvas->page.y,exception);
     proceed=SetImageProgress(image,MergeLayersTag,(MagickOffsetType) scene,
       number_images);

diff --git a/MagickCore/montage.c b/MagickCore/montage.c
index 079d6d801b644908ecee12c70a7a53c887354eea..cd622049592fe85da23beeddc8cf6571571ed206 100644 (file)
--- a/MagickCore/montage.c
+++ b/MagickCore/montage.c
@@ -823,14 +823,14 @@ MagickExport Image *MontageImageList(const ImageInfo *image_info,
               shadow_image=ShadowImage(image,80.0,2.0,5,5,exception);
               if (shadow_image != (Image *) NULL)
                 {
-                  (void) CompositeImage(shadow_image,OverCompositeOp,image,0,0,
-                    exception);
+                  (void) CompositeImage(shadow_image,image,OverCompositeOp,
+                    MagickFalse,0,0,exception);
                   image=DestroyImage(image);
                   image=shadow_image;
                 }
           }
-          (void) CompositeImage(montage,image->compose,image,x_offset+x,
-            y_offset+y,exception);
+          (void) CompositeImage(montage,image,image->compose,MagickFalse,
+            x_offset+x,y_offset+y,exception);
           value=GetImageProperty(image,"label",exception);
           if (value != (const char *) NULL)
             {

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index 7173b7de7a5722935ca586dd20c36cef57d3608c..ed99e2fc55847a1e2c0ed4727ed82c95ffc99340 100644 (file)
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -3876,8 +3876,8 @@ MagickPrivate Image *MorphologyApply(const Image *image,
         /* Preserve the alpha channel of input image - but turned off */
         (void) SetImageAlphaChannel(rslt_image, DeactivateAlphaChannel,
           exception);
-        (void) CompositeImage(rslt_image, CopyAlphaCompositeOp, image, 0, 0,
-          exception);
+        (void) CompositeImage(rslt_image,image,CopyAlphaCompositeOp,
+          MagickFalse,0,0,exception);
         (void) SetImageAlphaChannel(rslt_image, DeactivateAlphaChannel,
           exception);
       }
@@ -4103,16 +4103,16 @@ MagickPrivate Image *MorphologyApply(const Image *image,
             (void) FormatLocaleFile(stderr,
               "\n%s: Difference with original image",CommandOptionToMnemonic(
               MagickMorphologyOptions, method) );
-          (void) CompositeImage(curr_image,DifferenceCompositeOp,image,0,0,
-            exception);
+          (void) CompositeImage(curr_image,image,DifferenceCompositeOp,
+            MagickFalse,0,0,exception);
           break;
         case EdgeMorphology:
           if ( verbose == MagickTrue )
             (void) FormatLocaleFile(stderr,
               "\n%s: Difference of Dilate and Erode",CommandOptionToMnemonic(
               MagickMorphologyOptions, method) );
-          (void) CompositeImage(curr_image,DifferenceCompositeOp,save_image,0,
-            0,exception);
+          (void) CompositeImage(curr_image,save_image,DifferenceCompositeOp,
+            MagickFalse,0,0,exception);
           save_image = DestroyImage(save_image); /* finished with save image */
           break;
         default:
@@ -4147,9 +4147,9 @@ MagickPrivate Image *MorphologyApply(const Image *image,
           */
           if ( verbose == MagickTrue )
             (void) FormatLocaleFile(stderr, " (compose \"%s\")",
-                 CommandOptionToMnemonic(MagickComposeOptions, rslt_compose) );
-          (void) CompositeImage(rslt_image, rslt_compose, curr_image, 0, 0,
-            exception);
+              CommandOptionToMnemonic(MagickComposeOptions, rslt_compose) );
+          (void) CompositeImage(rslt_image,curr_image,rslt_compose,MagickFalse,
+            0,0,exception);
           curr_image = DestroyImage(curr_image);
           curr_image = (Image *) image;  /* continue with original image */
         }

diff --git a/MagickCore/transform.c b/MagickCore/transform.c
index e94e51f5b5f3150d29ce282f85ed0f2dfde17c2b..0546abc5aa13791dbf8dd11d682eed929f303353 100644 (file)
--- a/MagickCore/transform.c
+++ b/MagickCore/transform.c
@@ -1083,8 +1083,8 @@ MagickExport Image *ExtentImage(const Image *image,
   if (extent_image->background_color.alpha != OpaqueAlpha)
     extent_image->matte=MagickTrue;
   (void) SetImageBackgroundColor(extent_image,exception);
-  (void) CompositeImage(extent_image,image->compose,image,-geometry->x,
-    -geometry->y,exception);
+  (void) CompositeImage(extent_image,image,image->compose,MagickFalse,
+    -geometry->x,-geometry->y,exception);
   return(extent_image);
 }
 \f

diff --git a/MagickCore/xwindow.c b/MagickCore/xwindow.c
index eacd877276f660f05349462aa58865d14f566753..12eb39da085da0fc8c467cce110bc4136e3bba01 100644 (file)
--- a/MagickCore/xwindow.c
+++ b/MagickCore/xwindow.c
@@ -696,9 +696,9 @@ MagickPrivate MagickBooleanType XAnnotateImage(Display *display,
   */
   (void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
   matte=image->matte;
-  (void) CompositeImage(image,annotate_image->matte != MagickFalse ?
-    OverCompositeOp : CopyCompositeOp,annotate_image,(ssize_t) x,(ssize_t) y,
-    exception);
+  (void) CompositeImage(image,annotate_image,
+    annotate_image->matte != MagickFalse ? OverCompositeOp : CopyCompositeOp,
+    MagickFalse,(ssize_t) x,(ssize_t) y,exception);
   image->matte=matte;
   annotate_image=DestroyImage(annotate_image);
   return(MagickTrue);
@@ -2635,13 +2635,13 @@ MagickPrivate MagickBooleanType XDrawImage(Display *display,
   draw_view=DestroyCacheView(draw_view);
   (void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
   if (draw_info->stencil == TransparentStencil)
-    (void) CompositeImage(image,CopyAlphaCompositeOp,draw_image,(ssize_t) x,
-      (ssize_t) y,exception);
+    (void) CompositeImage(image,draw_image,CopyAlphaCompositeOp,MagickFalse,
+      (ssize_t) x,(ssize_t) y,exception);
   else
     {
       matte=image->matte;
-      (void) CompositeImage(image,OverCompositeOp,draw_image,(ssize_t) x,
-        (ssize_t) y,exception);
+      (void) CompositeImage(image,draw_image,OverCompositeOp,MagickFalse,
+        (ssize_t) x,(ssize_t) y,exception);
       image->matte=matte;
     }
   draw_image=DestroyImage(draw_image);
@@ -4523,8 +4523,8 @@ static Image *XGetWindowImage(Display *display,const Window window,
         y_offset-=(int) crop_info.y;
         if (y_offset < 0)
           y_offset=0;
-        (void) CompositeImage(image,CopyCompositeOp,composite_image,(ssize_t)
-          x_offset,(ssize_t) y_offset,exception);
+        (void) CompositeImage(image,composite_image,CopyCompositeOp,MagickFalse,
+          (ssize_t) x_offset,(ssize_t) y_offset,exception);
         composite_image=DestroyImage(composite_image);
       }
       /*
@@ -5935,8 +5935,8 @@ static void XMakeImageLSBFirst(const XResourceInfo *resource_info,
         {
           canvas=CloneImage(image,0,0,MagickTrue,exception);
           if (canvas != (Image *) NULL)
-            (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0,
-              exception);
+            (void) CompositeImage(canvas,pattern,DstOverCompositeOp,MagickFalse,
+              0,0,exception);
           pattern=DestroyImage(pattern);
         }
     }
@@ -6567,8 +6567,8 @@ static void XMakeImageMSBFirst(const XResourceInfo *resource_info,
         {
           canvas=CloneImage(image,0,0,MagickTrue,exception);
           if (canvas != (Image *) NULL)
-            (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0,
-              exception);
+            (void) CompositeImage(canvas,pattern,DstOverCompositeOp,MagickFalse,
+              0,0,exception);
           pattern=DestroyImage(pattern);
         }
     }

diff --git a/MagickWand/compare.c b/MagickWand/compare.c
index 4ea102e624c2b46261a8d0ec66eaef59ce7f00fd..4141bb09bf0c9fdbb868214afd7d97a5ec705083 100644 (file)
--- a/MagickWand/compare.c
+++ b/MagickWand/compare.c
@@ -959,8 +959,8 @@ WandExport MagickBooleanType CompareImagesCommand(ImageInfo *image_info,
             &distortion,exception);
         else
           {
-            (void) CompositeImage(composite_image,CopyCompositeOp,
-              reconstruct_image,offset.x,offset.y,exception);
+            (void) CompositeImage(composite_image,reconstruct_image,
+              CopyCompositeOp,MagickFalse,offset.x,offset.y,exception);
             difference_image=CompareImages(image,composite_image,metric,
               &distortion,exception);
             if (difference_image != (Image *) NULL)

diff --git a/MagickWand/composite.c b/MagickWand/composite.c
index 7da939e5ace2779dd58ff90d10cf889bb7cb0802..4c7e77f015c0026a54a7627c5deb9caf8831cdeb 100644 (file)
--- a/MagickWand/composite.c
+++ b/MagickWand/composite.c
@@ -193,8 +193,8 @@ static MagickBooleanType CompositeImageList(ImageInfo *image_info,Image **image,
               columns=composite_image->columns;
               for (y=0; y < (ssize_t) (*image)->rows; y+=(ssize_t) composite_image->rows)
                 for (x=0; x < (ssize_t) (*image)->columns; x+=(ssize_t) columns)
-                  status&=CompositeImage(*image,composite_options->compose,
-                    composite_image,x,y,exception);
+                  status&=CompositeImage(*image,composite_image,
+                    composite_options->compose,MagickFalse,x,y,exception);
             }
           else
             {
@@ -215,8 +215,9 @@ static MagickBooleanType CompositeImageList(ImageInfo *image_info,Image **image,
               /*
                 Digitally composite image.
               */
-              status&=CompositeImage(*image,composite_options->compose,
-                composite_image,geometry.x,geometry.y,exception);
+              status&=CompositeImage(*image,composite_image,
+                composite_options->compose,MagickFalse,geometry.x,geometry.y,
+                exception);
             }
     }
   (void) SetPixelChannelMapMask(composite_image,channel_mask);
@@ -1637,8 +1638,8 @@ WandExport MagickBooleanType CompositeImageCommand(ImageInfo *image_info,
           /*
             Merge Y displacement into X displacement image.
           */
-          (void) CompositeImage(composite_image,CopyGreenCompositeOp,mask_image,
-            0,0,exception);
+          (void) CompositeImage(composite_image,mask_image,CopyGreenCompositeOp,
+            MagickFalse,0,0,exception);
           mask_image=DestroyImage(mask_image);
         }
       else

diff --git a/MagickWand/magick-image.c b/MagickWand/magick-image.c
index f9d11498b99225a88d6f5ed10194deee4fa23f62..69aa16a404388705a5e9605851edc5f4f67fe0bb 100644 (file)
--- a/MagickWand/magick-image.c
+++ b/MagickWand/magick-image.c
@@ -1795,7 +1795,7 @@ WandExport MagickWand *MagickCompareImages(MagickWand *wand,
 %
 %      MagickBooleanType MagickCompositeImage(MagickWand *wand,
 %        const MagickWand *source_wand,const CompositeOperator compose,
-%        const ssize_t x,const ssize_t y)
+%        const MagickBooleanType clip_to_self,const ssize_t x,const ssize_t y)
 %
 %  A description of each parameter follows:
 %
@@ -1813,6 +1813,8 @@ WandExport MagickWand *MagickCompareImages(MagickWand *wand,
 %        DifferenceCompositeOp BumpmapCompositeOp    CopyCompositeOp
 %        DisplaceCompositeOp
 %
+%    o clip_to_self: set to MagickTrue to limit composition to area composed.
+%
 %    o x: the column offset of the composited image.
 %
 %    o y: the row offset of the composited image.
@@ -1820,7 +1822,7 @@ WandExport MagickWand *MagickCompareImages(MagickWand *wand,
 */
 WandExport MagickBooleanType MagickCompositeImage(MagickWand *wand,
   const MagickWand *source_wand,const CompositeOperator compose,
-  const ssize_t x,const ssize_t y)
+  const MagickBooleanType clip_to_self,const ssize_t x,const ssize_t y)
 {
   MagickBooleanType
     status;
@@ -1832,8 +1834,8 @@ WandExport MagickBooleanType MagickCompositeImage(MagickWand *wand,
   if ((wand->images == (Image *) NULL) ||
       (source_wand->images == (Image *) NULL))
     ThrowWandException(WandError,"ContainsNoImages",wand->name);
-  status=CompositeImage(wand->images,compose,source_wand->images,x,y,
-    wand->exception);
+  status=CompositeImage(wand->images,source_wand->images,compose,clip_to_self,
+    x,y,wand->exception);
   return(status);
 }
 \f

diff --git a/MagickWand/magick-image.h b/MagickWand/magick-image.h
index ba8763e6cba7e10caf0a65a47ec7950d8575d3b8..40e52f8c3eda9ae36f1dc40f98074f77e1c0311b 100644 (file)
--- a/MagickWand/magick-image.h
+++ b/MagickWand/magick-image.h
@@ -102,7 +102,7 @@ extern WandExport MagickBooleanType
   MagickColorMatrixImage(MagickWand *,const KernelInfo *),
   MagickCommentImage(MagickWand *,const char *),
   MagickCompositeImage(MagickWand *,const MagickWand *,const CompositeOperator,
-    const ssize_t,const ssize_t),
+    const MagickBooleanType,const ssize_t,const ssize_t),
   MagickCompositeLayers(MagickWand *,const MagickWand *,const CompositeOperator,
     const ssize_t,const ssize_t),
   MagickConstituteImage(MagickWand *,const size_t,const size_t,const char *,

diff --git a/MagickWand/mogrify.c b/MagickWand/mogrify.c
index 64d5272174cecce90b84df74769c2ed0e04cc065..ad3cc1e70e0139482b7d10aadad3c51968b67ba1 100644 (file)
--- a/MagickWand/mogrify.c
+++ b/MagickWand/mogrify.c
@@ -2448,8 +2448,8 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
                 /*
                   Composite region.
                 */
-                (void) CompositeImage(region_image,region_image->matte !=
-                   MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
+                (void) CompositeImage(region_image,*image,region_image->matte !=
+                   MagickFalse ? CopyCompositeOp : OverCompositeOp,MagickFalse,
                    region_geometry.x,region_geometry.y,exception);
                 *image=DestroyImage(*image);
                 *image=region_image;
@@ -3194,8 +3194,8 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
         Composite transformed region onto image.
       */
       (void) SyncImageSettings(mogrify_info,*image,exception);
-      (void) CompositeImage(region_image,region_image->matte !=
-         MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
+      (void) CompositeImage(region_image,*image,region_image->matte !=
+         MagickFalse ? CopyCompositeOp : OverCompositeOp,MagickFalse,
          region_geometry.x,region_geometry.y,exception);
       *image=DestroyImage(*image);
       *image=region_image;
@@ -7408,11 +7408,17 @@ WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
           }
         if (LocaleCompare("composite",option+1) == 0)
           {
+            const char
+              *value;
+
             Image
               *mask_image,
               *composite_image,
               *image;
 
+            MagickBooleanType
+              clip_to_self;
+
             RectangleInfo
               geometry;
 
@@ -7439,8 +7445,8 @@ WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
                     /*
                       Merge Y displacement into X displacement image.
                     */
-                    (void) CompositeImage(composite_image,CopyGreenCompositeOp,
-                      mask_image,0,0,exception);
+                    (void) CompositeImage(composite_image,mask_image,
+                      CopyGreenCompositeOp,MagickFalse,0,0,exception);
                     mask_image=DestroyImage(mask_image);
                   }
                 else
@@ -7453,8 +7459,13 @@ WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
                     mask_image=DestroyImage(mask_image);
                   }
               }
-            (void) CompositeImage(image,image->compose,composite_image,
-              geometry.x,geometry.y,exception);
+            clip_to_self=MagickFalse;
+            value=GetImageArtifact(composite_image,"compose:outside-overlay");
+            if (value != (const char *) NULL)
+              clip_to_self=IsMagickTrue(value) == MagickFalse ? MagickTrue :
+                MagickFalse;
+            (void) CompositeImage(image,composite_image,image->compose,
+              clip_to_self,geometry.x,geometry.y,exception);
             (void) SetImageMask(image,(Image *) NULL,exception);
             composite_image=DestroyImage(composite_image);
             *images=DestroyImageList(*images);

diff --git a/MagickWand/operation.c b/MagickWand/operation.c
index 5f6a32c94a66424bb369990ecc91b63fb5b9f3ae..7d972ea64d18ad43296705fb28fac7ec798ca48b 100644 (file)
--- a/MagickWand/operation.c
+++ b/MagickWand/operation.c
@@ -3842,6 +3842,15 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
         }
       if (LocaleCompare("composite",option+1) == 0)
         {
+          CompositeOperator
+            compose;
+
+          const char*
+            value;
+
+          MagickBooleanType
+            clip_to_self;
+
           Image
             *mask_image,
             *source_image;
@@ -3849,12 +3858,6 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
           RectangleInfo
             geometry;
 
-          CompositeOperator
-            compose;
-
-          const char*
-            value;
-
           value=GetImageOption(_image_info,"compose");
           if (value != (const char *) NULL)
             compose=(CompositeOperator) ParseCommandOption(
@@ -3883,8 +3886,8 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
               if ((compose == DisplaceCompositeOp) ||
                   (compose == DistortCompositeOp))
                 { /* Merge Y displacement into X displace/distort map. */
-                  (void) CompositeImage(source_image,CopyGreenCompositeOp,
-                    mask_image,0,0,_exception);
+                  (void) CompositeImage(source_image,mask_image,
+                    CopyGreenCompositeOp,MagickFalse,0,0,_exception);
                   mask_image=DestroyImage(mask_image);
                 }
               else
@@ -3897,8 +3900,13 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
                   mask_image=DestroyImage(mask_image);
                 }
             }
-          (void) CompositeImage(new_images,compose,source_image,geometry.x,
-                     geometry.y,_exception);
+          clip_to_self=MagickFalse;
+          value=GetImageArtifact(source_image,"compose:outside-overlay");
+          if (value != (const char *) NULL)
+            clip_to_self=IsMagickTrue(value) == MagickFalse ? MagickTrue :
+              MagickFalse;
+          (void) CompositeImage(new_images,source_image,compose,clip_to_self,
+            geometry.x,geometry.y,_exception);
           (void) SetImageMask(new_images,(Image *) NULL,_exception);
           source_image=DestroyImage(source_image);
           break;

diff --git a/PerlMagick/Magick.xs b/PerlMagick/Magick.xs
index 8fb5a10779093ad53ab2ee0d928aaca724eeda02..098fa5b1d0ddca4ae7bc85ba88070667289738dd 100644 (file)
--- a/PerlMagick/Magick.xs
+++ b/PerlMagick/Magick.xs
@@ -299,7 +299,7 @@ static struct
       {"color", StringReference}, {"mask", ImageReference},
       {"channel", MagickChannelOptions},
       {"interpolate", MagickInterpolateOptions}, {"args", StringReference},
-      {"blend", StringReference} } },
+      {"blend", StringReference}, {"crop-to-self", MagickBooleanOptions} } },
     { "Contrast", { {"sharpen", MagickBooleanOptions} } },
     { "CycleColormap", { {"display", IntegerReference} } },
     { "Draw", { {"primitive", MagickPrimitiveOptions},
@@ -8375,6 +8375,9 @@ Mogrify(ref,...)
             *composite_image,
             *rotate_image;
 
+          MagickBooleanType
+            clip_to_self;
+
           compose=OverCompositeOp;
           if (attribute_flag[0] != 0)
             composite_image=argument_list[0].image_reference;
@@ -8457,6 +8460,10 @@ Mogrify(ref,...)
           if (attribute_flag[14] != 0)   /* "blend=>"  depreciated */
             (void) SetImageArtifact(composite_image,"compose:args",
               argument_list[14].string_reference);
+          clip_to_self=MagickFalse;
+          if (attribute_flag[15] != 0)
+            clip_to_self=(MagickBooleanType)
+              argument_list[15].integer_reference;
           /*
             Tiling Composition (with orthogonal rotate).
           */
@@ -8491,11 +8498,11 @@ Mogrify(ref,...)
                 for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) composite_image->columns)
                 {
                   if (attribute_flag[8] != 0) /* rotate */
-                    (void) CompositeImage(image,compose,rotate_image,x,y,
-                      exception);
+                    (void) CompositeImage(image,rotate_image,compose,
+                      MagickFalse,x,y,exception);
                   else
-                    (void) CompositeImage(image,compose,composite_image,x,y,
-                      exception);
+                    (void) CompositeImage(image,composite_image,compose,
+                      MagickFalse,x,y,exception);
                 }
               if (attribute_flag[8] != 0) /* rotate */
                 rotate_image=DestroyImage(rotate_image);
@@ -8528,8 +8535,9 @@ Mogrify(ref,...)
                   */
                   composite_image=CloneImage(composite_image,0,0,MagickTrue,
                     exception);
-                  (void) CompositeImage(composite_image,CopyGreenCompositeOp,
-                    argument_list[10].image_reference,0,0,exception);
+                  (void) CompositeImage(composite_image,
+                    argument_list[10].image_reference,CopyGreenCompositeOp,
+                    MagickFalse,0,0,exception);
                 }
               else
                 {
@@ -8559,8 +8567,8 @@ Mogrify(ref,...)
             exception);
           channel_mask=SetPixelChannelMask(image,channel);
           if (attribute_flag[8] == 0) /* no rotate */
-            CompositeImage(image,compose,composite_image,geometry.x,geometry.y,
-              exception);
+            CompositeImage(image,composite_image,compose,clip_to_self,
+              geometry.x,geometry.y,exception);
           else
             {
               /*
@@ -8570,8 +8578,8 @@ Mogrify(ref,...)
                 composite_image->columns)/2;
               geometry.y-=(ssize_t) (rotate_image->rows-
                 composite_image->rows)/2;
-              CompositeImage(image,compose,rotate_image,geometry.x,geometry.y,
-                exception);
+              CompositeImage(image,rotate_image,compose,clip_to_self,geometry.x,
+                geometry.y,exception);
               rotate_image=DestroyImage(rotate_image);
             }
           if (attribute_flag[10] != 0) /* mask */
@@ -10917,7 +10925,7 @@ Mogrify(ref,...)
           /*
             Composite region.
           */ 
-          status=CompositeImage(region_image,CopyCompositeOp,image,
+          status=CompositeImage(region_image,image,CopyCompositeOp,MagickFalse,
             region_info.x,region_info.y,exception);
           (void) status;
           (void) CatchImageException(region_image);

diff --git a/coders/msl.c b/coders/msl.c
index bc8b7f05f6e08cc8c5fca4691b8ee99e7b2cf0f2..3c785d634ee9091503ab7f7c07d613260fa7df2f 100644 (file)
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -1915,8 +1915,8 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                           SetImageType(composite_image,TrueColorMatteType,
                             &exception);
                           (void) CompositeImage(composite_image,
-                            CopyAlphaCompositeOp,msl_info->image[j],0,0,
-                            &exception);
+                            msl_info->image[j],CopyAlphaCompositeOp,MagickFalse,
+                            0,0,&exception);
                           break;
                         }
                     }
@@ -2017,11 +2017,11 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                          for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) width)
                          {
                            if (rotate_image != (Image *) NULL)
-                             (void) CompositeImage(image,compose,rotate_image,
-                               x,y,&exception);
+                             (void) CompositeImage(image,rotate_image,compose,
+                               MagickFalse,x,y,&exception);
                            else
-                             (void) CompositeImage(image,compose,
-                               composite_image,x,y,&exception);
+                             (void) CompositeImage(image,composite_image,
+                               compose,MagickFalse,x,y,&exception);
                          }
                       if (rotate_image != (Image *) NULL)
                         rotate_image=DestroyImage(rotate_image);
@@ -2072,8 +2072,8 @@ static void MSLStartElement(void *context,const xmlChar *tag,
             &exception);
           channel_mask=SetPixelChannelMask(image,channel);
           if (rotate_image == (Image *) NULL)
-            CompositeImage(image,compose,composite_image,geometry.x,geometry.y,
-              &exception);
+            CompositeImage(image,composite_image,compose,MagickFalse,geometry.x,
+              geometry.y,&exception);
           else
             {
               /*
@@ -2083,8 +2083,8 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                 composite_image->columns)/2;
               geometry.y-=(ssize_t) (rotate_image->rows-
                 composite_image->rows)/2;
-              CompositeImage(image,compose,rotate_image,geometry.x,geometry.y,
-                &exception);
+              CompositeImage(image,rotate_image,compose,MagickFalse,geometry.x,
+                geometry.y,&exception);
               rotate_image=DestroyImage(rotate_image);
             }
           (void) SetPixelChannelMask(image,channel_mask);

diff --git a/coders/pict.c b/coders/pict.c
index 36224e0faba55bed076f4ec0bc77b0daa8cc6fa3..d0721e46b81c4d6e678086e13693f3ea8c217b02 100644 (file)
--- a/coders/pict.c
+++ b/coders/pict.c
@@ -1241,8 +1241,8 @@ static Image *ReadPICTImage(const ImageInfo *image_info,
             if (jpeg == MagickFalse)
               if ((code == 0x9a) || (code == 0x9b) ||
                   ((bytes_per_line & 0x8000) != 0))
-                (void) CompositeImage(image,CopyCompositeOp,tile_image,
-                  destination.left,destination.top,exception);
+                (void) CompositeImage(image,tile_image,CopyCompositeOp,
+                  MagickFalse,destination.left,destination.top,exception);
             tile_image=DestroyImage(tile_image);
             break;
           }
@@ -1388,8 +1388,8 @@ static Image *ReadPICTImage(const ImageInfo *image_info,
         if (IsRGBColorspace(image->colorspace) == MagickFalse)
           (void) TransformImageColorspace(image,tile_image->colorspace,
             exception);
-        (void) CompositeImage(image,CopyCompositeOp,tile_image,frame.left,
-          frame.right,exception);
+        (void) CompositeImage(image,tile_image,CopyCompositeOp,MagickFalse,
+          frame.left,frame.right,exception);
         image->compression=tile_image->compression;
         tile_image=DestroyImage(tile_image);
         continue;

diff --git a/coders/xcf.c b/coders/xcf.c
index 024c257fcb857ca2225f373f2a0c61d8e06196f0..c62bd71e6dbba1a062dd098f76b0cb95a5d9b96c 100644 (file)
--- a/coders/xcf.c
+++ b/coders/xcf.c
@@ -682,8 +682,8 @@ static MagickBooleanType load_level(Image *image,XCFDocInfo *inDocInfo,
       }
 
       /* composite the tile onto the layer's image, and then destroy it */
-      (void) CompositeImage(inLayerInfo->image,CopyCompositeOp,tile_image,
-        destLeft * TILE_WIDTH,destTop*TILE_HEIGHT,exception);
+      (void) CompositeImage(inLayerInfo->image,tile_image,CopyCompositeOp,
+        MagickFalse,destLeft*TILE_WIDTH,destTop*TILE_HEIGHT,exception);
       tile_image=DestroyImage(tile_image);
 
       /* adjust tile position */
@@ -1310,8 +1310,8 @@ static Image *ReadXCFImage(const ImageInfo *image_info,ExceptionInfo *exception)
         /*
           Composite the layer data onto the main image, dispose the layer.
         */
-        (void) CompositeImage(image,OverCompositeOp,layer_info[0].image,
-          layer_info[0].offset_x,layer_info[0].offset_y,exception);
+        (void) CompositeImage(image,layer_info[0].image,OverCompositeOp,
+          MagickFalse,layer_info[0].offset_x,layer_info[0].offset_y,exception);
         layer_info[0].image =DestroyImage( layer_info[0].image);
       }
     else
@@ -1344,12 +1344,11 @@ static Image *ReadXCFImage(const ImageInfo *image_info,ExceptionInfo *exception)
         signed int  j;
 
         /* first we copy the last layer on top of the main image */
-        (void) CompositeImage(image,CopyCompositeOp,
-          layer_info[number_layers-1].image,
-          layer_info[number_layers-1].offset_x,
+        (void) CompositeImage(image,layer_info[number_layers-1].image,
+          CopyCompositeOp,MagickFalse,layer_info[number_layers-1].offset_x,
           layer_info[number_layers-1].offset_y,exception);
-          layer_info[number_layers-1].image=DestroyImage(
-            layer_info[number_layers-1].image);
+        layer_info[number_layers-1].image=DestroyImage(
+          layer_info[number_layers-1].image);
 
         /* now reverse the order of the layers as they are put
            into subimages