filterHeight = (unsigned int) kernel->height;
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(unsigned int),(void *)&filterWidth);
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(unsigned int),(void *)&filterHeight);
- matte = (image->alpha_trait != BlendPixelTrait)?1:0;
+ matte = (image->alpha_trait == UndefinedPixelTrait)?1:0;
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(unsigned int),(void *)&matte);
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(ChannelType),(void *)&channel);
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++, (localGroupSize[0] + kernel->width-1)*(localGroupSize[1] + kernel->height-1)*sizeof(CLPixelPacket),NULL);
filterHeight = (unsigned int) kernel->height;
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(unsigned int),(void *)&filterWidth);
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(unsigned int),(void *)&filterHeight);
- matte = (image->alpha_trait != BlendPixelTrait)?1:0;
+ matte = (image->alpha_trait == UndefinedPixelTrait)?1:0;
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(unsigned int),(void *)&matte);
clStatus|=clEnv->library->clSetKernelArg(clkernel,i++,sizeof(ChannelType),(void *)&channel);
if (clStatus != CL_SUCCESS)
clStatus|=clEnv->library->clSetKernelArg(rotationalBlurKernel,i++,sizeof(cl_float4), &biasPixel);
clStatus|=clEnv->library->clSetKernelArg(rotationalBlurKernel,i++,sizeof(ChannelType), &channel);
- matte = (image->alpha_trait != BlendPixelTrait)?1:0;
+ matte = (image->alpha_trait == UndefinedPixelTrait)?1:0;
clStatus|=clEnv->library->clSetKernelArg(rotationalBlurKernel,i++,sizeof(unsigned int), &matte);
clStatus=clEnv->library->clSetKernelArg(rotationalBlurKernel,i++,sizeof(cl_float2), &blurCenter);
goto cleanup;
}
- status = resizeHorizontalFilter(imageBuffer, (unsigned int) image->columns, (unsigned int) image->rows, (image->alpha_trait != BlendPixelTrait)?1:0
+ status = resizeHorizontalFilter(imageBuffer, (unsigned int) image->columns, (unsigned int) image->rows, (image->alpha_trait == UndefinedPixelTrait)?1:0
, tempImageBuffer, (unsigned int) resizedColumns, (unsigned int) image->rows
, resizeFilter, cubicCoefficientsBuffer
, xFactor, clEnv, queue, exception);
if (status != MagickTrue)
goto cleanup;
- status = resizeVerticalFilter(tempImageBuffer, (unsigned int) resizedColumns, (unsigned int) image->rows, (image->alpha_trait != BlendPixelTrait)?1:0
+ status = resizeVerticalFilter(tempImageBuffer, (unsigned int) resizedColumns, (unsigned int) image->rows, (image->alpha_trait == UndefinedPixelTrait)?1:0
, filteredImageBuffer, (unsigned int) resizedColumns, (unsigned int) resizedRows
, resizeFilter, cubicCoefficientsBuffer
, yFactor, clEnv, queue, exception);
goto cleanup;
}
- status = resizeVerticalFilter(imageBuffer, (unsigned int) image->columns, (unsigned int) image->rows, (image->alpha_trait != BlendPixelTrait)?1:0
+ status = resizeVerticalFilter(imageBuffer, (unsigned int) image->columns, (unsigned int) image->rows, (image->alpha_trait == UndefinedPixelTrait)?1:0
, tempImageBuffer, (unsigned int) image->columns, (unsigned int) resizedRows
, resizeFilter, cubicCoefficientsBuffer
, yFactor, clEnv, queue, exception);
if (status != MagickTrue)
goto cleanup;
- status = resizeHorizontalFilter(tempImageBuffer, (unsigned int) image->columns, (unsigned int) resizedRows, (image->alpha_trait != BlendPixelTrait)?1:0
+ status = resizeHorizontalFilter(tempImageBuffer, (unsigned int) image->columns, (unsigned int) resizedRows, (image->alpha_trait == UndefinedPixelTrait)?1:0
, filteredImageBuffer, (unsigned int) resizedColumns, (unsigned int) resizedRows
, resizeFilter, cubicCoefficientsBuffer
, xFactor, clEnv, queue, exception);
clStatus |=clEnv->library->clSetKernelArg(hullPass1,2,sizeof(unsigned int),(void *)&imageWidth);
imageHeight = (unsigned int) image->rows;
clStatus |=clEnv->library->clSetKernelArg(hullPass1,3,sizeof(unsigned int),(void *)&imageHeight);
- matte = (image->alpha_trait != BlendPixelTrait)?0:1;
+ matte = (image->alpha_trait == UndefinedPixelTrait)?0:1;
clStatus |=clEnv->library->clSetKernelArg(hullPass1,6,sizeof(int),(void *)&matte);
if (clStatus != CL_SUCCESS)
{
clStatus |=clEnv->library->clSetKernelArg(hullPass2,2,sizeof(unsigned int),(void *)&imageWidth);
imageHeight = (unsigned int) image->rows;
clStatus |=clEnv->library->clSetKernelArg(hullPass2,3,sizeof(unsigned int),(void *)&imageHeight);
- matte = (image->alpha_trait != BlendPixelTrait)?0:1;
+ matte = (image->alpha_trait == UndefinedPixelTrait)?0:1;
clStatus |=clEnv->library->clSetKernelArg(hullPass2,6,sizeof(int),(void *)&matte);
if (clStatus != CL_SUCCESS)
{
clStatus|=clEnv->library->clSetKernelArg(motionBlurKernel,i++,sizeof(cl_float4), &biasPixel);
clStatus|=clEnv->library->clSetKernelArg(motionBlurKernel,i++,sizeof(ChannelType), &channel);
- matte = (image->alpha_trait != BlendPixelTrait)?1:0;
+ matte = (image->alpha_trait == UndefinedPixelTrait)?1:0;
clStatus|=clEnv->library->clSetKernelArg(motionBlurKernel,i++,sizeof(unsigned int), &matte);
if (clStatus != CL_SUCCESS)
{
status = LaunchCompositeKernel(clEnv,queue,imageBuffer,
(unsigned int) image->columns,
(unsigned int) image->rows,
- (unsigned int) (image->alpha_trait != BlendPixelTrait) ? 1 : 0,
+ (unsigned int) (image->alpha_trait == UndefinedPixelTrait) ? 1 : 0,
channel, compose, compositeImageBuffer,
(unsigned int) compositeImage->columns,
(unsigned int) compositeImage->rows,
{
if (image->storage_class != DirectClass)
(void) SetImageStorageClass(image,DirectClass,exception);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
}
direction=1.0;
/*
Render fill color.
*/
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
- if (annotate_image->alpha_trait != BlendPixelTrait)
+ if (annotate_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(annotate_image,OpaqueAlphaChannel,
exception);
fill_color=draw_info->fill;
status=MagickTrue;
for (i=0; i < (ssize_t) number_threads; i++)
current_depth[i]=1;
- if ((image->storage_class == PseudoClass) && (image->alpha_trait != BlendPixelTrait))
+ if ((image->storage_class == PseudoClass) && (image->alpha_trait == UndefinedPixelTrait))
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (image->colorspace == CMYKColorspace)
{
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
return(ColorSeparationType);
return(ColorSeparationMatteType);
}
return(BilevelType);
if (IsImageGray(image,exception) != MagickFalse)
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
return(GrayscaleMatteType);
return(GrayscaleType);
}
if (IsPaletteImage(image,exception) != MagickFalse)
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
return(PaletteMatteType);
return(PaletteType);
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
return(TrueColorMatteType);
return(TrueColorType);
}
if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
return(MagickFalse);
((Image *) image)->type=type;
- if ((type == GrayscaleType) && (image->alpha_trait == BlendPixelTrait))
+ if ((type == GrayscaleType) && (image->alpha_trait != UndefinedPixelTrait))
((Image *) image)->type=GrayscaleMatteType;
return(MagickTrue);
}
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
return(MagickTrue);
image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
if (IsImageGray(image,exception) == MagickFalse)
status=TransformImageColorspace(image,GRAYColorspace,exception);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
break;
}
if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
channel_mask=SetImageChannelMask(image,AlphaChannel);
(void) BilevelImage(image,(double) QuantumRange/2.0,exception);
{
if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantize_info=AcquireQuantizeInfo(image_info);
quantize_info->colorspace=TransparentColorspace;
status=TransformImageColorspace(image,sRGBColorspace,exception);
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,exception);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
break;
}
}
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,exception);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
status=SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
break;
}
{
case BackgroundVirtualPixelMethod:
{
- if ((image->background_color.alpha_trait == BlendPixelTrait) &&
- (image->alpha_trait != BlendPixelTrait))
+ if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait))
(void) SetCacheAlphaChannel(image,OpaqueAlpha,exception);
if ((IsPixelInfoGray(&image->background_color) == MagickFalse) &&
(IsGrayColorspace(image->colorspace) != MagickFalse))
}
case TransparentVirtualPixelMethod:
{
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetCacheAlphaChannel(image,OpaqueAlpha,exception);
break;
}
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickSignature);
- return(image->alpha_trait == BlendPixelTrait ? MagickTrue : MagickFalse);
+ return(image->alpha_trait != UndefinedPixelTrait ? MagickTrue : MagickFalse);
}
\f
/*
%
% o alpha_type: The alpha channel type: ActivateAlphaChannel,
% AssociateAlphaChannel, CopyAlphaChannel, DeactivateAlphaChannel,
-% DisassociateAlphaChannel, ExtractAlphaChannel, OpaqueAlphaChannel,
-% SetAlphaChannel, ShapeAlphaChannel, and TransparentAlphaChannel.
+% DisassociateAlphaChannel, ExtractAlphaChannel, OffAlphaChannel,
+% OnAlphaChannel, OpaqueAlphaChannel, SetAlphaChannel, ShapeAlphaChannel,
+% and TransparentAlphaChannel.
%
% o exception: return any errors or warnings in this structure.
%
/*
Set transparent pixels to background color.
*/
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
break;
status=SetImageStorageClass(image,DirectClass,exception);
if (status == MagickFalse)
}
case DeactivateAlphaChannel:
{
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
status=SetImageAlpha(image,OpaqueAlpha,exception);
image->alpha_trait=CopyPixelTrait;
break;
image->alpha_trait=UndefinedPixelTrait;
break;
}
+ case OffAlphaChannel:
+ {
+ image->alpha_trait=UndefinedPixelTrait;
+ break;
+ }
+ case OnAlphaChannel:
+ {
+ status=SetImageAlpha(image,OpaqueAlpha,exception);
+ image->alpha_trait=BlendPixelTrait;
+ break;
+ }
case OpaqueAlphaChannel:
{
status=SetImageAlpha(image,OpaqueAlpha,exception);
/*
Remove transparency.
*/
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
break;
status=SetImageStorageClass(image,DirectClass,exception);
if (status == MagickFalse)
}
case SetAlphaChannel:
{
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
status=SetImageAlpha(image,OpaqueAlpha,exception);
break;
}
ConcatentateHexColorComponent(pixel,BluePixelChannel,tuple);
if (pixel->colorspace == CMYKColorspace)
ConcatentateHexColorComponent(pixel,BlackPixelChannel,tuple);
- if ((pixel->alpha_trait == BlendPixelTrait) &&
+ if ((pixel->alpha_trait != UndefinedPixelTrait) &&
(pixel->alpha != OpaqueAlpha))
ConcatentateHexColorComponent(pixel,AlphaPixelChannel,tuple);
return;
if (color.colorspace-CMYKColorspace)
status&=IsMagickTrue(fabs(color.black-SVGCompliant(color.black))
< MagickEpsilon);
- if (color.alpha_trait == BlendPixelTrait)
+ if (color.alpha_trait != UndefinedPixelTrait)
status&=IsMagickTrue(fabs(color.alpha-SVGCompliant(color.alpha))
< MagickEpsilon);
if (IfMagickTrue(status))
}
(void) ConcatenateMagickString(tuple,CommandOptionToMnemonic(
MagickColorspaceOptions,(ssize_t) color.colorspace),MaxTextExtent);
- if (color.alpha_trait == BlendPixelTrait)
+ if (color.alpha_trait != UndefinedPixelTrait)
(void) ConcatenateMagickString(tuple,"a",MaxTextExtent);
(void) ConcatenateMagickString(tuple,"(",MaxTextExtent);
if (color.colorspace == GRAYColorspace)
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&color,BlackPixelChannel,SVGCompliance,tuple);
}
- if (color.alpha_trait == BlendPixelTrait)
+ if (color.alpha_trait != UndefinedPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&color,AlphaPixelChannel,SVGCompliance,tuple);
register double
distance;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
return(MagickTrue);
if (p->alpha == q->alpha)
return(MagickTrue);
color->black=(double) ClampToQuantum(scale*
geometry_info.psi);
else
- if (color->alpha_trait == BlendPixelTrait)
+ if (color->alpha_trait != UndefinedPixelTrait)
color->alpha=(double) ClampToQuantum(QuantumRange*
geometry_info.psi);
}
if (((flags & ChiValue) != 0) &&
- (color->alpha_trait == BlendPixelTrait))
+ (color->alpha_trait != UndefinedPixelTrait))
color->alpha=(double) ClampToQuantum(QuantumRange*
geometry_info.chi);
if (color->colorspace == LabColorspace)
color->green=color->red;
color->blue=color->red;
if (((flags & SigmaValue) != 0) &&
- (color->alpha_trait == BlendPixelTrait))
+ (color->alpha_trait != UndefinedPixelTrait))
color->alpha=(double) ClampToQuantum(QuantumRange*
geometry_info.sigma);
}
GetColorTuple(&pixel,IsMagickTrue(compliance != SVGCompliance),name);
if (IfMagickFalse(IssRGBColorspace(pixel.colorspace)))
return(MagickFalse);
- alpha=color->alpha_trait == BlendPixelTrait ? color->alpha : OpaqueAlpha;
+ alpha=color->alpha_trait != UndefinedPixelTrait ? color->alpha : OpaqueAlpha;
(void) GetColorInfo("*",exception);
ResetLinkedListIterator(color_cache);
p=(const ColorInfo *) GetNextValueInLinkedList(color_cache);
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
- image->type=image->alpha_trait != BlendPixelTrait ? ColorSeparationType :
+ image->type=image->alpha_trait == UndefinedPixelTrait ? ColorSeparationType :
ColorSeparationMatteType;
if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
return(MagickFalse);
Modify destination outside the overlaid region and require an alpha
channel to exist, to add transparency.
*/
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
SetPixelAlphaTraits(image,CopyPixelTrait);
break;
case CopyAlphaCompositeOp:
{
pixel=QuantumRange*Sa;
- if (composite_image->alpha_trait != BlendPixelTrait)
+ if (composite_image->alpha_trait == UndefinedPixelTrait)
pixel=GetPixelIntensity(composite_image,p);
break;
}
status=MagickTrue;
if ((image->compose != CopyCompositeOp) &&
((image->compose != OverCompositeOp) ||
- (image->alpha_trait == BlendPixelTrait) ||
- (texture_image->alpha_trait == BlendPixelTrait)))
+ (image->alpha_trait != UndefinedPixelTrait) ||
+ (texture_image->alpha_trait != UndefinedPixelTrait)))
{
/*
Tile texture onto the image background.
if ((IsPixelInfoGray(&frame_image->border_color) == MagickFalse) &&
(IsGrayColorspace(frame_image->colorspace) != MagickFalse))
(void) SetImageColorspace(frame_image,sRGBColorspace,exception);
- if ((frame_image->matte_color.alpha_trait == BlendPixelTrait) &&
- (frame_image->alpha_trait != BlendPixelTrait))
+ if ((frame_image->matte_color.alpha_trait != UndefinedPixelTrait) &&
+ (frame_image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlpha(frame_image,OpaqueAlpha,exception);
frame_image->page=image->page;
if ((image->page.width != 0) && (image->page.height != 0))
Set frame interior to interior color.
*/
if ((compose != CopyCompositeOp) && ((compose != OverCompositeOp) ||
- (image->alpha_trait == BlendPixelTrait)))
+ (image->alpha_trait != UndefinedPixelTrait)))
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelInfoPixel(frame_image,&interior,q);
frame_view=DestroyCacheView(frame_view);
image_view=DestroyCacheView(image_view);
if ((compose != CopyCompositeOp) && ((compose != OverCompositeOp) ||
- (image->alpha_trait == BlendPixelTrait)))
+ (image->alpha_trait != UndefinedPixelTrait)))
{
x=(ssize_t) (frame_info->outer_bevel+(frame_info->x-bevel_width)+
frame_info->inner_bevel);
*/
XSetCursorState(display,windows,MagickTrue);
XCheckRefreshWindows(display,windows);
- (void) SetImageType(*image,(*image)->alpha_trait != BlendPixelTrait ?
+ (void) SetImageType(*image,(*image)->alpha_trait == UndefinedPixelTrait ?
GrayscaleType : GrayscaleMatteType,exception);
XSetCursorState(display,windows,MagickFalse);
if (IfMagickTrue(windows->image.orphan) )
Image
*matte_image;
- if ((*image)->alpha_trait != BlendPixelTrait)
+ if ((*image)->alpha_trait == UndefinedPixelTrait)
{
XNoticeWidget(display,windows,
"Image does not have any matte information",(*image)->filename);
continue;
if (IfMagickFalse(SetImageStorageClass(*image,DirectClass,exception)) )
return(MagickFalse);
- if ((*image)->alpha_trait != BlendPixelTrait)
+ if ((*image)->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(*image,OpaqueAlphaChannel,exception);
image_view=AcquireAuthenticCacheView(*image,exception);
switch (method)
exception);
tmp_image->image_info=image->image_info; /* preserve global options */
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
{
/*
Image has not transparency channel, so we free to use it
if ((IsPixelInfoGray(&distort_image->background_color) == MagickFalse) &&
(IsGrayColorspace(distort_image->colorspace) != MagickFalse))
(void) SetImageColorspace(distort_image,sRGBColorspace,exception);
- if (distort_image->background_color.alpha_trait == BlendPixelTrait)
+ if (distort_image->background_color.alpha_trait != UndefinedPixelTrait)
distort_image->alpha_trait=BlendPixelTrait;
distort_image->page.x=geometry.x;
distort_image->page.y=geometry.y;
(image->colorspace == CMYKColorspace))
number_colors++;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
number_colors++;
/*
(void) FormatLocaleFile(stderr, " -channel K -fx '%+lf*i %+lf*j %+lf' \\\n",
coeff[x], coeff[x+1], coeff[x+2]),x+=3;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
(void) FormatLocaleFile(stderr, " -channel A -fx '%+lf*i %+lf*j %+lf' \\\n",
coeff[x], coeff[x+1], coeff[x+2]),x+=3;
break;
coeff[ x ], coeff[x+1],
coeff[x+2], coeff[x+3]),x+=4;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
(void) FormatLocaleFile(stderr, " -channel A -fx '%+lf*i %+lf*j %+lf*i*j %+lf;\n",
coeff[ x ], coeff[x+1],
coeff[x+2], coeff[x+3]),x+=4;
pixel.black = coeff[x]*i +coeff[x+1]*j
+coeff[x+2], x+=3;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
pixel.alpha = coeff[x]*i +coeff[x+1]*j
+coeff[x+2], x+=3;
break;
pixel.black = coeff[x]*i + coeff[x+1]*j +
coeff[x+2]*i*j + coeff[x+3], x+=4;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
pixel.alpha = coeff[x]*i + coeff[x+1]*j +
coeff[x+2]*i*j + coeff[x+3], x+=4;
break;
(image->colorspace == CMYKColorspace))
pixel.black=0.0;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
pixel.alpha=0.0;
denominator = 0.0;
for(k=0; k<number_arguments; k+=2+number_colors) {
(image->colorspace == CMYKColorspace))
pixel.black += arguments[x++]*weight;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
pixel.alpha += arguments[x++]*weight;
denominator += weight;
}
(image->colorspace == CMYKColorspace))
pixel.black/=denominator;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
pixel.alpha/=denominator;
break;
}
(image->colorspace == CMYKColorspace))
pixel.black=arguments[x++];
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
pixel.alpha=arguments[x++];
minimum = distance;
}
(image->colorspace == CMYKColorspace))
pixel.black*=QuantumRange;
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
pixel.alpha*=QuantumRange;
SetPixelInfoPixel(sparse_image,&pixel,q);
q+=GetPixelChannels(sparse_image);
/*
Draw polygon or line.
*/
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
start=(ssize_t) ceil(bounds.y1-0.5);
stop=(ssize_t) floor(bounds.y2+0.5);
}
case MattePrimitive:
{
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
switch (primitive_info->method)
{
(void) TransformImage(&composite_image,(char *) NULL,geometry,
exception);
}
- if (composite_image->alpha_trait != BlendPixelTrait)
+ if (composite_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(composite_image,OpaqueAlphaChannel,
exception);
if (draw_info->alpha != OpaqueAlpha)
}
image_view=DestroyCacheView(image_view);
clut_map=(PixelInfo *) RelinquishMagickMemory(clut_map);
- if ((clut_image->alpha_trait == BlendPixelTrait) &&
+ if ((clut_image->alpha_trait != UndefinedPixelTrait) &&
((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0))
(void) SetImageAlphaChannel(image,ActivateAlphaChannel,exception);
return(status);
assert(hald_image->signature == MagickSignature);
if( IfMagickFalse(SetImageStorageClass(image,DirectClass,exception)) )
return(MagickFalse);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
/*
Hald clut image.
(image->colorspace == CMYKColorspace))
SetPixelBlack(image,ClampToQuantum(pixel.black),q);
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
SetPixelAlpha(image,ClampToQuantum(pixel.alpha),q);
q+=GetPixelChannels(image);
}
(void) SetImageChannelMask(image,channel_mask);
}
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
{
channel_mask=SetImageChannelMask(image,AlphaChannel);
status&=LevelImage(image,black_color->alpha,white_color->alpha,1.0,
(void) SetImageChannelMask(image,channel_mask);
}
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
{
channel_mask=SetImageChannelMask(image,AlphaChannel);
status&=LevelizeImage(image,black_color->alpha,white_color->alpha,1.0,
if (image->colorspace == CMYKColorspace)
grays[ScaleQuantumToMap(GetPixelBlack(image,p))].black=
ScaleQuantumToMap(GetPixelBlack(image,p));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
grays[ScaleQuantumToMap(GetPixelAlpha(image,p))].alpha=
ScaleQuantumToMap(GetPixelAlpha(image,p));
p+=GetPixelChannels(image);
if (image->colorspace == CMYKColorspace)
if (grays[i].black != ~0U)
grays[gray.black++].black=grays[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
if (grays[i].alpha != ~0U)
grays[gray.alpha++].alpha=grays[i].alpha;
}
if (image->colorspace == CMYKColorspace)
if (gray.black > number_grays)
number_grays=gray.black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
if (gray.alpha > number_grays)
number_grays=gray.alpha;
cooccurrence=(ChannelStatistics **) AcquireQuantumMemory(number_grays,
cooccurrence[u][v].direction[i].black++;
cooccurrence[v][u].direction[i].black++;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
u=0;
v=0;
cooccurrence[x][y].direction[i].blue*=normalize;
if (image->colorspace == CMYKColorspace)
cooccurrence[x][y].direction[i].black*=normalize;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
cooccurrence[x][y].direction[i].alpha*=normalize;
}
}
channel_features[BlackPixelChannel].angular_second_moment[i]+=
cooccurrence[x][y].direction[i].black*
cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].angular_second_moment[i]+=
cooccurrence[x][y].direction[i].alpha*
cooccurrence[x][y].direction[i].alpha;
sum[y].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
sum[y].direction[i].black+=cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
sum[y].direction[i].alpha+=cooccurrence[x][y].direction[i].alpha;
correlation.direction[i].red+=x*y*cooccurrence[x][y].direction[i].red;
correlation.direction[i].green+=x*y*
if (image->colorspace == CMYKColorspace)
correlation.direction[i].black+=x*y*
cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
correlation.direction[i].alpha+=x*y*
cooccurrence[x][y].direction[i].alpha;
/*
if (image->colorspace == CMYKColorspace)
channel_features[BlackPixelChannel].inverse_difference_moment[i]+=
cooccurrence[x][y].direction[i].black/((y-x)*(y-x)+1);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].inverse_difference_moment[i]+=
cooccurrence[x][y].direction[i].alpha/((y-x)*(y-x)+1);
/*
if (image->colorspace == CMYKColorspace)
density_xy[y+x+2].direction[i].black+=
cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
density_xy[y+x+2].direction[i].alpha+=
cooccurrence[x][y].direction[i].alpha;
/*
channel_features[BlackPixelChannel].entropy[i]-=
cooccurrence[x][y].direction[i].black*
MagickLog10(cooccurrence[x][y].direction[i].black);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].entropy[i]-=
cooccurrence[x][y].direction[i].alpha*
MagickLog10(cooccurrence[x][y].direction[i].alpha);
density_x[x].direction[i].red+=cooccurrence[x][y].direction[i].red;
density_x[x].direction[i].green+=cooccurrence[x][y].direction[i].green;
density_x[x].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
density_x[x].direction[i].alpha+=
cooccurrence[x][y].direction[i].alpha;
if (image->colorspace == CMYKColorspace)
if (image->colorspace == CMYKColorspace)
density_y[y].direction[i].black+=
cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
density_y[y].direction[i].alpha+=
cooccurrence[x][y].direction[i].alpha;
}
mean.direction[i].black+=y*sum[y].direction[i].black;
sum_squares.direction[i].black+=y*y*sum[y].direction[i].black;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
mean.direction[i].alpha+=y*sum[y].direction[i].alpha;
sum_squares.direction[i].alpha+=y*y*sum[y].direction[i].alpha;
(mean.direction[i].black*mean.direction[i].black))*sqrt(
sum_squares.direction[i].black-(mean.direction[i].black*
mean.direction[i].black)));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].correlation[i]=
(correlation.direction[i].alpha-mean.direction[i].alpha*
mean.direction[i].alpha)/(sqrt(sum_squares.direction[i].alpha-
if (image->colorspace == CMYKColorspace)
channel_features[BlackPixelChannel].sum_average[i]+=
x*density_xy[x].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].sum_average[i]+=
x*density_xy[x].direction[i].alpha;
/*
channel_features[BlackPixelChannel].sum_entropy[i]-=
density_xy[x].direction[i].black*
MagickLog10(density_xy[x].direction[i].black);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].sum_entropy[i]-=
density_xy[x].direction[i].alpha*
MagickLog10(density_xy[x].direction[i].alpha);
(x-channel_features[BlackPixelChannel].sum_entropy[i])*
(x-channel_features[BlackPixelChannel].sum_entropy[i])*
density_xy[x].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].sum_variance[i]+=
(x-channel_features[AlphaPixelChannel].sum_entropy[i])*
(x-channel_features[AlphaPixelChannel].sum_entropy[i])*
if (image->colorspace == CMYKColorspace)
variance.direction[i].black+=(y-mean.direction[i].black+1)*
(y-mean.direction[i].black+1)*cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
variance.direction[i].alpha+=(y-mean.direction[i].alpha+1)*
(y-mean.direction[i].alpha+1)*
cooccurrence[x][y].direction[i].alpha;
if (image->colorspace == CMYKColorspace)
density_xy[MagickAbsoluteValue(y-x)].direction[i].black+=
cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
density_xy[MagickAbsoluteValue(y-x)].direction[i].alpha+=
cooccurrence[x][y].direction[i].alpha;
/*
if (image->colorspace == CMYKColorspace)
entropy_xy.direction[i].black-=cooccurrence[x][y].direction[i].black*
MagickLog10(cooccurrence[x][y].direction[i].black);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
entropy_xy.direction[i].alpha-=
cooccurrence[x][y].direction[i].alpha*MagickLog10(
cooccurrence[x][y].direction[i].alpha);
entropy_xy1.direction[i].black-=(
cooccurrence[x][y].direction[i].black*MagickLog10(
density_x[x].direction[i].black*density_y[y].direction[i].black));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
entropy_xy1.direction[i].alpha-=(
cooccurrence[x][y].direction[i].alpha*MagickLog10(
density_x[x].direction[i].alpha*density_y[y].direction[i].alpha));
entropy_xy2.direction[i].black-=(density_x[x].direction[i].black*
density_y[y].direction[i].black*MagickLog10(
density_x[x].direction[i].black*density_y[y].direction[i].black));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
entropy_xy2.direction[i].alpha-=(density_x[x].direction[i].alpha*
density_y[y].direction[i].alpha*MagickLog10(
density_x[x].direction[i].alpha*density_y[y].direction[i].alpha));
if (image->colorspace == CMYKColorspace)
channel_features[BlackPixelChannel].variance_sum_of_squares[i]=
variance.direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].variance_sum_of_squares[i]=
variance.direction[i].alpha;
}
variance.direction[i].blue+=density_xy[x].direction[i].blue;
if (image->colorspace == CMYKColorspace)
variance.direction[i].black+=density_xy[x].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
variance.direction[i].alpha+=density_xy[x].direction[i].alpha;
sum_squares.direction[i].red+=density_xy[x].direction[i].red*
density_xy[x].direction[i].red;
if (image->colorspace == CMYKColorspace)
sum_squares.direction[i].black+=density_xy[x].direction[i].black*
density_xy[x].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
sum_squares.direction[i].alpha+=density_xy[x].direction[i].alpha*
density_xy[x].direction[i].alpha;
/*
channel_features[BlackPixelChannel].difference_entropy[i]-=
density_xy[x].direction[i].black*
MagickLog10(density_xy[x].direction[i].black);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].difference_entropy[i]-=
density_xy[x].direction[i].alpha*
MagickLog10(density_xy[x].direction[i].alpha);
if (image->colorspace == CMYKColorspace)
entropy_x.direction[i].black-=(density_x[x].direction[i].black*
MagickLog10(density_x[x].direction[i].black));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
entropy_x.direction[i].alpha-=(density_x[x].direction[i].alpha*
MagickLog10(density_x[x].direction[i].alpha));
entropy_y.direction[i].red-=(density_y[x].direction[i].red*
if (image->colorspace == CMYKColorspace)
entropy_y.direction[i].black-=(density_y[x].direction[i].black*
MagickLog10(density_y[x].direction[i].black));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
entropy_y.direction[i].alpha-=(density_y[x].direction[i].alpha*
MagickLog10(density_y[x].direction[i].alpha));
}
(((double) number_grays*number_grays*sum_squares.direction[i].black)-
(variance.direction[i].black*variance.direction[i].black))/
((double) number_grays*number_grays*number_grays*number_grays);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].difference_variance[i]=
(((double) number_grays*number_grays*sum_squares.direction[i].alpha)-
(variance.direction[i].alpha*variance.direction[i].alpha))/
(entropy_xy.direction[i].black-entropy_xy1.direction[i].black)/
(entropy_x.direction[i].black > entropy_y.direction[i].black ?
entropy_x.direction[i].black : entropy_y.direction[i].black);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].measure_of_correlation_1[i]=
(entropy_xy.direction[i].alpha-entropy_xy1.direction[i].alpha)/
(entropy_x.direction[i].alpha > entropy_y.direction[i].alpha ?
channel_features[BlackPixelChannel].measure_of_correlation_2[i]=
(sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].black-
entropy_xy.direction[i].black)))));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].measure_of_correlation_2[i]=
(sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].alpha-
entropy_xy.direction[i].alpha)))));
pixel.direction[i].blue+=cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
pixel.direction[i].black+=cooccurrence[x][y].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
pixel.direction[i].alpha+=
cooccurrence[x][y].direction[i].alpha;
}
Q[z][y].direction[i].black+=cooccurrence[z][x].direction[i].black*
cooccurrence[y][x].direction[i].black/
density_x[z].direction[i].black/density_y[x].direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
Q[z][y].direction[i].alpha+=
cooccurrence[z][x].direction[i].alpha*
cooccurrence[y][x].direction[i].alpha/
if (image->colorspace == CMYKColorspace)
channel_features[BlackPixelChannel].contrast[i]+=z*z*
pixel.direction[i].black;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].contrast[i]+=z*z*
pixel.direction[i].alpha;
}
if (image->colorspace == CMYKColorspace)
channel_features[BlackPixelChannel].maximum_correlation_coefficient[i]=
sqrt((double) -1.0);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channel_features[AlphaPixelChannel].maximum_correlation_coefficient[i]=
sqrt((double) -1.0);
}
thread_status;
thread_status=MagickTrue;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
thread_status=ForwardFourierTransformChannel(image,
AlphaPixelChannel,modulus,fourier_image,exception);
if (thread_status == MagickFalse)
thread_status;
thread_status=MagickTrue;
- if (magnitude_image->alpha_trait == BlendPixelTrait)
+ if (magnitude_image->alpha_trait != UndefinedPixelTrait)
thread_status=InverseFourierTransformChannel(magnitude_image,
phase_image,AlphaPixelChannel,modulus,fourier_image,exception);
if (thread_status == MagickFalse)
if ((IsGrayColorspace(image->colorspace) != MagickFalse) ||
(IsPixelInfoGray(colorize) != MagickFalse))
(void) SetImageColorspace(colorize_image,sRGBColorspace,exception);
- if ((colorize_image->alpha_trait != BlendPixelTrait) &&
- (colorize->alpha_trait == BlendPixelTrait))
+ if ((colorize_image->alpha_trait == UndefinedPixelTrait) &&
+ (colorize->alpha_trait != UndefinedPixelTrait))
(void) SetImageAlpha(colorize_image,OpaqueAlpha,exception);
if (blend == (const char *) NULL)
return(colorize_image);
GetPixelGreen(image,p)+ColorMatrix[v][2]*GetPixelBlue(image,p);
if (image->colorspace == CMYKColorspace)
sum+=ColorMatrix[v][3]*GetPixelBlack(image,p);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
sum+=ColorMatrix[v][4]*GetPixelAlpha(image,p);
sum+=QuantumRange*ColorMatrix[v][5];
switch (v)
double
alpha;
- if (pixel.alpha_trait != BlendPixelTrait)
+ if (pixel.alpha_trait == UndefinedPixelTrait)
return(1.0);
alpha=(double) (QuantumScale*pixel.alpha);
return(alpha);
clone_image=DestroyImage(clone_image);
if (border_image == (Image *) NULL)
return((Image *) NULL);
- if (border_image->alpha_trait != BlendPixelTrait)
+ if (border_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(border_image,OpaqueAlphaChannel,exception);
/*
Shadow image.
background_color.alpha_trait=BlendPixelTrait;
for (x=0; x < (ssize_t) border_image->columns; x++)
{
- if (border_image->alpha_trait == BlendPixelTrait)
+ if (border_image->alpha_trait != UndefinedPixelTrait)
background_color.alpha=GetPixelAlpha(border_image,q)*alpha/100.0;
SetPixelInfoPixel(border_image,&background_color,q);
q+=GetPixelChannels(border_image);
((ScaleQuantumToChar(ClampToQuantum(pixel->red)) >> index) & 0x01) |
((ScaleQuantumToChar(ClampToQuantum(pixel->green)) >> index) & 0x01) << 1 |
((ScaleQuantumToChar(ClampToQuantum(pixel->blue)) >> index) & 0x01) << 2);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
id|=((ScaleQuantumToChar(ClampToQuantum(pixel->alpha)) >> index) &
0x01) << 3;
return(id);
/*
Traverse any children.
*/
- number_children=image->alpha_trait != BlendPixelTrait ? 8UL : 16UL;
+ number_children=image->alpha_trait == UndefinedPixelTrait ? 8UL : 16UL;
for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
DefineImageHistogram(image,node_info->child[i],histogram);
/*
Traverse any children.
*/
- number_children=image->alpha_trait != BlendPixelTrait ? 8UL : 16UL;
+ number_children=image->alpha_trait == UndefinedPixelTrait ? 8UL : 16UL;
for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
DestroyColorCube(image,node_info->child[i]);
ConcatenateColorComponent(&pixel,BlackPixelChannel,X11Compliance,
tuple);
}
- if (pixel.alpha_trait == BlendPixelTrait)
+ if (pixel.alpha_trait != UndefinedPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,AlphaPixelChannel,X11Compliance,
/*
Traverse any children.
*/
- number_children=unique_image->alpha_trait != BlendPixelTrait ? 8UL : 16UL;
+ number_children=unique_image->alpha_trait == UndefinedPixelTrait ? 8UL : 16UL;
for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
UniqueColorsToImage(unique_image,unique_view,cube_info,
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelLocations(file,image,AlphaPixelChannel,"Alpha",
type,max_locations,channel_statistics);
channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) FormatLocaleFile(file," Alpha: %.20g-bit\n",(double)
channel_statistics[AlphaPixelChannel].depth);
scale=1.0;
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelStatistics(file,AlphaPixelChannel,"Alpha",1.0/
scale,channel_statistics);
if (colorspace != GRAYColorspace)
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelMoments(file,AlphaPixelChannel,"Alpha",scale,
channel_moments);
if (colorspace != GRAYColorspace)
channel_phash);
(void) PrintChannelPerceptualHash(file,BluePixelChannel,"Blue, Luma",
channel_phash);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelPerceptualHash(file,AlphaPixelChannel,"Alpha, Alpha",
channel_phash);
channel_phash=(ChannelPerceptualHash *) RelinquishMagickMemory(
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelFeatures(file,AlphaPixelChannel,"Alpha",
channel_features);
channel_features=(ChannelFeatures *) RelinquishMagickMemory(
GetMagickPrecision(),100.0*GetImageTotalInkDensity(image,exception)/
(double) QuantumRange);
x=0;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
register const Quantum
*p;
ConcatenateColorComponent(&pixel,BlackPixelChannel,
X11Compliance,tuple);
}
- if (pixel.alpha_trait == BlendPixelTrait)
+ if (pixel.alpha_trait != UndefinedPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,AlphaPixelChannel,
next=GetNextImageInList(images);
for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
{
- if (next->alpha_trait == BlendPixelTrait)
+ if (next->alpha_trait != UndefinedPixelTrait)
alpha_trait=BlendPixelTrait;
number_images++;
if (stack != MagickFalse)
next=GetNextImageInList(image);
for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
{
- if (next->alpha_trait == BlendPixelTrait)
+ if (next->alpha_trait != UndefinedPixelTrait)
alpha_trait=BlendPixelTrait;
number_images++;
if (stack != MagickFalse)
DiscreteAlphaChannel,
DisassociateAlphaChannel,
ExtractAlphaChannel,
+ OffAlphaChannel,
+ OnAlphaChannel,
OpaqueAlphaChannel,
RemoveAlphaChannel,
SetAlphaChannel,
if (bounds->x < 0)
return;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
for (y=0; y < (ssize_t) bounds->height; y++)
{
previous=coalesce_image;
coalesce_image=GetNextImageInList(coalesce_image);
(void) CompositeImage(coalesce_image,next,
- next->alpha_trait == BlendPixelTrait ? OverCompositeOp : CopyCompositeOp,
+ next->alpha_trait != UndefinedPixelTrait ? OverCompositeOp : CopyCompositeOp,
MagickTrue,next->page.x,next->page.y,exception);
(void) CloneImageProfiles(coalesce_image,next);
(void) CloneImageProperties(coalesce_image,next);
return((Image *) NULL);
}
(void) CompositeImage(current_image,next,
- next->alpha_trait == BlendPixelTrait ? OverCompositeOp : CopyCompositeOp,
+ next->alpha_trait != UndefinedPixelTrait ? OverCompositeOp : CopyCompositeOp,
MagickTrue,next->page.x,next->page.y,exception);
/*
Handle Background dispose: image is displayed for the delay period.
if (method == CompareAnyLayer)
return((MagickBooleanType)(IsFuzzyEquivalencePixelInfo(p,q) == MagickFalse));
- o1 = (p->alpha_trait == BlendPixelTrait) ? p->alpha : OpaqueAlpha;
- o2 = (q->alpha_trait == BlendPixelTrait) ? q->alpha : OpaqueAlpha;
+ o1 = (p->alpha_trait != UndefinedPixelTrait) ? p->alpha : OpaqueAlpha;
+ o2 = (q->alpha_trait != UndefinedPixelTrait) ? q->alpha : OpaqueAlpha;
/*
Pixel goes from opaque to transprency.
*/
dispose_image=DestroyImage(dispose_image);
return;
}
- (void) CompositeImage(current_image,next,next->alpha_trait == BlendPixelTrait ?
+ (void) CompositeImage(current_image,next,next->alpha_trait != UndefinedPixelTrait ?
OverCompositeOp : CopyCompositeOp,MagickTrue,next->page.x,next->page.y,
exception);
/*
{ "Discrete", DiscreteAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Disassociate", DisassociateAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Extract", ExtractAlphaChannel, UndefinedOptionFlag, MagickFalse },
- { "Off", DeactivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
- { "On", ActivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Off", OffAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "On", OnAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Opaque", OpaqueAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Remove", RemoveAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Set", SetAlphaChannel, UndefinedOptionFlag, MagickFalse },
return(MagickFalse);
if (IsGrayColorspace(image->colorspace) != MagickFalse)
(void) SetImageColorspace(image,sRGBColorspace,exception);
- if ((image->alpha_trait != BlendPixelTrait) &&
- (draw_info->fill.alpha_trait == BlendPixelTrait))
+ if ((image->alpha_trait == UndefinedPixelTrait) &&
+ (draw_info->fill.alpha_trait != UndefinedPixelTrait))
(void) SetImageAlpha(image,OpaqueAlpha,exception);
/*
Set floodfill state.
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
/*
Make image color transparent.
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
/*
Make image color transparent.
pixel[image->channel_map[BlackPixelChannel].offset];
pixel_info->alpha=(MagickRealType) OpaqueAlpha;
pixel_info->alpha_trait=UndefinedPixelTrait;
- if (image->channel_map[AlphaPixelChannel].traits == BlendPixelTrait)
+ if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
{
pixel_info->alpha=(MagickRealType)
pixel[image->channel_map[AlphaPixelChannel].offset];
static inline void SetPixelAlpha(const Image *restrict image,
const Quantum alpha,Quantum *restrict pixel)
{
- if (image->channel_map[AlphaPixelChannel].traits == BlendPixelTrait)
+ if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[AlphaPixelChannel].offset]=alpha;
}
if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[BlackPixelChannel].offset]=
ClampToQuantum(image->background_color.black);
- if (image->channel_map[AlphaPixelChannel].traits == BlendPixelTrait)
+ if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[AlphaPixelChannel].offset]=
image->background_color.alpha_trait == UndefinedPixelTrait ? OpaqueAlpha :
ClampToQuantum(image->background_color.alpha);
if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[BlackPixelChannel].offset]=
ClampToQuantum(pixel_info->black);
- if (image->channel_map[AlphaPixelChannel].traits == BlendPixelTrait)
+ if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[AlphaPixelChannel].offset]=
pixel_info->alpha_trait == UndefinedPixelTrait ? OpaqueAlpha :
ClampToQuantum(pixel_info->alpha);
static inline void SetPixelOpacity(const Image *restrict image,
const Quantum alpha,Quantum *restrict pixel)
{
- if (image->channel_map[AlphaPixelChannel].traits == BlendPixelTrait)
+ if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[AlphaPixelChannel].offset]=QuantumRange-alpha;
}
if ((IsPixelInfoGray(&image->background_color) == MagickFalse) &&
(IsGrayColorspace(image->colorspace) != MagickFalse))
(void) TransformImageColorspace(image,sRGBColorspace,exception);
- if ((destination->alpha_trait == BlendPixelTrait) &&
- (image->alpha_trait != BlendPixelTrait))
+ if ((destination->alpha_trait != UndefinedPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlpha(image,OpaqueAlpha,exception);
}
\f
(void) ResetMagickMemory(image->channel_map,0,MaxPixelChannels*
sizeof(*image->channel_map));
trait=UpdatePixelTrait;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
trait=(PixelTrait) (trait | BlendPixelTrait);
n=0;
if (image->colorspace == GRAYColorspace)
}
if (image->colorspace == CMYKColorspace)
SetPixelChannelAttributes(image,BlackPixelChannel,trait,n++);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelChannelAttributes(image,AlphaPixelChannel,CopyPixelTrait,n++);
if (image->storage_class == PseudoClass)
SetPixelChannelAttributes(image,IndexPixelChannel,CopyPixelTrait,n++);
static inline void AlphaBlendPixelInfo(const Image *image,
const Quantum *pixel,PixelInfo *pixel_info,double *alpha)
{
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
{
*alpha=1.0;
pixel_info->red=(double) GetPixelRed(image,pixel);
destination->fuzz,(MagickRealType) MagickSQ1_2);
scale=1.0;
distance=0.0;
- if (source->alpha_trait == BlendPixelTrait)
+ if (source->alpha_trait != UndefinedPixelTrait)
{
/*
Transparencies are involved - set alpha distance
MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
scale=1.0;
distance=0.0;
- if ((p->alpha_trait == BlendPixelTrait) ||
- (q->alpha_trait == BlendPixelTrait))
+ if ((p->alpha_trait != UndefinedPixelTrait) ||
+ (q->alpha_trait != UndefinedPixelTrait))
{
/*
Transparencies are involved - set alpha distance.
*/
- pixel=(p->alpha_trait == BlendPixelTrait ? p->alpha : OpaqueAlpha)-
- (q->alpha_trait == BlendPixelTrait ? q->alpha : OpaqueAlpha);
+ pixel=(p->alpha_trait != UndefinedPixelTrait ? p->alpha : OpaqueAlpha)-
+ (q->alpha_trait != UndefinedPixelTrait ? q->alpha : OpaqueAlpha);
distance=pixel*pixel;
if (distance > fuzz)
return(MagickFalse);
Generate a alpha scaling factor to generate a 4D cone on colorspace.
If one color is transparent, distance has no color component.
*/
- if (p->alpha_trait == BlendPixelTrait)
+ if (p->alpha_trait != UndefinedPixelTrait)
scale=(QuantumScale*p->alpha);
- if (q->alpha_trait == BlendPixelTrait)
+ if (q->alpha_trait != UndefinedPixelTrait)
scale*=(QuantumScale*q->alpha);
if (scale <= MagickEpsilon )
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel=GetPixelChannelChannel(image,i);
+ if (GetChannelBit(channel_mask,channel) == 0)
+ {
+ SetPixelChannelTraits(image,channel,CopyPixelTrait);
+ continue;
+ }
if (channel == AlphaPixelChannel)
- SetPixelChannelTraits(image,channel,
- GetChannelBit(channel_mask,channel) == 0 ? CopyPixelTrait :
- image->alpha_trait);
- else
- SetPixelChannelTraits(image,channel,
- GetChannelBit(channel_mask,channel) == 0 ? CopyPixelTrait :
- (image->alpha_trait == BlendPixelTrait) ? (PixelTrait)
- (UpdatePixelTrait | BlendPixelTrait) : UpdatePixelTrait);
+ {
+ if ((image->alpha_trait & CopyPixelTrait) != 0)
+ {
+ SetPixelChannelTraits(image,channel,CopyPixelTrait);
+ continue;
+ }
+ SetPixelChannelTraits(image,channel,UpdatePixelTrait);
+ continue;
+ }
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ SetPixelChannelTraits(image,channel,UpdatePixelTrait | BlendPixelTrait);
+ continue;
+ }
+ SetPixelChannelTraits(image,channel,UpdatePixelTrait);
}
if (image->storage_class == PseudoClass)
SetPixelChannelTraits(image,IndexPixelChannel,CopyPixelTrait);
{
case cmsSigRgbData:
{
- image->type=image->alpha_trait != BlendPixelTrait ?
+ image->type=image->alpha_trait == UndefinedPixelTrait ?
TrueColorType : TrueColorMatteType;
break;
}
case cmsSigCmykData:
{
- image->type=image->alpha_trait != BlendPixelTrait ?
+ image->type=image->alpha_trait == UndefinedPixelTrait ?
ColorSeparationType : ColorSeparationMatteType;
break;
}
case cmsSigGrayData:
{
- image->type=image->alpha_trait != BlendPixelTrait ?
+ image->type=image->alpha_trait == UndefinedPixelTrait ?
GrayscaleType : GrayscaleMatteType;
break;
}
(void) FormatLocaleString(value,MaxTextExtent,"%s %s %s",
CommandOptionToMnemonic(MagickClassOptions,(ssize_t) image->storage_class),
CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t) colorspace),
- image->alpha_trait == BlendPixelTrait ? "Alpha" : "");
+ image->alpha_trait != UndefinedPixelTrait ? "Alpha" : "");
break;
}
case 's': /* Image scene number */
CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t)
image->colorspace));
LocaleLower(value);
- if( image->alpha_trait == BlendPixelTrait )
+ if( image->alpha_trait != UndefinedPixelTrait )
(void) ConcatenateMagickString(value,"a",MaxTextExtent);
break;
}
MagickBooleanType
associate_alpha;
- associate_alpha=image->alpha_trait == BlendPixelTrait ? MagickTrue :
+ associate_alpha=image->alpha_trait != UndefinedPixelTrait ? MagickTrue :
MagickFalse;
if ((cube_info->quantize_info->number_colors == 2) &&
(cube_info->quantize_info->colorspace == GRAYColorspace))
for (x=0; x < (ssize_t) image->columns; x++)
{
index=1UL*GetPixelIndex(image,p);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
alpha=(double) (QuantumScale*GetPixelAlpha(image,p));
beta=(double) (QuantumScale*image->colormap[index].alpha);
(image->colorspace == CMYKColorspace))
SetPixelBlack(image,PosterizePixel(GetPixelBlack(image,q)),q);
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
SetPixelAlpha(image,PosterizePixel(GetPixelAlpha(image,q)),q);
q+=GetPixelChannels(image);
}
maximum_colors=MaxColormapSize;
if (maximum_colors > MaxColormapSize)
maximum_colors=MaxColormapSize;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
{
if ((image->columns*image->rows) <= maximum_colors)
(void) DirectToColormapImage(image,exception);
colors>>=2;
if ((quantize_info->dither_method != NoDitherMethod) && (depth > 2))
depth--;
- if ((image->alpha_trait == BlendPixelTrait) && (depth > 5))
+ if ((image->alpha_trait != UndefinedPixelTrait) && (depth > 5))
depth--;
if (IsImageGray(image,exception) != MagickFalse)
depth=MaxTreeDepth;
pixel->red = pixel->green = pixel->blue = 0.0;
if (pixel->colorspace == CMYKColorspace)
pixel->black = 0.0;
- if (pixel->alpha_trait == BlendPixelTrait)
+ if (pixel->alpha_trait != UndefinedPixelTrait)
pixel->alpha = 0.0;
/*
pixel->alpha += weight*GetPixelAlpha(resample_filter->image,pixels);
divisor_m += weight;
- if (pixel->alpha_trait == BlendPixelTrait)
+ if (pixel->alpha_trait != UndefinedPixelTrait)
weight *= QuantumScale*((double) GetPixelAlpha(resample_filter->image,pixels));
pixel->red += weight*GetPixelRed(resample_filter->image,pixels);
pixel->green += weight*GetPixelGreen(resample_filter->image,pixels);
return((double *) resize_filter->coefficient);
}
-MagickPrivate double GetResizeFilterBlur(
- const ResizeFilter *resize_filter)
+MagickPrivate double GetResizeFilterBlur(const ResizeFilter *resize_filter)
{
assert(resize_filter != (ResizeFilter *) NULL);
assert(resize_filter->signature == MagickSignature);
return(resize_filter->blur);
}
-MagickPrivate double GetResizeFilterScale(
- const ResizeFilter *resize_filter)
+MagickPrivate double GetResizeFilterScale(const ResizeFilter *resize_filter)
{
assert(resize_filter != (ResizeFilter *) NULL);
assert(resize_filter->signature == MagickSignature);
return(resize_filter->windowWeightingType);
}
-MagickPrivate double GetResizeFilterSupport(
- const ResizeFilter *resize_filter)
+MagickPrivate double GetResizeFilterSupport(const ResizeFilter *resize_filter)
{
assert(resize_filter != (ResizeFilter *) NULL);
assert(resize_filter->signature == MagickSignature);
filter_type=PointFilter;
else
if ((image->storage_class == PseudoClass) ||
- (image->alpha_trait == BlendPixelTrait) ||
+ (image->alpha_trait != UndefinedPixelTrait) ||
((x_factor*y_factor) > 1.0))
filter_type=MitchellFilter;
resize_filter=AcquireResizeFilter(image,filter_type,MagickFalse,exception);
double
alpha,
- gamma,
pixel[CompositePixelChannel],
*scale_scanline,
*scanline,
scanline[x*GetPixelChannels(image)+offset]),q);
continue;
}
- alpha=QuantumScale*scanline[x*GetPixelChannels(image)+
- GetPixelChannelChannel(image,AlphaPixelChannel)];
- gamma=PerceptibleReciprocal(alpha);
- SetPixelChannel(scale_image,channel,ClampToQuantum(gamma*scanline[
- x*GetPixelChannels(image)+offset]),q);
+ alpha=QuantumScale*scanline[x*GetPixelChannels(scale_image)+
+ GetPixelChannelChannel(scale_image,AlphaPixelChannel)];
+ SetPixelChannel(scale_image,channel,ClampToQuantum(scanline[
+ x*GetPixelChannels(scale_image)+offset]),q);
}
q+=GetPixelChannels(scale_image);
}
PixelTrait traits=GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
- pixel[i]+=span.x*scanline[x*GetPixelChannels(image)+i];
+ pixel[i]+=span.x*scanline[x*GetPixelChannels(scale_image)+i];
scale_scanline[n*MaxPixelChannels+channel]=pixel[i];
}
scale.x-=span.x;
next_column=MagickFalse;
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- pixel[i]+=scale.x*scanline[x*GetPixelChannels(image)+i];
+ pixel[i]+=scale.x*scanline[x*GetPixelChannels(scale_image)+i];
span.x-=scale.x;
}
}
if (span.x > 0)
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- pixel[i]+=span.x*scanline[(x-1)*GetPixelChannels(image)+i];
+ pixel[i]+=span.x*scanline[(x-1)*GetPixelChannels(scale_image)+i];
}
if ((next_column == MagickFalse) &&
((ssize_t) n < (ssize_t) scale_image->columns))
if (thumbnail_image == (Image *) NULL)
return(thumbnail_image);
(void) ParseAbsoluteGeometry("0x0+0+0",&thumbnail_image->page);
- if (thumbnail_image->alpha_trait != BlendPixelTrait)
+ if (thumbnail_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(thumbnail_image,OpaqueAlphaChannel,exception);
thumbnail_image->depth=8;
thumbnail_image->interlace=NoInterlace;
integral_image=DestroyImage(integral_image);
return(integral_image);
}
- if (integral_image->alpha_trait != BlendPixelTrait)
+ if (integral_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(integral_image,OpaqueAlphaChannel,exception);
/*
Compute image size.
/*
Shear the image.
*/
- if (shear_image->alpha_trait != BlendPixelTrait)
+ if (shear_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(shear_image,OpaqueAlphaChannel,exception);
status=XShearImage(shear_image,shear.x,image->columns,image->rows,bounds.x,
(ssize_t) (shear_image->rows-image->rows)/2,exception);
integral_image=DestroyImage(integral_image);
return(integral_image);
}
- if (integral_image->alpha_trait != BlendPixelTrait)
+ if (integral_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(integral_image,OpaqueAlphaChannel,exception);
/*
Compute maximum bounds for 3 shear operations.
if ((IsPixelInfoGray(&splice_image->background_color) == MagickFalse) &&
(IsGrayColorspace(splice_image->colorspace) != MagickFalse))
(void) SetImageColorspace(splice_image,sRGBColorspace,exception);
- if ((splice_image->background_color.alpha_trait == BlendPixelTrait) &&
- (splice_image->alpha_trait != BlendPixelTrait))
+ if ((splice_image->background_color.alpha_trait != UndefinedPixelTrait) &&
+ (splice_image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlpha(splice_image,OpaqueAlpha,exception);
(void) SetImageBackgroundColor(splice_image,exception);
/*
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
alpha_trait=image->alpha_trait;
(void) CompositeImage(image,annotate_image,
- annotate_image->alpha_trait == BlendPixelTrait ? OverCompositeOp :
+ annotate_image->alpha_trait != UndefinedPixelTrait ? OverCompositeOp :
CopyCompositeOp,MagickTrue,(ssize_t) x,(ssize_t) y,exception);
image->alpha_trait=alpha_trait;
annotate_image=DestroyImage(annotate_image);
window->ximage=ximage;
matte_image=(XImage *) NULL;
if ((window->shape != MagickFalse) && (window->image != (Image *) NULL))
- if ((window->image->alpha_trait == BlendPixelTrait) &&
+ if ((window->image->alpha_trait != UndefinedPixelTrait) &&
((int) width <= XDisplayWidth(display,window->screen)) &&
((int) height <= XDisplayHeight(display,window->screen)))
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
canvas=image;
if ((window->immutable == MagickFalse) &&
- (image->storage_class == DirectClass) && (image->alpha_trait == BlendPixelTrait))
+ (image->storage_class == DirectClass) && (image->alpha_trait != UndefinedPixelTrait))
{
char
size[MaxTextExtent];
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
canvas=image;
if ((window->immutable != MagickFalse) &&
- (image->storage_class == DirectClass) && (image->alpha_trait == BlendPixelTrait))
+ (image->storage_class == DirectClass) && (image->alpha_trait != UndefinedPixelTrait))
{
char
size[MaxTextExtent];
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,BlackPixelChannel,X11Compliance,tuple);
}
- if (pixel.alpha_trait == BlendPixelTrait)
+ if (pixel.alpha_trait != UndefinedPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,AlphaPixelChannel,X11Compliance,tuple);
number_colors=(unsigned int) (map_info->base_pixel+
(map_info->red_max+1)*(map_info->green_max+1)*(map_info->blue_max+1));
if ((map_info->red_max*map_info->green_max*map_info->blue_max) != 0)
- if ((image->alpha_trait != BlendPixelTrait) &&
+ if ((image->alpha_trait == UndefinedPixelTrait) &&
(resource_info->color_recovery == MagickFalse) &&
(resource_info->quantize_info->dither_method != NoDitherMethod) &&
(number_colors < MaxColormapSize))
ChannelFeatures(BlueChannel,i);
if (image->colorspace == CMYKColorspace)
ChannelFeatures(BlackChannel,i);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
ChannelFeatures(AlphaChannel,i);
}
channel_features=(ChannelFeatures *)
if (LocaleCompare(attribute,"matte") == 0)
{
if (image != (Image *) NULL)
- s=newSViv((ssize_t) image->alpha_trait == BlendPixelTrait ?
+ s=newSViv((ssize_t) image->alpha_trait != UndefinedPixelTrait ?
1 : 0);
PUSHs(s ? sv_2mortal(s) : &sv_undef);
continue;
goto PerlException;
}
map="RGB";
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
map="RGBA";
if (image->colorspace == CMYKColorspace)
{
map="CMYK";
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
map="CMYKA";
}
normalize=MagickFalse;
{
QueryColorCompliance(argument_list[1].string_reference,
AllCompliance,&image->background_color,exception);
- if ((image->background_color.alpha_trait == BlendPixelTrait) &&
- (image->alpha_trait != BlendPixelTrait))
+ if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlpha(image,OpaqueAlpha,exception);
}
image=RotateImage(image,argument_list[0].real_reference,exception);
opacity=(Quantum) StringToDoubleInterval(
argument_list[6].string_reference,(double) QuantumRange+
1.0);
- if (composite_image->alpha_trait == BlendPixelTrait)
+ if (composite_image->alpha_trait != UndefinedPixelTrait)
(void) SetImageAlpha(composite_image,OpaqueAlpha,exception);
composite_view=AcquireAuthenticCacheView(composite_image,exception);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
geometry.x=argument_list[1].integer_reference;
if (attribute_flag[2] != 0)
geometry.y=argument_list[2].integer_reference;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlpha(image,OpaqueAlpha,exception);
(void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,
geometry.x,geometry.y,&target,exception);
PUSHs(sv_2mortal(newSViv((size_t) floor(color.blue+0.5))));
if (color.colorspace == CMYKColorspace)
PUSHs(sv_2mortal(newSViv((size_t) floor(color.black+0.5))));
- if (color.alpha_trait == BlendPixelTrait)
+ if (color.alpha_trait != UndefinedPixelTrait)
PUSHs(sv_2mortal(newSViv((size_t) floor(color.alpha+0.5))));
}
ChannelStatistics(BlueChannel);
if (image->colorspace == CMYKColorspace)
ChannelStatistics(BlackChannel);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
ChannelStatistics(AlphaChannel);
channel_statistics=(ChannelStatistics *)
RelinquishMagickMemory(channel_statistics);
ChannelFeatures(BlueChannel,i);
if (image->colorspace == CMYKColorspace)
ChannelFeatures(BlackChannel,i);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
ChannelFeatures(AlphaChannel,i);
}
channel_features=(ChannelFeatures *)
if (LocaleCompare(attribute,"matte") == 0)
{
if (image != (Image *) NULL)
- s=newSViv((ssize_t) image->alpha_trait == BlendPixelTrait ?
+ s=newSViv((ssize_t) image->alpha_trait != UndefinedPixelTrait ?
1 : 0);
PUSHs(s ? sv_2mortal(s) : &sv_undef);
continue;
goto PerlException;
}
map="RGB";
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
map="RGBA";
if (image->colorspace == CMYKColorspace)
{
map="CMYK";
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
map="CMYKA";
}
normalize=MagickFalse;
{
QueryColorCompliance(argument_list[1].string_reference,
AllCompliance,&image->background_color,exception);
- if ((image->background_color.alpha_trait == BlendPixelTrait) &&
- (image->alpha_trait != BlendPixelTrait))
+ if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlpha(image,OpaqueAlpha,exception);
}
image=RotateImage(image,argument_list[0].real_reference,exception);
opacity=(Quantum) StringToDoubleInterval(
argument_list[6].string_reference,(double) QuantumRange+
1.0);
- if (composite_image->alpha_trait == BlendPixelTrait)
+ if (composite_image->alpha_trait != UndefinedPixelTrait)
(void) SetImageAlpha(composite_image,OpaqueAlpha,exception);
composite_view=AcquireAuthenticCacheView(composite_image,exception);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
geometry.x=argument_list[1].integer_reference;
if (attribute_flag[2] != 0)
geometry.y=argument_list[2].integer_reference;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlpha(image,OpaqueAlpha,exception);
(void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,
geometry.x,geometry.y,&target,exception);
PUSHs(sv_2mortal(newSViv((size_t) floor(color.blue+0.5))));
if (color.colorspace == CMYKColorspace)
PUSHs(sv_2mortal(newSViv((size_t) floor(color.black+0.5))));
- if (color.alpha_trait == BlendPixelTrait)
+ if (color.alpha_trait != UndefinedPixelTrait)
PUSHs(sv_2mortal(newSViv((size_t) floor(color.alpha+0.5))));
}
ChannelStatistics(BlueChannel);
if (image->colorspace == CMYKColorspace)
ChannelStatistics(BlackChannel);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
ChannelStatistics(AlphaChannel);
channel_statistics=(ChannelStatistics *)
RelinquishMagickMemory(channel_statistics);
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
- *q=ScaleQuantumToChar((Quantum) (image->alpha_trait == BlendPixelTrait ?
+ *q=ScaleQuantumToChar((Quantum) (image->alpha_trait != UndefinedPixelTrait ?
GetPixelAlpha(image,p) : OpaqueAlpha));
if (*q == 255)
*q=254;
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
p+=GetPixelChannels(canvas_image);
q+=GetPixelChannels(image);
"UnexpectedEndOfFile",image->filename);
break;
}
- for (i=0; i < (ssize_t) (image->alpha_trait == BlendPixelTrait ? 4 : 3); i++)
+ for (i=0; i < (ssize_t) (image->alpha_trait != UndefinedPixelTrait ? 4 : 3); i++)
{
quantum_type=quantum_types[i];
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
(void) CloseBlob(image);
AppendImageFormat("A",image->filename);
*/
(void) TransformImageColorspace(image,sRGBColorspace,exception);
if ((LocaleCompare(image_info->magick,"BGRA") == 0) &&
- (image->alpha_trait != BlendPixelTrait))
+ (image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
If we find a non zero value we asume the program that wrote the file
wants to use the alpha channel.
*/
- if ((image->alpha_trait != BlendPixelTrait) && (bmp_info.size == 40) &&
+ if ((image->alpha_trait == UndefinedPixelTrait) && (bmp_info.size == 40) &&
(bmp_info.bits_per_pixel == 32))
{
bytes_per_line=4*(image->columns);
}
}
}
- bmp_info.alpha_mask=image->alpha_trait == BlendPixelTrait ?
+ bmp_info.alpha_mask=image->alpha_trait != UndefinedPixelTrait ?
0xff000000U : 0U;
bmp_info.red_mask=0x00ff0000U;
bmp_info.green_mask=0x0000ff00U;
SetPixelGreen(image,ScaleShortToQuantum((unsigned short) green),q);
SetPixelBlue(image,ScaleShortToQuantum((unsigned short) blue),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
alpha=((pixel & bmp_info.alpha_mask) << shift.alpha) >> 16;
if (quantum_bits.alpha <= 8)
SetPixelGreen(image,ScaleShortToQuantum((unsigned short) green),q);
SetPixelBlue(image,ScaleShortToQuantum((unsigned short) blue),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
alpha=((pixel & bmp_info.alpha_mask) << shift.alpha) >> 16;
if (quantum_bits.alpha == 8)
if (image_info->compression == RLECompression)
bmp_info.bits_per_pixel=8;
bmp_info.number_colors=1U << bmp_info.bits_per_pixel;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) SetImageStorageClass(image,DirectClass,exception);
else
if ((size_t) bmp_info.number_colors < image->colors)
*/
bmp_info.number_colors=0;
bmp_info.bits_per_pixel=(unsigned short)
- ((type > 3) && (image->alpha_trait == BlendPixelTrait) ? 32 : 24);
+ ((type > 3) && (image->alpha_trait != UndefinedPixelTrait) ? 32 : 24);
bmp_info.compression=(unsigned int) ((type > 3) &&
- (image->alpha_trait == BlendPixelTrait) ? BI_BITFIELDS : BI_RGB);
+ (image->alpha_trait != UndefinedPixelTrait) ? BI_BITFIELDS : BI_RGB);
}
bytes_per_line=4*((image->columns*bmp_info.bits_per_pixel+31)/32);
bmp_info.ba_offset=0;
if (type == 2)
bmp_info.size=12;
else
- if ((type == 3) || ((image->alpha_trait != BlendPixelTrait) &&
+ if ((type == 3) || ((image->alpha_trait == UndefinedPixelTrait) &&
(have_color_info == MagickFalse)))
{
type=3;
" Storage class=PseudoClass");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Image depth=%.20g",(double) image->depth);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Matte=True");
else
(void) WriteBlobLSBLong(image,bmp_info.number_colors);
(void) WriteBlobLSBLong(image,bmp_info.colors_important);
}
- if ((type > 3) && ((image->alpha_trait == BlendPixelTrait) ||
+ if ((type > 3) && ((image->alpha_trait != UndefinedPixelTrait) ||
(have_color_info != MagickFalse)))
{
/*
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
SetPixelBlack(image,GetPixelBlack(canvas_image,p),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
p+=GetPixelChannels(canvas_image);
q+=GetPixelChannels(image);
"UnexpectedEndOfFile",image->filename);
break;
}
- for (i=0; i < (image->alpha_trait == BlendPixelTrait ? 5 : 4); i++)
+ for (i=0; i < (image->alpha_trait != UndefinedPixelTrait ? 5 : 4); i++)
{
quantum_type=quantum_types[i];
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
(void) CloseBlob(image);
AppendImageFormat("A",image->filename);
if (LocaleCompare(image_info->magick,"CMYKA") == 0)
{
quantum_type=CMYKAQuantum;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
}
quantum_info=AcquireQuantumInfo(image_info,image);
SetPixelGreen(image,ScaleCharToQuantum(colors.g[code]),q);
SetPixelBlue(image,ScaleCharToQuantum(colors.b[code]),q);
SetPixelAlpha(image,ScaleCharToQuantum(colors.a[code]),q);
- if (colors.a[code] && (image->alpha_trait != BlendPixelTrait))
+ if (colors.a[code] && (image->alpha_trait == UndefinedPixelTrait))
image->alpha_trait=BlendPixelTrait; /* Correct matte */
q+=GetPixelChannels(image);
}
pixelFormat=DDPF_FOURCC;
compression=FOURCC_DXT5;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
compression=FOURCC_DXT1;
if (LocaleCompare(image_info->magick,"dxt1") == 0)
caps=caps | (unsigned int) (DDSCAPS_MIPMAP | DDSCAPS_COMPLEX);
}
- if (format != DDPF_FOURCC && image->alpha_trait == BlendPixelTrait)
+ if (format != DDPF_FOURCC && image->alpha_trait != UndefinedPixelTrait)
format=format | DDPF_ALPHAPIXELS;
(void) WriteBlob(image,4,(unsigned char *) "DDS ");
else
{
(void) WriteBlobLSBLong(image,0x00);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
(void) WriteBlobLSBLong(image,32);
(void) WriteBlobLSBLong(image,0xff0000);
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelBlue(image,p)));
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelGreen(image,p)));
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(image,p)));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelAlpha(image,p)));
p+=GetPixelChannels(image);
}
MagickColorspaceOptions,(ssize_t) image->colorspace),MaxTextExtent);
LocaleLower(colorspace);
image->depth=GetImageQuantumDepth(image,MagickTrue);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) ConcatenateMagickString(colorspace,"a",MaxTextExtent);
(void) FormatLocaleString(buffer,MaxTextExtent,
"# ImageMagick pixel debugging: %.20g,%.20g,%.20g,%s\n",(double)
(double) pixel.black);
(void) ConcatenateMagickString(tuple,black,MaxTextExtent);
}
- if (pixel.alpha_trait == BlendPixelTrait)
+ if (pixel.alpha_trait != UndefinedPixelTrait)
{
char
alpha[MaxTextExtent];
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
q+=GetPixelChannels(image);
}
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
p+=GetPixelChannels(image);
}
case YCbCrColorspace:
{
dpx.image.image_element[i].descriptor=CbYCr444ComponentType;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
dpx.image.image_element[i].descriptor=CbYCrA4444ComponentType;
break;
}
default:
{
dpx.image.image_element[i].descriptor=RGBComponentType;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
dpx.image.image_element[i].descriptor=RGBAComponentType;
if ((image_info->type != TrueColorType) &&
- (image->alpha_trait != BlendPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait) &&
(IsImageGray(image,exception) != MagickFalse))
dpx.image.image_element[i].descriptor=LumaComponentType;
break;
SetQuantumPack(quantum_info,dpx.image.image_element[0].packing == 0 ?
MagickTrue : MagickFalse);
quantum_type=RGBQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
quantum_type=RGBAQuantum;
if (image->colorspace == YCbCrColorspace)
{
quantum_type=CbYCrQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
quantum_type=CbYCrAQuantum;
if ((horizontal_factor == 2) || (vertical_factor == 2))
quantum_type=CbYCrYQuantum;
}
- extent=GetBytesPerRow(image->columns,image->alpha_trait == BlendPixelTrait ?
+ extent=GetBytesPerRow(image->columns,image->alpha_trait != UndefinedPixelTrait ?
4UL : 3UL,image->depth,MagickTrue);
if ((image_info->type != TrueColorType) &&
- (image->alpha_trait != BlendPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait) &&
(IsImageGray(image,exception) != MagickFalse))
{
quantum_type=GrayQuantum;
scanline[x].g=half_quantum;
ImfFloatToHalf(QuantumScale*GetPixelBlue(image,p),&half_quantum);
scanline[x].b=half_quantum;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
ImfFloatToHalf(1.0,&half_quantum);
else
ImfFloatToHalf(QuantumScale*GetPixelAlpha(image,p),&half_quantum);
SetPixelBlue(image,index,q);
}
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum(*a),q);
q+=GetPixelChannels(image);
r+=red_component->columnStride;
tile_width=64;
tile_height=64;
colorspace.numberOfComponents=3;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
colorspace.numberOfComponents=4;
if ((image_info->type != TrueColorType) &&
(IsImageGray(image,exception) != MagickFalse))
Write image pixelss.
*/
quantum_type=RGBQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
quantum_type=RGBAQuantum;
if (fpx_info.numberOfComponents == 1)
quantum_type=GrayQuantum;
return((Image *) NULL);
}
image->alpha_trait=start_color.alpha_trait;
- if (stop_color.alpha_trait == BlendPixelTrait)
+ if (stop_color.alpha_trait != UndefinedPixelTrait)
image->alpha_trait=stop_color.alpha_trait;
status=GradientImage(image,LocaleCompare(image_info->magick,"GRADIENT") == 0 ?
LinearGradient : RadialGradient,PadSpread,&start_color,&stop_color,
*q++=ScaleQuantumToChar(GetPixelBlue(next,p));
*q++=ScaleQuantumToChar(GetPixelGreen(next,p));
*q++=ScaleQuantumToChar(GetPixelRed(next,p));
- if (next->alpha_trait != BlendPixelTrait)
+ if (next->alpha_trait == UndefinedPixelTrait)
*q++=ScaleQuantumToChar(QuantumRange);
else
*q++=ScaleQuantumToChar(GetPixelAlpha(next,p));
for (x=0; x < (ssize_t) next->columns; x++)
{
byte<<=1;
- if ((next->alpha_trait == BlendPixelTrait) &&
+ if ((next->alpha_trait != UndefinedPixelTrait) &&
(GetPixelAlpha(next,p) == (Quantum) TransparentAlpha))
byte|=0x01;
bit++;
channels=1;
jp2_colorspace=OPJ_CLRSPC_GRAY;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channels++;
}
parameters.tcp_mct=channels == 3 ? 1 : 0;
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelLocations(file,image,AlphaPixelChannel,"Alpha",
type,max_locations,channel_statistics);
channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) FormatLocaleFile(file," alpha: %.20g-bit\n",(double)
channel_statistics[AlphaPixelChannel].depth);
scale=1;
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelStatistics(file,AlphaPixelChannel,"Alpha",1.0/
scale,channel_statistics);
if (colorspace != GRAYColorspace)
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelMoments(file,AlphaPixelChannel,"Alpha",
channel_moments);
channel_moments=(ChannelMoments *) RelinquishMagickMemory(
if (channel_phash != (ChannelPerceptualHash *) NULL)
{
(void) FormatLocaleFile(file," \"channelPerceptualHash\": {\n");
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelPerceptualHash(file,AlphaChannel,"alphaAlpha",
MagickTrue,channel_phash);
(void) PrintChannelPerceptualHash(file,RedChannel,"redHue",MagickTrue,
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) PrintChannelFeatures(file,AlphaPixelChannel,"Alpha",
channel_features);
channel_features=(ChannelFeatures *) RelinquishMagickMemory(
(void) FormatLocaleFile(file," Total ink density: %.0f%%\n",100.0*
GetImageTotalInkDensity(image,exception)/(double) QuantumRange);
x=0;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
register const Quantum
*p;
ConcatenateColorComponent(&pixel,BlackPixelChannel,
X11Compliance,tuple);
}
- if (pixel.alpha_trait == BlendPixelTrait)
+ if (pixel.alpha_trait != UndefinedPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,AlphaPixelChannel,
ssize_t
y;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
ThrowWriterException(CoderError,"ImageDoesNotHaveAnAlphaChannel");
matte_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
if (matte_image == (Image *) NULL)
}
(void) SetImageArtifact(msl_info->image[n],
"compose:args",value);
- if (composite_image->alpha_trait != BlendPixelTrait)
+ if (composite_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlpha(composite_image,OpaqueAlpha,
exception);
composite_view=AcquireAuthenticCacheView(composite_image,exception);
SetPixelRed(image,ScaleCharToQuantum(*r++),q);
SetPixelGreen(image,ScaleCharToQuantum(*r++),q);
SetPixelBlue(image,ScaleCharToQuantum(*r++),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum(*r++),q);
}
q+=GetPixelChannels(image);
if ((image->storage_class == DirectClass) || (image->colors > 256))
{
pcx_info.planes=3;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
pcx_info.planes++;
}
pcx_info.bytes_per_line=(unsigned short) (((size_t) image->columns*
if (image_info->compression == JPEG2000Compression)
version=(size_t) MagickMax(version,5);
for (next=image; next != (Image *) NULL; next=GetNextImageInList(next))
- if (next->alpha_trait == BlendPixelTrait)
+ if (next->alpha_trait != UndefinedPixelTrait)
version=(size_t) MagickMax(version,4);
if (LocaleCompare(image_info->magick,"PDFA") == 0)
version=(size_t) MagickMax(version,6);
case Group4Compression:
{
if ((IsImageMonochrome(image,exception) == MagickFalse) ||
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
compression=RLECompression;
break;
}
(compression == FaxCompression) || (compression == Group4Compression) ?
1 : 8);
(void) WriteBlobString(image,buffer);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
(void) FormatLocaleString(buffer,MaxTextExtent,"/SMask %.20g 0 R\n",
(double) object+7);
object);
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"<<\n");
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
(void) WriteBlobString(image,">>\n");
else
{
tile_image->resolution.x=(double) pixmap.horizontal_resolution;
tile_image->resolution.y=(double) pixmap.vertical_resolution;
tile_image->units=PixelsPerInchResolution;
- if (tile_image->alpha_trait == BlendPixelTrait)
+ if (tile_image->alpha_trait != UndefinedPixelTrait)
image->alpha_trait=tile_image->alpha_trait;
}
if ((code != 0x9a) && (code != 0x9b))
(unsigned char) ((j & 0x1f) << 3)),q);
}
else
- if (tile_image->alpha_trait != BlendPixelTrait)
+ if (tile_image->alpha_trait == UndefinedPixelTrait)
{
if (p > (pixels+extent+2*image->columns))
ThrowReaderException(CorruptImageError,
storage_class=DirectClass;
if (storage_class == DirectClass)
{
- pixmap.component_count=image->alpha_trait == BlendPixelTrait ? 4 : 3;
+ pixmap.component_count=image->alpha_trait != UndefinedPixelTrait ? 4 : 3;
pixmap.pixel_type=16;
pixmap.bits_per_pixel=32;
pixmap.pack_type=0x04;
*/
bytes_per_line=image->columns;
if (storage_class == DirectClass)
- bytes_per_line*=image->alpha_trait == BlendPixelTrait ? 4 : 3;
+ bytes_per_line*=image->alpha_trait != UndefinedPixelTrait ? 4 : 3;
buffer=(unsigned char *) AcquireQuantumMemory(PictInfoSize,sizeof(*buffer));
packed_scanline=(unsigned char *) AcquireQuantumMemory((size_t)
(row_bytes+MaxCount),sizeof(*packed_scanline));
red=scanline;
green=scanline+image->columns;
blue=scanline+2*image->columns;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
opacity=scanline;
red=scanline+image->columns;
*red++=ScaleQuantumToChar(GetPixelRed(image,p));
*green++=ScaleQuantumToChar(GetPixelGreen(image,p));
*blue++=ScaleQuantumToChar(GetPixelBlue(image,p));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
*opacity++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
p+=GetPixelChannels(image);
}
BlendPixelTrait : UndefinedPixelTrait;
#if 0 /* I'm not sure what's wrong here but it does not work. */
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
(void) SetImageType(image,GrayscaleMatteType,exception);
exception);
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
for (x=(ssize_t) image->columns; x != 0; x--)
{
SetPixelAlpha(image,GetPixelRed(jng_image,s),q);
#define QM Quantum
#endif
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) SetImageBackgroundColor(large_image,exception);
else
((ssize_t) (m*2))
+GetPixelBlue(image,pixels)))),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(large_image, ((QM) (((ssize_t)
(2*i*(GetPixelAlpha(image,n)
-GetPixelAlpha(image,pixels)+m))
-GetPixelBlue(image,pixels))+m)
/((ssize_t) (m*2))+
GetPixelBlue(image,pixels)),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,(QM) ((2*i*(
GetPixelAlpha(image,n)
-GetPixelAlpha(image,pixels))+m)
if (mng_info->write_png_colortype &&
(mng_info->write_png_colortype > 4 || (mng_info->write_png_depth >= 8 &&
mng_info->write_png_colortype < 4 &&
- image->alpha_trait != BlendPixelTrait)))
+ image->alpha_trait == UndefinedPixelTrait)))
{
/* Avoid the expensive BUILD_PALETTE operation if we're sure that we
* are not going to need the result.
mng_info->write_png_colortype == 5)
ping_have_color=MagickFalse;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
number_transparent = 2;
number_semitransparent = 1;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (image->alpha_trait != BlendPixelTrait ||
+ if (image->alpha_trait == UndefinedPixelTrait ||
GetPixelAlpha(image,q) == OpaqueAlpha)
{
if (number_opaque < 259)
{
for (i=0; i< (ssize_t) image_colors; i++)
{
- if ((image->alpha_trait != BlendPixelTrait ||
+ if ((image->alpha_trait == UndefinedPixelTrait ||
image->colormap[i].alpha == GetPixelAlpha(image,q)) &&
image->colormap[i].red == GetPixelRed(image,q) &&
image->colormap[i].green == GetPixelGreen(image,q) &&
quantum_info = (QuantumInfo *) NULL;
number_colors=0;
image_colors=(int) image->colors;
- image_matte=image->alpha_trait == BlendPixelTrait ? MagickTrue : MagickFalse;
+ image_matte=image->alpha_trait != UndefinedPixelTrait ? MagickTrue : MagickFalse;
if (mng_info->write_png_colortype < 5)
mng_info->IsPalette=image->storage_class == PseudoClass &&
if (ping_color_type == PNG_COLOR_TYPE_GRAY)
{
- if (image->alpha_trait != BlendPixelTrait && ping_have_non_bw == MagickFalse)
+ if (image->alpha_trait == UndefinedPixelTrait && ping_have_non_bw == MagickFalse)
ping_bit_depth=1;
}
"Cannot write image with defined png:bit-depth or png:color-type.");
}
- if (image_matte != MagickFalse && image->alpha_trait != BlendPixelTrait)
+ if (image_matte != MagickFalse && image->alpha_trait == UndefinedPixelTrait)
{
/* Add an opaque matte channel */
image->alpha_trait = BlendPixelTrait;
mng_info->write_png_depth = 8;
image->depth = 8;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) SetImageType(image,TrueColorMatteType,exception);
else
mng_info->write_png_depth = 16;
image->depth = 16;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) SetImageType(image,TrueColorMatteType,exception);
else
status=MagickTrue;
transparent=image_info->type==GrayscaleMatteType ||
- image_info->type==TrueColorMatteType || image->alpha_trait == BlendPixelTrait;
+ image_info->type==TrueColorMatteType || image->alpha_trait != UndefinedPixelTrait;
jng_alpha_sample_depth = 0;
" Scene: %.20g\n, Image depth: %.20g",
(double) scene++, (double) p->depth);
- if (p->alpha_trait == BlendPixelTrait)
+ if (p->alpha_trait != UndefinedPixelTrait)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Matte: True");
if (next_image->page.x || next_image->page.y)
need_defi=MagickTrue;
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
need_matte=MagickTrue;
if ((int) next_image->dispose >= BackgroundDispose)
- if ((next_image->alpha_trait == BlendPixelTrait) ||
+ if ((next_image->alpha_trait != UndefinedPixelTrait) ||
next_image->page.x || next_image->page.y ||
((next_image->columns < mng_info->page.width) &&
(next_image->rows < mng_info->page.height)))
/*
check for global palette possibility.
*/
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
need_local_plte=MagickTrue;
if (need_local_plte == 0)
Write MNG BACK chunk and global bKGD chunk, if the image is transparent
or does not cover the entire frame.
*/
- if (write_mng && ((image->alpha_trait == BlendPixelTrait) ||
+ if (write_mng && ((image->alpha_trait != UndefinedPixelTrait) ||
image->page.x > 0 || image->page.y > 0 || (image->page.width &&
(image->page.width+image->page.x < mng_info->page.width))
|| (image->page.height && (image->page.height+image->page.y
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channels++;
if (image->depth <= 8)
extent=channels*image->columns;
p=PushCharPixel(p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushCharPixel(p,&pixel);
if (image->depth != 1)
SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),
q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
p=PushLongPixel(MSBEndian,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushLongPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
p=PushCharPixel(p,&pixel);
SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushCharPixel(p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
p=PushLongPixel(MSBEndian,p,&pixel);
SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushLongPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
p=PushCharPixel(p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushCharPixel(p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
p=PushLongPixel(MSBEndian,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
p=PushLongPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
default:
{
quantum_type=RGBQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
quantum_type=RGBAQuantum;
packet_size=3;
(void) CopyMagickString(type,"RGB",MaxTextExtent);
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
packet_size++;
(void) ConcatenateMagickString(type,"_ALPHA",MaxTextExtent);
pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
image,p)),max_value);
q=PopCharPixel((unsigned char) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=(unsigned char) ScaleQuantumToAny(
GetPixelAlpha(image,p),max_value);
pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
image,p)),max_value);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=(unsigned char) ScaleQuantumToAny(
GetPixelAlpha(image,p),max_value);
pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
p)),max_value);
q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=(unsigned char) ScaleQuantumToAny(
GetPixelAlpha(image,p),max_value);
pixel=ScaleQuantumToAny(GetPixelBlack(image,p),
max_value);
q=PopCharPixel((unsigned char) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
max_value);
pixel=ScaleQuantumToAny(GetPixelBlack(image,p),
max_value);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
max_value);
q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
pixel=ScaleQuantumToAny(GetPixelBlack(image,p),max_value);
q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
max_value);
pixel=ScaleQuantumToAny(GetPixelBlue(image,p),
max_value);
q=PopCharPixel((unsigned char) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
max_value);
pixel=ScaleQuantumToAny(GetPixelBlue(image,p),
max_value);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
max_value);
q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
max_value);
{
#define WriteRunlengthPacket(image,pixel,length,p) \
{ \
- if ((image->alpha_trait == BlendPixelTrait) && \
+ if ((image->alpha_trait != UndefinedPixelTrait) && \
(GetPixelAlpha(image,p) == (Quantum) TransparentAlpha)) \
{ \
q=PopHexPixel(hex_digits,0xff,q); \
}
else
if ((image->storage_class == DirectClass) ||
- (image->colors > 256) || (image->alpha_trait == BlendPixelTrait))
+ (image->colors > 256) || (image->alpha_trait != UndefinedPixelTrait))
{
/*
Dump DirectClass image.
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((image->alpha_trait == BlendPixelTrait) &&
+ if ((image->alpha_trait != UndefinedPixelTrait) &&
(GetPixelAlpha(image,p) == (Quantum) TransparentAlpha))
{
q=PopHexPixel(hex_digits,0xff,q);
}
else
if ((image->storage_class == DirectClass) || (image->colors > 256) ||
- (compression == JPEGCompression) || (image->alpha_trait == BlendPixelTrait))
+ (compression == JPEGCompression) || (image->alpha_trait != UndefinedPixelTrait))
{
(void) FormatLocaleString(buffer,MaxTextExtent,"%.20g %.20g\n0\n%d\n",
(double) image->columns,(double) image->rows,(int)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((image->alpha_trait == BlendPixelTrait) &&
+ if ((image->alpha_trait != UndefinedPixelTrait) &&
(GetPixelAlpha(image,p) == (Quantum) TransparentAlpha))
{
*q++=ScaleQuantumToChar(QuantumRange);
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((image->alpha_trait == BlendPixelTrait) &&
+ if ((image->alpha_trait != UndefinedPixelTrait) &&
(GetPixelAlpha(image,p) == (Quantum) TransparentAlpha))
{
Ascii85Encode(image,ScaleQuantumToChar((Quantum)
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(image->alpha_trait == BlendPixelTrait);
+ assert(image->alpha_trait != UndefinedPixelTrait);
status=MagickTrue;
/*
Note BeginData DSC comment for update later.
case Group4Compression:
{
if ((IsImageMonochrome(image,exception) == MagickFalse) ||
- (image->alpha_trait == BlendPixelTrait))
+ (image->alpha_trait != UndefinedPixelTrait))
compression=RLECompression;
break;
}
/*
Image mask.
*/
- if ((image->alpha_trait == BlendPixelTrait) &&
+ if ((image->alpha_trait != UndefinedPixelTrait) &&
(WritePS3MaskImage(image_info,image,compression,exception) == MagickFalse))
{
(void) CloseBlob(image);
/*
Masked image?
*/
- (void) WriteBlobString(image,image->alpha_trait == BlendPixelTrait ?
+ (void) WriteBlobString(image,image->alpha_trait != UndefinedPixelTrait ?
"true\n" : "false\n");
/*
Render with imagemask operator?
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,pixel,q);
else
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,pixel,q);
break;
}
if ((IssRGBCompatibleColorspace(image->colorspace) != MagickFalse) &&
(channels > 3))
break;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,pixel,q);
break;
}
(void) WriteBlobMSBShort(image,1);
WritePackbitsLength(psd_info,image_info,image,next_image,
compact_pixels,GrayQuantum,exception);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
WritePackbitsLength(psd_info,image_info,image,next_image,
compact_pixels,AlphaQuantum,exception);
}
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
GrayQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
MagickFalse,exception);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
AlphaQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
MagickFalse,exception);
(void) WriteBlobMSBShort(image,1);
WritePackbitsLength(psd_info,image_info,image,next_image,
compact_pixels,IndexQuantum,exception);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
WritePackbitsLength(psd_info,image_info,image,next_image,
compact_pixels,AlphaQuantum,exception);
}
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
IndexQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
MagickFalse,exception);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
AlphaQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
MagickFalse,exception);
if (next_image->colorspace == CMYKColorspace)
WritePackbitsLength(psd_info,image_info,image,next_image,
compact_pixels,BlackQuantum,exception);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
WritePackbitsLength(psd_info,image_info,image,next_image,
compact_pixels,AlphaQuantum,exception);
}
BlackQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,4,6);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
AlphaQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
MagickFalse,exception);
if (status == MagickFalse)
return(status);
packet_size=(size_t) (image->depth > 8 ? 6 : 3);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
packet_size+=image->depth > 8 ? 2 : 1;
psd_info.version=1;
if ((LocaleCompare(image_info->magick,"PSB") == 0) ||
for (i=1; i <= 6; i++)
(void) WriteBlobByte(image, 0); /* 6 bytes of reserved */
if (IsImageGray(image,exception) != MagickFalse)
- num_channels=(image->alpha_trait == BlendPixelTrait ? 2UL : 1UL);
+ num_channels=(image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL);
else
if (image->storage_class == PseudoClass)
- num_channels=(image->alpha_trait == BlendPixelTrait ? 2UL : 1UL);
+ num_channels=(image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL);
else
{
if (image->colorspace != CMYKColorspace)
- num_channels=(image->alpha_trait == BlendPixelTrait ? 4UL : 3UL);
+ num_channels=(image->alpha_trait != UndefinedPixelTrait ? 4UL : 3UL);
else
- num_channels=(image->alpha_trait == BlendPixelTrait ? 5UL : 4UL);
+ num_channels=(image->alpha_trait != UndefinedPixelTrait ? 5UL : 4UL);
}
(void) WriteBlobMSBShort(image,(unsigned short) num_channels);
(void) WriteBlobMSBLong(image,(unsigned int) image->rows);
layer_count=0;
layer_info_size=2;
base_image=GetNextImageInList(image);
- if ((image->alpha_trait == BlendPixelTrait) && (base_image == (Image *) NULL))
+ if ((image->alpha_trait != UndefinedPixelTrait) && (base_image == (Image *) NULL))
base_image=image;
next_image=base_image;
while ( next_image != NULL )
{
packet_size=next_image->depth > 8 ? 2UL : 1UL;
if (IsImageGray(next_image,exception) != MagickFalse)
- num_channels=next_image->alpha_trait == BlendPixelTrait ? 2UL : 1UL;
+ num_channels=next_image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL;
else
if (next_image->storage_class == PseudoClass)
- num_channels=next_image->alpha_trait == BlendPixelTrait ? 2UL : 1UL;
+ num_channels=next_image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL;
else
if (next_image->colorspace != CMYKColorspace)
- num_channels=next_image->alpha_trait == BlendPixelTrait ? 4UL : 3UL;
+ num_channels=next_image->alpha_trait != UndefinedPixelTrait ? 4UL : 3UL;
else
- num_channels=next_image->alpha_trait == BlendPixelTrait ? 5UL : 4UL;
+ num_channels=next_image->alpha_trait != UndefinedPixelTrait ? 5UL : 4UL;
channelLength=(size_t) (next_image->columns*next_image->rows*packet_size+2);
layer_info_size+=(size_t) (4*4+2+num_channels*6+(psd_info.version == 1 ? 8 :
16)+4*1+4+num_channels*channelLength);
else
rounded_layer_info_size=layer_info_size;
(void) SetPSDSize(&psd_info,image,rounded_layer_info_size);
- if (base_image->alpha_trait == BlendPixelTrait)
+ if (base_image->alpha_trait != UndefinedPixelTrait)
(void) WriteBlobMSBShort(image,-(unsigned short) layer_count);
else
(void) WriteBlobMSBShort(image,(unsigned short) layer_count);
(next_image->storage_class == PseudoClass))
{
(void) WriteBlobMSBShort(image,(unsigned short)
- (next_image->alpha_trait == BlendPixelTrait ? 2 : 1));
+ (next_image->alpha_trait != UndefinedPixelTrait ? 2 : 1));
(void) WriteBlobMSBShort(image,0);
(void) SetPSDSize(&psd_info,image,channel_size);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
{
(void) WriteBlobMSBShort(image,(unsigned short) -1);
(void) SetPSDSize(&psd_info,image,channel_size);
if (next_image->colorspace != CMYKColorspace)
{
(void) WriteBlobMSBShort(image,(unsigned short)
- (next_image->alpha_trait == BlendPixelTrait ? 4 : 3));
+ (next_image->alpha_trait != UndefinedPixelTrait ? 4 : 3));
(void) WriteBlobMSBShort(image,0);
(void) SetPSDSize(&psd_info,image,channel_size);
(void) WriteBlobMSBShort(image,1);
(void) SetPSDSize(&psd_info,image,channel_size);
(void) WriteBlobMSBShort(image,2);
(void) SetPSDSize(&psd_info,image,channel_size);
- if (next_image->alpha_trait == BlendPixelTrait)
+ if (next_image->alpha_trait != UndefinedPixelTrait)
{
(void) WriteBlobMSBShort(image,(unsigned short) -1);
(void) SetPSDSize(&psd_info,image,channel_size);
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
p+=GetPixelChannels(canvas_image);
q+=GetPixelChannels(image);
"UnexpectedEndOfFile",image->filename);
break;
}
- for (i=0; i < (ssize_t) (image->alpha_trait == BlendPixelTrait ? 4 : 3); i++)
+ for (i=0; i < (ssize_t) (image->alpha_trait != UndefinedPixelTrait ? 4 : 3); i++)
{
quantum_type=quantum_types[i];
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
(void) CloseBlob(image);
AppendImageFormat("A",image->filename);
*/
(void) TransformImageColorspace(image,sRGBColorspace,exception);
if ((LocaleCompare(image_info->magick,"RGBA") == 0) &&
- (image->alpha_trait != BlendPixelTrait))
+ (image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
/*
Allocate RLE pixels.
*/
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
number_planes++;
number_pixels=(MagickSizeType) image->columns*image->rows;
if ((number_pixels*number_planes) != (size_t) (number_pixels*number_planes))
p=pixels;
for (i=0; i < (ssize_t) number_pixels; i++)
{
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
for (j=0; j < (ssize_t) number_planes; j++)
*p++=background_color[j];
else
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
q+=GetPixelChannels(image);
}
p++;
}
p=pixels;
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
{
/*
Convert raster image to PseudoClass pixel packets.
SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
((*(p+4) << 8) | (*(p+5)))),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
((*(p+6) << 8) | (*(p+7)))),q);
p+=8;
SetPixelGreen(image,ScaleCharToQuantum(*(p+1)),q);
SetPixelBlue(image,ScaleCharToQuantum(*(p+2)),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum(*(p+3)),q);
p+=4;
q+=GetPixelChannels(image);
iris_info.dimension=3;
iris_info.columns=(unsigned short) image->columns;
iris_info.rows=(unsigned short) image->rows;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
iris_info.depth=4;
else
{
if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,sRGBColorspace,exception);
opacity=(-1);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
{
if ((image->storage_class == DirectClass) || (image->colors > 256))
(void) SetImageType(image,PaletteType,exception);
bytes_per_pixel;
bytes_per_pixel=3;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
bytes_per_pixel++;
if (bytes_per_line == 0)
bytes_per_line=bytes_per_pixel*image->columns;
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
if (sun_info.type == RT_STANDARD)
{
/*
Full color SUN raster.
*/
- sun_info.depth=(unsigned int) image->alpha_trait == BlendPixelTrait ?
+ sun_info.depth=(unsigned int) image->alpha_trait != UndefinedPixelTrait ?
32U : 24U;
- sun_info.length=(unsigned int) ((image->alpha_trait == BlendPixelTrait ?
+ sun_info.length=(unsigned int) ((image->alpha_trait != UndefinedPixelTrait ?
4 : 3)*number_pixels);
sun_info.length+=sun_info.length & 0x01 ? (unsigned int) image->rows :
0;
Allocate memory for pixels.
*/
bytes_per_pixel=3;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
bytes_per_pixel++;
length=image->columns;
pixels=(unsigned char *) AcquireQuantumMemory(length,4*sizeof(*pixels));
q=pixels;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
pixel.green=(MagickRealType) ScaleAnyToQuantum((1UL*(k & 0x03)
<< 3)+(1UL*(j & 0xe0) >> 5),range);
pixel.blue=(MagickRealType) ScaleAnyToQuantum(1UL*(j & 0x1f),range);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
pixel.alpha=(MagickRealType) ((k & 0x80) == 0 ? (Quantum)
OpaqueAlpha : (Quantum) TransparentAlpha);
if (image->storage_class == PseudoClass)
SetPixelRed(image,ClampToQuantum(pixel.red),q);
SetPixelGreen(image,ClampToQuantum(pixel.green),q);
SetPixelBlue(image,ClampToQuantum(pixel.blue),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ClampToQuantum(pixel.alpha),q);
q+=GetPixelChannels(image);
}
value=((unsigned char) ScaleQuantumToAny(ClampToQuantum(
GetPixelBlue(image,p)),range)) | ((green & 0x07) << 5);
(void) WriteBlobByte(image,value);
- value=(((image->alpha_trait == BlendPixelTrait) && (ClampToQuantum(
+ value=(((image->alpha_trait != UndefinedPixelTrait) && (ClampToQuantum(
GetPixelAlpha(image,p)) < midpoint)) ? 80 : 0) |
((unsigned char) ScaleQuantumToAny(ClampToQuantum(
GetPixelRed(image,p)),range) << 2) | ((green & 0x18) >> 3);
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelGreen(image,
p)));
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(image,p)));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelAlpha(image,
p)));
}
if ((image_info->type != TrueColorType) &&
(image_info->type != TrueColorMatteType) &&
(image_info->type != PaletteType) &&
- (image->alpha_trait != BlendPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait) &&
(IsImageGray(image,exception) != MagickFalse))
tga_info.image_type=compression == RLECompression ? TGARLEMonochrome :
TGAMonochrome;
else
{
tga_info.bits_per_pixel=24;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
tga_info.bits_per_pixel=32;
tga_info.attributes=8; /* # of alpha bits */
image->colormap[i].green),range);
*q++=((unsigned char) ScaleQuantumToAny(ClampToQuantum(
image->colormap[i].blue),range)) | ((green & 0x07) << 5);
- *q++=(((image->alpha_trait == BlendPixelTrait) && (ClampToQuantum(
+ *q++=(((image->alpha_trait != UndefinedPixelTrait) && (ClampToQuantum(
image->colormap[i].alpha) < midpoint)) ? 80 : 0) |
((unsigned char) ScaleQuantumToAny(ClampToQuantum(
image->colormap[i].red),range) << 2) | ((green & 0x18) >> 3);
(GetPixelRed(image,p+(i*channels)) !=
GetPixelRed(image,p+((i-1)*channels))))
break;
- if ((image->alpha_trait == BlendPixelTrait) &&
+ if ((image->alpha_trait != UndefinedPixelTrait) &&
(GetPixelAlpha(image,p+(i*channels)) !=
GetPixelAlpha(image,p+(i-1)*channels)))
break;
length,exception);
if (thumbnail_image == (Image *) NULL)
return(MagickFalse);
- (void) SetImageType(thumbnail_image,thumbnail_image->alpha_trait != BlendPixelTrait ?
+ (void) SetImageType(thumbnail_image,thumbnail_image->alpha_trait == UndefinedPixelTrait ?
TrueColorType : TrueColorMatteType,exception);
(void) CopyMagickString(thumbnail_image->filename,image->filename,
MaxTextExtent);
}
quantum_type=IndexQuantum;
pad=(size_t) MagickMax((size_t) samples_per_pixel-1,0);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
if (image->storage_class != PseudoClass)
{
*/
pad=(size_t) MagickMax((size_t) samples_per_pixel-3,0);
quantum_type=RGBQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
quantum_type=RGBAQuantum;
pad=(size_t) MagickMax((size_t) samples_per_pixel-4,0);
{
pad=(size_t) MagickMax((size_t) samples_per_pixel-4,0);
quantum_type=CMYKQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
quantum_type=CMYKAQuantum;
pad=(size_t) MagickMax((size_t) samples_per_pixel-5,0);
(TIFFGetG(*p))),q);
SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
(TIFFGetB(*p))),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
(TIFFGetA(*p))),q);
p++;
x);
for (row=rows_remaining; row > 0; row--)
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
for (column=columns_remaining; column > 0; column--)
{
SetPixelRed(image,ScaleCharToQuantum((unsigned char)
TIFFGetG(*p)),q);
SetPixelBlue(image,ScaleCharToQuantum((unsigned char) TIFFGetB(*p)),
q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
TIFFGetA(*p)),q);
p--;
PHOTOMETRIC_MINISBLACK);
(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,1);
if ((image_info->depth == 0) &&
- (image->alpha_trait != BlendPixelTrait) &&
+ (image->alpha_trait == UndefinedPixelTrait) &&
(IsImageMonochrome(image,exception) != MagickFalse))
{
status=SetQuantumDepth(image,quantum_info,1);
(void) TIFFSetField(tiff,TIFFTAG_COMPRESSION,compress_tag);
(void) TIFFSetField(tiff,TIFFTAG_FILLORDER,endian);
(void) TIFFSetField(tiff,TIFFTAG_BITSPERSAMPLE,quantum_info->depth);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
uint16
extra_samples,
default:
{
quantum_type=RGBQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
quantum_type=RGBAQuantum;
for (y=0; y < (ssize_t) image->rows; y++)
{
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
CMYK TIFF image.
*/
quantum_type=CMYKQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
quantum_type=CMYKAQuantum;
if (image->colorspace != CMYKColorspace)
(void) TransformImageColorspace(image,CMYKColorspace,exception);
Convert PseudoClass packets to contiguous grayscale scanlines.
*/
quantum_type=IndexQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
if (photometric != PHOTOMETRIC_PALETTE)
quantum_type=GrayAlphaQuantum;
return(DestroyImageList(image));
image->colorspace=tile_image->colorspace;
image->alpha_trait=tile_image->alpha_trait;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) SetImageBackgroundColor(image,exception);
(void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent);
if (LocaleCompare(tile_image->magick,"PATTERN") == 0)
{
case GRAYColorspace:
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
count=(ssize_t) sscanf(text,"%ld,%ld: (%lf%*[%,]%lf%*[%,]",
&x_offset,&y_offset,&red,&alpha);
}
case CMYKColorspace:
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
count=(ssize_t) sscanf(text,
"%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",
}
default:
{
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
count=(ssize_t) sscanf(text,
"%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",
MagickColorspaceOptions,(ssize_t) image->colorspace),MaxTextExtent);
LocaleLower(colorspace);
image->depth=GetImageQuantumDepth(image,MagickTrue);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
(void) ConcatenateMagickString(colorspace,"a",MaxTextExtent);
compliance=NoCompliance;
if (LocaleCompare(image_info->magick,"SPARSE-COLOR") != 0)
ConcatenateColorComponent(&pixel,BlackPixelChannel,compliance,
tuple);
}
- if (pixel.alpha_trait == BlendPixelTrait)
+ if (pixel.alpha_trait != UndefinedPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,AlphaPixelChannel,compliance,
Convert DirectClass to PseudoClass image.
*/
matte_image=(unsigned char *) NULL;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
/*
Map all the transparent pixels.
SetPixelBlue(image,image->colormap[
ConstrainColormapIndex(image,index,exception)].blue,q);
}
- SetPixelAlpha(image,image->alpha_trait == BlendPixelTrait ?
+ SetPixelAlpha(image,image->alpha_trait != UndefinedPixelTrait ?
ScaleCharToQuantum(*(p+number_pixels*3)) : OpaqueAlpha,q);
p++;
q+=GetPixelChannels(image);
*q=ScaleQuantumToChar(GetPixelRed(image,p));
*(q+number_pixels)=ScaleQuantumToChar(GetPixelGreen(image,p));
*(q+number_pixels*2)=ScaleQuantumToChar(GetPixelBlue(image,p));
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
*(q+number_pixels*3)=ScaleQuantumToChar((Quantum)
(GetPixelAlpha(image,p)));
p+=GetPixelChannels(image);
(void) WriteBlobLong(image,(unsigned int) image->columns);
(void) WriteBlobLong(image,(unsigned int) image->rows);
(void) SetImageStorageClass(image,DirectClass,exception);
- channels=image->alpha_trait == BlendPixelTrait ? 4 : 3;
+ channels=image->alpha_trait != UndefinedPixelTrait ? 4 : 3;
if (IsImageGray(image,exception) != MagickFalse)
- channels=image->alpha_trait == BlendPixelTrait ? 2 : 1;
+ channels=image->alpha_trait != UndefinedPixelTrait ? 2 : 1;
else if (image->colorspace == CMYKColorspace)
- channels=image->alpha_trait == BlendPixelTrait ? 5 : 4;
+ channels=image->alpha_trait != UndefinedPixelTrait ? 5 : 4;
(void) WriteBlobLong(image,channels);
(void) WriteBlobLong(image,0);
if (image->depth == 16)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- *q++=(uint32_t) (image->alpha_trait == BlendPixelTrait ?
+ *q++=(uint32_t) (image->alpha_trait != UndefinedPixelTrait ?
ScaleQuantumToChar(GetPixelAlpha(image,p)) << 24 : 0xff000000) |
(ScaleQuantumToChar(GetPixelRed(image,p)) << 16) |
(ScaleQuantumToChar(GetPixelGreen(image,p)) << 8) |
if (picon->storage_class == PseudoClass)
{
(void) CompressImageColormap(picon,exception);
- if (picon->alpha_trait == BlendPixelTrait)
+ if (picon->alpha_trait != UndefinedPixelTrait)
transparent=MagickTrue;
}
else
/*
Convert DirectClass to PseudoClass picon.
*/
- if (picon->alpha_trait == BlendPixelTrait)
+ if (picon->alpha_trait != UndefinedPixelTrait)
{
/*
Map all the transparent pixels.
if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,sRGBColorspace,exception);
opacity=(-1);
- if (image->alpha_trait != BlendPixelTrait)
+ if (image->alpha_trait == UndefinedPixelTrait)
{
if ((image->storage_class == DirectClass) || (image->colors > 256))
(void) SetImageType(image,PaletteType,exception);
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
p+=GetPixelChannels(canvas_image);
q+=GetPixelChannels(image);
}
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
- for (i=0; i < (image->alpha_trait == BlendPixelTrait ? 4 : 3); i++)
+ for (i=0; i < (image->alpha_trait != UndefinedPixelTrait ? 4 : 3); i++)
{
if (count != (ssize_t) length)
{
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
if (status == MagickFalse)
break;
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
(void) CloseBlob(image);
AppendImageFormat("A",image->filename);
if (image->colorspace != YCbCrColorspace)
(void) TransformImageColorspace(image,YCbCrColorspace,exception);
if ((LocaleCompare(image_info->magick,"YCbCrA") == 0) &&
- (image->alpha_trait != BlendPixelTrait))
+ (image->alpha_trait == UndefinedPixelTrait))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
projects / imagemagick / commitdiff