% July 1992 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
/*
Include declarations.
*/
-#include "magick/studio.h"
-#include "magick/blob.h"
-#include "magick/blob-private.h"
-#include "magick/cache.h"
-#include "magick/color.h"
-#include "magick/color-private.h"
-#include "magick/colorspace.h"
-#include "magick/constitute.h"
-#include "magick/delegate.h"
-#include "magick/delegate-private.h"
-#include "magick/draw.h"
-#include "magick/exception.h"
-#include "magick/exception-private.h"
-#include "magick/geometry.h"
-#include "magick/image.h"
-#include "magick/image-private.h"
-#include "magick/list.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/option.h"
-#include "magick/profile.h"
-#include "magick/resource_.h"
-#include "magick/pixel-private.h"
-#include "magick/property.h"
-#include "magick/quantum-private.h"
-#include "magick/static.h"
-#include "magick/string_.h"
-#include "magick/module.h"
-#include "magick/token.h"
-#include "magick/transform.h"
-#include "magick/utility.h"
+#include "MagickCore/studio.h"
+#include "MagickCore/attribute.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/blob-private.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/color.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
+#include "MagickCore/constitute.h"
+#include "MagickCore/delegate.h"
+#include "MagickCore/delegate-private.h"
+#include "MagickCore/draw.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/exception-private.h"
+#include "MagickCore/geometry.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/list.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/monitor-private.h"
+#include "MagickCore/option.h"
+#include "MagickCore/profile.h"
+#include "MagickCore/resource_.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/property.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/static.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/module.h"
+#include "MagickCore/token.h"
+#include "MagickCore/transform.h"
+#include "MagickCore/utility.h"
\f
/*
Forward declarations.
*/
static MagickBooleanType
- WritePSImage(const ImageInfo *,Image *);
+ WritePSImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
options[MaxTextExtent],
postscript_filename[MaxTextExtent];
- const char
- *option;
-
const DelegateInfo
*delegate_info;
flags;
PointInfo
- delta;
+ delta,
+ resolution;
RectangleInfo
page;
hex_digits[256];
size_t
- length;
+ length,
+ priority;
ssize_t
count;
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=AcquireImage(image_info);
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
*/
delta.x=DefaultResolution;
delta.y=DefaultResolution;
- if ((image->x_resolution == 0.0) || (image->y_resolution == 0.0))
+ if ((image->resolution.x == 0.0) || (image->resolution.y == 0.0))
{
flags=ParseGeometry(PSDensityGeometry,&geometry_info);
- image->x_resolution=geometry_info.rho;
- image->y_resolution=geometry_info.sigma;
+ image->resolution.x=geometry_info.rho;
+ image->resolution.y=geometry_info.sigma;
if ((flags & SigmaValue) == 0)
- image->y_resolution=image->x_resolution;
+ image->resolution.y=image->resolution.x;
}
+ if (image_info->density != (char *) NULL)
+ {
+ flags=ParseGeometry(image_info->density,&geometry_info);
+ image->resolution.x=geometry_info.rho;
+ image->resolution.y=geometry_info.sigma;
+ if ((flags & SigmaValue) == 0)
+ image->resolution.y=image->resolution.x;
+ }
+ (void) ParseAbsoluteGeometry(PSPageGeometry,&page);
+ if (image_info->page != (char *) NULL)
+ (void) ParseAbsoluteGeometry(image_info->page,&page);
+ resolution=image->resolution;
+ page.width=(size_t) ceil((double) (page.width*resolution.x/delta.x)-0.5);
+ page.height=(size_t) ceil((double) (page.height*resolution.y/delta.y)-0.5);
/*
Determine page geometry from the Postscript bounding box.
*/
(void) ResetMagickMemory(&bounds,0,sizeof(bounds));
- (void) ResetMagickMemory(&hires_bounds,0,sizeof(hires_bounds));
- (void) ResetMagickMemory(&page,0,sizeof(page));
(void) ResetMagickMemory(command,0,sizeof(command));
- hires_bounds.x2=0.0;
- hires_bounds.y2=0.0;
- columns=0;
+ cmyk=image_info->colorspace == CMYKColorspace ? MagickTrue : MagickFalse;
+ (void) ResetMagickMemory(&hires_bounds,0,sizeof(hires_bounds));
+ priority=0;
rows=0;
extent=0;
spotcolor=0;
language_level=1;
- skip=MagickFalse;
- cmyk=image_info->colorspace == CMYKColorspace ? MagickTrue : MagickFalse;
pages=(~0UL);
+ skip=MagickFalse;
p=command;
for (c=ReadBlobByte(image); c != EOF; c=ReadBlobByte(image))
{
continue;
if (LocaleNCompare(PostscriptLevel,command,strlen(PostscriptLevel)) == 0)
{
- (void) SetImageProperty(image,"ps:Level",command+4);
+ (void) SetImageProperty(image,"ps:Level",command+4,exception);
if (GlobExpression(command,"*EPSF-*",MagickTrue) != MagickFalse)
pages=1;
}
datum=GetStringInfoDatum(profile);
datum[i]=(unsigned char) c;
}
- (void) SetImageProfile(image,"icc",profile);
+ (void) SetImageProfile(image,"icc",profile,exception);
profile=DestroyStringInfo(profile);
continue;
}
if (count != 1)
continue;
length=extent;
- profile=AcquireStringInfo(length);
+ profile=BlobToStringInfo((const void *) NULL,length);
p=GetStringInfoDatum(profile);
for (i=0; i < (ssize_t) length; i++)
*p++=(unsigned char) ProfileInteger(image,hex_digits);
- (void) SetImageProfile(image,"8bim",profile);
+ (void) SetImageProfile(image,"8bim",profile,exception);
profile=DestroyStringInfo(profile);
continue;
}
break;
}
SetStringInfoLength(profile,i);
- (void) SetImageProfile(image,"xmp",profile);
+ (void) SetImageProfile(image,"xmp",profile,exception);
profile=DestroyStringInfo(profile);
continue;
}
/*
Note spot names.
*/
- (void) FormatMagickString(property,MaxTextExtent,"ps:SpotColor-%.20g",
+ (void) FormatLocaleString(property,MaxTextExtent,"ps:SpotColor-%.20g",
(double) (spotcolor++));
for (p=command; *p != '\0'; p++)
if (isspace((int) (unsigned char) *p) != 0)
(void) SubstituteString(&value,"(","");
(void) SubstituteString(&value,")","");
(void) StripString(value);
- (void) SetImageProperty(image,property,value);
+ (void) SetImageProperty(image,property,value,exception);
value=DestroyString(value);
continue;
}
+ if (image_info->page != (char *) NULL)
+ continue;
/*
Note region defined by bounding box.
*/
count=0;
+ i=0;
if (LocaleNCompare(BoundingBox,command,strlen(BoundingBox)) == 0)
- count=(ssize_t) sscanf(command,BoundingBox " %lf %lf %lf %lf",&bounds.x1,
- &bounds.y1,&bounds.x2,&bounds.y2);
+ {
+ count=(ssize_t) sscanf(command,BoundingBox " %lf %lf %lf %lf",
+ &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
+ i=2;
+ }
if (LocaleNCompare(DocumentMedia,command,strlen(DocumentMedia)) == 0)
- count=(ssize_t) sscanf(command,DocumentMedia " %*s %lf %lf",&bounds.x2,
- &bounds.y2)+2;
+ {
+ count=(ssize_t) sscanf(command,DocumentMedia " %lf %lf %lf %lf",
+ &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
+ i=1;
+ }
if (LocaleNCompare(HiResBoundingBox,command,strlen(HiResBoundingBox)) == 0)
- count=(ssize_t) sscanf(command,HiResBoundingBox " %lf %lf %lf %lf",
- &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
+ {
+ count=(ssize_t) sscanf(command,HiResBoundingBox " %lf %lf %lf %lf",
+ &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
+ i=3;
+ }
if (LocaleNCompare(PageBoundingBox,command,strlen(PageBoundingBox)) == 0)
- count=(ssize_t) sscanf(command,PageBoundingBox " %lf %lf %lf %lf",
- &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
+ {
+ count=(ssize_t) sscanf(command,PageBoundingBox " %lf %lf %lf %lf",
+ &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
+ i=1;
+ }
if (LocaleNCompare(PageMedia,command,strlen(PageMedia)) == 0)
- count=(ssize_t) sscanf(command,PageMedia " %*s %lf %lf",&bounds.x2,
- &bounds.y2)+2;
- if (count != 4)
- continue;
- if (((bounds.x2 > hires_bounds.x2) && (bounds.y2 > hires_bounds.y2)) ||
- ((hires_bounds.x2 == 0.0) && (hires_bounds.y2 == 0.0)))
{
- /*
- Set Postscript render geometry.
- */
- (void) FormatMagickString(geometry,MaxTextExtent,
- "%gx%g%+.15g%+.15g",bounds.x2-bounds.x1,bounds.y2-bounds.y1,
- bounds.x1,bounds.y1);
- (void) SetImageProperty(image,"ps:HiResBoundingBox",geometry);
- page.width=(size_t) floor(bounds.x2-bounds.x1+0.5);
- page.height=(size_t) floor(bounds.y2-bounds.y1+0.5);
- hires_bounds=bounds;
+ count=(ssize_t) sscanf(command,PageMedia " %lf %lf %lf %lf",
+ &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
+ i=1;
}
+ if ((count != 4) || (i < (ssize_t) priority))
+ continue;
+ if ((fabs(bounds.x2-bounds.x1) <= fabs(hires_bounds.x2-hires_bounds.x1)) ||
+ (fabs(bounds.y2-bounds.y1) <= fabs(hires_bounds.y2-hires_bounds.y1)))
+ continue;
+ hires_bounds=bounds;
+ priority=i;
}
+ if ((fabs(hires_bounds.x2-hires_bounds.x1) >= MagickEpsilon) &&
+ (fabs(hires_bounds.y2-hires_bounds.y1) >= MagickEpsilon))
+ {
+ /*
+ Set Postscript render geometry.
+ */
+ (void) FormatLocaleString(geometry,MaxTextExtent,"%gx%g%+.15g%+.15g",
+ hires_bounds.x2-hires_bounds.x1,hires_bounds.y2-hires_bounds.y1,
+ hires_bounds.x1,hires_bounds.y1);
+ (void) SetImageProperty(image,"ps:HiResBoundingBox",geometry,exception);
+ page.width=(size_t) ceil((double) ((hires_bounds.x2-hires_bounds.x1)*
+ resolution.x/delta.x)-0.5);
+ page.height=(size_t) ceil((double) ((hires_bounds.y2-hires_bounds.y1)*
+ resolution.y/delta.y)-0.5);
+ }
(void) CloseBlob(image);
- if (image_info->colorspace == RGBColorspace)
+ if (IssRGBCompatibleColorspace(image_info->colorspace) != MagickFalse)
cmyk=MagickFalse;
/*
Create Ghostscript control file.
file=AcquireUniqueFileResource(postscript_filename);
if (file == -1)
{
- ThrowFileException(&image->exception,FileOpenError,"UnableToOpenFile",
+ ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
image_info->filename);
image=DestroyImageList(image);
return((Image *) NULL);
char
translate_geometry[MaxTextExtent];
- (void) FormatMagickString(translate_geometry,MaxTextExtent,
+ (void) FormatLocaleString(translate_geometry,MaxTextExtent,
"%g %g translate\n",-bounds.x1,-bounds.y1);
count=write(file,translate_geometry,(unsigned int)
strlen(translate_geometry));
return((Image *) NULL);
}
*options='\0';
- if ((page.width == 0) || (page.height == 0))
- (void) ParseAbsoluteGeometry(PSPageGeometry,&page);
- if (image_info->density != (char *) NULL)
- {
- flags=ParseGeometry(image_info->density,&geometry_info);
- image->x_resolution=geometry_info.rho;
- image->y_resolution=geometry_info.sigma;
- if ((flags & SigmaValue) == 0)
- image->y_resolution=image->x_resolution;
- }
- (void) FormatMagickString(density,MaxTextExtent,"%gx%g",
- image->x_resolution,image->y_resolution);
- if (image_info->page != (char *) NULL)
- (void) ParseAbsoluteGeometry(image_info->page,&page);
- page.width=(size_t) floor((double) (page.width*image->x_resolution/delta.x)+
- 0.5);
- page.height=(size_t) floor((double) (page.height*image->y_resolution/delta.y)+
- 0.5);
- (void) FormatMagickString(options,MaxTextExtent,"-g%.20gx%.20g ",(double)
+ (void) FormatLocaleString(density,MaxTextExtent,"%gx%g",resolution.x,
+ resolution.y);
+ (void) FormatLocaleString(options,MaxTextExtent,"-g%.20gx%.20g ",(double)
page.width,(double) page.height);
read_info=CloneImageInfo(image_info);
*read_info->magick='\0';
char
pages[MaxTextExtent];
- (void) FormatMagickString(pages,MaxTextExtent,"-dFirstPage=%.20g "
+ (void) FormatLocaleString(pages,MaxTextExtent,"-dFirstPage=%.20g "
"-dLastPage=%.20g",(double) read_info->scene+1,(double)
(read_info->scene+read_info->number_scenes));
(void) ConcatenateMagickString(options,pages,MaxTextExtent);
if (read_info->scenes != (char *) NULL)
*read_info->scenes='\0';
}
- option=GetImageOption(image_info,"ps:use-cropbox");
- if ((option != (const char *) NULL) && (IsMagickTrue(option) != MagickFalse))
+ if (IfMagickTrue(IsStringTrue(GetImageOption(image_info,"ps:use-cropbox"))))
(void) ConcatenateMagickString(options,"-dEPSCrop ",MaxTextExtent);
(void) CopyMagickString(filename,read_info->filename,MaxTextExtent);
(void) AcquireUniqueFilename(filename);
(void) ConcatenateMagickString(filename,"-%08d",MaxTextExtent);
- (void) FormatMagickString(command,MaxTextExtent,
+ (void) FormatLocaleString(command,MaxTextExtent,
GetDelegateCommands(delegate_info),
read_info->antialias != MagickFalse ? 4 : 1,
read_info->antialias != MagickFalse ? 4 : 1,density,options,filename,
postscript_filename,input_filename);
status=InvokePostscriptDelegate(read_info->verbose,command,exception);
(void) InterpretImageFilename(image_info,image,filename,1,
- read_info->filename);
+ read_info->filename,exception);
if ((status == MagickFalse) ||
(IsPostscriptRendered(read_info->filename) == MagickFalse))
{
for (i=1; ; i++)
{
(void) InterpretImageFilename(image_info,image,filename,(int) i,
- read_info->filename);
+ read_info->filename,exception);
if (IsPostscriptRendered(read_info->filename) == MagickFalse)
break;
(void) RelinquishUniqueFileResource(read_info->filename);
for (i=1; ; i++)
{
(void) InterpretImageFilename(image_info,image,filename,(int) i,
- read_info->filename);
+ read_info->filename,exception);
if (IsPostscriptRendered(read_info->filename) == MagickFalse)
break;
+ read_info->blob=NULL;
+ read_info->length=0;
next=ReadImage(read_info,exception);
(void) RelinquishUniqueFileResource(read_info->filename);
if (next == (Image *) NULL)
%
% The format of the WritePSImage method is:
%
-% MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePSImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline size_t MagickMin(const size_t x,const size_t y)
return(pixels);
}
-static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
#define WriteRunlengthPacket(image,pixel,length,p) \
{ \
- if ((image->matte != MagickFalse) && \
- (p->opacity == (Quantum) TransparentOpacity)) \
+ if ((image->alpha_trait == BlendPixelTrait) && \
+ (GetPixelAlpha(image,p) == (Quantum) TransparentAlpha)) \
{ \
q=PopHexPixel(hex_digits,0xff,q); \
q=PopHexPixel(hex_digits,0xff,q); \
q=PopHexPixel(hex_digits,ScaleQuantumToChar(pixel.green),q); \
q=PopHexPixel(hex_digits,ScaleQuantumToChar(pixel.blue),q); \
} \
- q=PopHexPixel(hex_digits,(const size_t) MagickMin(length,0xff),q); \
+ q=PopHexPixel(hex_digits,(size_t) MagickMin(length,0xff),q); \
}
static const char
" currentfile buffer readline pop",
" token pop /compression exch def pop",
" class 0 gt { PseudoClassImage } { DirectClassImage } ifelse",
+ " grestore",
(char *) NULL
};
GeometryInfo
geometry_info;
- IndexPacket
- index;
-
- ssize_t
- j,
- y;
-
MagickBooleanType
status;
MagickStatusType
flags;
- PixelPacket
+ PixelInfo
pixel;
PointInfo
resolution,
scale;
+ Quantum
+ index;
+
RectangleInfo
geometry,
media_info,
page_info;
- register const IndexPacket
- *indexes;
-
- register const PixelPacket
+ register const Quantum
*p;
register ssize_t
bounds;
size_t
- length;
+ bit,
+ byte,
+ length,
+ page,
+ text_size;
+
+ ssize_t
+ j,
+ y;
time_t
timer;
unsigned char
pixels[2048];
- size_t
- bit,
- byte,
- page,
- text_size;
-
/*
Open output image file.
*/
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) ResetMagickMemory(&bounds,0,sizeof(bounds));
/*
Scale relative to dots-per-inch.
*/
- if ((image->colorspace != RGBColorspace) &&
- (image->colorspace != CMYKColorspace))
- (void) TransformImageColorspace(image,RGBColorspace);
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
delta.x=DefaultResolution;
delta.y=DefaultResolution;
- resolution.x=image->x_resolution;
- resolution.y=image->y_resolution;
+ resolution.x=image->resolution.x;
+ resolution.y=image->resolution.y;
if ((resolution.x == 0.0) || (resolution.y == 0.0))
{
flags=ParseGeometry(PSDensityGeometry,&geometry_info);
resolution.y=(double) ((size_t) (100.0*2.54*resolution.y+0.5)/100.0);
}
SetGeometry(image,&geometry);
- (void) FormatMagickString(page_geometry,MaxTextExtent,"%.20gx%.20g",
+ (void) FormatLocaleString(page_geometry,MaxTextExtent,"%.20gx%.20g",
(double) image->columns,(double) image->rows);
if (image_info->page != (char *) NULL)
(void) CopyMagickString(page_geometry,image_info->page,MaxTextExtent);
else
if ((image->page.width != 0) && (image->page.height != 0))
- (void) FormatMagickString(page_geometry,MaxTextExtent,
+ (void) FormatLocaleString(page_geometry,MaxTextExtent,
"%.20gx%.20g%+.20g%+.20g",(double) image->page.width,(double)
image->page.height,(double) image->page.x,(double) image->page.y);
else
scale.y=(double) (geometry.height*delta.y)/resolution.y;
geometry.height=(size_t) floor(scale.y+0.5);
(void) ParseAbsoluteGeometry(page_geometry,&media_info);
- (void) ParseGravityGeometry(image,page_geometry,&page_info,
- &image->exception);
+ (void) ParseGravityGeometry(image,page_geometry,&page_info,exception);
if (image->gravity != UndefinedGravity)
{
geometry.x=(-page_info.x);
if (image_info->pointsize != 0.0)
pointsize=image_info->pointsize;
text_size=0;
- value=GetImageProperty(image,"label");
+ value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
text_size=(size_t) (MultilineCensus(value)*pointsize+12);
if (page == 1)
MaxTextExtent);
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"%%Creator: (ImageMagick)\n");
- (void) FormatMagickString(buffer,MaxTextExtent,"%%%%Title: (%s)\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%%%%Title: (%s)\n",
image->filename);
(void) WriteBlobString(image,buffer);
timer=time((time_t *) NULL);
(void) FormatMagickTime(timer,MaxTextExtent,date);
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%%%%CreationDate: (%s)\n",date);
(void) WriteBlobString(image,buffer);
bounds.x1=(double) geometry.x;
MaxTextExtent);
else
{
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%%%%BoundingBox: %.20g %.20g %.20g %.20g\n",ceil(bounds.x1-0.5),
- ceil(bounds.y1-0.5),floor(bounds.x2+0.5),floor(bounds.y2+0.5));
+ ceil(bounds.y1-0.5),floor(bounds.x2-0.5),floor(bounds.y2-0.5));
(void) WriteBlobString(image,buffer);
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%%%%HiResBoundingBox: %g %g %g %g\n",bounds.x1,
bounds.y1,bounds.x2,bounds.y2);
}
/*
Embed Photoshop profile.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%%BeginPhotoshop: %.20g",(double) GetStringInfoLength(profile));
(void) WriteBlobString(image,buffer);
for (i=0; i < (ssize_t) GetStringInfoLength(profile); i++)
{
if ((i % 32) == 0)
(void) WriteBlobString(image,"\n% ");
- (void) FormatMagickString(buffer,MaxTextExtent,"%02X",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%02X",
(unsigned int) (GetStringInfoDatum(profile)[i] & 0xff));
(void) WriteBlobString(image,buffer);
}
Embed XML profile.
*/
(void) WriteBlobString(image,"\n%begin_xml_code\n");
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"\n%%begin_xml_packet: %.20g\n",(double)
GetStringInfoLength(profile));
(void) WriteBlobString(image,buffer);
(void) WriteBlobByte(image,GetStringInfoDatum(profile)[i]);
(void) WriteBlobString(image,"\n%end_xml_packet\n%end_xml_code\n");
}
- value=GetImageProperty(image,"label");
+ value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
(void) WriteBlobString(image,
"%%DocumentNeededResources: font Times-Roman\n");
*/
(void) WriteBlobString(image,"%%Orientation: Portrait\n");
(void) WriteBlobString(image,"%%PageOrder: Ascend\n");
- (void) FormatMagickString(buffer,MaxTextExtent,"%%%%Pages: %.20g\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%%%%Pages: %.20g\n",
image_info->adjoin != MagickFalse ? (double)
GetImageListLength(image) : 1.0);
(void) WriteBlobString(image,buffer);
Image
*preview_image;
- ssize_t
- y;
-
Quantum
pixel;
register ssize_t
x;
+ ssize_t
+ y;
+
/*
Create preview image.
*/
- preview_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ preview_image=CloneImage(image,0,0,MagickTrue,exception);
if (preview_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
/*
Dump image as bitmap.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%%%%BeginPreview: %.20g %.20g %.20g %.20g\n%% ",(double)
preview_image->columns,(double) preview_image->rows,1.0,
(double) ((((preview_image->columns+7) >> 3)*preview_image->rows+
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(preview_image,0,y,preview_image->columns,1,
- &preview_image->exception);
- if (p == (const PixelPacket *) NULL)
+ exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(preview_image);
bit=0;
byte=0;
for (x=0; x < (ssize_t) preview_image->columns; x++)
{
byte<<=1;
- pixel=PixelIntensityToQuantum(p);
+ pixel=GetPixelIntensity(preview_image,p);
if (pixel >= (Quantum) (QuantumRange/2))
byte|=0x01;
bit++;
*/
for (s=PostscriptProlog; *s != (char *) NULL; s++)
{
- (void) FormatMagickString(buffer,MaxTextExtent,"%s\n",*s);
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%s\n",*s);
(void) WriteBlobString(image,buffer);
}
- value=GetImageProperty(image,"label");
+ value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
for (j=(ssize_t) MultilineCensus(value)-1; j >= 0; j--)
{
(void) WriteBlobString(image," /label 512 string def\n");
(void) WriteBlobString(image," currentfile label readline pop\n");
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
" 0 y %g add moveto label show pop\n",j*pointsize+12);
(void) WriteBlobString(image,buffer);
}
for (s=PostscriptEpilog; *s != (char *) NULL; s++)
{
- (void) FormatMagickString(buffer,MaxTextExtent,"%s\n",*s);
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%s\n",*s);
(void) WriteBlobString(image,buffer);
}
if (LocaleCompare(image_info->magick,"PS") == 0)
(void) WriteBlobString(image,"} bind def\n");
(void) WriteBlobString(image,"%%EndProlog\n");
}
- (void) FormatMagickString(buffer,MaxTextExtent,"%%%%Page: 1 %.20g\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%%%%Page: 1 %.20g\n",
(double) (page++));
(void) WriteBlobString(image,buffer);
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%%%%PageBoundingBox: %.20g %.20g %.20g %.20g\n",(double) geometry.x,
(double) geometry.y,geometry.x+(double) geometry.width,geometry.y+(double)
(geometry.height+text_size));
bounds.x2=(double) geometry.x+geometry.width-1;
if ((double) (geometry.y+(geometry.height+text_size)-1) > bounds.y2)
bounds.y2=(double) geometry.y+(geometry.height+text_size)-1;
- value=GetImageProperty(image,"label");
+ value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
(void) WriteBlobString(image,"%%%%PageResources: font Times-Roman\n");
if (LocaleCompare(image_info->magick,"PS") != 0)
/*
Output image data.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,"%.20g %.20g\n%g %g\n%g\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%.20g %.20g\n%g %g\n%g\n",
(double) geometry.x,(double) geometry.y,scale.x,scale.y,pointsize);
(void) WriteBlobString(image,buffer);
labels=(char **) NULL;
- value=GetImageProperty(image,"label");
+ value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
labels=StringToList(value);
if (labels != (char **) NULL)
{
for (i=0; labels[i] != (char *) NULL; i++)
{
- (void) FormatMagickString(buffer,MaxTextExtent,"%s \n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%s \n",
labels[i]);
(void) WriteBlobString(image,buffer);
labels[i]=DestroyString(labels[i]);
labels=(char **) RelinquishMagickMemory(labels);
}
(void) ResetMagickMemory(&pixel,0,sizeof(pixel));
- pixel.opacity=(Quantum) TransparentOpacity;
- index=(IndexPacket) 0;
+ pixel.alpha=(Quantum) TransparentAlpha;
+ index=0;
x=0;
if ((image_info->type != TrueColorType) &&
- (IsGrayImage(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
- if (IsMonochromeImage(image,&image->exception) == MagickFalse)
+ if (IsImageMonochrome(image,exception) == MagickFalse)
{
Quantum
pixel;
/*
Dump image as grayscale.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%.20g %.20g\n1\n1\n1\n8\n",(double) image->columns,(double)
image->rows);
(void) WriteBlobString(image,buffer);
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel=(Quantum) ScaleQuantumToChar(PixelIntensityToQuantum(p));
+ pixel=(Quantum) ScaleQuantumToChar(GetPixelIntensity(image,p));
q=PopHexPixel(hex_digits,(size_t) pixel,q);
i++;
if ((q-pixels+8) >= 80)
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p++;
+ p+=GetPixelChannels(image);
}
if (image->previous == (Image *) NULL)
{
/*
Dump image as bitmap.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%.20g %.20g\n1\n1\n1\n1\n",(double) image->columns,(double)
image->rows);
(void) WriteBlobString(image,buffer);
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(image);
bit=0;
byte=0;
for (x=0; x < (ssize_t) image->columns; x++)
{
byte<<=1;
- pixel=PixelIntensityToQuantum(p);
+ pixel=GetPixelIntensity(image,p);
if (pixel >= (Quantum) (QuantumRange/2))
byte|=0x01;
bit++;
bit=0;
byte=0;
}
- p++;
+ p+=GetPixelChannels(image);
}
if (bit != 0)
{
};
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
+ y,image->rows);
if (status == MagickFalse)
break;
}
}
else
if ((image->storage_class == DirectClass) ||
- (image->colors > 256) || (image->matte != MagickFalse))
+ (image->colors > 256) || (image->alpha_trait == BlendPixelTrait))
{
/*
Dump DirectClass image.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,"%.20g %.20g\n0\n%d\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%.20g %.20g\n0\n%d\n",
(double) image->columns,(double) image->rows,
image_info->compression == RLECompression ? 1 : 0);
(void) WriteBlobString(image,buffer);
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- pixel=(*p);
+ GetPixelInfoPixel(image,p,&pixel);
length=255;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((p->red == pixel.red) && (p->green == pixel.green) &&
- (p->blue == pixel.blue) &&
- (p->opacity == pixel.opacity) && (length < 255) &&
- (x < (ssize_t) (image->columns-1)))
+ if ((GetPixelRed(image,p) == pixel.red) &&
+ (GetPixelGreen(image,p) == pixel.green) &&
+ (GetPixelBlue(image,p) == pixel.blue) &&
+ (GetPixelAlpha(image,p) == pixel.alpha) &&
+ (length < 255) && (x < (ssize_t) (image->columns-1)))
length++;
else
{
}
length=0;
}
- pixel=(*p);
- p++;
+ GetPixelInfoPixel(image,p,&pixel);
+ p+=GetPixelChannels(image);
}
WriteRunlengthPacket(image,pixel,length,p);
if ((q-pixels+10) >= 80)
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ status=SetImageProgress(image,SaveImageTag,
+ (MagickOffsetType) y,image->rows);
if (status == MagickFalse)
break;
}
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((image->matte != MagickFalse) &&
- (p->opacity == (Quantum) TransparentOpacity))
+ if ((image->alpha_trait == BlendPixelTrait) &&
+ (GetPixelAlpha(image,p) == (Quantum) TransparentAlpha))
{
q=PopHexPixel(hex_digits,0xff,q);
q=PopHexPixel(hex_digits,0xff,q);
}
else
{
- q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetRedPixelComponent(p)),q);
- q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
- q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetBluePixelComponent(p)),q);
+ q=PopHexPixel(hex_digits,ScaleQuantumToChar(
+ GetPixelRed(image,p)),q);
+ q=PopHexPixel(hex_digits,ScaleQuantumToChar(
+ GetPixelGreen(image,p)),q);
+ q=PopHexPixel(hex_digits,ScaleQuantumToChar(
+ GetPixelBlue(image,p)),q);
}
if ((q-pixels+6) >= 80)
{
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p++;
+ p+=GetPixelChannels(image);
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ status=SetImageProgress(image,SaveImageTag,
+ (MagickOffsetType) y,image->rows);
if (status == MagickFalse)
break;
}
/*
Dump PseudoClass image.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%.20g %.20g\n%d\n%d\n0\n",(double) image->columns,(double)
image->rows,image->storage_class == PseudoClass ? 1 : 0,
image_info->compression == RLECompression ? 1 : 0);
/*
Dump number of colors and colormap.
*/
- (void) FormatMagickString(buffer,MaxTextExtent,"%.20g\n",(double)
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%.20g\n",(double)
image->colors);
(void) WriteBlobString(image,buffer);
for (i=0; i < (ssize_t) image->colors; i++)
{
- (void) FormatMagickString(buffer,MaxTextExtent,"%02X%02X%02X\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"%02X%02X%02X\n",
ScaleQuantumToChar(image->colormap[i].red),
ScaleQuantumToChar(image->colormap[i].green),
ScaleQuantumToChar(image->colormap[i].blue));
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(image);
- index=(*indexes);
+ index=GetPixelIndex(image,p);
length=255;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((index == indexes[x]) && (length < 255) &&
- (x < ((ssize_t) image->columns-1)))
+ if ((index == GetPixelIndex(image,p)) &&
+ (length < 255) && (x < ((ssize_t) image->columns-1)))
length++;
else
{
}
length=0;
}
- index=indexes[x];
- pixel=(*p);
- p++;
+ index=GetPixelIndex(image,p);
+ pixel.red=GetPixelRed(image,p);
+ pixel.green=GetPixelGreen(image,p);
+ pixel.blue=GetPixelBlue(image,p);
+ pixel.alpha=GetPixelAlpha(image,p);
+ p+=GetPixelChannels(image);
}
q=PopHexPixel(hex_digits,(size_t) index,q);
q=PopHexPixel(hex_digits,(size_t)
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
- q=PopHexPixel(hex_digits,(size_t) indexes[x],q);
+ q=PopHexPixel(hex_digits,(size_t) GetPixelIndex(image,p),q);
if ((q-pixels+4) >= 80)
{
*q++='\n';
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p++;
+ p+=GetPixelChannels(image);
}
if (image->previous == (Image *) NULL)
{
(void) WriteBlobString(image,"%%Trailer\n");
if (page > 2)
{
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"%%%%BoundingBox: %.20g %.20g %.20g %.20g\n",ceil(bounds.x1-0.5),
- ceil(bounds.y1-0.5),floor(bounds.x2+0.5),floor(bounds.y2+0.5));
+ ceil(bounds.y1-0.5),floor(bounds.x2-0.5),floor(bounds.y2-0.5));
(void) WriteBlobString(image,buffer);
- (void) FormatMagickString(buffer,MaxTextExtent,
- "%%%%HiResBoundingBox: %g %g %g %g\n",bounds.x1,bounds.y1,
- bounds.x2,bounds.y2);
+ (void) FormatLocaleString(buffer,MaxTextExtent,
+ "%%%%HiResBoundingBox: %g %g %g %g\n",bounds.x1,bounds.y1,bounds.x2,
+ bounds.y2);
(void) WriteBlobString(image,buffer);
}
(void) WriteBlobString(image,"%%EOF\n");
projects / imagemagick / blobdiff