/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

% GGGG EEEEE OOO M M EEEEE TTTTT RRRR Y Y %

% G E O O MM MM E T R R Y Y %

% G GG EEE O O M M M EEE T RRRR Y %

% G G E O O M M E T R R Y %

% GGGG EEEEE OOO M M EEEEE T R R Y %

% %

% %

% MagickCore Geometry Methods %

% %

% Software Design %

% Cristy %

% January 2003 %

% %

% %

% Copyright 1999-2020 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 %

% obtain a copy of the License at %

% %

% https://imagemagick.org/script/license.php %

% %

% Unless required by applicable law or agreed to in writing, software %

% distributed under the License is distributed on an "AS IS" BASIS, %

% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %

% See the License for the specific language governing permissions and %

% limitations under the License. %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

*/



/*

Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/constitute.h"

#include "MagickCore/draw.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/geometry.h"

#include "MagickCore/image-private.h"

#include "MagickCore/memory_.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/string_.h"

#include "MagickCore/string-private.h"

#include "MagickCore/token.h"



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

% G e t G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% GetGeometry() parses a geometry specification and returns the width,

% height, x, and y values. It also returns flags that indicates which

% of the four values (width, height, x, y) were located in the string, and

% whether the x or y values are negative. In addition, there are flags to

% report any meta characters (%, !, <, or >).

%

% The value must form a proper geometry style specification of WxH+X+Y

% of integers only, and values can not be separated by comma, colon, or

% slash charcaters. See ParseGeometry() below.

%

% Offsets may be prefixed by multiple signs to make offset string

% substitutions easier to handle from shell scripts.

% For example: "-10-10", "-+10-+10", or "+-10+-10" will generate negtive

% offsets, while "+10+10", "++10++10", or "--10--10" will generate positive

% offsets.

%

% The format of the GetGeometry method is:

%

% MagickStatusType GetGeometry(const char *geometry,ssize_t *x,ssize_t *y,

% size_t *width,size_t *height)

%

% A description of each parameter follows:

%

% o geometry: The geometry.

%

% o x,y: The x and y offset as determined by the geometry specification.

%

% o width,height: The width and height as determined by the geometry

% specification.

%

*/

MagickExport MagickStatusType GetGeometry(const char *geometry,ssize_t *x,

ssize_t *y,size_t *width,size_t *height)

{

char

*p,

pedantic_geometry[MagickPathExtent],

*q;

double

value;

int

c;

MagickStatusType

flags;

/*

Remove whitespace and meta characters from geometry specification.

*/

flags=NoValue;

if ((geometry == (char *) NULL) || (*geometry == '\0'))

return(flags);

if (strlen(geometry) >= (MagickPathExtent-1))

return(flags);

(void) CopyMagickString(pedantic_geometry,geometry,MagickPathExtent);

for (p=pedantic_geometry; *p != '\0'; )

{

if (isspace((int) ((unsigned char) *p)) != 0)

{

(void) CopyMagickString(p,p+1,MagickPathExtent);

continue;

}

c=(int)*p;

switch (c)

{

case '%':

{

flags|=PercentValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '!':

{

flags|=AspectValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '<':

{

flags|=LessValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '>':

{

flags|=GreaterValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '^':

{

flags|=MinimumValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '@':

{

flags|=AreaValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '(':

case ')':

{

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case 'x':

case 'X':

{

flags|=SeparatorValue;

p++;

break;

}

case '-':

case ',':

case '+':

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

case 215:

case 'e':

case 'E':

{

p++;

break;

}

case '.':

{

p++;

flags|=DecimalValue;

break;

}

case ':':

{

p++;

flags|=AspectRatioValue;

break;

}

default:

return(flags);

}

}

/*

Parse width, height, x, and y.

*/

p=pedantic_geometry;

if (*p == '\0')

return(flags);

q=p;

value=StringToDouble(p,&q);

(void) value;

if (LocaleNCompare(p,"0x",2) == 0)

value=(double) strtol(p,&q,10);

if ((*p != '+') && (*p != '-'))

{

c=(int) ((unsigned char) *q);

if ((c == 215) || (*q == 'x') || (*q == 'X') || (*q == ':') ||

(*q == '\0'))

{

/*

Parse width.

*/

q=p;

if (width != (size_t *) NULL)

{

if (LocaleNCompare(p,"0x",2) == 0)

*width=(size_t) strtol(p,&p,10);

else

*width=((size_t) floor(StringToDouble(p,&p)+0.5)) & 0x7fffffff;

}

if (p != q)

flags|=WidthValue;

}

}

if ((*p != '+') && (*p != '-'))

{

c=(int) ((unsigned char) *p);

if ((c == 215) || (*p == 'x') || (*p == 'X') || (*p == ':'))

{

p++;

if ((*p != '+') && (*p != '-'))

{

/*

Parse height.

*/

q=p;

if (height != (size_t *) NULL)

*height=((size_t) floor(StringToDouble(p,&p)+0.5)) & 0x7fffffff;

if (p != q)

flags|=HeightValue;

}

}

}

if ((*p == '+') || (*p == '-'))

{

/*

Parse x value.

*/

while ((*p == '+') || (*p == '-'))

{

if (*p == '-')

flags^=XNegative; /* negate sign */

p++;

}

q=p;

if (x != (ssize_t *) NULL)

*x=((ssize_t) ceil(StringToDouble(p,&p)-0.5)) & 0x7fffffff;

if (p != q)

{

flags|=XValue;

if (((flags & XNegative) != 0) && (x != (ssize_t *) NULL))

*x=(-*x);

}

}

if ((*p == '+') || (*p == '-'))

{

/*

Parse y value.

*/

while ((*p == '+') || (*p == '-'))

{

if (*p == '-')

flags^=YNegative; /* negate sign */

p++;

}

q=p;

if (y != (ssize_t *) NULL)

*y=((ssize_t) ceil(StringToDouble(p,&p)-0.5)) & 0x7fffffff;

if (p != q)

{

flags|=YValue;

if (((flags & YNegative) != 0) && (y != (ssize_t *) NULL))

*y=(-*y);

}

}

if ((flags & PercentValue) != 0)

{

if (((flags & SeparatorValue) == 0) && ((flags & HeightValue) == 0))

{

if ((height != (size_t *) NULL) && (width != (size_t *) NULL))

*height=(*width);

flags|=HeightValue;

}

if (((flags & SeparatorValue) != 0) && ((flags & WidthValue) == 0) &&

(height != (size_t *) NULL) && (width != (size_t *) NULL))

*width=(*height);

}

#if 0

/* Debugging Geometry */

(void) fprintf(stderr,"GetGeometry...\n");

(void) fprintf(stderr,"Input: %s\n",geometry);

(void) fprintf(stderr,"Flags: %c %c %s %s\n",

(flags & WidthValue) ? 'W' : ' ',(flags & HeightValue) ? 'H' : ' ',

(flags & XValue) ? ((flags & XNegative) ? "-X" : "+X") : " ",

(flags & YValue) ? ((flags & YNegative) ? "-Y" : "+Y") : " ");

(void) fprintf(stderr,"Geometry: %ldx%ld%+ld%+ld\n",(long) *width,(long)

*height,(long) *x,(long) *y);

#endif

return(flags);

}



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

% G e t P a g e G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% GetPageGeometry() replaces any page mneumonic with the equivalent size in

% picas.

%

% The format of the GetPageGeometry method is:

%

% char *GetPageGeometry(const char *page_geometry)

%

% A description of each parameter follows.

%

% o page_geometry: Specifies a pointer to an array of characters. The

% string is either a Postscript page name (e.g. A4) or a postscript page

% geometry (e.g. 612x792+36+36).

%

*/

MagickExport char *GetPageGeometry(const char *page_geometry)

{

#define MagickPageSize(name,geometry) { (name), sizeof(name)-1, (geometry) }

typedef struct _PageInfo

{

const char

name[12];

size_t

extent;

const char

geometry[10];

} PageInfo;

static const PageInfo

PageSizes[] =

{

MagickPageSize("4x6", "288x432"),

MagickPageSize("5x7", "360x504"),

MagickPageSize("7x9", "504x648"),

MagickPageSize("8x10", "576x720"),

MagickPageSize("9x11", "648x792"),

MagickPageSize("9x12", "648x864"),

MagickPageSize("10x13", "720x936"),

MagickPageSize("10x14", "720x1008"),

MagickPageSize("11x17", "792x1224"),

MagickPageSize("a0", "2384x3370"),

MagickPageSize("a1", "1684x2384"),

MagickPageSize("a10", "73x105"),

MagickPageSize("a2", "1191x1684"),

MagickPageSize("a3", "842x1191"),

MagickPageSize("a4", "595x842"),

MagickPageSize("a4small", "595x842"),

MagickPageSize("a5", "420x595"),

MagickPageSize("a6", "297x420"),

MagickPageSize("a7", "210x297"),

MagickPageSize("a8", "148x210"),

MagickPageSize("a9", "105x148"),

MagickPageSize("archa", "648x864"),

MagickPageSize("archb", "864x1296"),

MagickPageSize("archC", "1296x1728"),

MagickPageSize("archd", "1728x2592"),

MagickPageSize("arche", "2592x3456"),

MagickPageSize("b0", "2920x4127"),

MagickPageSize("b1", "2064x2920"),

MagickPageSize("b10", "91x127"),

MagickPageSize("b2", "1460x2064"),

MagickPageSize("b3", "1032x1460"),

MagickPageSize("b4", "729x1032"),

MagickPageSize("b5", "516x729"),

MagickPageSize("b6", "363x516"),

MagickPageSize("b7", "258x363"),

MagickPageSize("b8", "181x258"),

MagickPageSize("b9", "127x181"),

MagickPageSize("c0", "2599x3676"),

MagickPageSize("c1", "1837x2599"),

MagickPageSize("c2", "1298x1837"),

MagickPageSize("c3", "918x1296"),

MagickPageSize("c4", "649x918"),

MagickPageSize("c5", "459x649"),

MagickPageSize("c6", "323x459"),

MagickPageSize("c7", "230x323"),

MagickPageSize("csheet", "1224x1584"),

MagickPageSize("dsheet", "1584x2448"),

MagickPageSize("esheet", "2448x3168"),

MagickPageSize("executive", "540x720"),

MagickPageSize("flsa", "612x936"),

MagickPageSize("flse", "612x936"),

MagickPageSize("folio", "612x936"),

MagickPageSize("halfletter", "396x612"),

MagickPageSize("isob0", "2835x4008"),

MagickPageSize("isob1", "2004x2835"),

MagickPageSize("isob10", "88x125"),

MagickPageSize("isob2", "1417x2004"),

MagickPageSize("isob3", "1001x1417"),

MagickPageSize("isob4", "709x1001"),

MagickPageSize("isob5", "499x709"),

MagickPageSize("isob6", "354x499"),

MagickPageSize("isob7", "249x354"),

MagickPageSize("isob8", "176x249"),

MagickPageSize("isob9", "125x176"),

MagickPageSize("jisb0", "1030x1456"),

MagickPageSize("jisb1", "728x1030"),

MagickPageSize("jisb2", "515x728"),

MagickPageSize("jisb3", "364x515"),

MagickPageSize("jisb4", "257x364"),

MagickPageSize("jisb5", "182x257"),

MagickPageSize("jisb6", "128x182"),

MagickPageSize("ledger", "1224x792"),

MagickPageSize("legal", "612x1008"),

MagickPageSize("letter", "612x792"),

MagickPageSize("lettersmall", "612x792"),

MagickPageSize("monarch", "279x540"),

MagickPageSize("quarto", "610x780"),

MagickPageSize("statement", "396x612"),

MagickPageSize("tabloid", "792x1224")

};

char

page[MaxTextExtent];

register ssize_t

i;

assert(page_geometry != (char *) NULL);

(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",page_geometry);

(void) CopyMagickString(page,page_geometry,MaxTextExtent);

for (i=0; i < (ssize_t) (sizeof(PageSizes)/sizeof(PageSizes[0])); i++)

{

int

status;

status=LocaleNCompare(PageSizes[i].name,page_geometry,PageSizes[i].extent);

if (status == 0)

{

MagickStatusType

flags;

RectangleInfo

geometry;

/*

Replace mneumonic with the equivalent size in dots-per-inch.

*/

(void) FormatLocaleString(page,MaxTextExtent,"%s%.80s",

PageSizes[i].geometry,page_geometry+PageSizes[i].extent);

flags=GetGeometry(page,&geometry.x,&geometry.y,&geometry.width,

&geometry.height);

if ((flags & GreaterValue) == 0)

(void) ConcatenateMagickString(page,">",MaxTextExtent);

break;

}

}

return(AcquireString(page));

}



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

% G r a v i t y A d j u s t G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% GravityAdjustGeometry() adjusts the offset of a region with regard to the

% given: width, height and gravity; against which it is positioned.

%

% The region should also have an appropriate width and height to correctly

% set the right offset of the top left corner of the region.

%

% The format of the GravityAdjustGeometry method is:

%

% void GravityAdjustGeometry(const size_t width, const size_t height,

% const GravityType gravity,RectangleInfo *region);

%

% A description of each parameter follows:

%

% o width, height: the larger area the region is relative to

%

% o gravity: the edge/corner the current offset is relative to

%

% o region: The region requiring a offset adjustment relative to gravity

%

*/

MagickExport void GravityAdjustGeometry(const size_t width,

const size_t height,const GravityType gravity,RectangleInfo *region)

{

if (region->height == 0)

region->height=height;

if (region->width == 0)

region->width=width;

switch (gravity)

{

case NorthEastGravity:

case EastGravity:

case SouthEastGravity:

{

region->x=(ssize_t) (width-region->width-region->x);

break;

}

case NorthGravity:

case SouthGravity:

case CenterGravity:

{

region->x+=(ssize_t) (width/2-region->width/2);

break;

}

case ForgetGravity:

case NorthWestGravity:

case WestGravity:

case SouthWestGravity:

default:

break;

}

switch (gravity)

{

case SouthWestGravity:

case SouthGravity:

case SouthEastGravity:

{

region->y=(ssize_t) (height-region->height-region->y);

break;

}

case EastGravity:

case WestGravity:

case CenterGravity:

{

region->y+=(ssize_t) (height/2-region->height/2);

break;

}

case ForgetGravity:

case NorthWestGravity:

case NorthGravity:

case NorthEastGravity:

default:

break;

}

return;

}



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

+ I s G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% IsGeometry() returns MagickTrue if the geometry specification is valid.

% Examples are 100, 100x200, x200, 100x200+10+20, +10+20, 200%, 200x200!, etc.

%

% The format of the IsGeometry method is:

%

% MagickBooleanType IsGeometry(const char *geometry)

%

% A description of each parameter follows:

%

% o geometry: This string is the geometry specification.

%

*/

MagickExport MagickBooleanType IsGeometry(const char *geometry)

{

GeometryInfo

geometry_info;

MagickStatusType

flags;

if (geometry == (const char *) NULL)

return(MagickFalse);

flags=ParseGeometry(geometry,&geometry_info);

return(flags != NoValue ? MagickTrue : MagickFalse);

}



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

+ I s S c e n e G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% IsSceneGeometry() returns MagickTrue if the geometry is a valid scene

% specification (e.g. [1], [1-9], [1,7,4]).

%

% The format of the IsSceneGeometry method is:

%

% MagickBooleanType IsSceneGeometry(const char *geometry,

% const MagickBooleanType pedantic)

%

% A description of each parameter follows:

%

% o geometry: This string is the geometry specification.

%

% o pedantic: A value other than 0 invokes a more restrictive set of

% conditions for a valid specification (e.g. [1], [1-4], [4-1]).

%

*/

MagickExport MagickBooleanType IsSceneGeometry(const char *geometry,

const MagickBooleanType pedantic)

{

char

*p;

double

value;

if (geometry == (const char *) NULL)

return(MagickFalse);

p=(char *) geometry;

value=StringToDouble(geometry,&p);

(void) value;

if (p == geometry)

return(MagickFalse);

if (strspn(geometry,"0123456789-, ") != strlen(geometry))

return(MagickFalse);

if ((pedantic != MagickFalse) && (strchr(geometry,',') != (char *) NULL))

return(MagickFalse);

return(MagickTrue);

}



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

% P a r s e A b s o l u t e G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% ParseAbsoluteGeometry() returns a region as defined by the geometry string,

% without any modification by percentages or gravity.

%

% It currently just a wrapper around GetGeometry(), but may be expanded in

% the future to handle other positioning information.

%

% The format of the ParseAbsoluteGeometry method is:

%

% MagickStatusType ParseAbsoluteGeometry(const char *geometry,

% RectangleInfo *region_info)

%

% A description of each parameter follows:

%

% o geometry: The geometry string (e.g. "100x100+10+10").

%

% o region_info: the region as defined by the geometry string.

%

*/

MagickExport MagickStatusType ParseAbsoluteGeometry(const char *geometry,

RectangleInfo *region_info)

{

MagickStatusType

flags;

flags=GetGeometry(geometry,&region_info->x,&region_info->y,

&region_info->width,&region_info->height);

return(flags);

}



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

% P a r s e A f f i n e G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% ParseAffineGeometry() returns an affine matrix as defined by a string of 4

% to 6 comma/space separated floating point values.

%

% The affine matrix determinant is checked for validity of the values.

%

% The format of the ParseAffineGeometry method is:

%

% MagickStatusType ParseAffineGeometry(const char *geometry,

% AffineMatrix *affine_matrix,ExceptionInfo *exception)

%

% A description of each parameter follows:

%

% o geometry: The geometry string (e.g. "1.0,0.0,0.0,1.0,3.2,1.2").

%

% o affine_matrix: the affine matrix as defined by the geometry string.

%

% o exception: return any errors or warnings in this structure.

%

*/

MagickExport MagickStatusType ParseAffineGeometry(const char *geometry,

AffineMatrix *affine_matrix,ExceptionInfo *exception)

{

char

token[MagickPathExtent];

const char

*p;

double

determinant;

MagickStatusType

flags;

register ssize_t

i;

GetAffineMatrix(affine_matrix);

flags=NoValue;

p=(char *) geometry;

for (i=0; (*p != '\0') && (i < 6); i++)

{

(void) GetNextToken(p,&p,MagickPathExtent,token);

if (*token == ',')

(void) GetNextToken(p,&p,MagickPathExtent,token);

switch (i)

{

case 0:

{

affine_matrix->sx=StringToDouble(token,(char **) NULL);

break;

}

case 1:

{

affine_matrix->rx=StringToDouble(token,(char **) NULL);

break;

}

case 2:

{

affine_matrix->ry=StringToDouble(token,(char **) NULL);

break;

}

case 3:

{

affine_matrix->sy=StringToDouble(token,(char **) NULL);

break;

}

case 4:

{

affine_matrix->tx=StringToDouble(token,(char **) NULL);

flags|=XValue;

break;

}

case 5:

{

affine_matrix->ty=StringToDouble(token,(char **) NULL);

flags|=YValue;

break;

}

}

}

determinant=(affine_matrix->sx*affine_matrix->sy-affine_matrix->rx*

affine_matrix->ry);

if (fabs(determinant) < MagickEpsilon)

(void) ThrowMagickException(exception,GetMagickModule(),OptionError,

"InvalidArgument","'%s' : 'Indeterminate Matrix'",geometry);

return(flags);

}



/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% %

% %

% %

% P a r s e G e o m e t r y %

% %

% %

% %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% ParseGeometry() parses a geometry specification and returns the sigma,

% rho, xi, and psi values. It also returns flags that indicates which

% of the four values (sigma, rho, xi, psi) were located in the string, and

% whether the xi or pi values are negative.

%

% In addition, it reports if there are any of meta characters (%, !, <, >, @,

% and ^) flags present. It does not report the location of the percentage

% relative to the values.

%

% Values may also be separated by commas, colons, or slashes, and offsets.

% Offsets may be prefixed by multiple signs to make offset string

% substitutions easier to handle from shell scripts.

% For example: "-10-10", "-+10-+10", or "+-10+-10" will generate negtive

% offsets, while "+10+10", "++10++10", or "--10--10" will generate positive

% offsets.

%

% The format of the ParseGeometry method is:

%

% MagickStatusType ParseGeometry(const char *geometry,

% GeometryInfo *geometry_info)

%

% A description of each parameter follows:

%

% o geometry: The geometry string (e.g. "100x100+10+10").

%

% o geometry_info: returns the parsed width/height/x/y in this structure.

%

*/

MagickExport MagickStatusType ParseGeometry(const char *geometry,

GeometryInfo *geometry_info)

{

char

*p,

pedantic_geometry[MagickPathExtent],

*q;

double

value;

GeometryInfo

coordinate;

int

c;

MagickStatusType

flags;

/*

Remove whitespaces meta characters from geometry specification.

*/

assert(geometry_info != (GeometryInfo *) NULL);

(void) memset(geometry_info,0,sizeof(*geometry_info));

flags=NoValue;

if ((geometry == (char *) NULL) || (*geometry == '\0'))

return(flags);

if (strlen(geometry) >= (MagickPathExtent-1))

return(flags);

c=sscanf(geometry,"%lf%*[ ,]%lf%*[ ,]%lf%*[ ,]%lf",&coordinate.rho,

&coordinate.sigma,&coordinate.xi,&coordinate.psi);

if (c == 4)

{

/*

Special case: coordinate (e.g. 0,0 255,255).

*/

geometry_info->rho=coordinate.rho;

geometry_info->sigma=coordinate.sigma;

geometry_info->xi=coordinate.xi;

geometry_info->psi=coordinate.psi;

flags|=RhoValue | SigmaValue | XiValue | PsiValue;

return(flags);

}

(void) CopyMagickString(pedantic_geometry,geometry,MagickPathExtent);

for (p=pedantic_geometry; *p != '\0'; )

{

c=(int) ((unsigned char) *p);

if (isspace(c) != 0)

{

(void) CopyMagickString(p,p+1,MagickPathExtent);

continue;

}

switch (c)

{

case '%':

{

flags|=PercentValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '!':

{

flags|=AspectValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '<':

{

flags|=LessValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '>':

{

flags|=GreaterValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '^':

{

flags|=MinimumValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '@':

{

flags|=AreaValue;

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case '(':

{

if (*(p+1) == ')')

return(flags);

}

case ')':

{

(void) CopyMagickString(p,p+1,MagickPathExtent);

break;

}

case 'x':

case 'X':

{

flags|=SeparatorValue;

p++;

break;

}

case '-':

case '+':

case ',':

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

case '/':

case 215:

case 'e':

case 'E':

{

p++;

break;

}

case '.':

{

p++;

flags|=DecimalValue;

break;

}

case ':':

{

p++;

flags|=AspectRatioValue;

break;

}

default:

return(NoValue);

}

}

/*

Parse rho, sigma, xi, psi, and optionally chi.

*/