#include "MagickCore/resource_.h"
#include "MagickCore/string_.h"
#include "MagickCore/thread-private.h"
+#include "MagickCore/token.h"
#include "MagickCore/utility.h"
#include "MagickCore/utility-private.h"
#include "MagickCore/version.h"
% 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.
%
% Compose methods needing such arguments include "BlendCompositeOp" and
% "DisplaceCompositeOp".
%
-% o "compose:outside-overlay"
-% Modify how the composition is to effect areas not directly covered
-% by the 'composite_image' at the offset given. Normally this is
-% dependant on the 'compose' method, especially Duff-Porter methods.
-%
-% If set to "false" then disable all normal handling of pixels not
-% covered by the composite_image. Typically used for repeated tiling
-% of the composite_image by the calling API.
-%
-% Previous to IM v6.5.3-3 this was called "modify-outside-overlay"
-%
% o exception: return any errors or warnings in this structure.
%
*/
-static void CompositeHSB(const Quantum red,const Quantum green,
- const Quantum blue,double *hue,double *saturation,double *brightness)
+/*
+ Composition based on the SVG specification:
+
+ A Composition is defined by...
+ Color Function : f(Sc,Dc) where Sc and Dc are the normizalized colors
+ Blending areas : X = 1 for area of overlap, ie: f(Sc,Dc)
+ Y = 1 for source preserved
+ Z = 1 for destination preserved
+
+ Conversion to transparency (then optimized)
+ Dca' = f(Sc, Dc)*Sa*Da + Y*Sca*(1-Da) + Z*Dca*(1-Sa)
+ Da' = X*Sa*Da + Y*Sa*(1-Da) + Z*Da*(1-Sa)
+
+ Where...
+ Sca = Sc*Sa normalized Source color divided by Source alpha
+ Dca = Dc*Da normalized Dest color divided by Dest alpha
+ Dc' = Dca'/Da' the desired color value for this channel.
+
+ Da' in in the follow formula as 'gamma' The resulting alpla value.
+
+ Most functions use a blending mode of over (X=1,Y=1,Z=1) this results in
+ the following optimizations...
+ gamma = Sa+Da-Sa*Da;
+ gamma = 1 - QuantiumScale*alpha * QuantiumScale*beta;
+ opacity = QuantiumScale*alpha*beta; // over blend, optimized 1-Gamma
+
+ The above SVG definitions also definate that Mathematical Composition
+ methods should use a 'Over' blending mode for Alpha Channel.
+ It however was not applied for composition modes of 'Plus', 'Minus',
+ the modulus versions of 'Add' and 'Subtract'.
+
+ Mathematical operator changes to be applied from IM v6.7...
+
+ 1) Modulus modes 'Add' and 'Subtract' are obsoleted and renamed
+ 'ModulusAdd' and 'ModulusSubtract' for clarity.
+
+ 2) All mathematical compositions work as per the SVG specification
+ with regard to blending. This now includes 'ModulusAdd' and
+ 'ModulusSubtract'.
+
+ 3) When the special channel flag 'sync' (syncronize channel updates)
+ is turned off (enabled by default) then mathematical compositions are
+ only performed on the channels specified, and are applied
+ independantally of each other. In other words the mathematics is
+ performed as 'pure' mathematical operations, rather than as image
+ operations.
+*/
+static void CompositeHSB(const double red,const double green,
+ const double blue,double *hue,double *saturation,double *brightness)
{
double
- delta;
-
- Quantum
+ delta,
max,
min;
return(x);
return(y);
}
+
static inline double MagickMax(const double x,const double y)
{
if (x > 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"
*composite_view,
*image_view;
- const char
- *value;
-
MagickBooleanType
- modify_outside_overlay,
status;
MagickOffsetType
ssize_t
y;
- /*
- Prepare composite image.
- */
- modify_outside_overlay=MagickFalse;
- value=GetImageArtifact(composite_image,"compose:outside-overlay");
- if (value != (const char *) NULL)
- modify_outside_overlay=IsMagickTrue(value);
/*
Composite image.
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireVirtualCacheView(composite_image,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
if (status == MagickFalse)
continue;
- if (modify_outside_overlay == MagickFalse)
+ if (clip_to_self != MagickFalse)
{
if (y < y_offset)
continue;
register ssize_t
i;
- if (modify_outside_overlay == MagickFalse)
+ if (clip_to_self != MagickFalse)
{
if (x < x_offset)
{
Sc: source color.
Dc: destination color.
*/
+ if (GetPixelMask(image,q) != 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
(void) GetOneVirtualPixel(composite_image,x-x_offset,y-y_offset,
source,exception);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
channel=GetPixelChannelMapChannel(image,i);
traits=GetPixelChannelMapTraits(image,channel);
- composite_traits=GetPixelChannelMapTraits(composite_image,
- channel);
+ composite_traits=GetPixelChannelMapTraits(composite_image,channel);
if ((traits == UndefinedPixelTrait) ||
(composite_traits == UndefinedPixelTrait))
continue;
Sa: normalized source alpha.
Da: normalized destination alpha.
*/
+ if (GetPixelMask(composite_image,p) != 0)
+ {
+ p+=GetPixelChannels(composite_image);
+ channels=GetPixelChannels(composite_image);
+ if (p >= (pixels+channels*composite_image->columns))
+ p=pixels;
+ q+=GetPixelChannels(image);
+ continue;
+ }
Sa=QuantumScale*GetPixelAlpha(composite_image,p);
Da=QuantumScale*GetPixelAlpha(image,q);
alpha=Sa*(-Da)+Sa+Da;
}
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"
*composite_view,
*image_view;
- const char
- *value;
-
GeometryInfo
geometry_info;
*destination_image;
MagickBooleanType
- modify_outside_overlay,
status;
MagickOffsetType
ssize_t
y;
- /*
- Composition based on the SVG specification:
-
- A Composition is defined by...
- Color Function : f(Sc,Dc) where Sc and Dc are the normizalized colors
- Blending areas : X = 1 for area of overlap, ie: f(Sc,Dc)
- Y = 1 for source preserved
- Z = 1 for destination preserved
-
- Conversion to transparency (then optimized)
- Dca' = f(Sc, Dc)*Sa*Da + Y*Sca*(1-Da) + Z*Dca*(1-Sa)
- Da' = X*Sa*Da + Y*Sa*(1-Da) + Z*Da*(1-Sa)
-
- Where...
- Sca = Sc*Sa normalized Source color divided by Source alpha
- Dca = Dc*Da normalized Dest color divided by Dest alpha
- Dc' = Dca'/Da' the desired color value for this channel.
-
- Da' in in the follow formula as 'gamma' The resulting alpla value.
-
- Most functions use a blending mode of over (X=1,Y=1,Z=1) this results in
- the following optimizations...
- gamma = Sa+Da-Sa*Da;
- gamma = 1 - QuantiumScale*alpha * QuantiumScale*beta;
- opacity = QuantiumScale*alpha*beta; // over blend, optimized 1-Gamma
-
- The above SVG definitions also definate that Mathematical Composition
- methods should use a 'Over' blending mode for Alpha Channel.
- It however was not applied for composition modes of 'Plus', 'Minus',
- the modulus versions of 'Add' and 'Subtract'.
-
- Mathematical operator changes to be applied from IM v6.7...
-
- 1) Modulus modes 'Add' and 'Subtract' are obsoleted and renamed
- 'ModulusAdd' and 'ModulusSubtract' for clarity.
-
- 2) All mathematical compositions work as per the SVG specification
- with regard to blending. This now includes 'ModulusAdd' and
- 'ModulusSubtract'.
-
- 3) When the special channel flag 'sync' (syncronize channel updates)
- is turned off (enabled by default) then mathematical compositions are
- only performed on the channels specified, and are applied
- independantally of each other. In other words the mathematics is
- performed as 'pure' mathematical operations, rather than as image
- operations.
- */
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
assert(composite_image->signature == MagickSignature);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
+ if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
+ (IsGrayColorspace(composite_image->colorspace) == MagickFalse))
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
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;
- modify_outside_overlay=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.
- */
- modify_outside_overlay=MagickTrue;
- break;
- }
case CopyCompositeOp:
{
if ((x_offset < 0) || (y_offset < 0))
if ((y_offset+(ssize_t) composite_image->rows) >= (ssize_t) image->rows)
break;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireVirtualCacheView(composite_image,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(composite_image);
+ q+=GetPixelChannels(image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(composite_image); i++)
{
PixelChannel
*/
if (image->matte == MagickFalse)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
- modify_outside_overlay=MagickTrue;
break;
}
case BlurCompositeOp:
*composite_view,
*destination_view;
+ const char
+ *value;
+
PixelInfo
pixel;
}
/*
Blur Image by resampling.
+ FUTURE: this is currently broken, especially for small sigma blurs
+ This needs to be fixed to use a non-user filter setup that provides
+ far more control than currently available.
*/
resample_filter=AcquireResampleFilter(image,exception);
- SetResampleFilter(resample_filter,CubicFilter,2.0);
- destination_view=AcquireCacheView(destination_image);
- composite_view=AcquireCacheView(composite_image);
+ SetResampleFilter(resample_filter,GaussianFilter); /* was blur*2 */
+ composite_view=AcquireVirtualCacheView(composite_image,exception);
+ destination_view=AcquireAuthenticCacheView(destination_image,exception);
for (y=0; y < (ssize_t) composite_image->rows; y++)
{
MagickBooleanType
GetPixelRed(composite_image,p),blur.y2*QuantumScale*
GetPixelGreen(composite_image,p));
(void) ResamplePixelColor(resample_filter,(double) x_offset+x,
- (double) y_offset+y,&pixel);
+ (double) y_offset+y,&pixel,exception);
SetPixelInfoPixel(destination_image,&pixel,q);
p+=GetPixelChannels(composite_image);
q+=GetPixelChannels(destination_image);
*destination_view,
*image_view;
+ const char
+ *value;
+
PixelInfo
pixel;
displacement/distortion map. -- Like a lens...
*/
GetPixelInfo(image,&pixel);
- image_view=AcquireCacheView(image);
- destination_view=AcquireCacheView(destination_image);
- composite_view=AcquireCacheView(composite_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ composite_view=AcquireVirtualCacheView(composite_image,exception);
+ destination_view=AcquireAuthenticCacheView(destination_image,exception);
for (y=0; y < (ssize_t) composite_image->rows; y++)
{
MagickBooleanType
}
case DissolveCompositeOp:
{
+ const char
+ *value;
+
/*
Geometry arguments to dissolve factors.
*/
destination_dissolve=geometry_info.sigma/100.0;
if ((destination_dissolve-MagickEpsilon) < 0.0)
destination_dissolve=0.0;
- modify_outside_overlay=MagickTrue;
- if ((destination_dissolve+MagickEpsilon) > 1.0 )
- {
- destination_dissolve=1.0;
- modify_outside_overlay=MagickFalse;
- }
}
break;
}
case BlendCompositeOp:
{
+ const char
+ *value;
+
value=GetImageArtifact(composite_image,"compose:args");
if (value != (char *) NULL)
{
destination_dissolve=1.0-source_dissolve;
if ((flags & SigmaValue) != 0)
destination_dissolve=geometry_info.sigma/100.0;
- modify_outside_overlay=MagickTrue;
- if ((destination_dissolve+MagickEpsilon) > 1.0)
- modify_outside_overlay=MagickFalse;
}
break;
}
case MathematicsCompositeOp:
{
+ const char
+ *value;
+
/*
Just collect the values from "compose:args", setting.
Unused values are set to zero automagically.
}
case ModulateCompositeOp:
{
+ const char
+ *value;
+
/*
Determine the brightness and saturation scale.
*/
}
case ThresholdCompositeOp:
{
+ const char
+ *value;
+
/*
Determine the amount and threshold.
*/
default:
break;
}
- value=GetImageArtifact(composite_image,"compose:outside-overlay");
- if (value != (const char *) NULL)
- modify_outside_overlay=IsMagickTrue(value);
/*
Composite image.
*/
status=MagickTrue;
progress=0;
midpoint=((MagickRealType) QuantumRange+1.0)/2;
- image_view=AcquireCacheView(image);
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireVirtualCacheView(composite_image,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
red,
saturation;
+ PixelInfo
+ destination_pixel,
+ source_pixel;
+
register const Quantum
*restrict p;
if (status == MagickFalse)
continue;
- if (modify_outside_overlay == MagickFalse)
+ if (clip_to_self != MagickFalse)
{
if (y < y_offset)
continue;
hue=0.0;
saturation=0.0;
brightness=0.0;
+ GetPixelInfo(image,&destination_pixel);
+ GetPixelInfo(composite_image,&source_pixel);
for (x=0; x < (ssize_t) image->columns; x++)
{
MagickRealType
size_t
channels;
- if (modify_outside_overlay == MagickFalse)
+ if (clip_to_self != MagickFalse)
{
if (x < x_offset)
{
*/
(void) GetOneVirtualPixel(composite_image,x-x_offset,y-y_offset,
source,exception);
+ if (GetPixelMask(image,q) != 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
MagickRealType
channel=GetPixelChannelMapChannel(image,i);
traits=GetPixelChannelMapTraits(image,channel);
- composite_traits=GetPixelChannelMapTraits(composite_image,
- channel);
+ composite_traits=GetPixelChannelMapTraits(composite_image,channel);
if ((traits == UndefinedPixelTrait) ||
(composite_traits == UndefinedPixelTrait))
continue;
break;
}
}
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(composite_image);
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ switch (compose)
+ {
+ case ColorizeCompositeOp:
+ case HueCompositeOp:
+ case LuminizeCompositeOp:
+ case ModulateCompositeOp:
+ case SaturateCompositeOp:
+ {
+ GetPixelInfoPixel(composite_image,p,&source_pixel);
+ GetPixelInfoPixel(image,q,&destination_pixel);
+ break;
+ }
+ default:
+ break;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
double
pixel=Sc;
break;
}
- CompositeHSB(GetPixelRed(image,q),GetPixelGreen(image,q),
- GetPixelBlue(image,q),&sans,&sans,&brightness);
- CompositeHSB(GetPixelRed(composite_image,p),
- GetPixelGreen(composite_image,p),GetPixelBlue(composite_image,p),
+ CompositeHSB(destination_pixel.red,destination_pixel.green,
+ destination_pixel.blue,&sans,&sans,&brightness);
+ CompositeHSB(source_pixel.red,source_pixel.green,source_pixel.blue,
&hue,&saturation,&sans);
HSBComposite(hue,saturation,brightness,&red,&green,&blue);
switch (channel)
pixel=Sc;
break;
}
- CompositeHSB(GetPixelRed(image,q),GetPixelGreen(image,q),
- GetPixelBlue(image,q),&hue,&saturation,&brightness);
- CompositeHSB(GetPixelRed(composite_image,p),
- GetPixelGreen(composite_image,p),GetPixelBlue(composite_image,p),
+ CompositeHSB(destination_pixel.red,destination_pixel.green,
+ destination_pixel.blue,&hue,&saturation,&brightness);
+ CompositeHSB(source_pixel.red,source_pixel.green,source_pixel.blue,
&hue,&sans,&sans);
HSBComposite(hue,saturation,brightness,&red,&green,&blue);
switch (channel)
pixel=Sc;
break;
}
- CompositeHSB(GetPixelRed(image,q),GetPixelGreen(image,q),
- GetPixelBlue(image,q),&hue,&saturation,&brightness);
- CompositeHSB(GetPixelRed(composite_image,p),
- GetPixelGreen(composite_image,p),GetPixelBlue(composite_image,p),
+ CompositeHSB(destination_pixel.red,destination_pixel.green,
+ destination_pixel.blue,&hue,&saturation,&brightness);
+ CompositeHSB(source_pixel.red,source_pixel.green,source_pixel.blue,
&sans,&sans,&brightness);
HSBComposite(hue,saturation,brightness,&red,&green,&blue);
switch (channel)
pixel=Dc;
break;
}
- CompositeHSB(GetPixelRed(image,q),GetPixelGreen(image,q),
- GetPixelBlue(image,q),&hue,&saturation,&brightness);
+ CompositeHSB(destination_pixel.red,destination_pixel.green,
+ destination_pixel.blue,&hue,&saturation,&brightness);
brightness+=(0.01*percent_brightness*offset)/midpoint;
saturation*=0.01*percent_saturation;
HSBComposite(hue,saturation,brightness,&red,&green,&blue);
pixel=Sc;
break;
}
- CompositeHSB(GetPixelRed(image,q),GetPixelGreen(image,q),
- GetPixelBlue(image,q),&hue,&saturation,&brightness);
- CompositeHSB(GetPixelRed(composite_image,p),
- GetPixelGreen(composite_image,p),GetPixelBlue(composite_image,p),
+ CompositeHSB(destination_pixel.red,destination_pixel.green,
+ destination_pixel.blue,&hue,&saturation,&brightness);
+ CompositeHSB(source_pixel.red,source_pixel.green,source_pixel.blue,
&sans,&saturation,&sans);
HSBComposite(hue,saturation,brightness,&red,&green,&blue);
switch (channel)
%
% The format of the TextureImage method is:
%
-% MagickBooleanType TextureImage(Image *image,const Image *texture_image,
+% MagickBooleanType TextureImage(Image *image,const Image *texture,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
% o texture_image: This image is the texture to layer on the background.
%
*/
-MagickExport MagickBooleanType TextureImage(Image *image,
- const Image *texture_image,ExceptionInfo *exception)
+MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
+ ExceptionInfo *exception)
{
#define TextureImageTag "Texture/Image"
*image_view,
*texture_view;
+ Image
+ *texture_image;
+
MagickBooleanType
status;
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickSignature);
- if (texture_image == (const Image *) NULL)
+ if (texture == (const Image *) NULL)
return(MagickFalse);
- (void) SetImageVirtualPixelMethod(texture_image,TileVirtualPixelMethod);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
+ texture_image=CloneImage(texture,0,0,MagickTrue,exception);
+ if (texture_image == (const Image *) NULL)
+ return(MagickFalse);
+ (void) SetImageVirtualPixelMethod(texture_image,TileVirtualPixelMethod,
+ exception);
status=MagickTrue;
if ((image->compose != CopyCompositeOp) &&
((image->compose != OverCompositeOp) || (image->matte != MagickFalse) ||
Tile texture onto the image background.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(status)
+ #pragma omp parallel for schedule(static) shared(status)
#endif
for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) texture_image->rows)
{
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;
}
(void) SetImageProgress(image,TextureImageTag,(MagickOffsetType)
image->rows,image->rows);
+ texture_image=DestroyImage(texture_image);
return(status);
}
/*
Tile texture onto the image background (optimized).
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
- texture_view=AcquireCacheView(texture_image);
+ texture_view=AcquireVirtualCacheView(texture_image,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(status)
+ #pragma omp parallel for schedule(static) shared(status)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(texture_image);
+ q+=GetPixelChannels(image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(texture_image); i++)
{
PixelChannel
}
texture_view=DestroyCacheView(texture_view);
image_view=DestroyCacheView(image_view);
+ texture_image=DestroyImage(texture_image);
return(status);
}