AddNoiseImage ( image(),
noiseType_, 1.0,
&exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
MagickCore::Image* newImage =
BlurImage( image(), radius_, sigma_, image()->bias, &exceptionInfo);
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
SeparateImage ( image(), &exceptionInfo );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
}
// Set or obtain modulus channel depth
ChannelType channel_mask = SetPixelChannelMask( image(), channel );
MagickCore::Image* newImage =
FxImage ( image(), expression.c_str(), &exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
MagickCore::Image* newImage =
GaussianBlurImage( image(), width_, sigma_, image()->bias, &exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
GetExceptionInfo( &exceptionInfo );
FloodfillPaintImage ( image(), options()->drawInfo(), &target, x_, y_,
method_ == FloodfillMethod ? MagickFalse : MagickTrue, &exceptionInfo);
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
}
GetExceptionInfo( &exceptionInfo );
ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
EvaluateImage( image(), operator_, rvalue_, &exceptionInfo);
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
}
&exceptionInfo );
ChannelType channel_mask = SetPixelChannelMask( image(), channel_);
EvaluateImage( crop_image, operator_, rvalue_, &exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
(void) CompositeImage( image(), image()->matte != MagickFalse ?
OverCompositeOp : CopyCompositeOp, crop_image, geometry.x, geometry.y,
&exceptionInfo );
(void) RandomThresholdImage( image(),
static_cast<std::string>(thresholds_).c_str(),
&exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
throwImageException();
(void) DestroyExceptionInfo( &exceptionInfo );
}
sigma_,
image()->bias,
&exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
ChannelType channel_mask = SetPixelChannelMask( image(), channel );
MagickCore::Image* newImage = SparseColorImage ( image(), method,
number_arguments, arguments, &exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
amount_,
threshold_,
&exceptionInfo );
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
&statistics->red.standard_deviation,&exceptionInfo);
(void) GetImageKurtosis( image(),&statistics->red.kurtosis,
&statistics->red.skewness,&exceptionInfo);
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
channel_mask = SetPixelChannelMask( image(), GreenChannel);
(void) GetImageRange( image(),&minimum,&maximum,&exceptionInfo);
&statistics->green.standard_deviation,&exceptionInfo);
(void) GetImageKurtosis( image(),&statistics->green.kurtosis,
&statistics->green.skewness,&exceptionInfo);
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
channel_mask = SetPixelChannelMask( image(), GreenChannel);
(void) GetImageRange( image(),&minimum,&maximum,&exceptionInfo);
&statistics->blue.standard_deviation,&exceptionInfo);
(void) GetImageKurtosis( image(),&statistics->blue.kurtosis,
&statistics->blue.skewness,&exceptionInfo);
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
channel_mask = SetPixelChannelMask( image(), AlphaChannel);
(void) GetImageRange( image(),&minimum,&maximum,&exceptionInfo);
&statistics->alpha.standard_deviation,&exceptionInfo);
(void) GetImageKurtosis( image(),&statistics->alpha.kurtosis,
&statistics->alpha.skewness,&exceptionInfo);
- (void) SetPixelChannelMap( image(), channel_mask );
+ (void) SetPixelChannelMapMask( image(), channel_mask );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=ScaleAnyToQuantum(ScaleQuantumToAny(q[i],range),range);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(cache_view->image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(cache_view->image,i);
pixel[channel]=p[i];
}
return(MagickTrue);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(cache_view->image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(cache_view->image,i);
pixel[channel]=p[i];
}
return(MagickTrue);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(cache_view->image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(cache_view->image,i);
pixel[channel]=p[i];
}
return(MagickTrue);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
pixel[channel]=q[i];
}
return(MagickTrue);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
pixel[channel]=q[i];
}
return(MagickTrue);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
pixel[channel]=p[i];
}
return(MagickTrue);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
pixel[channel]=p[i];
}
return(MagickTrue);
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
channels++;
}
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
gamma=image_statistics[i].standard_deviation*
reconstruct_statistics[channel].standard_deviation;
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
reconstruct_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
reconstruct_traits=GetPixelChannelMapTraits(reconstruct_image,channel);
if ((traits == UndefinedPixelTrait) ||
(reconstruct_traits == UndefinedPixelTrait))
similarity_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
similarity_traits=GetPixelChannelMapTraits(similarity_image,channel);
if ((traits == UndefinedPixelTrait) ||
(similarity_traits == UndefinedPixelTrait))
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
if (traits == UndefinedPixelTrait)
continue;
switch (channel)
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
ShadowFactor+(MagickRealType) background*(QuantumRange-
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
ShadowFactor+(MagickRealType) background*(QuantumRange-
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
TroughFactor+(MagickRealType) background*(QuantumRange-
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
ShadowFactor+(MagickRealType) background*(QuantumRange-
(void) FloodfillPaintImage(*image,draw_info,&target,(ssize_t)
x_offset,(ssize_t) y_offset,method == FloodfillMethod ?
MagickFalse : MagickTrue,exception);
- (void) SetPixelChannelMap(*image,channel_mask);
+ (void) SetPixelChannelMapMask(*image,channel_mask);
draw_info=DestroyDrawInfo(draw_info);
break;
}
*/
channel_mask=SetPixelChannelMask(tmp_image,AlphaChannel);
(void) SeparateImage(tmp_image,exception);
- SetPixelChannelMap(tmp_image,channel_mask);
+ SetPixelChannelMapMask(tmp_image,channel_mask);
(void) SetImageAlphaChannel(tmp_image,OpaqueAlphaChannel,exception);
resize_alpha=DistortImage(tmp_image,AffineDistortion,12,distort_args,
MagickTrue,exception),
ssize_t
v;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
blur_traits=GetPixelChannelMapTraits(blur_image,channel);
if ((traits == UndefinedPixelTrait) ||
(blur_traits == UndefinedPixelTrait))
ssize_t
v;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
sharp_traits=GetPixelChannelMapTraits(sharp_image,channel);
if ((traits == UndefinedPixelTrait) ||
(sharp_traits == UndefinedPixelTrait))
register ssize_t
u;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
blur_traits=GetPixelChannelMapTraits(blur_image,channel);
if ((traits == UndefinedPixelTrait) ||
(blur_traits == UndefinedPixelTrait))
register ssize_t
u;
- traits=GetPixelChannelMapTraits(blur_image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(blur_image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(blur_image,i);
+ channel=GetPixelChannelMapChannel(blur_image,i);
blur_traits=GetPixelChannelMapTraits(blur_image,channel);
if ((traits == UndefinedPixelTrait) ||
(blur_traits == UndefinedPixelTrait))
ssize_t
v;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
convolve_traits=GetPixelChannelMapTraits(convolve_image,channel);
if ((traits == UndefinedPixelTrait) ||
(convolve_traits == UndefinedPixelTrait))
if (status == MagickFalse)
continue;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
despeckle_traits=GetPixelChannelMapTraits(despeckle_image,channel);
if ((traits == UndefinedPixelTrait) ||
(despeckle_traits == UndefinedPixelTrait))
register ssize_t
j;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
blur_traits=GetPixelChannelMapTraits(blur_image,channel);
if ((traits == UndefinedPixelTrait) ||
(blur_traits == UndefinedPixelTrait))
register ssize_t
j;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
blur_traits=GetPixelChannelMapTraits(blur_image,channel);
if ((traits == UndefinedPixelTrait) ||
(blur_traits == UndefinedPixelTrait))
ssize_t
v;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
blur_traits=GetPixelChannelMapTraits(blur_image,channel);
if ((traits == UndefinedPixelTrait) ||
(blur_traits == UndefinedPixelTrait))
shade_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
shade_traits=GetPixelChannelMapTraits(shade_image,channel);
if ((traits == UndefinedPixelTrait) ||
(shade_traits == UndefinedPixelTrait))
ssize_t
v;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
statistic_traits=GetPixelChannelMapTraits(statistic_image,channel);
if ((traits == UndefinedPixelTrait) ||
(statistic_traits == UndefinedPixelTrait))
traits,
unsharp_traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
unsharp_traits=GetPixelChannelMapTraits(unsharp_image,channel);
if ((traits == UndefinedPixelTrait) ||
(unsharp_traits == UndefinedPixelTrait))
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) == 0)
continue;
channel_mask=SetPixelChannelMask(image,(ChannelType) (1 << i));
clut_traits,
traits;
- clut_traits=GetPixelChannelMapTraits(clut_image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(clut_image,(PixelChannel) i);
+ clut_traits=GetPixelChannelMapTraits(clut_image,i);
+ channel=GetPixelChannelMapChannel(clut_image,i);
traits=GetPixelChannelMapTraits(clut_image,channel);
if ((traits == UndefinedPixelTrait) ||
(clut_traits == UndefinedPixelTrait) ||
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (((traits & UpdatePixelTrait) != 0) && (black[i] != white[i]))
q[i]=ClampToQuantum(stretch_map[GetPixelChannels(image)*
ScaleQuantumToMap(q[i])+i]);
register const Quantum
*restrict r;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
enhance_traits=GetPixelChannelMapTraits(enhance_image,channel);
if ((traits == UndefinedPixelTrait) ||
(enhance_traits == UndefinedPixelTrait))
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (((traits & UpdatePixelTrait) != 0) && (black[i] != white[i]))
q[i]=ClampToQuantum(equalize_map[GetPixelChannels(image)*
ScaleQuantumToMap(q[i])+i]);
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(gamma_map[ScaleQuantumToMap(q[i])]);
}
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits == UndefinedPixelTrait) ||
((traits & UpdatePixelTrait) == 0))
continue;
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=LevelizeValue(q[i]);
}
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=QuantumRange-q[i];
}
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=QuantumRange-q[i];
}
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(sigmoidal_map[ScaleQuantumToMap(q[i])]);
}
noise_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
noise_traits=GetPixelChannelMapTraits(noise_image,channel);
if ((traits == UndefinedPixelTrait) ||
(noise_traits == UndefinedPixelTrait))
colorize_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
colorize_traits=GetPixelChannelMapTraits(colorize_image,channel);
if ((traits == UndefinedPixelTrait) ||
(colorize_traits == UndefinedPixelTrait))
fx_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
fx_traits=GetPixelChannelMapTraits(fx_image,channel);
if ((traits == UndefinedPixelTrait) ||
(fx_traits == UndefinedPixelTrait))
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,(u[channel]+v[channel])/2.0,plasma);
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,(u[channel]+v[channel])/2.0,plasma);
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,(u[channel]+v[channel])/2.0,plasma);
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,(u[channel]+v[channel])/2.0,plasma);
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,(u[channel]+v[channel])/2.0,plasma);
(void) SetImageBackgroundColor(border_image,exception);
channel_mask=SetPixelChannelMask(border_image,AlphaChannel);
shadow_image=BlurImage(border_image,0.0,sigma,image->bias,exception);
- (void) SetPixelChannelMap(border_image,channel_mask);
+ (void) SetPixelChannelMapMask(border_image,channel_mask);
border_image=DestroyImage(border_image);
if (shadow_image == (Image *) NULL)
return((Image *) NULL);
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(random_image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(random_image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=ClampToQuantum(QuantumRange*value);
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits == UndefinedPixelTrait) ||
((traits & CopyPixelTrait) != 0))
continue;
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) == 0)
continue;
channel_mask=SetPixelChannelMask(image,(ChannelType) (1 << i));
append_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
append_traits=GetPixelChannelMapTraits(append_image,channel);
if ((traits == UndefinedPixelTrait) ||
(append_traits == UndefinedPixelTrait))
if (next == (Image *) NULL)
continue;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
combine_traits=GetPixelChannelMapTraits(combine_image,channel);
if ((traits == UndefinedPixelTrait) ||
(combine_traits == UndefinedPixelTrait))
MagickRealType
pixel;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
pixel=(MagickRealType) p[i];
register ssize_t
j;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) != 0)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) != 0)
channel_mask=SetPixelChannelMask(separate_image,
(ChannelType) (1 << i));
(void) SeparateImage(separate_image,exception);
- (void) SetPixelChannelMap(separate_image,channel_mask);
+ (void) SetPixelChannelMapMask(separate_image,channel_mask);
AppendImageToList(&images,separate_image);
}
}
/*
Set transparent pixels to background color.
*/
- if (image->matte == MagickFalse)
- break;
+ image->matte=MagickTrue;
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
break;
background=image->background_color;
case OpaqueAlphaChannel:
{
status=SetImageAlpha(image,OpaqueAlpha,exception);
- image->matte=MagickTrue;
break;
}
case TransparentAlphaChannel:
{
status=SetImageAlpha(image,TransparentAlpha,exception);
- image->matte=MagickTrue;
break;
}
case SetAlphaChannel:
{
if (image->matte == MagickFalse)
- {
- status=SetImageAlpha(image,OpaqueAlpha,exception);
- image->matte=MagickTrue;
- }
+ status=SetImageAlpha(image,OpaqueAlpha,exception);
break;
}
case UndefinedAlphaChannel:
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickSignature);
- image->matte=alpha != OpaqueAlpha ? MagickTrue : MagickFalse;
+ image->matte=MagickTrue;
status=MagickTrue;
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
/* #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 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 to 1 if you have the <CL/cl.h> header file. */
-/* #undef HAVE_CL_CL_H */
+#ifndef MAGICKCORE_HAVE_CL_CL_H
+#define MAGICKCORE_HAVE_CL_CL_H 1
+#endif
/* Define to 1 if you have the <complex.h> header file. */
#ifndef MAGICKCORE_HAVE_COMPLEX_H
#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/lib/llvm:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/qt-3.3/lib:/usr/lib64/tcl8.5/tclx8.4:/usr/lib64/tcl8.5:/usr/lib64/tracker-0.12:/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:/opt/intel/lib/intel64:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/nvidia:/usr/lib64/octave/3.4.3:/usr/lib64/qt-3.3/lib:/usr/lib64/tracker-0.12:/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
/* Name of package */
#ifndef MAGICKCORE_PACKAGE
#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
#endif
/* 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). */
/* #undef _MINIX */
/* Define this for the OpenCL Accelerator */
-/* #undef _OPENCL */
+#ifndef MAGICKCORE__OPENCL
+#define MAGICKCORE__OPENCL 1
+#endif
/* Define to 2 if the system does not provide POSIX.1 features except with
this defined. */
MagentaChannel = 0x0002,
BlueChannel = 0x0004,
YellowChannel = 0x0004,
- AlphaChannel = 0x0008,
- OpacityChannel = 0x0008,
- BlackChannel = 0x0010,
+ BlackChannel = 0x0008,
+ AlphaChannel = 0x0010,
+ OpacityChannel = 0x0010,
IndexChannel = 0x0020,
+ MaskChannel = 0x0040,
+ MetaChannel = 0x0080,
CompositeChannels = 0x002F,
AllChannels = 0x7ffffff,
/*
Special purpose channel types.
*/
- TrueAlphaChannel = 0x0040, /* extract actual alpha channel from opacity */
- RGBChannels = 0x0080, /* set alpha from grayscale mask in RGB */
- GrayChannels = 0x0080,
- SyncChannels = 0x0100, /* channels should be modified equally */
+ TrueAlphaChannel = 0x0100, /* extract actual alpha channel from opacity */
+ RGBChannels = 0x0200, /* set alpha from grayscale mask in RGB */
+ GrayChannels = 0x0400,
+ SyncChannels = 0x1000, /* channels should be modified equally */
DefaultChannels = ((AllChannels | SyncChannels) &~ AlphaChannel)
} ChannelType;
#include "MagickCore/monitor-private.h"
#include "MagickCore/montage.h"
#include "MagickCore/option.h"
+#include "MagickCore/pixel.h"
#include "MagickCore/quantize.h"
#include "MagickCore/property.h"
#include "MagickCore/resize.h"
if ((montage_info->frame != (char *) NULL) &&
(image->compose == DstOutCompositeOp))
{
- SetPixelChannelMap(image,AlphaChannel);
+ SetPixelChannelMapMask(image,AlphaChannel);
(void) NegateImage(image,MagickFalse,exception);
- SetPixelChannelMap(image,DefaultChannels);
+ SetPixelChannelMapMask(image,DefaultChannels);
}
}
/*
{
if (image->channel_map[AlphaPixelChannel].traits == UndefinedPixelTrait)
return(OpaqueAlpha);
- return(pixel[image->channel_map[AlphaPixelChannel].channel]);
+ return(pixel[image->channel_map[AlphaPixelChannel].offset]);
}
static inline PixelTrait GetPixelAlphaTraits(const Image *restrict image)
{
if (image->channel_map[BlackPixelChannel].traits == UndefinedPixelTrait)
return(0);
- return(pixel[image->channel_map[BlackPixelChannel].channel]);
+ return(pixel[image->channel_map[BlackPixelChannel].offset]);
}
static inline PixelTrait GetPixelBlackTraits(const Image *restrict image)
static inline Quantum GetPixelBlue(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[BluePixelChannel].channel]);
+ return(pixel[image->channel_map[BluePixelChannel].offset]);
}
static inline PixelTrait GetPixelBlueTraits(const Image *restrict image)
static inline Quantum GetPixelCb(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[CbPixelChannel].channel]);
+ return(pixel[image->channel_map[CbPixelChannel].offset]);
}
static inline PixelTrait GetPixelCbTraits(const Image *restrict image)
{
if (image->channel_map[channel].traits == UndefinedPixelTrait)
return(0);
- return(pixel[image->channel_map[channel].channel]);
+ return(pixel[image->channel_map[channel].offset]);
}
static inline PixelChannel GetPixelChannelMapChannel(
- const Image *restrict image,const PixelChannel channel)
+ const Image *restrict image,const int offset)
{
- return(image->channel_map[channel].channel);
+ return(image->channel_map[offset].channel);
}
static inline PixelTrait GetPixelChannelMapTraits(const Image *restrict image,
- const PixelChannel channel)
+ const int offset)
{
- return(image->channel_map[channel].traits);
+ return(image->channel_map[image->channel_map[offset].channel].traits);
}
static inline size_t GetPixelChannels(const Image *restrict image)
static inline Quantum GetPixelCr(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[CrPixelChannel].channel]);
+ return(pixel[image->channel_map[CrPixelChannel].offset]);
}
static inline PixelTrait GetPixelCrTraits(const Image *restrict image)
static inline Quantum GetPixelCyan(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[CyanPixelChannel].channel]);
+ return(pixel[image->channel_map[CyanPixelChannel].offset]);
}
static inline PixelTrait GetPixelCyanTraits(const Image *restrict image)
static inline Quantum GetPixelGray(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[GrayPixelChannel].channel]);
+ return(pixel[image->channel_map[GrayPixelChannel].offset]);
}
static inline PixelTrait GetPixelGrayTraits(const Image *restrict image)
static inline Quantum GetPixelGreen(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[GreenPixelChannel].channel]);
+ return(pixel[image->channel_map[GreenPixelChannel].offset]);
}
static inline PixelTrait GetPixelGreenTraits(const Image *restrict image)
{
if (image->channel_map[IndexPixelChannel].traits == UndefinedPixelTrait)
return(0);
- return(pixel[image->channel_map[IndexPixelChannel].channel]);
+ return(pixel[image->channel_map[IndexPixelChannel].offset]);
}
static inline PixelTrait GetPixelIndexTraits(const Image *restrict image)
static inline Quantum GetPixelMagenta(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[MagentaPixelChannel].channel]);
+ return(pixel[image->channel_map[MagentaPixelChannel].offset]);
}
static inline PixelTrait GetPixelMagentaTraits(const Image *restrict image)
static inline Quantum GetPixelRed(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[RedPixelChannel].channel]);
+ return(pixel[image->channel_map[RedPixelChannel].offset]);
}
static inline PixelTrait GetPixelRedTraits(const Image *restrict image)
const Quantum *restrict pixel,PixelInfo *restrict pixel_info)
{
pixel_info->red=(MagickRealType)
- pixel[image->channel_map[RedPixelChannel].channel];
+ pixel[image->channel_map[RedPixelChannel].offset];
pixel_info->green=(MagickRealType)
- pixel[image->channel_map[GreenPixelChannel].channel];
+ pixel[image->channel_map[GreenPixelChannel].offset];
pixel_info->blue=(MagickRealType)
- pixel[image->channel_map[BluePixelChannel].channel];
+ pixel[image->channel_map[BluePixelChannel].offset];
pixel_info->black=0;
if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
pixel_info->black=(MagickRealType)
- pixel[image->channel_map[BlackPixelChannel].channel];
+ pixel[image->channel_map[BlackPixelChannel].offset];
pixel_info->alpha=OpaqueAlpha;
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
pixel_info->alpha=(MagickRealType)
- pixel[image->channel_map[AlphaPixelChannel].channel];
+ pixel[image->channel_map[AlphaPixelChannel].offset];
pixel_info->index=0;
if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
pixel_info->index=(MagickRealType)
- pixel[image->channel_map[IndexPixelChannel].channel];
+ pixel[image->channel_map[IndexPixelChannel].offset];
}
static inline PixelTrait GetPixelTraits(const Image *restrict image,
static inline Quantum GetPixelY(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[YPixelChannel].channel]);
+ return(pixel[image->channel_map[YPixelChannel].offset]);
}
static inline PixelTrait GetPixelYTraits(const Image *restrict image)
static inline Quantum GetPixelYellow(const Image *restrict image,
const Quantum *restrict pixel)
{
- return(pixel[image->channel_map[YellowPixelChannel].channel]);
+ return(pixel[image->channel_map[YellowPixelChannel].offset]);
}
static inline PixelTrait GetPixelYellowTraits(const Image *restrict image)
static inline MagickBooleanType IsPixelEquivalent(const Image *restrict image,
const Quantum *restrict p,const PixelInfo *restrict q)
{
- if (((double) p[image->channel_map[RedPixelChannel].channel] == q->red) &&
- ((double) p[image->channel_map[GreenPixelChannel].channel] == q->green) &&
- ((double) p[image->channel_map[BluePixelChannel].channel] == q->blue))
+ if (((double) p[image->channel_map[RedPixelChannel].offset] == q->red) &&
+ ((double) p[image->channel_map[GreenPixelChannel].offset] == q->green) &&
+ ((double) p[image->channel_map[BluePixelChannel].offset] == q->blue))
return(MagickTrue);
return(MagickFalse);
}
const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
- if ((pixel[image->channel_map[RedPixelChannel].channel] ==
- pixel[image->channel_map[GreenPixelChannel].channel]) &&
- (pixel[image->channel_map[GreenPixelChannel].channel] ==
- pixel[image->channel_map[BluePixelChannel].channel]))
+ if ((pixel[image->channel_map[RedPixelChannel].offset] ==
+ pixel[image->channel_map[GreenPixelChannel].offset]) &&
+ (pixel[image->channel_map[GreenPixelChannel].offset] ==
+ pixel[image->channel_map[BluePixelChannel].offset]))
return(MagickTrue);
#else
{
alpha,
beta;
- alpha=pixel[image->channel_map[RedPixelChannel].channel]-(double)
- pixel[image->channel_map[GreenPixelChannel].channel];
- beta=pixel[image->channel_map[GreenPixelChannel].channel]-(double)
- pixel[image->channel_map[BluePixelChannel].channel];
+ alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
+ pixel[image->channel_map[GreenPixelChannel].offset];
+ beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
+ pixel[image->channel_map[BluePixelChannel].offset];
if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
return(MagickTrue);
}
const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
- if (((pixel[image->channel_map[RedPixelChannel].channel] == 0) ||
- (pixel[image->channel_map[RedPixelChannel].channel] == (Quantum) QuantumRange)) &&
- (pixel[image->channel_map[RedPixelChannel].channel] ==
- pixel[image->channel_map[GreenPixelChannel].channel]) &&
- (pixel[image->channel_map[GreenPixelChannel].channel] ==
- pixel[image->channel_map[BluePixelChannel].channel]))
+ if (((pixel[image->channel_map[RedPixelChannel].offset] == 0) ||
+ (pixel[image->channel_map[RedPixelChannel].offset] == (Quantum) QuantumRange)) &&
+ (pixel[image->channel_map[RedPixelChannel].offset] ==
+ pixel[image->channel_map[GreenPixelChannel].offset]) &&
+ (pixel[image->channel_map[GreenPixelChannel].offset] ==
+ pixel[image->channel_map[BluePixelChannel].offset]))
return(MagickTrue);
#else
{
alpha,
beta;
- alpha=pixel[image->channel_map[RedPixelChannel].channel]-(double)
- pixel[image->channel_map[GreenPixelChannel].channel];
- beta=pixel[image->channel_map[GreenPixelChannel].channel]-(double)
- pixel[image->channel_map[BluePixelChannel].channel];
- if (((fabs(pixel[image->channel_map[RedPixelChannel].channel]) <=
- MagickEpsilon) ||
- (fabs(pixel[image->channel_map[RedPixelChannel].channel]-
- QuantumRange) <= MagickEpsilon)) &&
+ alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
+ pixel[image->channel_map[GreenPixelChannel].offset];
+ beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
+ pixel[image->channel_map[BluePixelChannel].offset];
+ if (((fabs(pixel[image->channel_map[RedPixelChannel].offset]) <= MagickEpsilon) ||
+ (fabs(pixel[image->channel_map[RedPixelChannel].offset]-QuantumRange) <= MagickEpsilon)) &&
(fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
return(MagickTrue);
}
const Quantum alpha,Quantum *restrict pixel)
{
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
- pixel[image->channel_map[AlphaPixelChannel].channel]=alpha;
+ pixel[image->channel_map[AlphaPixelChannel].offset]=alpha;
}
static inline void SetPixelAlphaTraits(Image *image,const PixelTrait traits)
const Quantum black,Quantum *restrict pixel)
{
if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
- pixel[image->channel_map[BlackPixelChannel].channel]=black;
+ pixel[image->channel_map[BlackPixelChannel].offset]=black;
}
static inline void SetPixelBlackTraits(Image *image,const PixelTrait traits)
static inline void SetPixelBlue(const Image *restrict image,const Quantum blue,
Quantum *restrict pixel)
{
- pixel[image->channel_map[BluePixelChannel].channel]=blue;
+ pixel[image->channel_map[BluePixelChannel].offset]=blue;
}
static inline void SetPixelBlueTraits(Image *image,const PixelTrait traits)
static inline void SetPixelCb(const Image *restrict image,const Quantum cb,
Quantum *restrict pixel)
{
- pixel[image->channel_map[CbPixelChannel].channel]=cb;
+ pixel[image->channel_map[CbPixelChannel].offset]=cb;
}
static inline void SetPixelCbTraits(Image *image,const PixelTrait traits)
const PixelChannel channel,const Quantum quantum,Quantum *restrict pixel)
{
if (image->channel_map[channel].traits != UndefinedPixelTrait)
- pixel[image->channel_map[channel].channel]=quantum;
+ pixel[image->channel_map[channel].offset]=quantum;
}
static inline void SetPixelChannelMapChannel(const Image *restrict image,
- const PixelChannel channel,const PixelChannel channels)
+ const PixelChannel channel,const int offset)
+{
+ image->channel_map[offset].channel=channel;
+ image->channel_map[channel].offset=offset;
+}
+
+static inline void SetPixelChannelMap(const Image *restrict image,
+ const PixelChannel channel,const PixelTrait traits,const int offset)
{
- image->channel_map[channel].channel=channels;
+ image->channel_map[offset].channel=channel;
+ image->channel_map[channel].offset=offset;
+ image->channel_map[channel].traits=traits;
}
static inline void SetPixelChannels(Image *image,const size_t number_channels)
static inline void SetPixelCr(const Image *restrict image,const Quantum cr,
Quantum *restrict pixel)
{
- pixel[image->channel_map[CrPixelChannel].channel]=cr;
+ pixel[image->channel_map[CrPixelChannel].offset]=cr;
}
static inline void SetPixelCrTraits(Image *image,const PixelTrait traits)
static inline void SetPixelCyan(const Image *restrict image,const Quantum cyan,
Quantum *restrict pixel)
{
- pixel[image->channel_map[CyanPixelChannel].channel]=cyan;
+ pixel[image->channel_map[CyanPixelChannel].offset]=cyan;
}
static inline void SetPixelGray(const Image *restrict image,const Quantum gray,
Quantum *restrict pixel)
{
- pixel[image->channel_map[GrayPixelChannel].channel]=gray;
+ pixel[image->channel_map[GrayPixelChannel].offset]=gray;
}
static inline void SetPixelGrayTraits(Image *image,const PixelTrait traits)
static inline void SetPixelGreen(const Image *restrict image,
const Quantum green,Quantum *restrict pixel)
{
- pixel[image->channel_map[GreenPixelChannel].channel]=green;
+ pixel[image->channel_map[GreenPixelChannel].offset]=green;
}
static inline void SetPixelGreenTraits(Image *image,const PixelTrait traits)
const Quantum index,Quantum *restrict pixel)
{
if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
- pixel[image->channel_map[IndexPixelChannel].channel]=index;
+ pixel[image->channel_map[IndexPixelChannel].offset]=index;
}
static inline void SetPixelIndexTraits(Image *image,const PixelTrait traits)
static inline void SetPixelInfoPixel(const Image *restrict image,
const PixelInfo *restrict pixel_info,Quantum *restrict pixel)
{
- pixel[image->channel_map[RedPixelChannel].channel]=
+ pixel[image->channel_map[RedPixelChannel].offset]=
ClampToQuantum(pixel_info->red);
- pixel[image->channel_map[GreenPixelChannel].channel]=
+ pixel[image->channel_map[GreenPixelChannel].offset]=
ClampToQuantum(pixel_info->green);
- pixel[image->channel_map[BluePixelChannel].channel]=
+ pixel[image->channel_map[BluePixelChannel].offset]=
ClampToQuantum(pixel_info->blue);
if ((image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait) &&
(image->colorspace == CMYKColorspace) &&
(pixel_info->colorspace == CMYKColorspace))
- pixel[image->channel_map[BlackPixelChannel].channel]=
+ pixel[image->channel_map[BlackPixelChannel].offset]=
ClampToQuantum(pixel_info->black);
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
- pixel[image->channel_map[AlphaPixelChannel].channel]=
+ pixel[image->channel_map[AlphaPixelChannel].offset]=
pixel_info->matte == MagickFalse ? OpaqueAlpha :
ClampToQuantum(pixel_info->alpha);
}
static inline void SetPixelMagenta(const Image *restrict image,
const Quantum magenta,Quantum *restrict pixel)
{
- pixel[image->channel_map[MagentaPixelChannel].channel]=magenta;
+ pixel[image->channel_map[MagentaPixelChannel].offset]=magenta;
}
static inline void SetPixelMagentaTraits(Image *image,const PixelTrait traits)
static inline void SetPixelRed(const Image *restrict image,const Quantum red,
Quantum *restrict pixel)
{
- pixel[image->channel_map[RedPixelChannel].channel]=red;
+ pixel[image->channel_map[RedPixelChannel].offset]=red;
}
static inline void SetPixelRedTraits(Image *image,const PixelTrait traits)
static inline void SetPixelYellow(const Image *restrict image,
const Quantum yellow,Quantum *restrict pixel)
{
- pixel[image->channel_map[YellowPixelChannel].channel]=yellow;
+ pixel[image->channel_map[YellowPixelChannel].offset]=yellow;
}
static inline void SetPixelYellowTraits(Image *image,const PixelTrait traits)
static inline void SetPixelY(const Image *restrict image,const Quantum y,
Quantum *restrict pixel)
{
- pixel[image->channel_map[YPixelChannel].channel]=y;
+ pixel[image->channel_map[YPixelChannel].offset]=y;
}
static inline void SetPixelYTraits(Image *image,const PixelTrait traits)
const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
- if ((pixel[image->channel_map[RedPixelChannel].channel] ==
- pixel[image->channel_map[GreenPixelChannel].channel]) &&
- (pixel[image->channel_map[GreenPixelChannel].channel] ==
- pixel[image->channel_map[BluePixelChannel].channel]))
- return(pixel[image->channel_map[RedPixelChannel].channel]);
- return((Quantum) (0.299*pixel[image->channel_map[RedPixelChannel].channel]+
- 0.587*pixel[image->channel_map[GreenPixelChannel].channel]+0.114*
- pixel[image->channel_map[BluePixelChannel].channel]+0.5));
+ if ((pixel[image->channel_map[RedPixelChannel].offset] ==
+ pixel[image->channel_map[GreenPixelChannel].offset]) &&
+ (pixel[image->channel_map[GreenPixelChannel].offset] ==
+ pixel[image->channel_map[BluePixelChannel].offset]))
+ return(pixel[image->channel_map[RedPixelChannel].offset]);
+ return((Quantum) (0.299*pixel[image->channel_map[RedPixelChannel].offset]+
+ 0.587*pixel[image->channel_map[GreenPixelChannel].offset]+0.114*
+ pixel[image->channel_map[BluePixelChannel].offset]+0.5));
#else
{
double
alpha,
beta;
- alpha=pixel[image->channel_map[RedPixelChannel].channel]-(double)
- pixel[image->channel_map[GreenPixelChannel].channel];
- beta=pixel[image->channel_map[GreenPixelChannel].channel]-(double)
- pixel[image->channel_map[BluePixelChannel].channel];
+ alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
+ pixel[image->channel_map[GreenPixelChannel].offset];
+ beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
+ pixel[image->channel_map[BluePixelChannel].offset];
if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
- return(pixel[image->channel_map[RedPixelChannel].channel]);
- return((Quantum) (0.299*pixel[image->channel_map[RedPixelChannel].channel]+
- 0.587*pixel[image->channel_map[GreenPixelChannel].channel]+0.114*
- pixel[image->channel_map[BluePixelChannel].channel]));
+ return(pixel[image->channel_map[RedPixelChannel].offset]);
+ return((Quantum) (0.299*pixel[image->channel_map[RedPixelChannel].offset]+
+ 0.587*pixel[image->channel_map[GreenPixelChannel].offset]+0.114*
+ pixel[image->channel_map[BluePixelChannel].offset]));
}
#endif
}
const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
- return((Quantum) (0.21267*pixel[image->channel_map[RedPixelChannel].channel]+
- 0.71516*pixel[image->channel_map[GreenPixelChannel].channel]+0.07217*
- pixel[image->channel_map[BluePixelChannel].channel]+0.5));
+ return((Quantum) (0.21267*pixel[image->channel_map[RedPixelChannel].offset]+
+ 0.71516*pixel[image->channel_map[GreenPixelChannel].offset]+0.07217*
+ pixel[image->channel_map[BluePixelChannel].offset]+0.5));
#else
- return((Quantum) (0.21267*pixel[image->channel_map[RedPixelChannel].channel]+
- 0.71516*pixel[image->channel_map[GreenPixelChannel].channel]+0.07217*
- pixel[image->channel_map[BluePixelChannel].channel]));
+ return((Quantum) (0.21267*pixel[image->channel_map[RedPixelChannel].offset]+
+ 0.71516*pixel[image->channel_map[GreenPixelChannel].offset]+0.07217*
+ pixel[image->channel_map[BluePixelChannel].offset]));
#endif
}
#include "MagickCore/transform.h"
#include "MagickCore/utility.h"
\f
-/*
- Define declarations.
-*/
#define LogPixelChannels(image) \
{ \
register ssize_t \
const char \
*channel; \
\
- switch (image->channel_map[i].channel) \
+ switch (GetPixelChannelMapChannel(image,i)) \
{ \
case RedPixelChannel: \
{ \
channel="index"; \
break; \
} \
+ case IndexPixelChannel: \
+ { \
+ channel="index"; \
+ break; \
+ } \
case AlphaPixelChannel: \
{ \
channel="alpha"; \
channel="mask"; \
break; \
} \
- default: \
+ case MetaPixelChannel: \
{ \
- channel="undefined"; \
+ channel="meta"; \
+ break; \
} \
+ default: \
+ channel="undefined"; \
} \
*traits='\0'; \
- if ((image->channel_map[i].traits & UpdatePixelTrait) != 0) \
+ if ((GetPixelChannelMapTraits(image,i) & UpdatePixelTrait) != 0) \
(void) ConcatenateMagickString(traits,"update,",MaxTextExtent); \
- if ((image->channel_map[i].traits & BlendPixelTrait) != 0) \
+ if ((GetPixelChannelMapTraits(image,i) & BlendPixelTrait) != 0) \
(void) ConcatenateMagickString(traits,"blend,",MaxTextExtent); \
- if ((image->channel_map[i].traits & CopyPixelTrait) != 0) \
+ if ((GetPixelChannelMapTraits(image,i) & CopyPixelTrait) != 0) \
(void) ConcatenateMagickString(traits,"copy,",MaxTextExtent); \
if (*traits == '\0') \
(void) ConcatenateMagickString(traits,"undefined,",MaxTextExtent); \
% o image: the image.
%
*/
-
-MagickExport void PendInitializePixelChannelMap(Image *image)
+MagickExport void InitializePixelChannelMap(Image *image)
{
+ PixelTrait
+ trait;
+
register ssize_t
i;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- for (i=0; i < (ssize_t) MaxPixelChannels; i++)
- {
- SetPixelChannelMapChannel(image,(PixelChannel) i,(PixelChannel) 0);
- SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
- }
+ (void) ResetMagickMemory(image->channel_map,0,MaxPixelChannels*
+ sizeof(*image->channel_map));
+ trait=UpdatePixelTrait;
+ if (image->matte != MagickFalse)
+ trait|=BlendPixelTrait;
n=0;
- SetPixelChannelMapChannel(image,RedPixelChannel,(PixelChannel) n++);
- SetPixelChannelMapTraits(image,RedPixelChannel,(PixelTrait)
- (UpdatePixelTrait | BlendPixelTrait));
- SetPixelChannelMapChannel(image,GreenPixelChannel,(PixelChannel) n++);
- SetPixelChannelMapTraits(image,GreenPixelChannel,(PixelTrait)
- (UpdatePixelTrait | BlendPixelTrait));
- SetPixelChannelMapChannel(image,BluePixelChannel,(PixelChannel) n++);
- SetPixelChannelMapTraits(image,BluePixelChannel,(PixelTrait)
- (UpdatePixelTrait | BlendPixelTrait));
+ SetPixelChannelMap(image,RedPixelChannel,trait,n++);
+ SetPixelChannelMap(image,GreenPixelChannel,trait,n++);
+ SetPixelChannelMap(image,BluePixelChannel,trait,n++);
+if (0)
if (image->colorspace == GRAYColorspace)
{
n=0;
- SetPixelChannelMapChannel(image,RedPixelChannel,(PixelChannel) n);
- SetPixelChannelMapChannel(image,GreenPixelChannel,(PixelChannel) n);
- SetPixelChannelMapChannel(image,BluePixelChannel,(PixelChannel) n++);
+ SetPixelChannelMap(image,RedPixelChannel,trait,n);
+ SetPixelChannelMap(image,GreenPixelChannel,trait,n);
+ SetPixelChannelMap(image,BluePixelChannel,trait,n++);
}
if (image->colorspace == CMYKColorspace)
- {
- SetPixelChannelMapChannel(image,BlackPixelChannel,(PixelChannel) n++);
- SetPixelChannelMapTraits(image,BlackPixelChannel,(PixelTrait)
- (UpdatePixelTrait | BlendPixelTrait));
- }
- if (image->storage_class == PseudoClass)
- {
- SetPixelChannelMapChannel(image,IndexPixelChannel,(PixelChannel) n++);
- SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
- }
+ SetPixelChannelMap(image,BlackPixelChannel,trait,n++);
if (image->matte != MagickFalse)
- {
- SetPixelChannelMapChannel(image,AlphaPixelChannel,(PixelChannel) n++);
- SetPixelChannelMapTraits(image,AlphaPixelChannel,CopyPixelTrait);
- }
- n+=image->number_meta_channels;
- for ( ; i < (ssize_t) n; i++)
- SetPixelChannelMapTraits(image,(PixelChannel) i,CopyPixelTrait);
- image->number_channels=n;
- if (image->debug != MagickFalse)
- LogPixelChannels(image);
- (void) SetPixelChannelMask(image,image->channel_mask);
-}
-
-MagickExport void InitializePixelChannelMap(Image *image)
-{
- PixelChannel
- alpha_channel;
-
- register ssize_t
- i;
-
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- for (i=0; i < (ssize_t) MaxPixelChannels; i++)
- {
- SetPixelChannelMapChannel(image,(PixelChannel) i,(PixelChannel) i);
- SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
- }
- image->number_channels=4;
- if (0 && image->colorspace == GRAYColorspace)
- image->number_channels=2;
- if (image->colorspace == CMYKColorspace)
- image->number_channels++;
+ SetPixelChannelMap(image,AlphaPixelChannel,CopyPixelTrait,n++);
if (image->storage_class == PseudoClass)
- image->number_channels++;
- for (i=0; i < (ssize_t) image->number_channels; i++)
- SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
- UpdatePixelTrait);
- alpha_channel=GetPixelChannelMapChannel(image,AlphaPixelChannel);
- if (image->matte == MagickFalse)
- SetPixelChannelMapTraits(image,AlphaPixelChannel,CopyPixelTrait);
- else
- for (i=0; i < (ssize_t) image->number_channels; i++)
- if ((PixelChannel) i != alpha_channel)
- SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
- (UpdatePixelTrait | BlendPixelTrait));
- if (0 && image->colorspace == GRAYColorspace)
- {
- image->number_channels=2;
- SetPixelChannelMapChannel(image,GreenPixelChannel,RedPixelChannel);
- SetPixelChannelMapChannel(image,BluePixelChannel,RedPixelChannel);
- }
- if (image->storage_class == PseudoClass)
- {
- SetPixelChannelMapChannel(image,IndexPixelChannel,IndexPixelChannel);
- SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
- }
- image->number_channels+=image->number_meta_channels;
- for ( ; i < (ssize_t) image->number_channels; i++)
- SetPixelChannelMapTraits(image,(PixelChannel) i,CopyPixelTrait);
+ SetPixelChannelMap(image,IndexPixelChannel,CopyPixelTrait,n++);
+ assert((n+image->number_meta_channels) < MaxPixelChannels);
+ for (i=0; i < (ssize_t) image->number_meta_channels; i++)
+ SetPixelChannelMap(image,(PixelChannel) MetaPixelChannel+i,CopyPixelTrait,
+ n++);
+ image->number_channels=n;
if (image->debug != MagickFalse)
LogPixelChannels(image);
(void) SetPixelChannelMask(image,image->channel_mask);
register ssize_t
j;
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
register ssize_t
j;
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
delta,
epsilon;
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
RectangleInfo
geometry;
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
}
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
}
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
delta,
luminance;
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
k,
n;
- traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(source,i);
+ channel=GetPixelChannelMapChannel(source,i);
destination_traits=GetPixelChannelMapTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
% %
% %
% %
-% S e t P i x e l C h a n n e l M a p %
+% S e t P i x e l C h a n n e l M a p M a s k %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetPixelChannelMap() sets the pixel channel map from the specified channel
-% mask.
+% SetPixelChannelMapMask() sets the pixel channel map from the specified
+% channel mask.
%
-% The format of the SetPixelChannelMap method is:
+% The format of the SetPixelChannelMapMask method is:
%
-% void SetPixelChannelMap(Image *image,const ChannelType channel_mask)
+% void SetPixelChannelMapMask(Image *image,const ChannelType channel_mask)
%
% A description of each parameter follows:
%
% o mask: the channel mask.
%
*/
-MagickExport void SetPixelChannelMap(Image *image,
+MagickExport void SetPixelChannelMapMask(Image *image,
const ChannelType channel_mask)
{
#define GetChannelBit(mask,bit) (((size_t) (mask) >> (size_t) (bit)) & 0x01)
image->channel_mask=channel_mask;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- SetPixelChannelMapTraits(image,(PixelChannel) i,
- GetChannelBit(channel_mask,i) == 0 ? CopyPixelTrait :
+ {
+ PixelChannel
+ channel;
+
+ channel=GetPixelChannelMapChannel(image,i);
+ SetPixelChannelMapTraits(image,channel,
+ GetChannelBit(channel_mask,channel) == 0 ? CopyPixelTrait :
image->matte == MagickFalse ? UpdatePixelTrait : (PixelTrait)
(UpdatePixelTrait | BlendPixelTrait));
- for ( ; i < MaxPixelChannels; i++)
- SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
+ }
if (image->storage_class == PseudoClass)
SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
if (image->debug != MagickFalse)
mask=image->channel_mask;
image->channel_mask=channel_mask;
- SetPixelChannelMap(image,channel_mask);
+ SetPixelChannelMapMask(image,channel_mask);
return(mask);
}
BluePixelChannel = 2,
YellowPixelChannel = 2,
CrPixelChannel = 2,
- AlphaPixelChannel = 3,
- BlackPixelChannel = 4,
- IndexPixelChannel = 4,
- MaskPixelChannel = 5,
+ BlackPixelChannel = 3,
+ AlphaPixelChannel = 4,
+ IndexPixelChannel = 5,
+ MaskPixelChannel = 6,
+ MetaPixelChannel = 7,
IntensityPixelChannel = MaxPixelChannels,
CompositePixelChannel = MaxPixelChannels,
SyncPixelChannel = MaxPixelChannels+1
PixelTrait
traits;
+
+ int
+ offset;
} PixelChannelMap;
typedef struct _PixelInfo
extern MagickExport void
InitializePixelChannelMap(Image *),
GetPixelInfo(const Image *,PixelInfo *),
- SetPixelChannelMap(Image *,const ChannelType);
+ SetPixelChannelMapMask(Image *,const ChannelType);
#if defined(__cplusplus) || defined(c_plusplus)
}
rescale_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
rescale_traits=GetPixelChannelMapTraits(rescale_image,channel);
if ((traits == UndefinedPixelTrait) ||
(rescale_traits == UndefinedPixelTrait))
ssize_t
k;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
resize_traits=GetPixelChannelMapTraits(resize_image,channel);
if ((traits == UndefinedPixelTrait) ||
(resize_traits == UndefinedPixelTrait))
ssize_t
k;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
resize_traits=GetPixelChannelMapTraits(resize_image,channel);
if ((traits == UndefinedPixelTrait) ||
(resize_traits == UndefinedPixelTrait))
sample_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
sample_traits=GetPixelChannelMapTraits(sample_image,channel);
if ((traits == UndefinedPixelTrait) ||
(sample_traits == UndefinedPixelTrait))
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & BlendPixelTrait) == 0)
{
x_vector[x*GetPixelChannels(image)+i]=(MagickRealType) p[i];
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & BlendPixelTrait) == 0)
{
x_vector[x*GetPixelChannels(image)+i]=(MagickRealType)
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & BlendPixelTrait) == 0)
{
x_vector[x*GetPixelChannels(image)+i]=(MagickRealType) p[i];
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
scale_traits=GetPixelChannelMapTraits(scale_image,channel);
if ((traits == UndefinedPixelTrait) ||
(scale_traits == UndefinedPixelTrait))
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
pixel[i]+=span.x*scanline[x*GetPixelChannels(image)+i];
scale_scanline[n*GetPixelChannels(scale_image)+channel]=pixel[i];
}
{
for (i=0; i < (ssize_t) GetPixelChannels(scale_image); i++)
{
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
scale_traits=GetPixelChannelMapTraits(scale_image,channel);
if ((traits == UndefinedPixelTrait) ||
(scale_traits == UndefinedPixelTrait))
rotate_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
rotate_traits=GetPixelChannelMapTraits(rotate_image,channel);
if ((traits == UndefinedPixelTrait) ||
(rotate_traits == UndefinedPixelTrait))
rotate_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
rotate_traits=GetPixelChannelMapTraits(rotate_image,channel);
if ((traits == UndefinedPixelTrait) ||
(rotate_traits == UndefinedPixelTrait))
rotate_traits,
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
rotate_traits=GetPixelChannelMapTraits(rotate_image,channel);
if ((traits == UndefinedPixelTrait) ||
(rotate_traits == UndefinedPixelTrait))
register ssize_t
j;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
number_threads;
number_threads=GetOpenMPMaximumThreads();
- pixels=(PixelChannels **) AcquireQuantumMemory(number_threads,sizeof(*pixels));
+ pixels=(PixelChannels **) AcquireQuantumMemory(number_threads,
+ sizeof(*pixels));
if (pixels == (PixelChannels **) NULL)
return((PixelChannels **) NULL);
(void) ResetMagickMemory(pixels,0,number_threads*sizeof(*pixels));
case AddModulusEvaluateOperator:
{
/*
- This returns a 'floored modulus' of the addition which is a
- positive result. It differs from % or fmod() that returns a
- 'truncated modulus' result, where floor() is replaced by trunc() and
- could return a negative result (which is clipped).
+ This returns a 'floored modulus' of the addition which is a positive
+ result. It differs from % or fmod() that returns a 'truncated modulus'
+ result, where floor() is replaced by trunc() and could return a
+ negative result (which is clipped).
*/
result=pixel+value;
result-=(QuantumRange+1.0)*floor((double) result/(QuantumRange+1.0));
evaluate_view=AcquireCacheView(evaluate_image);
if (op == MedianEvaluateOperator)
{
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic) shared(progress,status)
#endif
for (y=0; y < (ssize_t) evaluate_image->rows; y++)
evaluate_traits=GetPixelChannelMapTraits(evaluate_image,
(PixelChannel) i);
- channel=GetPixelChannelMapChannel(evaluate_image,(PixelChannel)
- i);
+ channel=GetPixelChannelMapChannel(evaluate_image,i);
traits=GetPixelChannelMapTraits(next,channel);
if ((traits == UndefinedPixelTrait) ||
(evaluate_traits == UndefinedPixelTrait))
if ((traits & UpdatePixelTrait) == 0)
continue;
evaluate_pixel[x].channel[i]=ApplyEvaluateOperator(
- random_info[id],GetPixelChannel(evaluate_image,channel,p),
- j == 0 ? AddEvaluateOperator : op,evaluate_pixel[x].channel[i]);
+ random_info[id],GetPixelChannel(evaluate_image,channel,p),j ==
+ 0 ? AddEvaluateOperator : op,evaluate_pixel[x].channel[i]);
}
p+=GetPixelChannels(next);
}
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(evaluate_image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(evaluate_image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=ClampToQuantum(ApplyEvaluateOperator(random_info[id],q[i],op,
case PolynomialFunction:
{
/*
- Polynomial: polynomial constants, highest to lowest order
- (e.g. c0*x^3 + c1*x^2 + c2*x + c3).
+ Polynomial: polynomial constants, highest to lowest order (e.g. c0*x^3+
+ c1*x^2+c2*x+c3).
*/
result=0.0;
for (i=0; i < (ssize_t) number_parameters; i++)
width;
/*
- Arcsin (peged at range limits for invalid results):
- width, center, range, and bias.
+ Arcsin (peged at range limits for invalid results): width, center,
+ range, and bias.
*/
width=(number_parameters >= 1) ? parameters[0] : 1.0;
center=(number_parameters >= 2) ? parameters[1] : 0.5;
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
channel_statistics[CompositePixelChannel].standard_deviation=
sqrt(channel_statistics[CompositePixelChannel].standard_deviation/area);
*mean=channel_statistics[CompositePixelChannel].mean;
- *standard_deviation=channel_statistics[CompositePixelChannel].standard_deviation;
+ *standard_deviation=
+ channel_statistics[CompositePixelChannel].standard_deviation;
channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
channel_statistics);
return(MagickTrue);
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & UpdatePixelTrait) == 0)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
channels++;
}
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
if (channel_statistics[i].depth != MAGICKCORE_QUANTUM_DEPTH)
{
if (channel_statistics[i].standard_deviation == 0.0)
continue;
- channel_statistics[i].skewness=(channel_statistics[i].sum_cubed-
- 3.0*channel_statistics[i].mean*channel_statistics[i].sum_squared+
- 2.0*channel_statistics[i].mean*channel_statistics[i].mean*
+ channel_statistics[i].skewness=(channel_statistics[i].sum_cubed-3.0*
+ channel_statistics[i].mean*channel_statistics[i].sum_squared+2.0*
+ channel_statistics[i].mean*channel_statistics[i].mean*
channel_statistics[i].mean)/(channel_statistics[i].standard_deviation*
channel_statistics[i].standard_deviation*
channel_statistics[i].standard_deviation);
- channel_statistics[i].kurtosis=(channel_statistics[i].sum_fourth_power-
- 4.0*channel_statistics[i].mean*channel_statistics[i].sum_cubed+
- 6.0*channel_statistics[i].mean*channel_statistics[i].mean*
+ channel_statistics[i].kurtosis=(channel_statistics[i].sum_fourth_power-4.0*
+ channel_statistics[i].mean*channel_statistics[i].sum_cubed+6.0*
+ channel_statistics[i].mean*channel_statistics[i].mean*
channel_statistics[i].sum_squared-3.0*channel_statistics[i].mean*
channel_statistics[i].mean*1.0*channel_statistics[i].mean*
channel_statistics[i].mean)/(channel_statistics[i].standard_deviation*
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
pixel[channel]=q[i];
}
return(MagickTrue);
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ channel=GetPixelChannelMapChannel(image,i);
pixel[channel]=p[i];
}
return(MagickTrue);
ssize_t
v;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
- channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
+ channel=GetPixelChannelMapChannel(image,i);
threshold_traits=GetPixelChannelMapTraits(threshold_image,channel);
if ((traits == UndefinedPixelTrait) ||
(threshold_traits == UndefinedPixelTrait))
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) != 0)
q[i]=(Quantum) ((MagickRealType) q[i] <= threshold ? 0 :
QuantumRange);
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) == 0)
continue;
if ((MagickRealType) q[i] < threshold[n++ % 5])
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if (traits == UndefinedPixelTrait)
continue;
q[i]=ClampToUnsignedQuantum(q[i]);
level,
threshold;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) == 0)
continue;
if (fabs(levels[n++]) < MagickEpsilon)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) == 0)
continue;
if ((MagickRealType) q[i] < min_threshold)
PixelTrait
traits;
- traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ traits=GetPixelChannelMapTraits(image,i);
if ((traits & UpdatePixelTrait) == 0)
continue;
if ((MagickRealType) q[i] > threshold[n++ % 5])
*/
#define MagickPackageName "ImageMagick"
#define MagickCopyright "Copyright (C) 1999-2011 ImageMagick Studio LLC"
-#define MagickSVNRevision "6029"
+#define MagickSVNRevision "exported"
#define MagickLibVersion 0x700
#define MagickLibVersionText "7.0.0"
#define MagickLibVersionNumber 7,0,0
#define MagickLibAddendum "-0"
#define MagickLibInterface 7
#define MagickLibMinInterface 7
-#define MagickReleaseDate "2011-11-19"
+#define MagickReleaseDate "2011-12-03"
#define MagickChangeDate "20110801"
#define MagickAuthoritativeURL "http://www.imagemagick.org"
#if defined(MAGICKCORE_OPENMP_SUPPORT)
if (channel < 0)
ThrowCompareException(OptionError,"UnrecognizedChannelType",
argv[i]);
- SetPixelChannelMap(image,(ChannelType) channel);
+ SetPixelChannelMapMask(image,(ChannelType) channel);
break;
}
if (LocaleCompare("colorspace",option+1) == 0)
composite_image,geometry.x,geometry.y,exception);
}
}
- (void) SetPixelChannelMap(composite_image,channel_mask);
+ (void) SetPixelChannelMapMask(composite_image,channel_mask);
return(status != 0 ? MagickTrue : MagickFalse);
}
channel=DefaultChannels;
else
channel=(ChannelType) ParseChannelOption(argv[i+1]);
- SetPixelChannelMap(*image,channel);
+ SetPixelChannelMapMask(*image,channel);
break;
}
if (LocaleCompare("charcoal",option+1) == 0)
break;
}
channel=(ChannelType) ParseChannelOption(argv[i+1]);
- SetPixelChannelMap(*images,channel);
+ SetPixelChannelMapMask(*images,channel);
break;
}
if (LocaleCompare("clut",option+1) == 0)
"UnrecognizedType",SvPV(ST(i),na));
return;
}
- SetPixelChannelMap(image,(ChannelType) option);
+ SetPixelChannelMapMask(image,(ChannelType) option);
break;
}
ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
SvPV(ST(i),na));
return;
}
- SetPixelChannelMap(image,(ChannelType) option);
+ SetPixelChannelMapMask(image,(ChannelType) option);
break;
}
ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
print "Scale...\n";
$example=$model->Clone();
$example->Label('Scale');
-$example->Scale('60%');
+#$example->Scale('60%');
push(@$images,$example);
print "Segment...\n";
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
noise_image=AddNoiseImage(msl_info->image[n],noise,1.0,
msl_info->exception);
- (void) SetPixelChannelMap(msl_info->image[n],channel_mask);
+ (void) SetPixelChannelMapMask(msl_info->image[n],channel_mask);
if (noise_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
blur_image=BlurImage(msl_info->image[n],geometry_info.rho,
geometry_info.sigma,geometry_info.xi,
msl_info->exception);
- (void) SetPixelChannelMap(msl_info->image[n],channel_mask);
+ (void) SetPixelChannelMapMask(msl_info->image[n],channel_mask);
if (blur_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
(void) FloodfillPaintImage(msl_info->image[n],draw_info,&target,
geometry.x,geometry.y,paint_method == FloodfillMethod ?
MagickFalse : MagickTrue,msl_info->exception);
- (void) SetPixelChannelMap(msl_info->image[n],channel_mask);
+ (void) SetPixelChannelMapMask(msl_info->image[n],channel_mask);
draw_info=DestroyDrawInfo(draw_info);
break;
}
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
(void) NegateImage(msl_info->image[n],gray,
msl_info->exception);
- (void) SetPixelChannelMap(msl_info->image[n],channel_mask);
+ (void) SetPixelChannelMapMask(msl_info->image[n],channel_mask);
break;
}
if (LocaleCompare((const char *) tag,"normalize") == 0)
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
(void) OpaquePaintImage(msl_info->image[n],&target,&fill_color,
MagickFalse,msl_info->exception);
- (void) SetPixelChannelMap(msl_info->image[n],channel_mask);
+ (void) SetPixelChannelMapMask(msl_info->image[n],channel_mask);
break;
}
ThrowMSLException(OptionError,"UnrecognizedElement",(const char *) tag);
(void) CopyMagickString(jpeg_image->magick,"JPEG",MaxTextExtent);
channel_mask=SetPixelChannelMask(jpeg_image,AlphaChannel);
status=SeparateImage(jpeg_image,exception);
- (void) SetPixelChannelMap(jpeg_image,channel_mask);
+ (void) SetPixelChannelMapMask(jpeg_image,channel_mask);
jpeg_image->matte=MagickFalse;
if (jng_quality >= 1000)
ThrowWriterException(CoderError,exception->reason);
channel_mask=SetPixelChannelMask(mask_image,AlphaChannel);
status=SeparateImage(mask_image,exception);
- (void) SetPixelChannelMap(mask_image,channel_mask);
+ (void) SetPixelChannelMapMask(mask_image,channel_mask);
if (status == MagickFalse)
{
mask_image=DestroyImage(mask_image);
projects / imagemagick / commitdiff