#include "MagickCore/studio.h"
#include "MagickCore/accelerate.h"
#include "MagickCore/artifact.h"
+#include "MagickCore/cache.h"
#include "MagickCore/cache-view.h"
#include "MagickCore/color-private.h"
#include "MagickCore/enhance.h"
% %
% %
% %
-% C o m p o s i t e I m a g e C h a n n e l %
+% C o m p o s i t e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% CompositeImageChannel() returns the second image composited onto the first
+% CompositeImage() returns the second image composited onto the first
% at the specified offset, using the specified composite method.
%
-% The format of the CompositeImageChannel method is:
+% 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)
-% MagickBooleanType CompositeImageChannel(Image *image,
-% const ChannelType channel,const CompositeOperator compose,
-% Image *composite_image,const ssize_t x_offset,const ssize_t y_offset)
%
% A description of each parameter follows:
%
% o image: the destination image, modified by he composition
%
-% o channel: the channel.
-%
% 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.
}
static inline void CompositeDarken(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
gamma;
}
static inline void CompositeDarkenIntensity(const Image *image,
- const PixelInfo *p,const PixelInfo *q,const ChannelType channel,
- PixelInfo *composite)
+ const PixelInfo *p,const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeDifference(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeDivide(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeExclusion(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
gamma,
}
static inline void CompositeLighten(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
gamma;
}
static inline void CompositeLightenIntensity(const Image *image,
- const PixelInfo *p,const PixelInfo *q,const ChannelType channel,
- PixelInfo *composite)
+ const PixelInfo *p,const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeMathematics(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel, const GeometryInfo *args,
- PixelInfo *composite)
+ const PixelInfo *q,const GeometryInfo *args,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositePlus(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
/*
NOTE: "Plus" does not use 'over' alpha-blending but uses a special
}
static inline void CompositeMinus(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeModulusAdd(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeModulusSubtract(const Image *image,
- const PixelInfo *p,const PixelInfo *q, const ChannelType channel,
- PixelInfo *composite)
+ const PixelInfo *p,const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeMultiply(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
}
static inline void CompositeScreen(const Image *image,const PixelInfo *p,
- const PixelInfo *q,const ChannelType channel,PixelInfo *composite)
+ const PixelInfo *q,PixelInfo *composite)
{
MagickRealType
Da,
MagickExport MagickBooleanType CompositeImage(Image *image,
const CompositeOperator compose,const Image *composite_image,
const ssize_t x_offset,const ssize_t y_offset)
-{
- MagickBooleanType
- status;
-
- status=CompositeImageChannel(image,DefaultChannels,compose,composite_image,
- x_offset,y_offset);
- return(status);
-}
-
-MagickExport MagickBooleanType CompositeImageChannel(Image *image,
- const ChannelType channel,const CompositeOperator compose,
- const Image *composite_image,const ssize_t x_offset,const ssize_t y_offset)
{
#define CompositeImageTag "Composite/Image"
}
case PlusCompositeOp:
{
- CompositePlus(image,&source,&destination,channel,&composite);
+ CompositePlus(image,&source,&destination,&composite);
break;
}
case MinusDstCompositeOp:
{
- CompositeMinus(image,&source,&destination,channel,&composite);
+ CompositeMinus(image,&source,&destination,&composite);
break;
}
case MinusSrcCompositeOp:
{
- CompositeMinus(image,&destination,&source,channel,&composite);
+ CompositeMinus(image,&destination,&source,&composite);
break;
}
case ModulusAddCompositeOp:
{
- CompositeModulusAdd(image,&source,&destination,channel,&composite);
+ CompositeModulusAdd(image,&source,&destination,&composite);
break;
}
case ModulusSubtractCompositeOp:
{
- CompositeModulusSubtract(image,&source,&destination,channel,
- &composite);
+ CompositeModulusSubtract(image,&source,&destination,&composite);
break;
}
case DifferenceCompositeOp:
{
- CompositeDifference(image,&source,&destination,channel,&composite);
+ CompositeDifference(image,&source,&destination,&composite);
break;
}
case ExclusionCompositeOp:
{
- CompositeExclusion(image,&source,&destination,channel,&composite);
+ CompositeExclusion(image,&source,&destination,&composite);
break;
}
case MultiplyCompositeOp:
{
- CompositeMultiply(image,&source,&destination,channel,&composite);
+ CompositeMultiply(image,&source,&destination,&composite);
break;
}
case ScreenCompositeOp:
{
- CompositeScreen(image,&source,&destination,channel,&composite);
+ CompositeScreen(image,&source,&destination,&composite);
break;
}
case DivideDstCompositeOp:
{
- CompositeDivide(image,&source,&destination,channel,&composite);
+ CompositeDivide(image,&source,&destination,&composite);
break;
}
case DivideSrcCompositeOp:
{
- CompositeDivide(image,&destination,&source,channel,&composite);
+ CompositeDivide(image,&destination,&source,&composite);
break;
}
case DarkenCompositeOp:
{
- CompositeDarken(image,&source,&destination,channel,&composite);
+ CompositeDarken(image,&source,&destination,&composite);
break;
}
case LightenCompositeOp:
{
- CompositeLighten(image,&source,&destination,channel,&composite);
+ CompositeLighten(image,&source,&destination,&composite);
break;
}
case DarkenIntensityCompositeOp:
{
- CompositeDarkenIntensity(image,&source,&destination,channel,
- &composite);
+ CompositeDarkenIntensity(image,&source,&destination,&composite);
break;
}
case LightenIntensityCompositeOp:
{
- CompositeLightenIntensity(image,&source,&destination,channel,
- &composite);
+ CompositeLightenIntensity(image,&source,&destination,&composite);
break;
}
case MathematicsCompositeOp:
{
- CompositeMathematics(image,&source,&destination,channel,
- &geometry_info,&composite);
+ CompositeMathematics(image,&source,&destination,&geometry_info,
+ &composite);
break;
}
case ColorDodgeCompositeOp:
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_CompositeImageChannel)
+ #pragma omp critical (MagickCore_CompositeImage)
#endif
proceed=SetImageProgress(image,CompositeImageTag,progress++,
image->rows);
extern MagickExport MagickBooleanType
CompositeImage(Image *,const CompositeOperator,const Image *,const ssize_t,
const ssize_t),
- CompositeImageChannel(Image *,const ChannelType,const CompositeOperator,
- const Image *,const ssize_t,const ssize_t),
TextureImage(Image *,const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
/* #undef AUTOTRACE_DELEGATE */
/* Define if coders and filters are to be built as modules. */
-/* #undef BUILD_MODULES */
+#ifndef MAGICKCORE_BUILD_MODULES
+#define MAGICKCORE_BUILD_MODULES 1
+#endif
/* Define if you have the bzip2 library */
#ifndef MAGICKCORE_BZLIB_DELEGATE
#endif
/* Define if you have DJVU library */
-/* #undef DJVU_DELEGATE */
+#ifndef MAGICKCORE_DJVU_DELEGATE
+#define MAGICKCORE_DJVU_DELEGATE 1
+#endif
/* Directory where ImageMagick documents live. */
#ifndef MAGICKCORE_DOCUMENTATION_PATH
#endif
/* Define if you have FFTW library */
-/* #undef FFTW_DELEGATE */
+#ifndef MAGICKCORE_FFTW_DELEGATE
+#define MAGICKCORE_FFTW_DELEGATE 1
+#endif
/* Location of filter modules */
#ifndef MAGICKCORE_FILTER_PATH
#endif
/* Define if you have the <lcms2.h> header file. */
-#ifndef MAGICKCORE_HAVE_LCMS2_H
-#define MAGICKCORE_HAVE_LCMS2_H 1
-#endif
+/* #undef HAVE_LCMS2_H */
/* Define if you have the <lcms2/lcms2.h> header file. */
/* #undef HAVE_LCMS2_LCMS2_H */
/* Define if you have the <lcms.h> header file. */
-/* #undef HAVE_LCMS_H */
+#ifndef MAGICKCORE_HAVE_LCMS_H
+#define MAGICKCORE_HAVE_LCMS_H 1
+#endif
/* Define if you have the <lcms/lcms.h> header file. */
/* #undef HAVE_LCMS_LCMS_H */
#endif
/* Define if you have JBIG library */
-/* #undef JBIG_DELEGATE */
+#ifndef MAGICKCORE_JBIG_DELEGATE
+#define MAGICKCORE_JBIG_DELEGATE 1
+#endif
/* Define if you have JPEG version 2 "Jasper" library */
#ifndef MAGICKCORE_JP2_DELEGATE
#endif
/* Define if you have LQR library */
-/* #undef LQR_DELEGATE */
+#ifndef MAGICKCORE_LQR_DELEGATE
+#define MAGICKCORE_LQR_DELEGATE 1
+#endif
/* Define if using libltdl to support dynamically loadable modules */
#ifndef MAGICKCORE_LTDL_DELEGATE
/* Define to the system default library search path. */
#ifndef MAGICKCORE_LT_DLSEARCH_PATH
-#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/atlas:/usr/lib64/mysql:/usr/lib64/qt-3.3/lib:/usr/lib64/tcl8.5/tclx8.4:/usr/lib64/tcl8.5:/usr/lib/wine/:/usr/lib64/wine/:/usr/lib64/xulrunner-2"
+#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/R/lib:/usr/lib64/atlas:/opt/modules/pkg/intel/f77/10.0.025/lib:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/qt-3.3/lib:/usr/lib64/xulrunner-2"
#endif
/* The archive extension */
/* #undef NO_MINUS_C_MINUS_O */
/* Define if you have OPENEXR library */
-/* #undef OPENEXR_DELEGATE */
+#ifndef MAGICKCORE_OPENEXR_DELEGATE
+#define MAGICKCORE_OPENEXR_DELEGATE 1
+#endif
/* Define to the address where bug reports for this package should be sent. */
#ifndef MAGICKCORE_PACKAGE_BUGREPORT
#endif
/* Define if you have RSVG library */
-/* #undef RSVG_DELEGATE */
+#ifndef MAGICKCORE_RSVG_DELEGATE
+#define MAGICKCORE_RSVG_DELEGATE 1
+#endif
/* Define to the type of arg 1 for `select'. */
#ifndef MAGICKCORE_SELECT_TYPE_ARG1
/* Define if you have WEBP library */
-/* #undef WEBP_DELEGATE */
+#ifndef MAGICKCORE_WEBP_DELEGATE
+#define MAGICKCORE_WEBP_DELEGATE 1
+#endif
/* Define to use the Windows GDI32 library */
/* #undef WINGDI32_DELEGATE */
/* #undef WITH_DMALLOC */
/* Define if you have WMF library */
-/* #undef WMF_DELEGATE */
+#ifndef MAGICKCORE_WMF_DELEGATE
+#define MAGICKCORE_WMF_DELEGATE 1
+#endif
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */
#define CompareSplayTreeStringInfo PrependMagickMethod(CompareSplayTreeStringInfo)
#define CompareSplayTreeString PrependMagickMethod(CompareSplayTreeString)
#define CompareStringInfo PrependMagickMethod(CompareStringInfo)
-#define CompositeImageChannel PrependMagickMethod(CompositeImageChannel)
+#define CompositeImage PrependMagickMethod(CompositeImage)
#define CompositeImage PrependMagickMethod(CompositeImage)
#define CompositeLayers PrependMagickMethod(CompositeLayers)
#define CompressImageColormap PrependMagickMethod(CompressImageColormap)
if ( method == VoronoiMorphology ) {
/* Preserve the alpha channel of input image - but turned off */
(void) SetImageAlphaChannel(rslt_image, DeactivateAlphaChannel);
- (void) CompositeImageChannel(rslt_image, DefaultChannels,
- CopyOpacityCompositeOp, image, 0, 0);
+ (void) CompositeImage(rslt_image,CopyOpacityCompositeOp,image,0,0);
(void) SetImageAlphaChannel(rslt_image, DeactivateAlphaChannel);
}
goto exit_cleanup;
if ( verbose == MagickTrue )
(void) FormatLocaleFile(stderr, "\n%s: Difference with original image",
CommandOptionToMnemonic(MagickMorphologyOptions, method) );
- (void) CompositeImageChannel(curr_image,
- (ChannelType) (channel & ~SyncChannels),
- DifferenceCompositeOp, image, 0, 0);
+ (void) CompositeImage(curr_image,DifferenceCompositeOp,image,0,0);
break;
case EdgeMorphology:
if ( verbose == MagickTrue )
(void) FormatLocaleFile(stderr, "\n%s: Difference of Dilate and Erode",
CommandOptionToMnemonic(MagickMorphologyOptions, method) );
- (void) CompositeImageChannel(curr_image,
- (ChannelType) (channel & ~SyncChannels),
- DifferenceCompositeOp, save_image, 0, 0);
+ (void) CompositeImage(curr_image,DifferenceCompositeOp,save_image,
+ 0,0);
save_image = DestroyImage(save_image); /* finished with save image */
break;
default:
if ( verbose == MagickTrue )
(void) FormatLocaleFile(stderr, " (compose \"%s\")",
CommandOptionToMnemonic(MagickComposeOptions, rslt_compose) );
- (void) CompositeImageChannel(rslt_image,
- (ChannelType) (channel & ~SyncChannels), rslt_compose,
- curr_image, 0, 0);
+ (void) CompositeImage(rslt_image,rslt_compose,curr_image,0,0);
curr_image = DestroyImage(curr_image);
curr_image = (Image *) image; /* continue with original image */
}
*/
#define MagickPackageName "ImageMagick"
#define MagickCopyright "Copyright (C) 1999-2011 ImageMagick Studio LLC"
-#define MagickSVNRevision "4693"
+#define MagickSVNRevision "exported"
#define MagickLibVersion 0x700
#define MagickLibVersionText "7.0.0"
#define MagickLibVersionNumber 5,0,0
*/
typedef struct _CompositeOptions
{
- ChannelType
- channel;
-
char
*compose_args,
*geometry;
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&=CompositeImageChannel(*image,
- composite_options->channel,composite_options->compose,
+ status&=CompositeImage(*image,composite_options->compose,
composite_image,x,y);
GetImageException(*image,exception);
}
/*
Digitally composite image.
*/
- status&=CompositeImageChannel(*image,composite_options->channel,
- composite_options->compose,composite_image,geometry.x,
- geometry.y);
+ status&=CompositeImage(*image,composite_options->compose,
+ composite_image,geometry.x,geometry.y);
GetImageException(*image,exception);
}
}
static void GetCompositeOptions(CompositeOptions *composite_options)
{
(void) ResetMagickMemory(composite_options,0,sizeof(*composite_options));
- composite_options->channel=DefaultChannels;
composite_options->compose=OverCompositeOp;
}
if (*option == '+')
{
- composite_options.channel=DefaultChannels;
+ SetPixelComponentMap(image,DefaultChannels);
break;
}
i++;
if (channel < 0)
ThrowCompositeException(OptionError,"UnrecognizedChannelType",
argv[i]);
- composite_options.channel=(ChannelType) channel;
+ SetPixelComponentMap(image,(ChannelType) channel);
break;
}
if (LocaleCompare("colors",option+1) == 0)
% MagickBooleanType MagickCompositeImage(MagickWand *wand,
% const MagickWand *composite_wand,const CompositeOperator compose,
% const ssize_t x,const ssize_t y)
-% MagickBooleanType MagickCompositeImageChannel(MagickWand *wand,
-% const ChannelType channel,const MagickWand *composite_wand,
-% const CompositeOperator compose,const ssize_t x,const ssize_t y)
%
% A description of each parameter follows:
%
% o y: the row offset of the composited image.
%
*/
-
WandExport MagickBooleanType MagickCompositeImage(MagickWand *wand,
- const MagickWand *composite_wand,const CompositeOperator compose,const ssize_t x,
- const ssize_t y)
-{
- MagickBooleanType
- status;
-
- status=MagickCompositeImageChannel(wand,DefaultChannels,composite_wand,
- compose,x,y);
- return(status);
-}
-
-WandExport MagickBooleanType MagickCompositeImageChannel(MagickWand *wand,
- const ChannelType channel,const MagickWand *composite_wand,
- const CompositeOperator compose,const ssize_t x,const ssize_t y)
+ const MagickWand *composite_wand,const CompositeOperator compose,
+ const ssize_t x,const ssize_t y)
{
MagickBooleanType
status;
if ((wand->images == (Image *) NULL) ||
(composite_wand->images == (Image *) NULL))
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=CompositeImageChannel(wand->images,channel,compose,
- composite_wand->images,x,y);
+ status=CompositeImage(wand->images,compose,composite_wand->images,x,y);
if (status == MagickFalse)
InheritException(wand->exception,&wand->images->exception);
return(status);
MagickCommentImage(MagickWand *,const char *),
MagickCompositeImage(MagickWand *,const MagickWand *,const CompositeOperator,
const ssize_t,const ssize_t),
- MagickCompositeImageChannel(MagickWand *,const ChannelType,const MagickWand *, const CompositeOperator,const ssize_t,const ssize_t),
MagickConstituteImage(MagickWand *,const size_t,const size_t,const char *,
const StorageType,const void *),
MagickContrastImage(MagickWand *,const MagickBooleanType),
Composite region.
*/
(void) CompositeImage(region_image,region_image->matte !=
- MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
- region_geometry.x,region_geometry.y);
+ MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
+ region_geometry.x,region_geometry.y);
InheritException(exception,®ion_image->exception);
*image=DestroyImage(*image);
*image=region_image;
*/
(void) SyncImageSettings(mogrify_info,*image);
(void) CompositeImage(region_image,region_image->matte !=
- MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
- region_geometry.x,region_geometry.y);
+ MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
+ region_geometry.x,region_geometry.y);
InheritException(exception,®ion_image->exception);
*image=DestroyImage(*image);
*image=region_image;
(void) NegateImage(image->mask,MagickFalse);
}
}
- (void) CompositeImageChannel(image,channel,image->compose,
- composite_image,geometry.x,geometry.y);
+ (void) CompositeImage(image,image->compose,composite_image,
+ geometry.x,geometry.y);
if (mask_image != (Image *) NULL)
mask_image=image->mask=DestroyImage(image->mask);
composite_image=DestroyImage(composite_image);
flags=ParseGravityGeometry(image,composite_geometry,&geometry,
&exception);
if (rotate_image == (Image *) NULL)
- CompositeImageChannel(image,channel,compose,composite_image,
- geometry.x,geometry.y);
+ CompositeImage(image,compose,composite_image,geometry.x,geometry.y);
else
{
/*
geometry.x-=(ssize_t) (rotate_image->columns-
composite_image->columns)/2;
geometry.y-=(ssize_t) (rotate_image->rows-composite_image->rows)/2;
- CompositeImageChannel(image,channel,compose,rotate_image,
- geometry.x,geometry.y);
+ CompositeImage(image,compose,rotate_image,geometry.x,geometry.y);
rotate_image=DestroyImage(rotate_image);
}
composite_image=DestroyImage(composite_image);