/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% L i s t T y p e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ListTypeInfo() lists the fonts to a file.
%
% The format of the ListTypeInfo method is:
%
% MagickBooleanType ListTypeInfo(FILE *file,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% o file: An pointer to a FILE.
%
% o exception: Return any errors or warnings in this structure.
%
*/
MagickExport MagickBooleanType ListTypeInfo(FILE *file,ExceptionInfo *exception)
{
char
weight[MaxTextExtent];
const char
*family,
*name,
*path,
*stretch,
*style;
const TypeInfo
**type_info;
register long
i;
unsigned long
number_fonts;
if (file == (FILE *) NULL)
file=stdout;
number_fonts=0;
type_info=GetTypeInfoList("*",&number_fonts,exception);
if (type_info == (const TypeInfo **) NULL)
return(MagickFalse);
*weight='\0';
path=(const char *) NULL;
for (i=0; i < (long) number_fonts; i++)
{
if (type_info[i]->stealth != MagickFalse)
continue;
if ((path == (const char *) NULL) ||
(LocaleCompare(path,type_info[i]->path) != 0))
{
if (type_info[i]->path != (char *) NULL)
(void) fprintf(file,"\nPath: %s\n\n",type_info[i]->path);
(void) fprintf(file,"%-32.32s %-22.22s %-7.7s %-8.8s %-3s\n",
"Name","Family","Style","Stretch","Weight");
(void) fprintf(file,"--------------------------------------------------"
"------------------------------\n");
}
path=type_info[i]->path;
name="unknown";
if (type_info[i]->name != (char *) NULL)
name=type_info[i]->name;
family="unknown";
if (type_info[i]->family != (char *) NULL)
family=type_info[i]->family;
style=MagickOptionToMnemonic(MagickStyleOptions,type_info[i]->style);
stretch=MagickOptionToMnemonic(MagickStretchOptions,type_info[i]->stretch);
(void) FormatMagickString(weight,MaxTextExtent,"%lu",type_info[i]->weight);
(void) fprintf(file,"%-32.32s %-22.22s %-7.7s %-9.9s %6s\n",name,family,
style,stretch,weight);
}
(void) fflush(file);
type_info=(const TypeInfo **) RelinquishMagickMemory((void *) type_info);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e l i n q u i s h M a g i c k R e s o u r c e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% RelinquishMagickResource() relinquishes resources of the specified type.
%
% The format of the RelinquishMagickResource() method is:
%
% void RelinquishMagickResource(const ResourceType type,
% const MagickSizeType size)
%
% A description of each parameter follows:
%
% o type: The type of resource.
%
% o size: The size of the resource.
%
%
*/
MagickExport void RelinquishMagickResource(const ResourceType type,
const MagickSizeType size)
{
char
resource_current[MaxTextExtent],
resource_limit[MaxTextExtent],
resource_request[MaxTextExtent];
FormatSize(size,resource_request);
AcquireSemaphoreInfo(&resource_semaphore);
switch (type)
{
case AreaResource:
{
resource_info.area=size;
FormatSize((MagickSizeType) resource_info.area,resource_current);
FormatSize(MegabytesToBytes(resource_info.area_limit),resource_limit);
break;
}
case MemoryResource:
{
resource_info.memory-=size;
FormatSize((MagickSizeType) resource_info.memory,resource_current);
FormatSize(MegabytesToBytes(resource_info.memory_limit),resource_limit);
break;
}
case MapResource:
{
resource_info.map-=size;
FormatSize((MagickSizeType) resource_info.map,resource_current);
FormatSize(MegabytesToBytes(resource_info.map_limit),resource_limit);
break;
}
case DiskResource:
{
resource_info.disk-=size;
FormatSize((MagickSizeType) resource_info.disk,resource_current);
FormatSize(GigabytesToBytes(resource_info.disk_limit),resource_limit);
break;
}
case FileResource:
{
resource_info.file-=size;
FormatSize((MagickSizeType) resource_info.file,resource_current);
FormatSize((MagickSizeType) resource_info.file_limit,resource_limit);
break;
}
default:
break;
}
RelinquishSemaphoreInfo(resource_semaphore);
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s",
MagickOptionToMnemonic(MagickResourceOptions,(long) type),resource_request,
resource_current,resource_limit);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% L i s t T y p e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ListTypeInfo() lists the fonts to a file.
%
% The format of the ListTypeInfo method is:
%
% MagickBooleanType ListTypeInfo(FILE *file,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% o file: An pointer to a FILE.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport MagickBooleanType ListTypeInfo(FILE *file,ExceptionInfo *exception)
{
char
weight[MaxTextExtent];
const char
*family,
*glyphs,
*name,
*path,
*stretch,
*style;
const TypeInfo
**type_info;
register ssize_t
i;
size_t
number_fonts;
if (file == (FILE *) NULL)
file=stdout;
number_fonts=0;
type_info=GetTypeInfoList("*",&number_fonts,exception);
if (type_info == (const TypeInfo **) NULL)
return(MagickFalse);
*weight='\0';
path=(const char *) NULL;
for (i=0; i < (ssize_t) number_fonts; i++)
{
if (type_info[i]->stealth != MagickFalse)
continue;
if (((path == (const char *) NULL) ||
(LocaleCompare(path,type_info[i]->path) != 0)) &&
(type_info[i]->path != (char *) NULL))
(void) fprintf(file,"\nPath: %s\n",type_info[i]->path);
path=type_info[i]->path;
name="unknown";
if (type_info[i]->name != (char *) NULL)
name=type_info[i]->name;
family="unknown";
if (type_info[i]->family != (char *) NULL)
family=type_info[i]->family;
style=MagickOptionToMnemonic(MagickStyleOptions,type_info[i]->style);
stretch=MagickOptionToMnemonic(MagickStretchOptions,type_info[i]->stretch);
glyphs="unknown";
if (type_info[i]->glyphs != (char *) NULL)
glyphs=type_info[i]->glyphs;
(void) FormatMagickString(weight,MaxTextExtent,"%.20g",(double)
type_info[i]->weight);
(void) fprintf(file," Font: %s\n",name);
(void) fprintf(file," family: %s\n",family);
(void) fprintf(file," style: %s\n",style);
(void) fprintf(file," stretch: %s\n",stretch);
(void) fprintf(file," weight: %s\n",weight);
(void) fprintf(file," glyphs: %s\n",glyphs);
}
(void) fflush(file);
type_info=(const TypeInfo **) RelinquishMagickMemory((void *) type_info);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% V a l i d a t e I m p o r t E x p o r t P i x e l s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ValidateImportExportPixels() validates the pixel import and export methods.
% It returns the number of validation tests that passed and failed.
%
% The format of the ValidateImportExportPixels method is:
%
% unsigned long ValidateImportExportPixels(ImageInfo *image_info,
% const char *reference_filename,const char *output_filename,
% unsigned long *fail,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o reference_filename: the reference image filename.
%
% o output_filename: the output image filename.
%
% o fail: return the number of validation tests that pass.
%
% o exception: return any errors or warnings in this structure.
%
*/
static unsigned long ValidateImportExportPixels(ImageInfo *image_info,
const char *reference_filename,const char *output_filename,
unsigned long *fail,ExceptionInfo *exception)
{
double
distortion;
Image
*difference_image,
*reference_image,
*reconstruct_image;
MagickBooleanType
status;
register long
i,
j;
size_t
length;
unsigned char
*pixels;
unsigned long
test;
(void) output_filename;
test=0;
(void) fprintf(stdout,"validate the import and export of image pixels:\n");
for (i=0; reference_map[i] != (char *) NULL; i++)
{
for (j=0; reference_storage[j].type != UndefinedPixel; j++)
{
/*
Generate reference image.
*/
CatchException(exception);
(void) fprintf(stdout," test %lu: %s/%s",test++,
reference_map[i],MagickOptionToMnemonic(MagickStorageOptions,
reference_storage[j].type));
(void) CopyMagickString(image_info->filename,reference_filename,
MaxTextExtent);
reference_image=ReadImage(image_info,exception);
if (reference_image == (Image *) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
if (LocaleNCompare(reference_map[i],"cmy",3) == 0)
(void) TransformImageColorspace(reference_image,CMYKColorspace);
length=strlen(reference_map[i])*reference_image->columns*
reference_image->rows*reference_storage[j].quantum;
pixels=(unsigned char *) AcquireQuantumMemory(length,sizeof(*pixels));
if (pixels == (unsigned char *) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
reference_image=DestroyImage(reference_image);
continue;
}
(void) ResetMagickMemory(pixels,0,length*sizeof(*pixels));
status=ExportImagePixels(reference_image,0,0,reference_image->columns,
reference_image->rows,reference_map[i],reference_storage[j].type,pixels,
exception);
if (status == MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
reference_image=DestroyImage(reference_image);
continue;
}
(void) SetImageBackgroundColor(reference_image);
status=ImportImagePixels(reference_image,0,0,reference_image->columns,
reference_image->rows,reference_map[i],reference_storage[j].type,
pixels);
InheritException(exception,&reference_image->exception);
if (status == MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
reference_image=DestroyImage(reference_image);
continue;
}
/*
Read reconstruct image.
*/
reconstruct_image=AcquireImage(image_info);
(void) SetImageColorspace(reconstruct_image,reference_image->colorspace);
(void) SetImageExtent(reconstruct_image,reference_image->columns,
reference_image->rows);
(void) SetImageBackgroundColor(reconstruct_image);
status=ImportImagePixels(reconstruct_image,0,0,reconstruct_image->columns,
reconstruct_image->rows,reference_map[i],reference_storage[j].type,
pixels);
InheritException(exception,&reconstruct_image->exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
reference_image=DestroyImage(reference_image);
continue;
}
/*
Compare reference to reconstruct image.
*/
difference_image=CompareImageChannels(reference_image,reconstruct_image,
AllChannels,MeanSquaredErrorMetric,&distortion,exception);
reconstruct_image=DestroyImage(reconstruct_image);
reference_image=DestroyImage(reference_image);
if (difference_image == (Image *) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
difference_image=DestroyImage(difference_image);
if ((distortion/QuantumRange) > 0.0)
{
(void) fprintf(stdout,"... fail (with distortion %g).\n",distortion/
QuantumRange);
(*fail)++;
continue;
}
(void) fprintf(stdout,"... pass.\n");
}
}
(void) fprintf(stdout," summary: %lu subtests; %lu passed; %lu failed.\n",
test,test-(*fail),*fail);
return(test);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% V a l i d a t e I m a g e F o r m a t s O n D i s k %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ValidateImageFormatsOnDisk() validates the ImageMagick image formats on disk
% and returns the number of validation tests that passed and failed.
%
% The format of the ValidateImageFormatsOnDisk method is:
%
% unsigned long ValidateImageFormatsOnDisk(ImageInfo *image_info,
% const char *reference_filename,const char *output_filename,
% unsigned long *fail,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o reference_filename: the reference image filename.
%
% o output_filename: the output image filename.
%
% o fail: return the number of validation tests that pass.
%
% o exception: return any errors or warnings in this structure.
%
*/
static unsigned long ValidateImageFormatsOnDisk(ImageInfo *image_info,
const char *reference_filename,const char *output_filename,
unsigned long *fail,ExceptionInfo *exception)
{
char
size[MaxTextExtent];
const MagickInfo
*magick_info;
double
distortion,
fuzz;
Image
*difference_image,
*reference_image,
*reconstruct_image;
MagickBooleanType
status;
register long
i,
j;
unsigned long
test;
test=0;
(void) fprintf(stdout,"validate image formats on disk:\n");
for (i=0; reference_formats[i].magick != (char *) NULL; i++)
{
magick_info=GetMagickInfo(reference_formats[i].magick,exception);
if ((magick_info == (const MagickInfo *) NULL) ||
(magick_info->decoder == (DecodeImageHandler *) NULL) ||
(magick_info->encoder == (EncodeImageHandler *) NULL))
continue;
for (j=0; reference_types[j].type != UndefinedType; j++)
{
/*
Generate reference image.
*/
CatchException(exception);
(void) fprintf(stdout," test %lu: %s/%s/%lu-bits",test++,
reference_formats[i].magick,MagickOptionToMnemonic(MagickTypeOptions,
reference_types[j].type),reference_types[j].depth);
(void) CopyMagickString(image_info->filename,reference_filename,
MaxTextExtent);
reference_image=ReadImage(image_info,exception);
if (reference_image == (Image *) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
/*
Write reference image.
*/
(void) FormatMagickString(size,MaxTextExtent,"%lux%lu",
reference_image->columns,reference_image->rows);
(void) CloneString(&image_info->size,size);
image_info->depth=reference_types[j].depth;
(void) FormatMagickString(reference_image->filename,MaxTextExtent,"%s:%s",
reference_formats[i].magick,output_filename);
status=SetImageType(reference_image,reference_types[j].type);
InheritException(exception,&reference_image->exception);
if (status == MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
reference_image=DestroyImage(reference_image);
continue;
}
status=SetImageDepth(reference_image,reference_types[j].depth);
InheritException(exception,&reference_image->exception);
if (status == MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
reference_image=DestroyImage(reference_image);
continue;
}
status=WriteImage(image_info,reference_image);
InheritException(exception,&reference_image->exception);
reference_image=DestroyImage(reference_image);
if (status == MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
/*
Read reference image.
*/
(void) FormatMagickString(image_info->filename,MaxTextExtent,"%s:%s",
reference_formats[i].magick,output_filename);
reference_image=ReadImage(image_info,exception);
if (reference_image == (Image *) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
/*
Write reference image.
*/
(void) FormatMagickString(reference_image->filename,MaxTextExtent,"%s:%s",
reference_formats[i].magick,output_filename);
reference_image->depth=reference_types[j].depth;
status=WriteImage(image_info,reference_image);
InheritException(exception,&reference_image->exception);
if (status == MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
reference_image=DestroyImage(reference_image);
continue;
}
/*
Read reconstruct image.
*/
(void) FormatMagickString(image_info->filename,MaxTextExtent,"%s:%s",
reference_formats[i].magick,output_filename);
reconstruct_image=ReadImage(image_info,exception);
if (reconstruct_image == (Image *) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
reference_image=DestroyImage(reference_image);
continue;
}
/*
Compare reference to reconstruct image.
*/
fuzz=0.0;
if (reference_formats[i].fuzz != 0.0)
fuzz=reference_formats[i].fuzz;
#if defined(MAGICKCORE_HDRI_SUPPORT)
fuzz+=0.003;
#endif
if (reference_image->colorspace != RGBColorspace)
fuzz+=0.3;
fuzz+=MagickEpsilon;
difference_image=CompareImageChannels(reference_image,reconstruct_image,
AllChannels,MeanSquaredErrorMetric,&distortion,exception);
reconstruct_image=DestroyImage(reconstruct_image);
reference_image=DestroyImage(reference_image);
if (difference_image == (Image *) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
difference_image=DestroyImage(difference_image);
if ((distortion/QuantumRange) > fuzz)
{
(void) fprintf(stdout,"... fail (with distortion %g).\n",distortion/
QuantumRange);
(*fail)++;
continue;
}
(void) fprintf(stdout,"... pass.\n");
}
}
(void) fprintf(stdout," summary: %lu subtests; %lu passed; %lu failed.\n",
test,test-(*fail),*fail);
return(test);
}
int main(int argc,char **argv)
{
#define DestroyValidate() \
{ \
timer=DestroyTimerInfo(timer); \
image_info=DestroyImageInfo(image_info); \
exception=DestroyExceptionInfo(exception); \
}
#define ThrowValidateException(asperity,tag,option) \
{ \
(void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
option); \
CatchException(exception); \
DestroyValidate(); \
return(MagickFalse); \
}
char
output_filename[MaxTextExtent],
reference_filename[MaxTextExtent],
*option;
double
elapsed_time,
user_time;
ExceptionInfo
*exception;
Image
*reference_image;
ImageInfo
*image_info;
MagickBooleanType
regard_warnings,
status;
register long
i;
TimerInfo
*timer;
unsigned long
fail,
iterations,
tests;
ValidateType
type;
/*
Validate the ImageMagick image processing suite.
*/
MagickCoreGenesis(*argv,MagickFalse);
iterations=1;
status=MagickFalse;
type=AllValidate;
regard_warnings=MagickFalse;
exception=AcquireExceptionInfo();
image_info=AcquireImageInfo();
(void) CopyMagickString(image_info->filename,ReferenceFilename,MaxTextExtent);
timer=AcquireTimerInfo();
GetTimerInfo(timer);
for (i=1; i < (long) argc; i++)
{
option=argv[i];
if (IsMagickOption(option) == MagickFalse)
{
(void) CopyMagickString(image_info->filename,option,MaxTextExtent);
continue;
}
switch (*(option+1))
{
case 'b':
{
if (LocaleCompare("bench",option+1) == 0)
{
iterations=(unsigned long) atol(argv[++i]);
break;
}
ThrowValidateException(OptionError,"UnrecognizedOption",option)
}
case 'd':
{
if (LocaleCompare("debug",option+1) == 0)
{
(void) SetLogEventMask(argv[++i]);
break;
}
ThrowValidateException(OptionError,"UnrecognizedOption",option)
}
case 'h':
{
if (LocaleCompare("help",option+1) == 0)
{
(void) ValidateUsage();
return(0);
}
ThrowValidateException(OptionError,"UnrecognizedOption",option)
}
case 'l':
{
if (LocaleCompare("log",option+1) == 0)
{
if (*option != '+')
(void) SetLogFormat(argv[i+1]);
break;
}
ThrowValidateException(OptionError,"UnrecognizedOption",option)
}
case 'r':
{
if (LocaleCompare("regard-warnings",option+1) == 0)
{
regard_warnings=MagickTrue;
break;
}
ThrowValidateException(OptionError,"UnrecognizedOption",option)
}
case 'v':
{
if (LocaleCompare("validate",option+1) == 0)
{
long
validate;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowValidateException(OptionError,"MissingArgument",option);
validate=ParseMagickOption(MagickValidateOptions,MagickFalse,
argv[i]);
if (validate < 0)
ThrowValidateException(OptionError,"UnrecognizedValidateType",
argv[i]);
type=(ValidateType) validate;
break;
}
if ((LocaleCompare("version",option+1) == 0) ||
(LocaleCompare("-version",option+1) == 0))
{
(void) fprintf(stdout,"Version: %s\n",
GetMagickVersion((unsigned long *) NULL));
(void) fprintf(stdout,"Copyright: %s\n\n",GetMagickCopyright());
return(0);
}
ThrowValidateException(OptionError,"UnrecognizedOption",option)
}
default:
ThrowValidateException(OptionError,"UnrecognizedOption",option)
}
}
reference_image=ReadImage(image_info,exception);
tests=0;
fail=0;
if (reference_image == (Image *) NULL)
fail++;
else
{
if (LocaleCompare(image_info->filename,ReferenceFilename) == 0)
(void) CopyMagickString(reference_image->magick,ReferenceImageFormat,
MaxTextExtent);
(void) AcquireUniqueFilename(reference_filename);
(void) AcquireUniqueFilename(output_filename);
(void) CopyMagickString(reference_image->filename,reference_filename,
MaxTextExtent);
status=WriteImage(image_info,reference_image);
InheritException(exception,&reference_image->exception);
reference_image=DestroyImage(reference_image);
if (status == MagickFalse)
fail++;
else
{
(void) fprintf(stdout,"Version: %s\n",
GetMagickVersion((unsigned long *) NULL));
(void) fprintf(stdout,"Copyright: %s\n\n",
GetMagickCopyright());
(void) fprintf(stdout,"ImageMagick Validation Suite (%s)\n\n",
MagickOptionToMnemonic(MagickValidateOptions,(long) type));
if ((type & CompareValidate) != 0)
tests+=ValidateCompareCommand(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & CompositeValidate) != 0)
tests+=ValidateCompositeCommand(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & ConvertValidate) != 0)
tests+=ValidateConvertCommand(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & FormatsInMemoryValidate) != 0)
tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & FormatsOnDiskValidate) != 0)
tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & IdentifyValidate) != 0)
tests+=ValidateIdentifyCommand(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & ImportExportValidate) != 0)
tests+=ValidateImportExportPixels(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & MontageValidate) != 0)
tests+=ValidateMontageCommand(image_info,reference_filename,
output_filename,&fail,exception);
if ((type & StreamValidate) != 0)
tests+=ValidateStreamCommand(image_info,reference_filename,
output_filename,&fail,exception);
(void) fprintf(stdout,"validation suite: %lu tests; %lu passed; "
"%lu failed.\n",tests,tests-fail,fail);
}
(void) RelinquishUniqueFileResource(output_filename);
(void) RelinquishUniqueFileResource(reference_filename);
}
if (exception->severity != UndefinedException)
CatchException(exception);
if (iterations > 1)
{
elapsed_time=GetElapsedTime(timer);
user_time=GetUserTime(timer);
(void) fprintf(stderr,"Performance: %lui %gips %0.3fu %ld:%02ld\n",
iterations,1.0*iterations/elapsed_time,user_time,(long)
(elapsed_time/60.0+0.5),(long) ceil(fmod(elapsed_time,60.0)));
}
DestroyValidate();
MagickCoreTerminus();
return(fail == 0 ? 0 : 1);
}
MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
const MagickBooleanType verbose)
{
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;
const PixelPacket
*pixels;
double
elapsed_time,
user_time;
ExceptionInfo
*exception;
ImageType
type;
ssize_t
y;
MagickBooleanType
ping;
register ssize_t
i,
x;
size_t
distance,
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[%.20g] ",image->filename,(double) 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,"%.20gx%.20g=>",(double) image->magick_columns,
(double) image->magick_rows);
(void) fprintf(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) fprintf(file,"%.20gx%.20g%+.20g%+.20g ",(double)
image->page.width,(double) image->page.height,(double) image->page.x,
(double) image->page.y);
(void) fprintf(file,"%.20g-bit ",(double) image->depth);
if (image->type != UndefinedType)
(void) fprintf(file,"%s ",MagickOptionToMnemonic(MagickTypeOptions,
(ssize_t) image->type));
if (image->storage_class == DirectClass)
{
(void) fprintf(file,"DirectClass ");
if (image->total_colors != 0)
{
(void) FormatMagickSize(image->total_colors,MagickFalse,format);
(void) fprintf(file,"%s ",format);
}
}
else if (image->total_colors <= image->colors)
(void) fprintf(file,"PseudoClass %.20gc ",(double) image->colors);
else
(void) fprintf(file,"PseudoClass %.20g=>%.20gc ",(double)
image->total_colors,(double) image->colors);
if (image->error.mean_error_per_pixel != 0.0)
(void) fprintf(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) fprintf(file,"%sB ",format);
}
(void) fprintf(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) fprintf(file,"\n");
(void) fflush(file);
return(ferror(file) != 0 ? MagickFalse : MagickTrue);
}
/*
Display verbose info about the image.
*/
exception=AcquireExceptionInfo();
pixels=GetVirtualPixels(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,
(ssize_t) image->storage_class));
(void) fprintf(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) fprintf(file," Base geometry: %.20gx%.20g\n",(double)
image->magick_columns,(double) image->magick_rows);
if ((image->x_resolution != 0.0) && (image->y_resolution != 0.0))
{
(void) fprintf(file," Resolution: %gx%g\n",image->x_resolution,
image->y_resolution);
(void) fprintf(file," Print size: %gx%g\n",(double) image->columns/
image->x_resolution,(double) image->rows/image->y_resolution);
}
(void) fprintf(file," Units: %s\n",MagickOptionToMnemonic(
MagickResolutionOptions,(ssize_t) image->units));
(void) fprintf(file," Type: %s\n",MagickOptionToMnemonic(MagickTypeOptions,
(ssize_t) type));
if (image->type != UndefinedType)
(void) fprintf(file," Base type: %s\n",MagickOptionToMnemonic(
MagickTypeOptions,(ssize_t) image->type));
(void) fprintf(file," Endianess: %s\n",MagickOptionToMnemonic(
MagickEndianOptions,(ssize_t) image->endian));
/*
Detail channel depth and extrema.
*/
(void) fprintf(file," Colorspace: %s\n",MagickOptionToMnemonic(
MagickColorspaceOptions,(ssize_t) image->colorspace));
channel_statistics=(ChannelStatistics *) NULL;
channel_features=(ChannelFeatures *) NULL;
colorspace=image->colorspace;
if (ping == MagickFalse)
{
size_t
depth;
channel_statistics=GetImageChannelStatistics(image,&image->exception);
artifact=GetImageArtifact(image,"identify:features");
if (artifact != (const char *) NULL)
{
distance=StringToUnsignedLong(artifact);
channel_features=GetImageChannelFeatures(image,distance,
&image->exception);
}
depth=GetImageDepth(image,&image->exception);
if (image->depth == depth)
(void) fprintf(file," Depth: %.20g-bit\n",(double) image->depth);
else
(void) fprintf(file," Depth: %.20g/%.20g-bit\n",(double)
image->depth,(double) depth);
(void) fprintf(file," Channel depth:\n");
if (IsGrayImage(image,&image->exception) != MagickFalse)
colorspace=GRAYColorspace;
switch (colorspace)
{
case RGBColorspace:
default:
{
(void) fprintf(file," red: %.20g-bit\n",(double)
channel_statistics[RedChannel].depth);
(void) fprintf(file," green: %.20g-bit\n",(double)
channel_statistics[GreenChannel].depth);
(void) fprintf(file," blue: %.20g-bit\n",(double)
channel_statistics[BlueChannel].depth);
break;
}
case CMYKColorspace:
{
(void) fprintf(file," cyan: %.20g-bit\n",(double)
channel_statistics[CyanChannel].depth);
(void) fprintf(file," magenta: %.20g-bit\n",(double)
channel_statistics[MagentaChannel].depth);
(void) fprintf(file," yellow: %.20g-bit\n",(double)
channel_statistics[YellowChannel].depth);
(void) fprintf(file," black: %.20g-bit\n",(double)
channel_statistics[BlackChannel].depth);
break;
}
case GRAYColorspace:
{
(void) fprintf(file," gray: %.20g-bit\n",(double)
channel_statistics[GrayChannel].depth);
break;
}
}
if (image->matte != MagickFalse)
(void) fprintf(file," alpha: %.20g-bit\n",(double)
channel_statistics[OpacityChannel].depth);
scale=1;
if (image->depth <= MAGICKCORE_QUANTUM_DEPTH)
scale=QuantumRange/((size_t) QuantumRange >> ((size_t)
MAGICKCORE_QUANTUM_DEPTH-image->depth));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% A c q u i r e M a g i c k R e s o u r c e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% AcquireMagickResource() acquires resources of the specified type.
% MagickFalse is returned if the specified resource is exhausted otherwise
% MagickTrue.
%
% The format of the AcquireMagickResource() method is:
%
% MagickBooleanType AcquireMagickResource(const ResourceType type,
% const MagickSizeType size)
%
% A description of each parameter follows:
%
% o type: the type of resource.
%
% o size: the number of bytes needed from for this resource.
%
*/
MagickExport MagickBooleanType AcquireMagickResource(const ResourceType type,
const MagickSizeType size)
{
char
resource_current[MaxTextExtent],
resource_limit[MaxTextExtent],
resource_request[MaxTextExtent];
MagickBooleanType
status;
MagickSizeType
limit;
status=MagickFalse;
(void) FormatMagickSize(size,resource_request);
AcquireSemaphoreInfo(&resource_semaphore);
switch (type)
{
case AreaResource:
{
resource_info.area=(MagickOffsetType) size;
limit=resource_info.area_limit;
status=(resource_info.area_limit == MagickResourceInfinity) ||
(size < limit) ? MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.area,
resource_current);
(void) FormatMagickSize(resource_info.area_limit,resource_limit);
break;
}
case MemoryResource:
{
resource_info.memory+=size;
limit=resource_info.memory_limit;
status=(resource_info.memory_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.memory < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.memory,
resource_current);
(void) FormatMagickSize(resource_info.memory_limit,
resource_limit);
break;
}
case MapResource:
{
resource_info.map+=size;
limit=resource_info.map_limit;
status=(resource_info.map_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.map < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.map,
resource_current);
(void) FormatMagickSize(resource_info.map_limit,
resource_limit);
break;
}
case DiskResource:
{
resource_info.disk+=size;
limit=resource_info.disk_limit;
status=(resource_info.disk_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.disk < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.disk,
resource_current);
(void) FormatMagickSize(resource_info.disk_limit,resource_limit);
break;
}
case FileResource:
{
resource_info.file+=size;
limit=resource_info.file_limit;
status=(resource_info.file_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.file < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.file,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.file_limit,
resource_limit);
break;
}
default:
break;
}
RelinquishSemaphoreInfo(resource_semaphore);
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s",
MagickOptionToMnemonic(MagickResourceOptions,(long) type),resource_request,
resource_current,resource_limit);
return(status);
}
WandExport MagickBooleanType CompareImageCommand(ImageInfo *image_info,
int argc,char **argv,char **metadata,ExceptionInfo *exception)
{
#define DefaultDissimilarityThreshold 0.31830988618379067154
#define DestroyCompare() \
{ \
if (similarity_image != (Image *) NULL) \
similarity_image=DestroyImageList(similarity_image); \
if (difference_image != (Image *) NULL) \
difference_image=DestroyImageList(difference_image); \
DestroyImageStack(); \
for (i=0; i < (long) argc; i++) \
argv[i]=DestroyString(argv[i]); \
argv=(char **) RelinquishMagickMemory(argv); \
}
#define ThrowCompareException(asperity,tag,option) \
{ \
if (exception->severity < (asperity)) \
(void) ThrowMagickException(exception,GetMagickModule(),asperity,tag, \
"`%s'",option); \
DestroyCompare(); \
return(MagickFalse); \
}
#define ThrowCompareInvalidArgumentException(option,argument) \
{ \
(void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
"InvalidArgument","`%s': %s",option,argument); \
DestroyCompare(); \
return(MagickFalse); \
}
char
*filename,
*option;
const char
*format;
ChannelType
channels;
double
dissimilarity_threshold,
distortion,
similarity_metric;
Image
*difference_image,
*image,
*reconstruct_image,
*similarity_image;
ImageStack
image_stack[MaxImageStackDepth+1];
long
j,
k;
MagickBooleanType
fire,
pend;
MagickStatusType
status;
MetricType
metric;
RectangleInfo
offset;
register long
i;
/*
Set defaults.
*/
assert(image_info != (ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(exception != (ExceptionInfo *) NULL);
if (argc == 2)
{
option=argv[1];
if ((LocaleCompare("version",option+1) == 0) ||
(LocaleCompare("-version",option+1) == 0))
{
(void) fprintf(stdout,"Version: %s\n",
GetMagickVersion((unsigned long *) NULL));
(void) fprintf(stdout,"Copyright: %s\n",GetMagickCopyright());
(void) fprintf(stdout,"Features: %s\n\n",GetMagickFeatures());
return(MagickFalse);
}
}
if (argc < 3)
return(CompareUsage());
channels=AllChannels;
difference_image=NewImageList();
similarity_image=NewImageList();
dissimilarity_threshold=DefaultDissimilarityThreshold;
distortion=0.0;
format=(char *) NULL;
j=1;
k=0;
metric=UndefinedMetric;
NewImageStack();
option=(char *) NULL;
pend=MagickFalse;
reconstruct_image=NewImageList();
status=MagickTrue;
/*
Compare an image.
*/
ReadCommandlLine(argc,&argv);
status=ExpandFilenames(&argc,&argv);
if (status == MagickFalse)
ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
for (i=1; i < (long) (argc-1); i++)
{
option=argv[i];
if (LocaleCompare(option,"(") == 0)
{
FireImageStack(MagickTrue,MagickTrue,pend);
if (k == MaxImageStackDepth)
ThrowCompareException(OptionError,"ParenthesisNestedTooDeeply",
option);
PushImageStack();
continue;
}
if (LocaleCompare(option,")") == 0)
{
FireImageStack(MagickTrue,MagickTrue,MagickTrue);
if (k == 0)
ThrowCompareException(OptionError,"UnableToParseExpression",option);
PopImageStack();
continue;
}
if (IsMagickOption(option) == MagickFalse)
{
Image
*images;
/*
Read input image.
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=argv[i];
if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
images=ReadImages(image_info,exception);
status&=(images != (Image *) NULL) &&
(exception->severity < ErrorException);
if (images == (Image *) NULL)
continue;
AppendImageStack(images);
continue;
}
pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
switch (*(option+1))
{
case 'a':
{
if (LocaleCompare("alpha",option+1) == 0)
{
long
type;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
type=ParseMagickOption(MagickAlphaOptions,MagickFalse,argv[i]);
if (type < 0)
ThrowCompareException(OptionError,"UnrecognizedAlphaChannelType",
argv[i]);
break;
}
if (LocaleCompare("authenticate",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option);
}
case 'c':
{
if (LocaleCompare("cache",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("channel",option+1) == 0)
{
long
channel;
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
channel=ParseChannelOption(argv[i]);
if (channel < 0)
ThrowCompareException(OptionError,"UnrecognizedChannelType",
argv[i]);
channels=(ChannelType) channel;
break;
}
if (LocaleCompare("colorspace",option+1) == 0)
{
long
colorspace;
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
colorspace=ParseMagickOption(MagickColorspaceOptions,MagickFalse,
argv[i]);
if (colorspace < 0)
ThrowCompareException(OptionError,"UnrecognizedColorspace",
argv[i]);
break;
}
if (LocaleCompare("compose",option+1) == 0)
{
long
compose;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
compose=ParseMagickOption(MagickComposeOptions,MagickFalse,
argv[i]);
if (compose < 0)
ThrowCompareException(OptionError,"UnrecognizedComposeOperator",
argv[i]);
break;
}
if (LocaleCompare("compress",option+1) == 0)
{
long
compress;
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
compress=ParseMagickOption(MagickCompressOptions,MagickFalse,
argv[i]);
if (compress < 0)
ThrowCompareException(OptionError,"UnrecognizedImageCompression",
argv[i]);
break;
}
if (LocaleCompare("concurrent",option+1) == 0)
break;
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'd':
{
if (LocaleCompare("debug",option+1) == 0)
{
LogEventType
event_mask;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
event_mask=SetLogEventMask(argv[i]);
if (event_mask == UndefinedEvents)
ThrowCompareException(OptionError,"UnrecognizedEventType",
argv[i]);
break;
}
if (LocaleCompare("decipher",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("define",option+1) == 0)
{
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (*option == '+')
{
const char
*define;
define=GetImageOption(image_info,argv[i]);
if (define == (const char *) NULL)
ThrowCompareException(OptionError,"NoSuchOption",argv[i]);
break;
}
break;
}
if (LocaleCompare("density",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("depth",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("dissimilarity-threshold",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
if (*option == '+')
dissimilarity_threshold=DefaultDissimilarityThreshold;
else
dissimilarity_threshold=StringToDouble(argv[i]);
break;
}
if (LocaleCompare("duration",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'e':
{
if (LocaleCompare("encipher",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("extract",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'f':
{
if (LocaleCompare("format",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
format=argv[i];
break;
}
if (LocaleCompare("fuzz",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'h':
{
if ((LocaleCompare("help",option+1) == 0) ||
(LocaleCompare("-help",option+1) == 0))
return(CompareUsage());
if (LocaleCompare("highlight-color",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'i':
{
if (LocaleCompare("identify",option+1) == 0)
break;
if (LocaleCompare("interlace",option+1) == 0)
{
long
interlace;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
interlace=ParseMagickOption(MagickInterlaceOptions,MagickFalse,
argv[i]);
if (interlace < 0)
ThrowCompareException(OptionError,"UnrecognizedInterlaceType",
argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'l':
{
if (LocaleCompare("limit",option+1) == 0)
{
char
*p;
double
value;
long
resource;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
resource=ParseMagickOption(MagickResourceOptions,MagickFalse,
argv[i]);
if (resource < 0)
ThrowCompareException(OptionError,"UnrecognizedResourceType",
argv[i]);
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
value=strtod(argv[i],&p);
if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("list",option+1) == 0)
{
long
list;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
list=ParseMagickOption(MagickListOptions,MagickFalse,argv[i]);
if (list < 0)
ThrowCompareException(OptionError,"UnrecognizedListType",argv[i]);
status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
argv+j,exception);
DestroyCompare();
return(status != 0 ? MagickFalse : MagickTrue);
}
if (LocaleCompare("log",option+1) == 0)
{
if (*option == '+')
break;
i++;
if ((i == (long) argc) || (strchr(argv[i],'%') == (char *) NULL))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("lowlight-color",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'm':
{
if (LocaleCompare("matte",option+1) == 0)
break;
if (LocaleCompare("metric",option+1) == 0)
{
long
type;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
type=ParseMagickOption(MagickMetricOptions,MagickTrue,argv[i]);
if (type < 0)
ThrowCompareException(OptionError,"UnrecognizedMetricType",
argv[i]);
metric=(MetricType) type;
break;
}
if (LocaleCompare("monitor",option+1) == 0)
break;
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'p':
{
if (LocaleCompare("passphrase",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("profile",option+1) == 0)
{
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'q':
{
if (LocaleCompare("quality",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("quantize",option+1) == 0)
{
long
colorspace;
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
colorspace=ParseMagickOption(MagickColorspaceOptions,
MagickFalse,argv[i]);
if (colorspace < 0)
ThrowCompareException(OptionError,"UnrecognizedColorspace",
argv[i]);
break;
}
if (LocaleCompare("quiet",option+1) == 0)
break;
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'r':
{
if (LocaleCompare("regard-warnings",option+1) == 0)
break;
if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
{
respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 's':
{
if (LocaleCompare("sampling-factor",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("seed",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("set",option+1) == 0)
{
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("size",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 't':
{
if (LocaleCompare("transparent-color",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("type",option+1) == 0)
{
long
type;
if (*option == '+')
break;
i++;
if (i == (long) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
type=ParseMagickOption(MagickTypeOptions,MagickFalse,argv[i]);
if (type < 0)
ThrowCompareException(OptionError,"UnrecognizedImageType",
argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'v':
{
if (LocaleCompare("verbose",option+1) == 0)
break;
if ((LocaleCompare("version",option+1) == 0) ||
(LocaleCompare("-version",option+1) == 0))
{
(void) fprintf(stdout,"Version: %s\n",
GetMagickVersion((unsigned long *) NULL));
(void) fprintf(stdout,"Copyright: %s\n",GetMagickCopyright());
(void) fprintf(stdout,"Features: %s\n\n",GetMagickFeatures());
break;
}
if (LocaleCompare("virtual-pixel",option+1) == 0)
{
long
method;
if (*option == '+')
break;
i++;
if (i == (long) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
method=ParseMagickOption(MagickVirtualPixelOptions,MagickFalse,
argv[i]);
if (method < 0)
ThrowCompareException(OptionError,
"UnrecognizedVirtualPixelMethod",argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case '?':
break;
default:
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
fire=ParseMagickOption(MagickImageListOptions,MagickFalse,option+1) < 0 ?
MagickFalse : MagickTrue;
if (fire != MagickFalse)
FireImageStack(MagickTrue,MagickTrue,MagickTrue);
}
if (k != 0)
ThrowCompareException(OptionError,"UnbalancedParenthesis",argv[i]);
if (i-- != (long) (argc-1))
ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
FinalizeImageSettings(image_info,image,MagickTrue);
if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
image=GetImageFromList(image,0);
reconstruct_image=GetImageFromList(image,1);
similarity_image=SimilarityImage(image,reconstruct_image,&offset,
&similarity_metric,exception);
if (similarity_metric > dissimilarity_threshold)
ThrowCompareException(ImageError,"ImagesTooDissimilar",image->filename);
if ((reconstruct_image->columns == image->columns) &&
(reconstruct_image->rows == image->rows))
difference_image=CompareImageChannels(image,reconstruct_image,channels,
metric,&distortion,exception);
else
if (similarity_image != (Image *) NULL)
{
Image
*composite_image;
/*
Determine if reconstructed image is a subimage of the image.
*/
composite_image=CloneImage(image,0,0,MagickTrue,exception);
if (composite_image == (Image *) NULL)
difference_image=CompareImageChannels(image,reconstruct_image,
channels,metric,&distortion,exception);
else
{
(void) CompositeImage(composite_image,CopyCompositeOp,
reconstruct_image,offset.x,offset.y);
difference_image=CompareImageChannels(image,composite_image,
channels,metric,&distortion,exception);
if (difference_image != (Image *) NULL)
{
difference_image->page.x=offset.x;
difference_image->page.y=offset.y;
}
composite_image=DestroyImage(composite_image);
}
if (difference_image == (Image *) NULL)
similarity_image=DestroyImage(similarity_image);
else
{
AppendImageToList(&difference_image,similarity_image);
similarity_image=(Image *) NULL;
}
}
if (difference_image == (Image *) NULL)
status=0;
else
{
if (image_info->verbose != MagickFalse)
(void) IsImagesEqual(image,reconstruct_image);
if (*difference_image->magick == '\0')
(void) CopyMagickString(difference_image->magick,image->magick,
MaxTextExtent);
if (image_info->verbose == MagickFalse)
{
switch (metric)
{
case MeanAbsoluteErrorMetric:
case MeanSquaredErrorMetric:
case RootMeanSquaredErrorMetric:
case PeakAbsoluteErrorMetric:
{
(void) fprintf(stderr,"%g (%g)",QuantumRange*distortion,
(double) distortion);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) fprintf(stderr," @ %ld,%ld",difference_image->page.x,
difference_image->page.y);
(void) fprintf(stderr,"\n");
break;
}
case AbsoluteErrorMetric:
case PeakSignalToNoiseRatioMetric:
{
(void) fprintf(stderr,"%g",distortion);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) fprintf(stderr," @ %ld,%ld",difference_image->page.x,
difference_image->page.y);
(void) fprintf(stderr,"\n");
break;
}
case MeanErrorPerPixelMetric:
{
(void) fprintf(stderr,"%g (%g, %g)",distortion,
image->error.normalized_mean_error,
image->error.normalized_maximum_error);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) fprintf(stderr," @ %ld,%ld",difference_image->page.x,
difference_image->page.y);
(void) fprintf(stderr,"\n");
break;
}
case UndefinedMetric:
break;
}
}
else
{
double
*channel_distortion;
channel_distortion=GetImageChannelDistortions(image,reconstruct_image,
metric,&image->exception);
(void) fprintf(stderr,"Image: %s\n",image->filename);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) fprintf(stderr,"Offset: %ld,%ld\n",difference_image->page.x,
difference_image->page.y);
(void) fprintf(stderr," Channel distortion: %s\n",
MagickOptionToMnemonic(MagickMetricOptions,(long) metric));
switch (metric)
{
case MeanAbsoluteErrorMetric:
case MeanSquaredErrorMetric:
case RootMeanSquaredErrorMetric:
case PeakAbsoluteErrorMetric:
{
switch (image->colorspace)
{
case RGBColorspace:
default:
{
(void) fprintf(stderr," red: %g (%g)\n",
QuantumRange*channel_distortion[RedChannel],
channel_distortion[RedChannel]);
(void) fprintf(stderr," green: %g (%g)\n",
QuantumRange*channel_distortion[GreenChannel],
channel_distortion[GreenChannel]);
(void) fprintf(stderr," blue: %g (%g)\n",
QuantumRange*channel_distortion[BlueChannel],
channel_distortion[BlueChannel]);
if (image->matte != MagickFalse)
(void) fprintf(stderr," alpha: %g (%g)\n",
QuantumRange*channel_distortion[OpacityChannel],
channel_distortion[OpacityChannel]);
break;
}
case CMYKColorspace:
{
(void) fprintf(stderr," cyan: %g (%g)\n",
QuantumRange*channel_distortion[CyanChannel],
channel_distortion[CyanChannel]);
(void) fprintf(stderr," magenta: %g (%g)\n",
QuantumRange*channel_distortion[MagentaChannel],
channel_distortion[MagentaChannel]);
(void) fprintf(stderr," yellow: %g (%g)\n",
QuantumRange*channel_distortion[YellowChannel],
channel_distortion[YellowChannel]);
(void) fprintf(stderr," black: %g (%g)\n",
QuantumRange*channel_distortion[BlackChannel],
channel_distortion[BlackChannel]);
if (image->matte != MagickFalse)
(void) fprintf(stderr," alpha: %g (%g)\n",
QuantumRange*channel_distortion[OpacityChannel],
channel_distortion[OpacityChannel]);
break;
}
case GRAYColorspace:
{
(void) fprintf(stderr," gray: %g (%g)\n",
QuantumRange*channel_distortion[GrayChannel],
channel_distortion[GrayChannel]);
if (image->matte != MagickFalse)
(void) fprintf(stderr," alpha: %g (%g)\n",
QuantumRange*channel_distortion[OpacityChannel],
channel_distortion[OpacityChannel]);
break;
}
}
(void) fprintf(stderr," all: %g (%g)\n",
QuantumRange*channel_distortion[AllChannels],
channel_distortion[AllChannels]);
break;
}
case AbsoluteErrorMetric:
case PeakSignalToNoiseRatioMetric:
{
switch (image->colorspace)
{
case RGBColorspace:
default:
{
(void) fprintf(stderr," red: %g\n",
channel_distortion[RedChannel]);
(void) fprintf(stderr," green: %g\n",
channel_distortion[GreenChannel]);
(void) fprintf(stderr," blue: %g\n",
channel_distortion[BlueChannel]);
if (image->matte != MagickFalse)
(void) fprintf(stderr," alpha: %g\n",
channel_distortion[OpacityChannel]);
break;
}
case CMYKColorspace:
{
(void) fprintf(stderr," cyan: %g\n",
channel_distortion[CyanChannel]);
(void) fprintf(stderr," magenta: %g\n",
channel_distortion[MagentaChannel]);
(void) fprintf(stderr," yellow: %g\n",
channel_distortion[YellowChannel]);
(void) fprintf(stderr," black: %g\n",
channel_distortion[BlackChannel]);
if (image->matte != MagickFalse)
(void) fprintf(stderr," alpha: %g\n",
channel_distortion[OpacityChannel]);
break;
}
case GRAYColorspace:
{
(void) fprintf(stderr," gray: %g\n",
channel_distortion[GrayChannel]);
if (image->matte != MagickFalse)
(void) fprintf(stderr," alpha: %g\n",
channel_distortion[OpacityChannel]);
break;
}
}
(void) fprintf(stderr," all: %g\n",
channel_distortion[AllChannels]);
break;
}
case MeanErrorPerPixelMetric:
{
(void) fprintf(stderr," %g (%g, %g)\n",
channel_distortion[AllChannels],
image->error.normalized_mean_error,
image->error.normalized_maximum_error);
break;
}
case UndefinedMetric:
break;
}
channel_distortion=(double *) RelinquishMagickMemory(
channel_distortion);
}
status&=WriteImages(image_info,difference_image,argv[argc-1],exception);
if ((metadata != (char **) NULL) && (format != (char *) NULL))
{
char
*text;
text=InterpretImageProperties(image_info,difference_image,format);
if (text == (char *) NULL)
ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
(void) ConcatenateString(&(*metadata),text);
(void) ConcatenateString(&(*metadata),"\n");
text=DestroyString(text);
}
difference_image=DestroyImageList(difference_image);
}
DestroyCompare();
return(status != 0 ? MagickTrue : MagickFalse);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e l i n q u i s h M a g i c k R e s o u r c e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% RelinquishMagickResource() relinquishes resources of the specified type.
%
% The format of the RelinquishMagickResource() method is:
%
% void RelinquishMagickResource(const ResourceType type,
% const MagickSizeType size)
%
% A description of each parameter follows:
%
% o type: the type of resource.
%
% o size: the size of the resource.
%
*/
MagickExport void RelinquishMagickResource(const ResourceType type,
const MagickSizeType size)
{
char
resource_current[MaxTextExtent],
resource_limit[MaxTextExtent],
resource_request[MaxTextExtent];
(void) FormatMagickSize(size,MagickFalse,resource_request);
if (resource_semaphore == (SemaphoreInfo *) NULL)
AcquireSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
case AreaResource:
{
resource_info.area=(MagickOffsetType) size;
(void) FormatMagickSize((MagickSizeType) resource_info.area,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.area_limit,MagickFalse,
resource_limit);
break;
}
case MemoryResource:
{
resource_info.memory-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.memory,
MagickTrue,resource_current);
(void) FormatMagickSize(resource_info.memory_limit,MagickTrue,
resource_limit);
break;
}
case MapResource:
{
resource_info.map-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.map,MagickTrue,
resource_current);
(void) FormatMagickSize(resource_info.map_limit,MagickTrue,
resource_limit);
break;
}
case DiskResource:
{
resource_info.disk-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.disk,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.disk_limit,MagickFalse,
resource_limit);
break;
}
case FileResource:
{
resource_info.file-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.file,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.file_limit,
MagickFalse,resource_limit);
break;
}
case ThreadResource:
{
resource_info.thread-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.thread,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.thread_limit,
MagickFalse,resource_limit);
break;
}
case TimeResource:
{
resource_info.time-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.time,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.time_limit,
MagickFalse,resource_limit);
break;
}
default:
break;
}
UnlockSemaphoreInfo(resource_semaphore);
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s",
MagickOptionToMnemonic(MagickResourceOptions,(ssize_t) type),
resource_request,resource_current,resource_limit);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e M P C I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteMPCImage() writes an Magick Persistent Cache image to a file.
%
% The format of the WriteMPCImage method is:
%
% MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o image: the image.
%
*/
static MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
{
char
buffer[MaxTextExtent],
cache_filename[MaxTextExtent];
const char
*property,
*value;
MagickBooleanType
status;
MagickOffsetType
offset,
scene;
register long
i;
unsigned long
depth;
/*
Open persistent cache.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
(void) CopyMagickString(cache_filename,image->filename,MaxTextExtent);
AppendImageFormat("cache",cache_filename);
scene=0;
offset=0;
do
{
/*
Write persistent cache meta-information.
*/
depth=GetImageQuantumDepth(image,MagickTrue);
if ((image->storage_class == PseudoClass) &&
(image->colors > (1UL << depth)))
image->storage_class=DirectClass;
(void) WriteBlobString(image,"id=MagickCache\n");
(void) FormatMagickString(buffer,MaxTextExtent,"quantum-depth=%d\n",
MAGICKCORE_QUANTUM_DEPTH);
(void) WriteBlobString(image,buffer);
(void) FormatMagickString(buffer,MaxTextExtent,
"class=%s colors=%lu matte=%s\n",MagickOptionToMnemonic(
MagickClassOptions,image->storage_class),image->colors,
MagickOptionToMnemonic(MagickBooleanOptions,(long) image->matte));
(void) WriteBlobString(image,buffer);
(void) FormatMagickString(buffer,MaxTextExtent,
"columns=%lu rows=%lu depth=%lu\n",image->columns,image->rows,
image->depth);
(void) WriteBlobString(image,buffer);
if (image->type != UndefinedType)
{
(void) FormatMagickString(buffer,MaxTextExtent,"type=%s\n",
MagickOptionToMnemonic(MagickTypeOptions,image->type));
(void) WriteBlobString(image,buffer);
}
if (image->colorspace != UndefinedColorspace)
{
(void) FormatMagickString(buffer,MaxTextExtent,"colorspace=%s\n",
MagickOptionToMnemonic(MagickColorspaceOptions,image->colorspace));
(void) WriteBlobString(image,buffer);
}
if (image->endian != UndefinedEndian)
{
(void) FormatMagickString(buffer,MaxTextExtent,"endian=%s\n",
MagickOptionToMnemonic(MagickEndianOptions,image->endian));
(void) WriteBlobString(image,buffer);
}
if (image->compression != UndefinedCompression)
{
(void) FormatMagickString(buffer,MaxTextExtent,
"compression=%s quality=%lu\n",MagickOptionToMnemonic(
MagickCompressOptions,image->compression),image->quality);
(void) WriteBlobString(image,buffer);
}
if (image->units != UndefinedResolution)
{
(void) FormatMagickString(buffer,MaxTextExtent,"units=%s\n",
MagickOptionToMnemonic(MagickResolutionOptions,image->units));
(void) WriteBlobString(image,buffer);
}
if ((image->x_resolution != 0) || (image->y_resolution != 0))
{
(void) FormatMagickString(buffer,MaxTextExtent,
"resolution=%gx%g\n",image->x_resolution,image->y_resolution);
(void) WriteBlobString(image,buffer);
}
if ((image->page.width != 0) || (image->page.height != 0))
{
(void) FormatMagickString(buffer,MaxTextExtent,"page=%lux%lu%+ld%+ld\n",
image->page.width,image->page.height,image->page.x,image->page.y);
(void) WriteBlobString(image,buffer);
}
else
if ((image->page.x != 0) || (image->page.y != 0))
{
(void) FormatMagickString(buffer,MaxTextExtent,"page=%+ld%+ld\n",
image->page.x,image->page.y);
(void) WriteBlobString(image,buffer);
}
if ((image->page.x != 0) || (image->page.y != 0))
{
(void) FormatMagickString(buffer,MaxTextExtent,"tile-offset=%+ld%+ld\n",
image->tile_offset.x,image->tile_offset.y);
(void) WriteBlobString(image,buffer);
}
if ((GetNextImageInList(image) != (Image *) NULL) ||
(GetPreviousImageInList(image) != (Image *) NULL))
{
if (image->scene == 0)
(void) FormatMagickString(buffer,MaxTextExtent,
"iterations=%lu delay=%lu ticks-per-second=%lu\n",
image->iterations,image->delay,image->ticks_per_second);
else
(void) FormatMagickString(buffer,MaxTextExtent,
"scene=%lu iterations=%lu delay=%lu ticks-per-second=%lu\n",
image->scene,image->iterations,image->delay,
image->ticks_per_second);
(void) WriteBlobString(image,buffer);
}
else
{
if (image->scene != 0)
{
(void) FormatMagickString(buffer,MaxTextExtent,"scene=%lu\n",
image->scene);
(void) WriteBlobString(image,buffer);
}
if (image->iterations != 0)
{
(void) FormatMagickString(buffer,MaxTextExtent,"iterations=%lu\n",
image->iterations);
(void) WriteBlobString(image,buffer);
}
if (image->delay != 0)
{
(void) FormatMagickString(buffer,MaxTextExtent,"delay=%lu\n",
image->delay);
(void) WriteBlobString(image,buffer);
}
if (image->ticks_per_second != UndefinedTicksPerSecond)
{
(void) FormatMagickString(buffer,MaxTextExtent,
"ticks-per-second=%lu\n",image->ticks_per_second);
(void) WriteBlobString(image,buffer);
}
}
if (image->gravity != UndefinedGravity)
{
(void) FormatMagickString(buffer,MaxTextExtent,"gravity=%s\n",
MagickOptionToMnemonic(MagickGravityOptions,image->gravity));
(void) WriteBlobString(image,buffer);
}
if (image->dispose != UndefinedDispose)
{
(void) FormatMagickString(buffer,MaxTextExtent,"dispose=%s\n",
MagickOptionToMnemonic(MagickDisposeOptions,image->dispose));
(void) WriteBlobString(image,buffer);
}
if (image->rendering_intent != UndefinedIntent)
{
(void) FormatMagickString(buffer,MaxTextExtent,
"rendering-intent=%s\n",
MagickOptionToMnemonic(MagickIntentOptions,image->rendering_intent));
(void) WriteBlobString(image,buffer);
}
if (image->gamma != 0.0)
{
(void) FormatMagickString(buffer,MaxTextExtent,"gamma=%g\n",
image->gamma);
(void) WriteBlobString(image,buffer);
}
if (image->chromaticity.white_point.x != 0.0)
{
/*
Note chomaticity points.
*/
(void) FormatMagickString(buffer,MaxTextExtent,"red-primary="
"%g,%g green-primary=%g,%g blue-primary=%g,%g\n",
image->chromaticity.red_primary.x,image->chromaticity.red_primary.y,
image->chromaticity.green_primary.x,
image->chromaticity.green_primary.y,
image->chromaticity.blue_primary.x,
image->chromaticity.blue_primary.y);
(void) WriteBlobString(image,buffer);
(void) FormatMagickString(buffer,MaxTextExtent,
"white-point=%g,%g\n",image->chromaticity.white_point.x,
image->chromaticity.white_point.y);
(void) WriteBlobString(image,buffer);
}
if (image->orientation != UndefinedOrientation)
{
(void) FormatMagickString(buffer,MaxTextExtent,
"orientation=%s\n",MagickOptionToMnemonic(MagickOrientationOptions,
image->orientation));
(void) WriteBlobString(image,buffer);
}
if (image->profiles != (void *) NULL)
{
const char
*name;
const StringInfo
*profile;
/*
Generic profile.
*/
ResetImageProfileIterator(image);
for (name=GetNextImageProfile(image); name != (const char *) NULL; )
{
profile=GetImageProfile(image,name);
if (profile != (StringInfo *) NULL)
{
(void) FormatMagickString(buffer,MaxTextExtent,"profile:%s=%lu\n",
name,(unsigned long) GetStringInfoLength(profile));
(void) WriteBlobString(image,buffer);
}
name=GetNextImageProfile(image);
}
}
if (image->montage != (char *) NULL)
{
(void) FormatMagickString(buffer,MaxTextExtent,"montage=%s\n",
image->montage);
(void) WriteBlobString(image,buffer);
}
ResetImagePropertyIterator(image);
property=GetNextImageProperty(image);
while (property != (const char *) NULL)
{
(void) FormatMagickString(buffer,MaxTextExtent,"%s=",property);
(void) WriteBlobString(image,buffer);
value=GetImageProperty(image,property);
if (value != (const char *) NULL)
{
for (i=0; i < (long) strlen(value); i++)
if (isspace((int) ((unsigned char) value[i])) != 0)
break;
if (i <= (long) strlen(value))
(void) WriteBlobByte(image,'{');
(void) WriteBlob(image,strlen(value),(unsigned char *) value);
if (i <= (long) strlen(value))
(void) WriteBlobByte(image,'}');
}
(void) WriteBlobByte(image,'\n');
property=GetNextImageProperty(image);
}
ResetImageArtifactIterator(image);
(void) WriteBlobString(image,"\f\n:\032");
if (image->montage != (char *) NULL)
{
/*
Write montage tile directory.
*/
if (image->directory != (char *) NULL)
(void) WriteBlobString(image,image->directory);
(void) WriteBlobByte(image,'\0');
}
if (image->profiles != 0)
{
const char
*name;
const StringInfo
*profile;
/*
Write image profiles.
*/
ResetImageProfileIterator(image);
name=GetNextImageProfile(image);
while (name != (const char *) NULL)
{
profile=GetImageProfile(image,name);
(void) WriteBlob(image,GetStringInfoLength(profile),
GetStringInfoDatum(profile));
name=GetNextImageProfile(image);
}
}
if (image->storage_class == PseudoClass)
{
size_t
packet_size;
unsigned char
*colormap,
*q;
/*
Allocate colormap.
*/
packet_size=(size_t) (3UL*depth/8UL);
colormap=(unsigned char *) AcquireQuantumMemory(image->colors,
packet_size*sizeof(*colormap));
if (colormap == (unsigned char *) NULL)
return(MagickFalse);
/*
Write colormap to file.
*/
q=colormap;
for (i=0; i < (long) image->colors; i++)
{
switch (depth)
{
default:
ThrowWriterException(CorruptImageError,"ImageDepthNotSupported");
case 32:
{
unsigned long
pixel;
pixel=ScaleQuantumToLong(image->colormap[i].red);
q=PopLongPixel(MSBEndian,pixel,q);
pixel=ScaleQuantumToLong(image->colormap[i].green);
q=PopLongPixel(MSBEndian,pixel,q);
pixel=ScaleQuantumToLong(image->colormap[i].blue);
q=PopLongPixel(MSBEndian,pixel,q);
}
case 16:
{
unsigned short
pixel;
pixel=ScaleQuantumToShort(image->colormap[i].red);
q=PopShortPixel(MSBEndian,pixel,q);
pixel=ScaleQuantumToShort(image->colormap[i].green);
q=PopShortPixel(MSBEndian,pixel,q);
pixel=ScaleQuantumToShort(image->colormap[i].blue);
q=PopShortPixel(MSBEndian,pixel,q);
break;
}
case 8:
{
unsigned char
pixel;
pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].red);
q=PopCharPixel(pixel,q);
pixel=(unsigned char) ScaleQuantumToChar(
image->colormap[i].green);
q=PopCharPixel(pixel,q);
pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].blue);
q=PopCharPixel(pixel,q);
break;
}
}
}
(void) WriteBlob(image,packet_size*image->colors,colormap);
colormap=(unsigned char *) RelinquishMagickMemory(colormap);
}
/*
Initialize persistent pixel cache.
*/
status=PersistPixelCache(image,cache_filename,MagickFalse,&offset,
&image->exception);
if (status == MagickFalse)
ThrowWriterException(CacheError,"UnableToPersistPixelCache");
if (GetNextImageInList(image) == (Image *) NULL)
break;
image=SyncNextImageInList(image);
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
status=image->progress_monitor(SaveImagesTag,scene,
GetImageListLength(image),image->client_data);
if (status == MagickFalse)
break;
}
scene++;
} while (image_info->adjoin != MagickFalse);
(void) CloseBlob(image);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% 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);
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e T X T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteTXTImage writes the pixel values as text numbers.
%
% The format of the WriteTXTImage method is:
%
% MagickBooleanType WriteTXTImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o image_info: the image info.
%
% o image: The image.
%
*/
static MagickBooleanType WriteTXTImage(const ImageInfo *image_info,Image *image)
{
char
buffer[MaxTextExtent],
colorspace[MaxTextExtent],
tuple[MaxTextExtent];
long
y;
MagickBooleanType
status;
MagickPixelPacket
pixel;
register const IndexPacket
*indexes;
register const PixelPacket
*p;
register long
x;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=OpenBlob(image_info,image,WriteBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
(void) CopyMagickString(colorspace,MagickOptionToMnemonic(
MagickColorspaceOptions,(long) image->colorspace),MaxTextExtent);
LocaleLower(colorspace);
image->depth=GetImageQuantumDepth(image,MagickTrue);
if (image->matte != MagickFalse)
(void) ConcatenateMagickString(colorspace,"a",MaxTextExtent);
(void) FormatMagickString(buffer,MaxTextExtent,
"# ImageMagick pixel enumeration: %lu,%lu,%lu,%s\n",image->columns,
image->rows,(unsigned long) GetQuantumRange(image->depth),colorspace);
(void) WriteBlobString(image,buffer);
GetMagickPixelPacket(image,&pixel);
for (y=0; y < (long) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (long) image->columns; x++)
{
(void) FormatMagickString(buffer,MaxTextExtent,"%ld,%ld: ",x,y);
(void) WriteBlobString(image,buffer);
SetMagickPixelPacket(image,p,indexes+x,&pixel);
(void) CopyMagickString(tuple,"(",MaxTextExtent);
ConcatenateColorComponent(&pixel,RedChannel,X11Compliance,tuple);
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,GreenChannel,X11Compliance,tuple);
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,BlueChannel,X11Compliance,tuple);
if (pixel.colorspace == CMYKColorspace)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,IndexChannel,X11Compliance,tuple);
}
if (pixel.matte != MagickFalse)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,AlphaChannel,X11Compliance,tuple);
}
(void) ConcatenateMagickString(tuple,")",MaxTextExtent);
(void) WriteBlobString(image,tuple);
(void) WriteBlobString(image," ");
GetColorTuple(&pixel,MagickTrue,tuple);
(void) FormatMagickString(buffer,MaxTextExtent,"%s",tuple);
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image," ");
(void) QueryMagickColorname(image,&pixel,SVGCompliance,tuple,
&image->exception);
(void) WriteBlobString(image,tuple);
(void) WriteBlobString(image,"\n");
p++;
}
status=SetImageProgress(image,SaveImageTag,y,image->rows);
if (status == MagickFalse)
break;
}
(void) CloseBlob(image);
return(MagickTrue);
}