MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
const MagickBooleanType verbose,ExceptionInfo *exception)
{
char
color[MaxTextExtent],
format[MaxTextExtent],
key[MaxTextExtent];
ChannelFeatures
*channel_features;
ChannelStatistics
*channel_statistics;
ColorspaceType
colorspace;
const char
*artifact,
*name,
*property,
*registry,
*value;
const MagickInfo
*magick_info;
double
elapsed_time,
user_time;
ImageType
type;
MagickBooleanType
ping;
register const Quantum
*p;
register ssize_t
i,
x;
size_t
distance,
scale;
ssize_t
y;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (file == (FILE *) NULL)
file=stdout;
*format='\0';
elapsed_time=GetElapsedTime(&image->timer);
user_time=GetUserTime(&image->timer);
GetTimerInfo(&image->timer);
if (verbose == MagickFalse)
{
/*
Display summary info about the image.
*/
if (*image->magick_filename != '\0')
if (LocaleCompare(image->magick_filename,image->filename) != 0)
(void) FormatLocaleFile(file,"%s=>",image->magick_filename);
if ((GetPreviousImageInList(image) == (Image *) NULL) &&
(GetNextImageInList(image) == (Image *) NULL) &&
(image->scene == 0))
(void) FormatLocaleFile(file,"%s ",image->filename);
else
(void) FormatLocaleFile(file,"%s[%.20g] ",image->filename,(double)
image->scene);
(void) FormatLocaleFile(file,"%s ",image->magick);
if ((image->magick_columns != 0) || (image->magick_rows != 0))
if ((image->magick_columns != image->columns) ||
(image->magick_rows != image->rows))
(void) FormatLocaleFile(file,"%.20gx%.20g=>",(double)
image->magick_columns,(double) image->magick_rows);
(void) FormatLocaleFile(file,"%.20gx%.20g ",(double) image->columns,
(double) image->rows);
if ((image->page.width != 0) || (image->page.height != 0) ||
(image->page.x != 0) || (image->page.y != 0))
(void) FormatLocaleFile(file,"%.20gx%.20g%+.20g%+.20g ",(double)
image->page.width,(double) image->page.height,(double) image->page.x,
(double) image->page.y);
(void) FormatLocaleFile(file,"%.20g-bit ",(double) image->depth);
if (image->type != UndefinedType)
(void) FormatLocaleFile(file,"%s ",CommandOptionToMnemonic(
MagickTypeOptions,(ssize_t) image->type));
if (image->storage_class == DirectClass)
{
(void) FormatLocaleFile(file,"DirectClass ");
if (image->total_colors != 0)
{
(void) FormatMagickSize(image->total_colors,MagickFalse,format);
(void) FormatLocaleFile(file,"%s ",format);
}
}
else
if (image->total_colors <= image->colors)
(void) FormatLocaleFile(file,"PseudoClass %.20gc ",(double)
image->colors);
else
(void) FormatLocaleFile(file,"PseudoClass %.20g=>%.20gc ",(double)
image->total_colors,(double) image->colors);
if (image->error.mean_error_per_pixel != 0.0)
(void) FormatLocaleFile(file,"%.20g/%f/%fdb ",(double)
(image->error.mean_error_per_pixel+0.5),
image->error.normalized_mean_error,
image->error.normalized_maximum_error);
if (GetBlobSize(image) != 0)
{
(void) FormatMagickSize(GetBlobSize(image),MagickFalse,format);
(void) FormatLocaleFile(file,"%s ",format);
}
(void) FormatLocaleFile(file,"%0.3fu %lu:%02lu.%03lu",user_time,
(unsigned long) (elapsed_time/60.0),(unsigned long) floor(fmod(
elapsed_time,60.0)),(unsigned long) (1000.0*(elapsed_time-
floor(elapsed_time))));
(void) FormatLocaleFile(file,"\n");
(void) fflush(file);
return(ferror(file) != 0 ? MagickFalse : MagickTrue);
}
/*
Display verbose info about the image.
*/
p=GetVirtualPixels(image,0,0,1,1,exception);
ping=p == (const Quantum *) NULL ? MagickTrue : MagickFalse;
type=GetImageType(image,exception);
(void) SignatureImage(image,exception);
(void) FormatLocaleFile(file,"Image: %s\n",image->filename);
if (*image->magick_filename != '\0')
if (LocaleCompare(image->magick_filename,image->filename) != 0)
{
char
filename[MaxTextExtent];
GetPathComponent(image->magick_filename,TailPath,filename);
(void) FormatLocaleFile(file," Base filename: %s\n",filename);
}
magick_info=GetMagickInfo(image->magick,exception);
if ((magick_info == (const MagickInfo *) NULL) ||
(*GetMagickDescription(magick_info) == '\0'))
(void) FormatLocaleFile(file," Format: %s\n",image->magick);
else
(void) FormatLocaleFile(file," Format: %s (%s)\n",image->magick,
GetMagickDescription(magick_info));
(void) FormatLocaleFile(file," Class: %s\n",CommandOptionToMnemonic(
MagickClassOptions,(ssize_t) image->storage_class));
(void) FormatLocaleFile(file," Geometry: %.20gx%.20g%+.20g%+.20g\n",(double)
image->columns,(double) image->rows,(double) image->tile_offset.x,(double)
image->tile_offset.y);
if ((image->magick_columns != 0) || (image->magick_rows != 0))
if ((image->magick_columns != image->columns) ||
(image->magick_rows != image->rows))
(void) FormatLocaleFile(file," Base geometry: %.20gx%.20g\n",(double)
image->magick_columns,(double) image->magick_rows);
if ((image->resolution.x != 0.0) && (image->resolution.y != 0.0))
{
(void) FormatLocaleFile(file," Resolution: %gx%g\n",image->resolution.x,
image->resolution.y);
(void) FormatLocaleFile(file," Print size: %gx%g\n",(double)
image->columns/image->resolution.x,(double) image->rows/
image->resolution.y);
}
(void) FormatLocaleFile(file," Units: %s\n",CommandOptionToMnemonic(
MagickResolutionOptions,(ssize_t) image->units));
(void) FormatLocaleFile(file," Type: %s\n",CommandOptionToMnemonic(
MagickTypeOptions,(ssize_t) type));
if (image->type != UndefinedType)
(void) FormatLocaleFile(file," Base type: %s\n",CommandOptionToMnemonic(
MagickTypeOptions,(ssize_t) image->type));
(void) FormatLocaleFile(file," Endianess: %s\n",CommandOptionToMnemonic(
MagickEndianOptions,(ssize_t) image->endian));
/*
Detail channel depth and extrema.
*/
(void) FormatLocaleFile(file," Colorspace: %s\n",CommandOptionToMnemonic(
MagickColorspaceOptions,(ssize_t) image->colorspace));
channel_statistics=(ChannelStatistics *) NULL;
channel_features=(ChannelFeatures *) NULL;
colorspace=image->colorspace;
scale=1;
if (ping == MagickFalse)
{
size_t
depth;
channel_statistics=GetImageStatistics(image,exception);
artifact=GetImageArtifact(image,"identify:features");
if (artifact != (const char *) NULL)
{
distance=StringToUnsignedLong(artifact);
channel_features=GetImageFeatures(image,distance,exception);
}
depth=GetImageDepth(image,exception);
if (image->depth == depth)
(void) FormatLocaleFile(file," Depth: %.20g-bit\n",(double)
image->depth);
else
(void) FormatLocaleFile(file," Depth: %.20g/%.20g-bit\n",(double)
image->depth,(double) depth);
(void) FormatLocaleFile(file," Channel depth:\n");
if (IsImageGray(image,exception) != MagickFalse)
colorspace=GRAYColorspace;
switch (colorspace)
{
case RGBColorspace:
default:
{
(void) FormatLocaleFile(file," red: %.20g-bit\n",(double)
channel_statistics[RedPixelChannel].depth);
(void) FormatLocaleFile(file," green: %.20g-bit\n",(double)
channel_statistics[GreenPixelChannel].depth);
(void) FormatLocaleFile(file," blue: %.20g-bit\n",(double)
channel_statistics[BluePixelChannel].depth);
break;
}
case CMYKColorspace:
{
(void) FormatLocaleFile(file," cyan: %.20g-bit\n",(double)
channel_statistics[CyanPixelChannel].depth);
(void) FormatLocaleFile(file," magenta: %.20g-bit\n",(double)
channel_statistics[MagentaPixelChannel].depth);
(void) FormatLocaleFile(file," yellow: %.20g-bit\n",(double)
channel_statistics[YellowPixelChannel].depth);
(void) FormatLocaleFile(file," black: %.20g-bit\n",(double)
channel_statistics[BlackPixelChannel].depth);
break;
}
case GRAYColorspace:
{
(void) FormatLocaleFile(file," gray: %.20g-bit\n",(double)
channel_statistics[GrayPixelChannel].depth);
break;
}
}
if (image->matte != MagickFalse)
(void) FormatLocaleFile(file," alpha: %.20g-bit\n",(double)
channel_statistics[AlphaPixelChannel].depth);
scale=1;
if (image->depth <= MAGICKCORE_QUANTUM_DEPTH)
scale=QuantumRange/((size_t) QuantumRange >> ((size_t)
MAGICKCORE_QUANTUM_DEPTH-image->depth));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% I d e n t i f y I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% IdentifyImage() identifies an image by printing its attributes to the file.
% Attributes include the image width, height, size, and others.
%
% The format of the IdentifyImage method is:
%
% MagickBooleanType IdentifyImage(Image *image,FILE *file,
% const MagickBooleanType verbose)
%
% A description of each parameter follows:
%
% o image: The image.
%
% o file: The file, typically stdout.
%
% o verbose: A value other than zero prints more detailed information
% about the image.
%
*/
MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
const MagickBooleanType verbose)
{
#define IdentifyFormat " %s:\n Min: " QuantumFormat \
" (%g)\n Max: " QuantumFormat " (%g)\n" \
" Mean: %g (%g)\n Standard deviation: %g (%g)\n"
char
color[MaxTextExtent],
format[MaxTextExtent],
key[MaxTextExtent];
ColorspaceType
colorspace;
const char
*property,
*value;
const MagickInfo
*magick_info;
const PixelPacket
*pixels;
double
elapsed_time,
user_time;
ExceptionInfo
*exception;
Image
*p;
ImageType
type;
long
y;
MagickBooleanType
ping;
register long
i,
x;
unsigned long
scale;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (file == (FILE *) NULL)
file=stdout;
*format='\0';
elapsed_time=GetElapsedTime(&image->timer);
user_time=GetUserTime(&image->timer);
GetTimerInfo(&image->timer);
if (verbose == MagickFalse)
{
/*
Display summary info about the image.
*/
if (*image->magick_filename != '\0')
if (LocaleCompare(image->magick_filename,image->filename) != 0)
(void) fprintf(file,"%s=>",image->magick_filename);
if ((GetPreviousImageInList(image) == (Image *) NULL) &&
(GetNextImageInList(image) == (Image *) NULL) && (image->scene == 0))
(void) fprintf(file,"%s ",image->filename);
else
(void) fprintf(file,"%s[%lu] ",image->filename,image->scene);
(void) fprintf(file,"%s ",image->magick);
if ((image->magick_columns != 0) || (image->magick_rows != 0))
if ((image->magick_columns != image->columns) ||
(image->magick_rows != image->rows))
(void) fprintf(file,"%lux%lu=>",image->magick_columns,
image->magick_rows);
(void) fprintf(file,"%lux%lu ",image->columns,image->rows);
if ((image->page.width != 0) || (image->page.height != 0) ||
(image->page.x != 0) || (image->page.y != 0))
(void) fprintf(file,"%lux%lu%+ld%+ld ",image->page.width,
image->page.height,image->page.x,image->page.y);
if (image->storage_class == DirectClass)
{
(void) fprintf(file,"DirectClass ");
if (image->total_colors != 0)
{
(void) FormatMagickSize(image->total_colors,format);
(void) fprintf(file,"%s ",format);
}
}
else
if (image->total_colors <= image->colors)
(void) fprintf(file,"PseudoClass %luc ",image->colors);
else
(void) fprintf(file,"PseudoClass %lu=>%luc ",image->total_colors,
image->colors);
(void) fprintf(file,"%lu-bit ",image->depth);
if (image->error.mean_error_per_pixel != 0.0)
(void) fprintf(file,"%ld/%f/%fdb ",
(long) (image->error.mean_error_per_pixel+0.5),
image->error.normalized_mean_error,
image->error.normalized_maximum_error);
if (GetBlobSize(image) != 0)
{
(void) FormatMagickSize(GetBlobSize(image),format);
(void) fprintf(file,"%s ",format);
}
if (elapsed_time > 0.06)
(void) fprintf(file,"%0.3fu %ld:%02ld",user_time,
(long) (elapsed_time/60.0+0.5),(long) ceil(fmod(elapsed_time,60.0)));
(void) fprintf(file,"\n");
(void) fflush(file);
return(ferror(file) != 0 ? MagickFalse : MagickTrue);
}
/*
Display verbose info about the image.
*/
exception=AcquireExceptionInfo();
pixels=AcquireImagePixels(image,0,0,1,1,exception);
exception=DestroyExceptionInfo(exception);
ping=pixels == (const PixelPacket *) NULL ? MagickTrue : MagickFalse;
type=GetImageType(image,&image->exception);
(void) SignatureImage(image);
(void) fprintf(file,"Image: %s\n",image->filename);
if (*image->magick_filename != '\0')
if (LocaleCompare(image->magick_filename,image->filename) != 0)
{
char
filename[MaxTextExtent];
GetPathComponent(image->magick_filename,TailPath,filename);
(void) fprintf(file," Base filename: %s\n",filename);
}
magick_info=GetMagickInfo(image->magick,&image->exception);
if ((magick_info == (const MagickInfo *) NULL) ||
(*GetMagickDescription(magick_info) == '\0'))
(void) fprintf(file," Format: %s\n",image->magick);
else
(void) fprintf(file," Format: %s (%s)\n",image->magick,
GetMagickDescription(magick_info));
(void) fprintf(file," Class: %s\n",
MagickOptionToMnemonic(MagickClassOptions,(long) image->storage_class));
(void) fprintf(file," Geometry: %lux%lu%+ld%+ld\n",image->columns,
image->rows,image->tile_offset.x,image->tile_offset.y);
if ((image->magick_columns != 0) || (image->magick_rows != 0))
if ((image->magick_columns != image->columns) ||
(image->magick_rows != image->rows))
(void) fprintf(file," Base geometry: %lux%lu\n",image->magick_columns,
image->magick_rows);
(void) fprintf(file," Type: %s\n",MagickOptionToMnemonic(MagickTypeOptions,
(long) type));
(void) fprintf(file," Endianess: %s\n",MagickOptionToMnemonic(
MagickEndianOptions,(long) image->endian));
/*
Detail channel depth and extrema.
*/
colorspace=image->colorspace;
if (IsGrayImage(image,&image->exception) != MagickFalse)
colorspace=GRAYColorspace;
(void) fprintf(file," Colorspace: %s\n",
MagickOptionToMnemonic(MagickColorspaceOptions,(long) colorspace));
if (ping == MagickFalse)
{
ChannelStatistics
*channel_statistics;
(void) fprintf(file," Depth: %lu-bit\n",GetImageDepth(image,
&image->exception));
channel_statistics=GetImageChannelStatistics(image,&image->exception);
(void) fprintf(file," Channel depth:\n");
switch (colorspace)
{
case RGBColorspace:
default:
{
(void) fprintf(file," Red: %lu-bit\n",
channel_statistics[RedChannel].depth);
(void) fprintf(file," Green: %lu-bit\n",
channel_statistics[GreenChannel].depth);
(void) fprintf(file," Blue: %lu-bit\n",
channel_statistics[BlueChannel].depth);
if (image->matte != MagickFalse)
(void) fprintf(file," Alpha: %lu-bit\n",
channel_statistics[OpacityChannel].depth);
break;
}
case CMYKColorspace:
{
(void) fprintf(file," Cyan: %lu-bit\n",
channel_statistics[CyanChannel].depth);
(void) fprintf(file," Magenta: %lu-bit\n",
channel_statistics[MagentaChannel].depth);
(void) fprintf(file," Yellow: %lu-bit\n",
channel_statistics[YellowChannel].depth);
(void) fprintf(file," Black: %lu-bit\n",
channel_statistics[BlackChannel].depth);
if (image->matte != MagickFalse)
(void) fprintf(file," Alpha: %lu-bit\n",
channel_statistics[OpacityChannel].depth);
break;
}
case GRAYColorspace:
{
(void) fprintf(file," Gray: %lu-bit\n",
channel_statistics[GrayChannel].depth);
if (image->matte != MagickFalse)
(void) fprintf(file," Alpha: %lu-bit\n",
channel_statistics[OpacityChannel].depth);
break;
}
}
scale=QuantumRange/((unsigned long) QuantumRange >> ((unsigned long)
MAGICKCORE_QUANTUM_DEPTH-channel_statistics[AllChannels].depth));
(void) fprintf(file," Channel statistics:\n");
switch (colorspace)
{
case RGBColorspace:
default:
{
(void) fprintf(file,IdentifyFormat,"Red",(Quantum)
(channel_statistics[RedChannel].minima/scale),(double)
channel_statistics[RedChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[RedChannel].maxima/scale),(double)
channel_statistics[RedChannel].maxima/(double) QuantumRange,
channel_statistics[RedChannel].mean/(double) scale,
channel_statistics[RedChannel].mean/(double) QuantumRange,
channel_statistics[RedChannel].standard_deviation/(double) scale,
channel_statistics[RedChannel].standard_deviation/(double)
QuantumRange);
(void) fprintf(file,IdentifyFormat,"Green",(Quantum)
(channel_statistics[GreenChannel].minima/scale),(double)
channel_statistics[GreenChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[GreenChannel].maxima/scale),(double)
channel_statistics[GreenChannel].maxima/(double) QuantumRange,
channel_statistics[GreenChannel].mean/(double) scale,
channel_statistics[GreenChannel].mean/(double) QuantumRange,
channel_statistics[GreenChannel].standard_deviation/(double) scale,
channel_statistics[GreenChannel].standard_deviation/(double)
QuantumRange);
(void) fprintf(file,IdentifyFormat,"Blue",(Quantum)
(channel_statistics[BlueChannel].minima/scale),(double)
channel_statistics[BlueChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[BlueChannel].maxima/scale),(double)
channel_statistics[BlueChannel].maxima/(double) QuantumRange,
channel_statistics[BlueChannel].mean/(double) scale,
channel_statistics[BlueChannel].mean/(double) QuantumRange,
channel_statistics[BlueChannel].standard_deviation/(double) scale,
channel_statistics[BlueChannel].standard_deviation/(double)
QuantumRange);
break;
}
case CMYKColorspace:
{
(void) fprintf(file,IdentifyFormat,"Cyan",(Quantum)
(channel_statistics[CyanChannel].minima/scale),(double)
channel_statistics[CyanChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[CyanChannel].maxima/scale),(double)
channel_statistics[CyanChannel].maxima/(double) QuantumRange,
channel_statistics[CyanChannel].mean/(double) scale,
channel_statistics[CyanChannel].mean/(double) QuantumRange,
channel_statistics[CyanChannel].standard_deviation/(double) scale,
channel_statistics[CyanChannel].standard_deviation/(double)
QuantumRange);
(void) fprintf(file,IdentifyFormat,"Magenta",(Quantum)
(channel_statistics[MagentaChannel].minima/scale),(double)
channel_statistics[MagentaChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[MagentaChannel].maxima/scale),(double)
channel_statistics[MagentaChannel].maxima/(double) QuantumRange,
channel_statistics[MagentaChannel].mean/(double) scale,
channel_statistics[MagentaChannel].mean/(double) QuantumRange,
channel_statistics[MagentaChannel].standard_deviation/(double)
scale,channel_statistics[MagentaChannel].standard_deviation/(double)
QuantumRange);
(void) fprintf(file,IdentifyFormat,"Yellow",(Quantum)
(channel_statistics[YellowChannel].minima/scale),(double)
channel_statistics[YellowChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[YellowChannel].maxima/scale),(double)
channel_statistics[YellowChannel].maxima/(double) QuantumRange,
channel_statistics[YellowChannel].mean/(double) scale,
channel_statistics[YellowChannel].mean/(double) QuantumRange,
channel_statistics[YellowChannel].standard_deviation/(double) scale,
channel_statistics[YellowChannel].standard_deviation/(double)
QuantumRange);
(void) fprintf(file,IdentifyFormat,"Black",(Quantum)
(channel_statistics[BlackChannel].minima/scale),(double)
channel_statistics[BlackChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[BlackChannel].maxima/scale),(double)
channel_statistics[BlackChannel].maxima/(double) QuantumRange,
channel_statistics[BlackChannel].mean/(double) scale,
channel_statistics[BlackChannel].mean/(double) QuantumRange,
channel_statistics[BlackChannel].standard_deviation/(double) scale,
channel_statistics[BlackChannel].standard_deviation/(double)
QuantumRange);
break;
}
case GRAYColorspace:
{
(void) fprintf(file,IdentifyFormat,"Gray",(Quantum)
(channel_statistics[GrayChannel].minima/scale),(double)
channel_statistics[GrayChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[GrayChannel].maxima/scale),(double)
channel_statistics[GrayChannel].maxima/(double) QuantumRange,
channel_statistics[GrayChannel].mean/(double) scale,
channel_statistics[GrayChannel].mean/(double) QuantumRange,
channel_statistics[GrayChannel].standard_deviation/(double) scale,
channel_statistics[GrayChannel].standard_deviation/(double)
QuantumRange);
break;
}
}
if (image->matte != MagickFalse)
(void) fprintf(file,IdentifyFormat,"Opacity",(Quantum)
(channel_statistics[OpacityChannel].minima/scale),(double)
channel_statistics[OpacityChannel].minima/(double) QuantumRange,
(Quantum) (channel_statistics[OpacityChannel].maxima/scale),(double)
channel_statistics[OpacityChannel].maxima/(double) QuantumRange,
channel_statistics[OpacityChannel].mean/(double) scale,
channel_statistics[OpacityChannel].mean/(double) QuantumRange,
channel_statistics[OpacityChannel].standard_deviation/(double) scale,
channel_statistics[OpacityChannel].standard_deviation/(double)
QuantumRange);
channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
channel_statistics);
if (colorspace == CMYKColorspace)
(void) fprintf(file," Total ink density: %.0f%%\n",100.0*
GetImageTotalInkDensity(image)/(double) QuantumRange);
x=0;
p=NewImageList();
if (image->matte != MagickFalse)
{
register const IndexPacket
*indexes;
register const PixelPacket
*p;
p=(PixelPacket *) NULL;
indexes=(IndexPacket *) NULL;
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=AcquireIndexes(image);
for (x=0; x < (long) image->columns; x++)
{
if (p->opacity == (Quantum) TransparentOpacity)
break;
p++;
}
if (x < (long) image->columns)
break;
}
if ((x < (long) image->columns) || (y < (long) image->rows))
{
char
tuple[MaxTextExtent];
MagickPixelPacket
pixel;
GetMagickPixelPacket(image,&pixel);
SetMagickPixelPacket(image,p,indexes+x,&pixel);
(void) QueryMagickColorname(image,&pixel,SVGCompliance,
MagickFalse,tuple,&image->exception);
(void) fprintf(file," Alpha: %s ",tuple);
(void) QueryMagickColorname(image,&pixel,SVGCompliance,MagickTrue,
tuple,&image->exception);
(void) fprintf(file," %s\n",tuple);
}
}
if ((ping == MagickFalse) &&
(IsHistogramImage(image,&image->exception) != MagickFalse))
{
(void) fprintf(file," Histogram:\n");
(void) GetNumberColors(image,file,&image->exception);
}
}
