/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % 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-2021 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("4A0", "4768x6741"), MagickPageSize("2A0", "3370x4768"), MagickPageSize("a0", "2384x3370"), MagickPageSize("a1", "1684x2384"), MagickPageSize("a2", "1191x1684"), MagickPageSize("a3", "842x1191"), MagickPageSize("a4", "595x842"), MagickPageSize("a4small", "595x842"), MagickPageSize("a5", "420x595"), MagickPageSize("a6", "298x420"), MagickPageSize("a7", "210x298"), MagickPageSize("a8", "147x210"), MagickPageSize("a9", "105x147"), MagickPageSize("a10", "74x105"), 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[MagickPathExtent]; ssize_t i; assert(page_geometry != (char *) NULL); (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",page_geometry); (void) CopyMagickString(page,page_geometry,MagickPathExtent); 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,MagickPathExtent,"%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,">",MagickPathExtent); 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); if (IsNaN(value) != 0) return(MagickFalse); if (value > (double) MAGICK_SSIZE_MAX) return(MagickFalse); if (value < (double) MAGICK_SSIZE_MIN) return(MagickFalse); 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,®ion_info->x,®ion_info->y, ®ion_info->width,®ion_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; 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((int) ((unsigned char) 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. */ p=pedantic_geometry; if (*p == '\0') return(flags); q=p; value=StringToDouble(p,&q); if (LocaleNCompare(p,"0x",2) == 0) (void) strtol(p,&q,10); c=(int) ((unsigned char) *q); if ((c == 215) || (*q == 'x') || (*q == 'X') || (*q == ':') || (*q == ',') || (*q == '/') || (*q =='\0')) { /* Parse rho. */ q=p; if (LocaleNCompare(p,"0x",2) == 0) value=(double) strtol(p,&p,10); else value=StringToDouble(p,&p); if (p != q) { flags|=RhoValue; geometry_info->rho=value; } } q=p; c=(int) ((unsigned char) *p); if ((c == 215) || (*p == 'x') || (*p == 'X') || (*p == ':') || (*p == ',') || (*p == '/')) { /* Parse sigma. */ p++; while (isspace((int) ((unsigned char) *p)) != 0) p++; c=(int) ((unsigned char) *q); if (((c != 215) && (*q != 'x') && (*q != 'X') && (*q != ':')) || ((*p != '+') && (*p != '-'))) { q=p; value=StringToDouble(p,&p); if (p != q) { flags|=SigmaValue; geometry_info->sigma=value; } } } while (isspace((int) ((unsigned char) *p)) != 0) p++; if ((*p == '+') || (*p == '-') || (*p == ',') || (*p == '/') || (*p == ':')) { /* Parse xi value. */ if ((*p == ',') || (*p == '/') || (*p == ':') ) p++; while ((*p == '+') || (*p == '-')) { if (*p == '-') flags^=XiNegative; /* negate sign */ p++; } q=p; value=StringToDouble(p,&p); if (p != q) { flags|=XiValue; if ((flags & XiNegative) != 0) value=(-value); geometry_info->xi=value; } while (isspace((int) ((unsigned char) *p)) != 0) p++; if ((*p == '+') || (*p == '-') || (*p == ',') || (*p == '/') || (*p == ':')) { /* Parse psi value. */ if ((*p == ',') || (*p == '/') || (*p == ':')) p++; while ((*p == '+') || (*p == '-')) { if (*p == '-') flags^=PsiNegative; /* negate sign */ p++; } q=p; value=StringToDouble(p,&p); if (p != q) { flags|=PsiValue; if ((flags & PsiNegative) != 0) value=(-value); geometry_info->psi=value; } } while (isspace((int) ((unsigned char) *p)) != 0) p++; if ((*p == '+') || (*p == '-') || (*p == ',') || (*p == '/') || (*p == ':')) { /* Parse chi value. */ if ((*p == ',') || (*p == '/') || (*p == ':')) p++; while ((*p == '+') || (*p == '-')) { if (*p == '-') flags^=ChiNegative; /* negate sign */ p++; } q=p; value=StringToDouble(p,&p); if (p != q) { flags|=ChiValue; if ((flags & ChiNegative) != 0) value=(-value); geometry_info->chi=value; } } } if (strchr(pedantic_geometry,':') != (char *) NULL) { /* Normalize sampling factor (e.g. 4:2:2 => 2x1). */ if ((flags & SigmaValue) != 0) geometry_info->rho*=PerceptibleReciprocal(geometry_info->sigma); geometry_info->sigma=1.0; if (((flags & XiValue) != 0) && (geometry_info->xi == 0.0)) geometry_info->sigma=2.0; } if (((flags & RhoValue) != 0) && ((flags & SigmaValue) == 0) && ((flags & XiValue) != 0) && ((flags & XiNegative) != 0)) { if ((flags & PsiValue) == 0) { /* Support negative height values (e.g. 30x-20). */ geometry_info->sigma=geometry_info->xi; geometry_info->xi=0.0; flags|=SigmaValue; flags&=(~XiValue); } else if ((flags & ChiValue) == 0) { /* Support negative height values (e.g. 30x-20+10). */ geometry_info->sigma=geometry_info->xi; geometry_info->xi=geometry_info->psi; flags|=SigmaValue; flags|=XiValue; flags&=(~PsiValue); } else { /* Support negative height values (e.g. 30x-20+10+10). */ geometry_info->sigma=geometry_info->xi; geometry_info->xi=geometry_info->psi; geometry_info->psi=geometry_info->chi; flags|=SigmaValue; flags|=XiValue; flags|=PsiValue; flags&=(~ChiValue); } } if ((flags & PercentValue) != 0) { if (((flags & SeparatorValue) == 0) && ((flags & SigmaValue) == 0)) geometry_info->sigma=geometry_info->rho; if (((flags & SeparatorValue) != 0) && ((flags & RhoValue) == 0)) geometry_info->rho=geometry_info->sigma; } #if 0 /* Debugging Geometry */ (void) fprintf(stderr,"ParseGeometry...\n"); (void) fprintf(stderr,"Flags: %c %c %s %s %s\n", (flags & RhoValue) ? 'W' : ' ',(flags & SigmaValue) ? 'H' : ' ', (flags & XiValue) ? ((flags & XiNegative) ? "-X" : "+X") : " ", (flags & PsiValue) ? ((flags & PsiNegative) ? "-Y" : "+Y") : " ", (flags & ChiValue) ? ((flags & ChiNegative) ? "-Z" : "+Z") : " "); (void) fprintf(stderr,"Geometry: %lg,%lg,%lg,%lg,%lg\n",geometry_info->rho, geometry_info->sigma,geometry_info->xi,geometry_info->psi, geometry_info->chi); #endif return(flags); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % P a r s e G r a v i t y G e o m e t r y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ParseGravityGeometry() returns a region as defined by the geometry string % with respect to the given image page (canvas) dimensions and the images % gravity setting. % % This is typically used for specifing a area within a given image for % cropping images to a smaller size, chopping out rows and or columns, or % resizing and positioning overlay images. % % Percentages are relative to image size and not page size, and are set to % nearest integer (pixel) size. % % The format of the ParseGravityGeometry method is: % % MagickStatusType ParseGravityGeometry(Image *image,const char *geometry, % RectangeInfo *region_info,ExceptionInfo *exception) % % 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 with respect % to the image dimensions and its gravity. % % o exception: return any errors or warnings in this structure. % */ MagickExport MagickStatusType ParseGravityGeometry(const Image *image, const char *geometry,RectangleInfo *region_info,ExceptionInfo *exception) { MagickStatusType flags; size_t height, width; SetGeometry(image,region_info); if (image->page.width != 0) region_info->width=image->page.width; if (image->page.height != 0) region_info->height=image->page.height; flags=ParseAbsoluteGeometry(geometry,region_info); if (flags == NoValue) { (void) ThrowMagickException(exception,GetMagickModule(),OptionError, "InvalidGeometry","`%s'",geometry); return(flags); } if ((flags & PercentValue) != 0) { GeometryInfo geometry_info; MagickStatusType status; PointInfo scale; /* Geometry is a percentage of the image size, not canvas size */ if (image->gravity != UndefinedGravity) flags|=XValue | YValue; status=ParseGeometry(geometry,&geometry_info); scale.x=geometry_info.rho; if ((status & RhoValue) == 0) scale.x=100.0; scale.y=geometry_info.sigma; if ((status & SigmaValue) == 0) scale.y=scale.x; region_info->width=(size_t) floor((scale.x*image->columns/100.0)+0.5); region_info->height=(size_t) floor((scale.y*image->rows/100.0)+0.5); } if ((flags & AspectRatioValue) != 0) { double geometry_ratio, image_ratio; GeometryInfo geometry_info; /* Geometry is a relative to image size and aspect ratio. */ if (image->gravity != UndefinedGravity) flags|=XValue | YValue; (void) ParseGeometry(geometry,&geometry_info); geometry_ratio=geometry_info.rho; image_ratio=(double) image->columns/image->rows; if (geometry_ratio >= image_ratio) { region_info->width=image->columns; region_info->height=(size_t) floor((double) (image->rows*image_ratio/ geometry_ratio)+0.5); } else { region_info->width=(size_t) floor((double) (image->columns* geometry_ratio/image_ratio)+0.5); region_info->height=image->rows; } } /* Adjust offset according to gravity setting. */ width=region_info->width; height=region_info->height; if (width == 0) region_info->width=image->page.width | image->columns; if (height == 0) region_info->height=image->page.height | image->rows; GravityAdjustGeometry(image->columns,image->rows,image->gravity,region_info); region_info->width=width; region_info->height=height; return(flags); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % + P a r s e M e t a G e o m e t r y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ParseMetaGeometry() is similar to GetGeometry() except the returned % geometry is modified as determined by the meta characters: %, !, <, >, @, % :, and ^ in relation to image resizing. % % Final image dimensions are adjusted so as to preserve the aspect ratio as % much as possible, while generating a integer (pixel) size, and fitting the % image within the specified geometry width and height. % % Flags are interpreted... % % geometry size is given percentage of original width and height given % ! do not try to preserve aspect ratio % < only enlarge images smaller that geometry % > only shrink images larger than geometry % @ fit image to contain at most this many pixels % : width and height denotes an aspect ratio % ^ contain the given geometry given, (minimal dimensions given) % % The format of the ParseMetaGeometry method is: % % MagickStatusType ParseMetaGeometry(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 string (e.g. "100x100+10+10"). % % o x,y: The x and y offset, set according to the geometry specification. % % o width,height: The width and height of original image, modified by % the given geometry specification. % */ MagickExport MagickStatusType ParseMetaGeometry(const char *geometry,ssize_t *x, ssize_t *y,size_t *width,size_t *height) { GeometryInfo geometry_info; MagickStatusType flags; size_t former_height, former_width; /* Ensure the image geometry is valid. */ assert(x != (ssize_t *) NULL); assert(y != (ssize_t *) NULL); assert(width != (size_t *) NULL); assert(height != (size_t *) NULL); if ((geometry == (char *) NULL) || (*geometry == '\0')) return(NoValue); (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",geometry); /* Parse geometry using GetGeometry. */ SetGeometryInfo(&geometry_info); former_width=(*width); former_height=(*height); flags=GetGeometry(geometry,x,y,width,height); if ((flags & PercentValue) != 0) { MagickStatusType percent_flags; PointInfo scale; /* Geometry is a percentage of the image size. */ percent_flags=ParseGeometry(geometry,&geometry_info); scale.x=geometry_info.rho; if ((percent_flags & RhoValue) == 0) scale.x=100.0; scale.y=geometry_info.sigma; if ((percent_flags & SigmaValue) == 0) scale.y=scale.x; *width=(size_t) floor(scale.x*former_width/100.0+0.5); *height=(size_t) floor(scale.y*former_height/100.0+0.5); former_width=(*width); former_height=(*height); } if ((flags & AspectRatioValue) != 0) { double geometry_ratio, image_ratio; /* Geometry is a relative to image size and aspect ratio. */ (void) ParseGeometry(geometry,&geometry_info); geometry_ratio=geometry_info.rho; image_ratio=(double) former_width* PerceptibleReciprocal((double) former_height); if (geometry_ratio >= image_ratio) { *width=former_width; *height=(size_t) floor((double) (PerceptibleReciprocal( geometry_ratio)*former_height*image_ratio)+0.5); } else { *width=(size_t) floor((double) (PerceptibleReciprocal( image_ratio)*former_width*geometry_ratio)+0.5); *height=former_height; } former_width=(*width); former_height=(*height); } if (((flags & AspectValue) != 0) || ((*width == former_width) && (*height == former_height))) { if ((flags & RhoValue) == 0) *width=former_width; if ((flags & SigmaValue) == 0) *height=former_height; } else { double scale_factor; /* Respect aspect ratio of the image. */ if ((former_width == 0) || (former_height == 0)) scale_factor=1.0; else if (((flags & RhoValue) != 0) && (flags & SigmaValue) != 0) { scale_factor=(double) *width/(double) former_width; if ((flags & MinimumValue) == 0) { if (scale_factor > ((double) *height/(double) former_height)) scale_factor=(double) *height/(double) former_height; } else if (scale_factor < ((double) *height/(double) former_height)) scale_factor=(double) *height/(double) former_height; } else if ((flags & RhoValue) != 0) { scale_factor=(double) *width/(double) former_width; if (((flags & MinimumValue) != 0) && (scale_factor < ((double) *width/(double) former_height))) scale_factor=(double) *width/(double) former_height; } else { scale_factor=(double) *height/(double) former_height; if (((flags & MinimumValue) != 0) && (scale_factor < ((double) *height/(double) former_width))) scale_factor=(double) *height/(double) former_width; } *width=MagickMax((size_t) floor(scale_factor*former_width+0.5),1UL); *height=MagickMax((size_t) floor(scale_factor*former_height+0.5),1UL); } if ((flags & GreaterValue) != 0) { if (former_width < *width) *width=former_width; if (former_height < *height) *height=former_height; } if ((flags & LessValue) != 0) { if (former_width > *width) *width=former_width; if (former_height > *height) *height=former_height; } if ((flags & AreaValue) != 0) { double area, distance; PointInfo scale; /* Geometry is a maximum area in pixels. */ (void) ParseGeometry(geometry,&geometry_info); area=geometry_info.rho+sqrt(MagickEpsilon); distance=sqrt((double) former_width*former_height); scale.x=(double) former_width*PerceptibleReciprocal(distance* PerceptibleReciprocal(sqrt(area))); scale.y=(double) former_height*PerceptibleReciprocal(distance* PerceptibleReciprocal(sqrt(area))); if ((scale.x < (double) *width) || (scale.y < (double) *height)) { *width=(unsigned long) (former_width*PerceptibleReciprocal( distance*PerceptibleReciprocal(sqrt(area)))); *height=(unsigned long) (former_height*PerceptibleReciprocal( distance*PerceptibleReciprocal(sqrt(area)))); } former_width=(*width); former_height=(*height); } return(flags); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % P a r s e P a g e G e o m e t r y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ParsePageGeometry() returns a region as defined by the geometry string with % respect to the image page (canvas) dimensions. % % WARNING: Percentage dimensions remain relative to the actual image % dimensions, and not canvas dimensions. % % The format of the ParsePageGeometry method is: % % MagickStatusType ParsePageGeometry(const Image *image, % const char *geometry,RectangeInfo *region_info, % ExceptionInfo *exception) % % 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 with % respect to the image and its gravity. % % o exception: return any errors or warnings in this structure. % */ MagickExport MagickStatusType ParsePageGeometry(const Image *image, const char *geometry,RectangleInfo *region_info,ExceptionInfo *exception) { MagickStatusType flags; SetGeometry(image,region_info); if (image->page.width != 0) region_info->width=image->page.width; if (image->page.height != 0) region_info->height=image->page.height; flags=ParseAbsoluteGeometry(geometry,region_info); if (flags == NoValue) { (void) ThrowMagickException(exception,GetMagickModule(),OptionError, "InvalidGeometry","`%s'",geometry); return(flags); } if ((flags & PercentValue) != 0) { region_info->width=image->columns; region_info->height=image->rows; } flags=ParseMetaGeometry(geometry,®ion_info->x,®ion_info->y, ®ion_info->width,®ion_info->height); if ((((flags & WidthValue) != 0) || ((flags & HeightValue) != 0)) && (((flags & PercentValue) != 0) || ((flags & SeparatorValue) == 0))) { if ((flags & WidthValue) == 0) region_info->width=region_info->height; if ((flags & HeightValue) == 0) region_info->height=region_info->width; } return(flags); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % P a r s e R e g i o n G e o m e t r y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ParseRegionGeometry() returns a region as defined by the geometry string % with respect to the image dimensions and aspect ratio. % % This is basically a wrapper around ParseMetaGeometry. This is typically % used to parse a geometry string to work out the final integer dimensions % for image resizing. % % The format of the ParseRegionGeometry method is: % % MagickStatusType ParseRegionGeometry(const Image *image, % const char *geometry,RectangeInfo *region_info, % ExceptionInfo *exception) % % 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. % % o exception: return any errors or warnings in this structure. % */ MagickExport MagickStatusType ParseRegionGeometry(const Image *image, const char *geometry,RectangleInfo *region_info,ExceptionInfo *exception) { MagickStatusType flags; SetGeometry(image,region_info); flags=ParseMetaGeometry(geometry,®ion_info->x,®ion_info->y, ®ion_info->width,®ion_info->height); if (flags == NoValue) (void) ThrowMagickException(exception,GetMagickModule(),OptionError, "InvalidGeometry","`%s'",geometry); return(flags); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % S e t G e o m e t r y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % SetGeometry() sets the geometry to its default values. % % The format of the SetGeometry method is: % % SetGeometry(const Image *image,RectangleInfo *geometry) % % A description of each parameter follows: % % o image: the image. % % o geometry: the geometry. % */ MagickExport void SetGeometry(const Image *image,RectangleInfo *geometry) { assert(image != (Image *) NULL); assert(image->signature == MagickCoreSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); assert(geometry != (RectangleInfo *) NULL); (void) memset(geometry,0,sizeof(*geometry)); geometry->width=image->columns; geometry->height=image->rows; } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % S e t G e o m e t r y I n f o % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % SetGeometryInfo sets the GeometryInfo structure to its default values. % % The format of the SetGeometryInfo method is: % % SetGeometryInfo(GeometryInfo *geometry_info) % % A description of each parameter follows: % % o geometry_info: the geometry info structure. % */ MagickExport void SetGeometryInfo(GeometryInfo *geometry_info) { assert(geometry_info != (GeometryInfo *) NULL); (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); (void) memset(geometry_info,0,sizeof(*geometry_info)); }