mogrify.c revision 0d0fd35d98954a4802ec2ce48190a7f0ca9a7075
1/* 2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3% % 4% % 5% % 6% M M OOO GGGGG RRRR IIIII FFFFF Y Y % 7% MM MM O O G R R I F Y Y % 8% M M M O O G GGG RRRR I FFF Y % 9% M M O O G G R R I F Y % 10% M M OOO GGGG R R IIIII F Y % 11% % 12% % 13% MagickWand Module Methods % 14% % 15% Software Design % 16% John Cristy % 17% March 2000 % 18% % 19% % 20% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization % 21% dedicated to making software imaging solutions freely available. % 22% % 23% You may not use this file except in compliance with the License. You may % 24% obtain a copy of the License at % 25% % 26% http://www.imagemagick.org/script/license.php % 27% % 28% Unless required by applicable law or agreed to in writing, software % 29% distributed under the License is distributed on an "AS IS" BASIS, % 30% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % 31% See the License for the specific language governing permissions and % 32% limitations under the License. % 33% % 34%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 35% 36% Use the mogrify program to resize an image, blur, crop, despeckle, dither, 37% draw on, flip, join, re-sample, and much more. This tool is similiar to 38% convert except that the original image file is overwritten (unless you 39% change the file suffix with the -format option) with any changes you 40% request. 41% 42*/ 43 44/* 45 Include declarations. 46*/ 47#include "MagickWand/studio.h" 48#include "MagickWand/MagickWand.h" 49#include "MagickWand/mogrify-private.h" 50#undef DegreesToRadians 51#undef RadiansToDegrees 52#include "MagickCore/image-private.h" 53#include "MagickCore/monitor-private.h" 54#include "MagickCore/thread-private.h" 55#include "MagickCore/string-private.h" 56#include "MagickCore/utility-private.h" 57 58/* 59 Constant declaration. 60*/ 61static const char 62 MogrifyBackgroundColor[] = "#ffffff", /* white */ 63 MogrifyBorderColor[] = "#dfdfdf", /* gray */ 64 MogrifyMatteColor[] = "#bdbdbd"; /* gray */ 65 66/* 67 Define declarations. 68*/ 69#define UndefinedCompressionQuality 0UL 70 71/* 72%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 73% % 74% % 75% % 76% M a g i c k C o m m a n d G e n e s i s % 77% % 78% % 79% % 80%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 81% 82% MagickCommandGenesis() applies image processing options to an image as 83% prescribed by command line options. 84% 85% The format of the MagickCommandGenesis method is: 86% 87% MagickBooleanType MagickCommandGenesis(ImageInfo *image_info, 88% MagickCommand command,int argc,char **argv,char **metadata, 89% ExceptionInfo *exception) 90% 91% A description of each parameter follows: 92% 93% o image_info: the image info. 94% 95% o command: Choose from ConvertImageCommand, IdentifyImageCommand, 96% MogrifyImageCommand, CompositeImageCommand, CompareImagesCommand, 97% ConjureImageCommand, StreamImageCommand, ImportImageCommand, 98% DisplayImageCommand, or AnimateImageCommand. 99% 100% o argc: Specifies a pointer to an integer describing the number of 101% elements in the argument vector. 102% 103% o argv: Specifies a pointer to a text array containing the command line 104% arguments. 105% 106% o metadata: any metadata is returned here. 107% 108% o exception: return any errors or warnings in this structure. 109% 110*/ 111WandExport MagickBooleanType MagickCommandGenesis(ImageInfo *image_info, 112 MagickCommand command,int argc,char **argv,char **metadata, 113 ExceptionInfo *exception) 114{ 115 char 116 *option; 117 118 double 119 duration, 120 elapsed_time, 121 user_time; 122 123 MagickBooleanType 124 concurrent, 125 regard_warnings, 126 status; 127 128 register ssize_t 129 i; 130 131 TimerInfo 132 *timer; 133 134 size_t 135 iterations; 136 137 (void) setlocale(LC_ALL,""); 138 (void) setlocale(LC_NUMERIC,"C"); 139 concurrent=MagickFalse; 140 duration=(-1.0); 141 iterations=1; 142 status=MagickFalse; 143 regard_warnings=MagickFalse; 144 for (i=1; i < (ssize_t) (argc-1); i++) 145 { 146 option=argv[i]; 147 if ((strlen(option) == 1) || ((*option != '-') && (*option != '+'))) 148 continue; 149 if (LocaleCompare("bench",option+1) == 0) 150 iterations=StringToUnsignedLong(argv[++i]); 151 if (LocaleCompare("concurrent",option+1) == 0) 152 concurrent=MagickTrue; 153 if (LocaleCompare("debug",option+1) == 0) 154 (void) SetLogEventMask(argv[++i]); 155 if (LocaleCompare("duration",option+1) == 0) 156 duration=InterpretLocaleValue(argv[++i],(char **) NULL); 157 if (LocaleCompare("regard-warnings",option+1) == 0) 158 regard_warnings=MagickTrue; 159 } 160 timer=AcquireTimerInfo(); 161 if (concurrent == MagickFalse) 162 { 163 for (i=0; i < (ssize_t) iterations; i++) 164 { 165 if (status != MagickFalse) 166 continue; 167 if (duration > 0) 168 { 169 if (GetElapsedTime(timer) > duration) 170 continue; 171 (void) ContinueTimer(timer); 172 } 173 status=command(image_info,argc,argv,metadata,exception); 174 if (exception->severity != UndefinedException) 175 { 176 if ((exception->severity > ErrorException) || 177 (regard_warnings != MagickFalse)) 178 status=MagickTrue; 179 CatchException(exception); 180 } 181 if ((metadata != (char **) NULL) && (*metadata != (char *) NULL)) 182 { 183 (void) fputs(*metadata,stdout); 184 (void) fputc('\n',stdout); 185 *metadata=DestroyString(*metadata); 186 } 187 } 188 } 189 else 190 { 191 SetOpenMPNested(1); 192#if defined(MAGICKCORE_OPENMP_SUPPORT) 193 # pragma omp parallel for shared(status) 194#endif 195 for (i=0; i < (ssize_t) iterations; i++) 196 { 197 if (status != MagickFalse) 198 continue; 199 if (duration > 0) 200 { 201 if (GetElapsedTime(timer) > duration) 202 continue; 203 (void) ContinueTimer(timer); 204 } 205 status=command(image_info,argc,argv,metadata,exception); 206#if defined(MAGICKCORE_OPENMP_SUPPORT) 207 # pragma omp critical (MagickCore_CommandGenesis) 208#endif 209 { 210 if (exception->severity != UndefinedException) 211 { 212 if ((exception->severity > ErrorException) || 213 (regard_warnings != MagickFalse)) 214 status=MagickTrue; 215 CatchException(exception); 216 } 217 if ((metadata != (char **) NULL) && (*metadata != (char *) NULL)) 218 { 219 (void) fputs(*metadata,stdout); 220 (void) fputc('\n',stdout); 221 *metadata=DestroyString(*metadata); 222 } 223 } 224 } 225 } 226 if (iterations > 1) 227 { 228 elapsed_time=GetElapsedTime(timer); 229 user_time=GetUserTime(timer); 230 (void) FormatLocaleFile(stderr, 231 "Performance: %.20gi %gips %0.3fu %.20g:%02g.%03g\n",(double) 232 iterations,1.0*iterations/elapsed_time,user_time,(double) 233 (elapsed_time/60.0),floor(fmod(elapsed_time,60.0)),(double) 234 (1000.0*(elapsed_time-floor(elapsed_time)))); 235 (void) fflush(stderr); 236 } 237 timer=DestroyTimerInfo(timer); 238 return(status); 239} 240 241/* 242%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 243% % 244% % 245% % 246+ M o g r i f y I m a g e % 247% % 248% % 249% % 250%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 251% 252% MogrifyImage() applies simple single image processing options to a single 253% image that may be part of a large list, but also handles any 'region' 254% image handling. 255% 256% The image in the list may be modified in three different ways... 257% 258% * directly modified (EG: -negate, -gamma, -level, -annotate, -draw), 259% * replaced by a new image (EG: -spread, -resize, -rotate, -morphology) 260% * replace by a list of images (only the -separate option!) 261% 262% In each case the result is returned into the list, and a pointer to the 263% modified image (last image added if replaced by a list of images) is 264% returned. 265% 266% ASIDE: The -crop is present but restricted to non-tile single image crops 267% 268% This means if all the images are being processed (such as by 269% MogrifyImages(), next image to be processed will be as per the pointer 270% (*image)->next. Also the image list may grow as a result of some specific 271% operations but as images are never merged or deleted, it will never shrink 272% in length. Typically the list will remain the same length. 273% 274% WARNING: As the image pointed to may be replaced, the first image in the 275% list may also change. GetFirstImageInList() should be used by caller if 276% they wish return the Image pointer to the first image in list. 277% 278% 279% The format of the MogrifyImage method is: 280% 281% MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc, 282% const char **argv,Image **image) 283% 284% A description of each parameter follows: 285% 286% o image_info: the image info.. 287% 288% o argc: Specifies a pointer to an integer describing the number of 289% elements in the argument vector. 290% 291% o argv: Specifies a pointer to a text array containing the command line 292% arguments. 293% 294% o image: the image. 295% 296% o exception: return any errors or warnings in this structure. 297% 298*/ 299 300/* 301 GetImageCache() will read an image into a image cache if not already 302 present then return the image that is in the cache under that filename. 303*/ 304static inline Image *GetImageCache(const ImageInfo *image_info,const char *path, 305 ExceptionInfo *exception) 306{ 307 char 308 key[MaxTextExtent]; 309 310 ExceptionInfo 311 *sans_exception; 312 313 Image 314 *image; 315 316 ImageInfo 317 *read_info; 318 319 (void) FormatLocaleString(key,MaxTextExtent,"cache:%s",path); 320 sans_exception=AcquireExceptionInfo(); 321 image=(Image *) GetImageRegistry(ImageRegistryType,key,sans_exception); 322 sans_exception=DestroyExceptionInfo(sans_exception); 323 if (image != (Image *) NULL) 324 return(image); 325 read_info=CloneImageInfo(image_info); 326 (void) CopyMagickString(read_info->filename,path,MaxTextExtent); 327 image=ReadImage(read_info,exception); 328 read_info=DestroyImageInfo(read_info); 329 if (image != (Image *) NULL) 330 (void) SetImageRegistry(ImageRegistryType,key,image,exception); 331 return(image); 332} 333 334static MagickBooleanType IsPathWritable(const char *path) 335{ 336 if (IsPathAccessible(path) == MagickFalse) 337 return(MagickFalse); 338 if (access_utf8(path,W_OK) != 0) 339 return(MagickFalse); 340 return(MagickTrue); 341} 342 343static inline ssize_t MagickMax(const ssize_t x,const ssize_t y) 344{ 345 if (x > y) 346 return(x); 347 return(y); 348} 349 350static MagickBooleanType MonitorProgress(const char *text, 351 const MagickOffsetType offset,const MagickSizeType extent, 352 void *wand_unused(client_data)) 353{ 354 char 355 message[MaxTextExtent], 356 tag[MaxTextExtent]; 357 358 const char 359 *locale_message; 360 361 register char 362 *p; 363 364 if (extent < 2) 365 return(MagickTrue); 366 (void) CopyMagickMemory(tag,text,MaxTextExtent); 367 p=strrchr(tag,'/'); 368 if (p != (char *) NULL) 369 *p='\0'; 370 (void) FormatLocaleString(message,MaxTextExtent,"Monitor/%s",tag); 371 locale_message=GetLocaleMessage(message); 372 if (locale_message == message) 373 locale_message=tag; 374 if (p == (char *) NULL) 375 (void) FormatLocaleFile(stderr,"%s: %ld of %lu, %02ld%% complete\r", 376 locale_message,(long) offset,(unsigned long) extent,(long) 377 (100L*offset/(extent-1))); 378 else 379 (void) FormatLocaleFile(stderr,"%s[%s]: %ld of %lu, %02ld%% complete\r", 380 locale_message,p+1,(long) offset,(unsigned long) extent,(long) 381 (100L*offset/(extent-1))); 382 if (offset == (MagickOffsetType) (extent-1)) 383 (void) FormatLocaleFile(stderr,"\n"); 384 (void) fflush(stderr); 385 return(MagickTrue); 386} 387 388 /* 389 SparseColorOption() parses the complex -sparse-color argument into an 390 an array of floating point values then calls SparseColorImage(). 391 Argument is a complex mix of floating-point pixel coodinates, and color 392 specifications (or direct floating point numbers). The number of floats 393 needed to represent a color varies depending on the current channel 394 setting. 395 */ 396static Image *SparseColorOption(const Image *image, 397 const SparseColorMethod method,const char *arguments, 398 const MagickBooleanType color_from_image,ExceptionInfo *exception) 399{ 400 char 401 token[MaxTextExtent]; 402 403 const char 404 *p; 405 406 double 407 *sparse_arguments; 408 409 Image 410 *sparse_image; 411 412 PixelInfo 413 color; 414 415 MagickBooleanType 416 error; 417 418 register size_t 419 x; 420 421 size_t 422 number_arguments, 423 number_colors; 424 425 assert(image != (Image *) NULL); 426 assert(image->signature == MagickSignature); 427 if (image->debug != MagickFalse) 428 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); 429 assert(exception != (ExceptionInfo *) NULL); 430 assert(exception->signature == MagickSignature); 431 /* 432 Limit channels according to image - and add up number of color channel. 433 */ 434 number_colors=0; 435 if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0) 436 number_colors++; 437 if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0) 438 number_colors++; 439 if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0) 440 number_colors++; 441 if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) && 442 (image->colorspace == CMYKColorspace)) 443 number_colors++; 444 if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) && 445 (image->matte != MagickFalse)) 446 number_colors++; 447 448 /* 449 Read string, to determine number of arguments needed, 450 */ 451 p=arguments; 452 x=0; 453 while( *p != '\0' ) 454 { 455 GetMagickToken(p,&p,token); 456 if ( token[0] == ',' ) continue; 457 if ( isalpha((int) token[0]) || token[0] == '#' ) { 458 if ( color_from_image ) { 459 (void) ThrowMagickException(exception,GetMagickModule(), 460 OptionError, "InvalidArgument", "`%s': %s", "sparse-color", 461 "Color arg given, when colors are coming from image"); 462 return( (Image *)NULL); 463 } 464 x += number_colors; /* color argument */ 465 } 466 else { 467 x++; /* floating point argument */ 468 } 469 } 470 error=MagickTrue; 471 if ( color_from_image ) { 472 /* just the control points are being given */ 473 error = ( x % 2 != 0 ) ? MagickTrue : MagickFalse; 474 number_arguments=(x/2)*(2+number_colors); 475 } 476 else { 477 /* control points and color values */ 478 error = ( x % (2+number_colors) != 0 ) ? MagickTrue : MagickFalse; 479 number_arguments=x; 480 } 481 if ( error ) { 482 (void) ThrowMagickException(exception,GetMagickModule(), 483 OptionError, "InvalidArgument", "`%s': %s", "sparse-color", 484 "Invalid number of Arguments"); 485 return( (Image *)NULL); 486 } 487 488 /* Allocate and fill in the floating point arguments */ 489 sparse_arguments=(double *) AcquireQuantumMemory(number_arguments, 490 sizeof(*sparse_arguments)); 491 if (sparse_arguments == (double *) NULL) { 492 (void) ThrowMagickException(exception,GetMagickModule(),ResourceLimitError, 493 "MemoryAllocationFailed","%s","SparseColorOption"); 494 return( (Image *)NULL); 495 } 496 (void) ResetMagickMemory(sparse_arguments,0,number_arguments* 497 sizeof(*sparse_arguments)); 498 p=arguments; 499 x=0; 500 while( *p != '\0' && x < number_arguments ) { 501 /* X coordinate */ 502 token[0]=','; while ( token[0] == ',' ) GetMagickToken(p,&p,token); 503 if ( token[0] == '\0' ) break; 504 if ( isalpha((int) token[0]) || token[0] == '#' ) { 505 (void) ThrowMagickException(exception,GetMagickModule(), 506 OptionError, "InvalidArgument", "`%s': %s", "sparse-color", 507 "Color found, instead of X-coord"); 508 error = MagickTrue; 509 break; 510 } 511 sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL); 512 /* Y coordinate */ 513 token[0]=','; while ( token[0] == ',' ) GetMagickToken(p,&p,token); 514 if ( token[0] == '\0' ) break; 515 if ( isalpha((int) token[0]) || token[0] == '#' ) { 516 (void) ThrowMagickException(exception,GetMagickModule(), 517 OptionError, "InvalidArgument", "`%s': %s", "sparse-color", 518 "Color found, instead of Y-coord"); 519 error = MagickTrue; 520 break; 521 } 522 sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL); 523 /* color values for this control point */ 524#if 0 525 if ( (color_from_image ) { 526 /* get color from image */ 527 /* HOW??? */ 528 } 529 else 530#endif 531 { 532 /* color name or function given in string argument */ 533 token[0]=','; while ( token[0] == ',' ) GetMagickToken(p,&p,token); 534 if ( token[0] == '\0' ) break; 535 if ( isalpha((int) token[0]) || token[0] == '#' ) { 536 /* Color string given */ 537 (void) QueryMagickColorCompliance(token,AllCompliance,&color,exception); 538 if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0) 539 sparse_arguments[x++] = QuantumScale*color.red; 540 if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0) 541 sparse_arguments[x++] = QuantumScale*color.green; 542 if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0) 543 sparse_arguments[x++] = QuantumScale*color.blue; 544 if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) && 545 (image->colorspace == CMYKColorspace)) 546 sparse_arguments[x++] = QuantumScale*color.black; 547 if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) && 548 (image->matte != MagickFalse)) 549 sparse_arguments[x++] = QuantumScale*color.alpha; 550 } 551 else { 552 /* Colors given as a set of floating point values - experimental */ 553 /* NB: token contains the first floating point value to use! */ 554 if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0) 555 { 556 while ( token[0] == ',' ) GetMagickToken(p,&p,token); 557 if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' ) 558 break; 559 sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL); 560 token[0] = ','; /* used this token - get another */ 561 } 562 if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0) 563 { 564 while ( token[0] == ',' ) GetMagickToken(p,&p,token); 565 if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' ) 566 break; 567 sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL); 568 token[0] = ','; /* used this token - get another */ 569 } 570 if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0) 571 { 572 while ( token[0] == ',' ) GetMagickToken(p,&p,token); 573 if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' ) 574 break; 575 sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL); 576 token[0] = ','; /* used this token - get another */ 577 } 578 if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) && 579 (image->colorspace == CMYKColorspace)) 580 { 581 while ( token[0] == ',' ) GetMagickToken(p,&p,token); 582 if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' ) 583 break; 584 sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL); 585 token[0] = ','; /* used this token - get another */ 586 } 587 if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) && 588 (image->matte != MagickFalse)) 589 { 590 while ( token[0] == ',' ) GetMagickToken(p,&p,token); 591 if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' ) 592 break; 593 sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL); 594 token[0] = ','; /* used this token - get another */ 595 } 596 } 597 } 598 } 599 if ( number_arguments != x && !error ) { 600 (void) ThrowMagickException(exception,GetMagickModule(),OptionError, 601 "InvalidArgument","`%s': %s","sparse-color","Argument Parsing Error"); 602 sparse_arguments=(double *) RelinquishMagickMemory(sparse_arguments); 603 return( (Image *)NULL); 604 } 605 if ( error ) 606 return( (Image *)NULL); 607 608 /* Call the Interpolation function with the parsed arguments */ 609 sparse_image=SparseColorImage(image,method,number_arguments,sparse_arguments, 610 exception); 611 sparse_arguments=(double *) RelinquishMagickMemory(sparse_arguments); 612 return( sparse_image ); 613} 614 615WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc, 616 const char **argv,Image **image,ExceptionInfo *exception) 617{ 618 ChannelType 619 channel; 620 621 CompositeOperator 622 compose; 623 624 const char 625 *format, 626 *option; 627 628 DrawInfo 629 *draw_info; 630 631 GeometryInfo 632 geometry_info; 633 634 Image 635 *region_image; 636 637 ImageInfo 638 *mogrify_info; 639 640 MagickStatusType 641 status; 642 643 PixelInfo 644 fill; 645 646 MagickStatusType 647 flags; 648 649 PixelInterpolateMethod 650 interpolate_method; 651 652 QuantizeInfo 653 *quantize_info; 654 655 RectangleInfo 656 geometry, 657 region_geometry; 658 659 register ssize_t 660 i; 661 662 /* 663 Initialize method variables. 664 */ 665 assert(image_info != (const ImageInfo *) NULL); 666 assert(image_info->signature == MagickSignature); 667 assert(image != (Image **) NULL); 668 assert((*image)->signature == MagickSignature); 669 if ((*image)->debug != MagickFalse) 670 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename); 671 if (argc < 0) 672 return(MagickTrue); 673 mogrify_info=CloneImageInfo(image_info); 674 draw_info=CloneDrawInfo(mogrify_info,(DrawInfo *) NULL); 675 quantize_info=AcquireQuantizeInfo(mogrify_info); 676 SetGeometryInfo(&geometry_info); 677 GetPixelInfo(*image,&fill); 678 SetPixelInfoPacket(*image,&(*image)->background_color,&fill); 679 compose=(*image)->compose; 680 interpolate_method=UndefinedInterpolatePixel; 681 channel=mogrify_info->channel; 682 format=GetImageOption(mogrify_info,"format"); 683 SetGeometry(*image,®ion_geometry); 684 region_image=NewImageList(); 685 /* 686 Transmogrify the image. 687 */ 688 for (i=0; i < (ssize_t) argc; i++) 689 { 690 Image 691 *mogrify_image; 692 693 ssize_t 694 count; 695 696 option=argv[i]; 697 if (IsCommandOption(option) == MagickFalse) 698 continue; 699 count=MagickMax(ParseCommandOption(MagickCommandOptions,MagickFalse,option), 700 0L); 701 if ((i+count) >= (ssize_t) argc) 702 break; 703 status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception); 704 mogrify_image=(Image *)NULL; 705 switch (*(option+1)) 706 { 707 case 'a': 708 { 709 if (LocaleCompare("adaptive-blur",option+1) == 0) 710 { 711 /* 712 Adaptive blur image. 713 */ 714 (void) SyncImageSettings(mogrify_info,*image); 715 flags=ParseGeometry(argv[i+1],&geometry_info); 716 if ((flags & SigmaValue) == 0) 717 geometry_info.sigma=1.0; 718 if ((flags & XiValue) == 0) 719 geometry_info.xi=0.0; 720 mogrify_image=AdaptiveBlurImage(*image,geometry_info.rho, 721 geometry_info.sigma,geometry_info.xi,exception); 722 break; 723 } 724 if (LocaleCompare("adaptive-resize",option+1) == 0) 725 { 726 /* 727 Adaptive resize image. 728 */ 729 (void) SyncImageSettings(mogrify_info,*image); 730 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 731 mogrify_image=AdaptiveResizeImage(*image,geometry.width, 732 geometry.height,interpolate_method,exception); 733 break; 734 } 735 if (LocaleCompare("adaptive-sharpen",option+1) == 0) 736 { 737 /* 738 Adaptive sharpen image. 739 */ 740 (void) SyncImageSettings(mogrify_info,*image); 741 flags=ParseGeometry(argv[i+1],&geometry_info); 742 if ((flags & SigmaValue) == 0) 743 geometry_info.sigma=1.0; 744 if ((flags & XiValue) == 0) 745 geometry_info.xi=0.0; 746 mogrify_image=AdaptiveSharpenImage(*image,geometry_info.rho, 747 geometry_info.sigma,geometry_info.xi,exception); 748 break; 749 } 750 if (LocaleCompare("affine",option+1) == 0) 751 { 752 /* 753 Affine matrix. 754 */ 755 if (*option == '+') 756 { 757 GetAffineMatrix(&draw_info->affine); 758 break; 759 } 760 (void) ParseAffineGeometry(argv[i+1],&draw_info->affine,exception); 761 break; 762 } 763 if (LocaleCompare("alpha",option+1) == 0) 764 { 765 AlphaChannelType 766 alpha_type; 767 768 (void) SyncImageSettings(mogrify_info,*image); 769 alpha_type=(AlphaChannelType) ParseCommandOption(MagickAlphaOptions, 770 MagickFalse,argv[i+1]); 771 (void) SetImageAlphaChannel(*image,alpha_type,exception); 772 break; 773 } 774 if (LocaleCompare("annotate",option+1) == 0) 775 { 776 char 777 *text, 778 geometry[MaxTextExtent]; 779 780 /* 781 Annotate image. 782 */ 783 (void) SyncImageSettings(mogrify_info,*image); 784 SetGeometryInfo(&geometry_info); 785 flags=ParseGeometry(argv[i+1],&geometry_info); 786 if ((flags & SigmaValue) == 0) 787 geometry_info.sigma=geometry_info.rho; 788 text=InterpretImageProperties(mogrify_info,*image,argv[i+2], 789 exception); 790 if (text == (char *) NULL) 791 break; 792 (void) CloneString(&draw_info->text,text); 793 text=DestroyString(text); 794 (void) FormatLocaleString(geometry,MaxTextExtent,"%+f%+f", 795 geometry_info.xi,geometry_info.psi); 796 (void) CloneString(&draw_info->geometry,geometry); 797 draw_info->affine.sx=cos(DegreesToRadians( 798 fmod(geometry_info.rho,360.0))); 799 draw_info->affine.rx=sin(DegreesToRadians( 800 fmod(geometry_info.rho,360.0))); 801 draw_info->affine.ry=(-sin(DegreesToRadians( 802 fmod(geometry_info.sigma,360.0)))); 803 draw_info->affine.sy=cos(DegreesToRadians( 804 fmod(geometry_info.sigma,360.0))); 805 (void) AnnotateImage(*image,draw_info,exception); 806 break; 807 } 808 if (LocaleCompare("antialias",option+1) == 0) 809 { 810 draw_info->stroke_antialias=(*option == '-') ? MagickTrue : 811 MagickFalse; 812 draw_info->text_antialias=(*option == '-') ? MagickTrue : 813 MagickFalse; 814 break; 815 } 816 if (LocaleCompare("auto-gamma",option+1) == 0) 817 { 818 /* 819 Auto Adjust Gamma of image based on its mean 820 */ 821 (void) SyncImageSettings(mogrify_info,*image); 822 (void) AutoGammaImage(*image,exception); 823 break; 824 } 825 if (LocaleCompare("auto-level",option+1) == 0) 826 { 827 /* 828 Perfectly Normalize (max/min stretch) the image 829 */ 830 (void) SyncImageSettings(mogrify_info,*image); 831 (void) AutoLevelImage(*image,exception); 832 break; 833 } 834 if (LocaleCompare("auto-orient",option+1) == 0) 835 { 836 (void) SyncImageSettings(mogrify_info,*image); 837 switch ((*image)->orientation) 838 { 839 case TopRightOrientation: 840 { 841 mogrify_image=FlopImage(*image,exception); 842 break; 843 } 844 case BottomRightOrientation: 845 { 846 mogrify_image=RotateImage(*image,180.0,exception); 847 break; 848 } 849 case BottomLeftOrientation: 850 { 851 mogrify_image=FlipImage(*image,exception); 852 break; 853 } 854 case LeftTopOrientation: 855 { 856 mogrify_image=TransposeImage(*image,exception); 857 break; 858 } 859 case RightTopOrientation: 860 { 861 mogrify_image=RotateImage(*image,90.0,exception); 862 break; 863 } 864 case RightBottomOrientation: 865 { 866 mogrify_image=TransverseImage(*image,exception); 867 break; 868 } 869 case LeftBottomOrientation: 870 { 871 mogrify_image=RotateImage(*image,270.0,exception); 872 break; 873 } 874 default: 875 break; 876 } 877 if (mogrify_image != (Image *) NULL) 878 mogrify_image->orientation=TopLeftOrientation; 879 break; 880 } 881 break; 882 } 883 case 'b': 884 { 885 if (LocaleCompare("black-threshold",option+1) == 0) 886 { 887 /* 888 Black threshold image. 889 */ 890 (void) SyncImageSettings(mogrify_info,*image); 891 (void) BlackThresholdImage(*image,argv[i+1],exception); 892 InheritException(exception,&(*image)->exception); 893 break; 894 } 895 if (LocaleCompare("blue-shift",option+1) == 0) 896 { 897 /* 898 Blue shift image. 899 */ 900 (void) SyncImageSettings(mogrify_info,*image); 901 geometry_info.rho=1.5; 902 if (*option == '-') 903 flags=ParseGeometry(argv[i+1],&geometry_info); 904 mogrify_image=BlueShiftImage(*image,geometry_info.rho,exception); 905 break; 906 } 907 if (LocaleCompare("blur",option+1) == 0) 908 { 909 /* 910 Gaussian blur image. 911 */ 912 (void) SyncImageSettings(mogrify_info,*image); 913 flags=ParseGeometry(argv[i+1],&geometry_info); 914 if ((flags & SigmaValue) == 0) 915 geometry_info.sigma=1.0; 916 if ((flags & XiValue) == 0) 917 geometry_info.xi=0.0; 918 mogrify_image=BlurImage(*image,geometry_info.rho, 919 geometry_info.sigma,geometry_info.xi,exception); 920 break; 921 } 922 if (LocaleCompare("border",option+1) == 0) 923 { 924 /* 925 Surround image with a border of solid color. 926 */ 927 (void) SyncImageSettings(mogrify_info,*image); 928 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 929 if ((flags & SigmaValue) == 0) 930 geometry.height=geometry.width; 931 mogrify_image=BorderImage(*image,&geometry,compose,exception); 932 break; 933 } 934 if (LocaleCompare("bordercolor",option+1) == 0) 935 { 936 if (*option == '+') 937 { 938 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance, 939 &draw_info->border_color,exception); 940 break; 941 } 942 (void) QueryColorCompliance(argv[i+1],AllCompliance, 943 &draw_info->border_color,exception); 944 break; 945 } 946 if (LocaleCompare("box",option+1) == 0) 947 { 948 (void) QueryColorCompliance(argv[i+1],AllCompliance, 949 &draw_info->undercolor,exception); 950 break; 951 } 952 if (LocaleCompare("brightness-contrast",option+1) == 0) 953 { 954 double 955 brightness, 956 contrast; 957 958 GeometryInfo 959 geometry_info; 960 961 MagickStatusType 962 flags; 963 964 /* 965 Brightness / contrast image. 966 */ 967 (void) SyncImageSettings(mogrify_info,*image); 968 flags=ParseGeometry(argv[i+1],&geometry_info); 969 brightness=geometry_info.rho; 970 contrast=0.0; 971 if ((flags & SigmaValue) != 0) 972 contrast=geometry_info.sigma; 973 (void) BrightnessContrastImage(*image,brightness,contrast, 974 exception); 975 InheritException(exception,&(*image)->exception); 976 break; 977 } 978 break; 979 } 980 case 'c': 981 { 982 if (LocaleCompare("cdl",option+1) == 0) 983 { 984 char 985 *color_correction_collection; 986 987 /* 988 Color correct with a color decision list. 989 */ 990 (void) SyncImageSettings(mogrify_info,*image); 991 color_correction_collection=FileToString(argv[i+1],~0,exception); 992 if (color_correction_collection == (char *) NULL) 993 break; 994 (void) ColorDecisionListImage(*image,color_correction_collection, 995 exception); 996 InheritException(exception,&(*image)->exception); 997 break; 998 } 999 if (LocaleCompare("channel",option+1) == 0) 1000 { 1001 if (*option == '+') 1002 channel=DefaultChannels; 1003 else 1004 channel=(ChannelType) ParseChannelOption(argv[i+1]); 1005 SetPixelChannelMap(*image,channel); 1006 break; 1007 } 1008 if (LocaleCompare("charcoal",option+1) == 0) 1009 { 1010 /* 1011 Charcoal image. 1012 */ 1013 (void) SyncImageSettings(mogrify_info,*image); 1014 flags=ParseGeometry(argv[i+1],&geometry_info); 1015 if ((flags & SigmaValue) == 0) 1016 geometry_info.sigma=1.0; 1017 if ((flags & XiValue) == 0) 1018 geometry_info.xi=1.0; 1019 mogrify_image=CharcoalImage(*image,geometry_info.rho, 1020 geometry_info.sigma,geometry_info.xi,exception); 1021 break; 1022 } 1023 if (LocaleCompare("chop",option+1) == 0) 1024 { 1025 /* 1026 Chop the image. 1027 */ 1028 (void) SyncImageSettings(mogrify_info,*image); 1029 (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception); 1030 mogrify_image=ChopImage(*image,&geometry,exception); 1031 break; 1032 } 1033 if (LocaleCompare("clamp",option+1) == 0) 1034 { 1035 /* 1036 Clamp image. 1037 */ 1038 (void) SyncImageSettings(mogrify_info,*image); 1039 (void) ClampImage(*image); 1040 InheritException(exception,&(*image)->exception); 1041 break; 1042 } 1043 if (LocaleCompare("clip",option+1) == 0) 1044 { 1045 (void) SyncImageSettings(mogrify_info,*image); 1046 if (*option == '+') 1047 { 1048 (void) SetImageClipMask(*image,(Image *) NULL,exception); 1049 break; 1050 } 1051 (void) ClipImage(*image,exception); 1052 break; 1053 } 1054 if (LocaleCompare("clip-mask",option+1) == 0) 1055 { 1056 CacheView 1057 *mask_view; 1058 1059 Image 1060 *mask_image; 1061 1062 register Quantum 1063 *restrict q; 1064 1065 register ssize_t 1066 x; 1067 1068 ssize_t 1069 y; 1070 1071 (void) SyncImageSettings(mogrify_info,*image); 1072 if (*option == '+') 1073 { 1074 /* 1075 Remove a mask. 1076 */ 1077 (void) SetImageMask(*image,(Image *) NULL,exception); 1078 break; 1079 } 1080 /* 1081 Set the image mask. 1082 FUTURE: This Should Be a SetImageAlphaChannel() call, Or two. 1083 */ 1084 mask_image=GetImageCache(mogrify_info,argv[i+1],exception); 1085 if (mask_image == (Image *) NULL) 1086 break; 1087 if (SetImageStorageClass(mask_image,DirectClass,exception) == MagickFalse) 1088 return(MagickFalse); 1089 mask_view=AcquireCacheView(mask_image); 1090 for (y=0; y < (ssize_t) mask_image->rows; y++) 1091 { 1092 q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1, 1093 exception); 1094 if (q == (Quantum *) NULL) 1095 break; 1096 for (x=0; x < (ssize_t) mask_image->columns; x++) 1097 { 1098 if (mask_image->matte == MagickFalse) 1099 SetPixelAlpha(mask_image,GetPixelIntensity(mask_image,q),q); 1100 SetPixelRed(mask_image,GetPixelAlpha(mask_image,q),q); 1101 SetPixelGreen(mask_image,GetPixelAlpha(mask_image,q),q); 1102 SetPixelBlue(mask_image,GetPixelAlpha(mask_image,q),q); 1103 q+=GetPixelChannels(mask_image); 1104 } 1105 if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse) 1106 break; 1107 } 1108 mask_view=DestroyCacheView(mask_view); 1109 mask_image->matte=MagickTrue; 1110 (void) SetImageClipMask(*image,mask_image,exception); 1111 InheritException(exception,&(*image)->exception); 1112 break; 1113 } 1114 if (LocaleCompare("clip-path",option+1) == 0) 1115 { 1116 (void) SyncImageSettings(mogrify_info,*image); 1117 (void) ClipImagePath(*image,argv[i+1],*option == '-' ? MagickTrue : 1118 MagickFalse,exception); 1119 break; 1120 } 1121 if (LocaleCompare("colorize",option+1) == 0) 1122 { 1123 /* 1124 Colorize the image. 1125 */ 1126 (void) SyncImageSettings(mogrify_info,*image); 1127 mogrify_image=ColorizeImage(*image,argv[i+1],&fill,exception); 1128 break; 1129 } 1130 if (LocaleCompare("color-matrix",option+1) == 0) 1131 { 1132 KernelInfo 1133 *kernel; 1134 1135 (void) SyncImageSettings(mogrify_info,*image); 1136 kernel=AcquireKernelInfo(argv[i+1]); 1137 if (kernel == (KernelInfo *) NULL) 1138 break; 1139 mogrify_image=ColorMatrixImage(*image,kernel,exception); 1140 kernel=DestroyKernelInfo(kernel); 1141 break; 1142 } 1143 if (LocaleCompare("colors",option+1) == 0) 1144 { 1145 /* 1146 Reduce the number of colors in the image. 1147 */ 1148 (void) SyncImageSettings(mogrify_info,*image); 1149 quantize_info->number_colors=StringToUnsignedLong(argv[i+1]); 1150 if (quantize_info->number_colors == 0) 1151 break; 1152 if (((*image)->storage_class == DirectClass) || 1153 (*image)->colors > quantize_info->number_colors) 1154 (void) QuantizeImage(quantize_info,*image,exception); 1155 else 1156 (void) CompressImageColormap(*image,exception); 1157 break; 1158 } 1159 if (LocaleCompare("colorspace",option+1) == 0) 1160 { 1161 ColorspaceType 1162 colorspace; 1163 1164 (void) SyncImageSettings(mogrify_info,*image); 1165 if (*option == '+') 1166 { 1167 (void) TransformImageColorspace(*image,RGBColorspace); 1168 InheritException(exception,&(*image)->exception); 1169 break; 1170 } 1171 colorspace=(ColorspaceType) ParseCommandOption( 1172 MagickColorspaceOptions,MagickFalse,argv[i+1]); 1173 (void) TransformImageColorspace(*image,colorspace); 1174 InheritException(exception,&(*image)->exception); 1175 break; 1176 } 1177 if (LocaleCompare("compose",option+1) == 0) 1178 { 1179 (void) SyncImageSettings(mogrify_info,*image); 1180 compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions, 1181 MagickFalse,argv[i+1]); 1182 break; 1183 } 1184 if (LocaleCompare("contrast",option+1) == 0) 1185 { 1186 (void) SyncImageSettings(mogrify_info,*image); 1187 (void) ContrastImage(*image,(*option == '-') ? MagickTrue : 1188 MagickFalse,exception); 1189 break; 1190 } 1191 if (LocaleCompare("contrast-stretch",option+1) == 0) 1192 { 1193 double 1194 black_point, 1195 white_point; 1196 1197 MagickStatusType 1198 flags; 1199 1200 /* 1201 Contrast stretch image. 1202 */ 1203 (void) SyncImageSettings(mogrify_info,*image); 1204 flags=ParseGeometry(argv[i+1],&geometry_info); 1205 black_point=geometry_info.rho; 1206 white_point=(flags & SigmaValue) != 0 ? geometry_info.sigma : 1207 black_point; 1208 if ((flags & PercentValue) != 0) 1209 { 1210 black_point*=(double) (*image)->columns*(*image)->rows/100.0; 1211 white_point*=(double) (*image)->columns*(*image)->rows/100.0; 1212 } 1213 white_point=(MagickRealType) (*image)->columns*(*image)->rows- 1214 white_point; 1215 (void) ContrastStretchImage(*image,black_point,white_point, 1216 exception); 1217 InheritException(exception,&(*image)->exception); 1218 break; 1219 } 1220 if (LocaleCompare("convolve",option+1) == 0) 1221 { 1222 KernelInfo 1223 *kernel_info; 1224 1225 (void) SyncImageSettings(mogrify_info,*image); 1226 kernel_info=AcquireKernelInfo(argv[i+1]); 1227 if (kernel_info == (KernelInfo *) NULL) 1228 break; 1229 kernel_info->bias=(*image)->bias; 1230 mogrify_image=ConvolveImage(*image,kernel_info,exception); 1231 kernel_info=DestroyKernelInfo(kernel_info); 1232 break; 1233 } 1234 if (LocaleCompare("crop",option+1) == 0) 1235 { 1236 /* 1237 Crop a image to a smaller size 1238 */ 1239 (void) SyncImageSettings(mogrify_info,*image); 1240 mogrify_image=CropImageToTiles(*image,argv[i+1],exception); 1241 break; 1242 } 1243 if (LocaleCompare("cycle",option+1) == 0) 1244 { 1245 /* 1246 Cycle an image colormap. 1247 */ 1248 (void) SyncImageSettings(mogrify_info,*image); 1249 (void) CycleColormapImage(*image,(ssize_t) StringToLong(argv[i+1]), 1250 exception); 1251 break; 1252 } 1253 break; 1254 } 1255 case 'd': 1256 { 1257 if (LocaleCompare("decipher",option+1) == 0) 1258 { 1259 StringInfo 1260 *passkey; 1261 1262 /* 1263 Decipher pixels. 1264 */ 1265 (void) SyncImageSettings(mogrify_info,*image); 1266 passkey=FileToStringInfo(argv[i+1],~0,exception); 1267 if (passkey != (StringInfo *) NULL) 1268 { 1269 (void) PasskeyDecipherImage(*image,passkey,exception); 1270 passkey=DestroyStringInfo(passkey); 1271 } 1272 break; 1273 } 1274 if (LocaleCompare("density",option+1) == 0) 1275 { 1276 /* 1277 Set image density. 1278 */ 1279 (void) CloneString(&draw_info->density,argv[i+1]); 1280 break; 1281 } 1282 if (LocaleCompare("depth",option+1) == 0) 1283 { 1284 (void) SyncImageSettings(mogrify_info,*image); 1285 if (*option == '+') 1286 { 1287 (void) SetImageDepth(*image,MAGICKCORE_QUANTUM_DEPTH); 1288 break; 1289 } 1290 (void) SetImageDepth(*image,StringToUnsignedLong(argv[i+1])); 1291 break; 1292 } 1293 if (LocaleCompare("deskew",option+1) == 0) 1294 { 1295 double 1296 threshold; 1297 1298 /* 1299 Straighten the image. 1300 */ 1301 (void) SyncImageSettings(mogrify_info,*image); 1302 if (*option == '+') 1303 threshold=40.0*QuantumRange/100.0; 1304 else 1305 threshold=SiPrefixToDouble(argv[i+1],QuantumRange); 1306 mogrify_image=DeskewImage(*image,threshold,exception); 1307 break; 1308 } 1309 if (LocaleCompare("despeckle",option+1) == 0) 1310 { 1311 /* 1312 Reduce the speckles within an image. 1313 */ 1314 (void) SyncImageSettings(mogrify_info,*image); 1315 mogrify_image=DespeckleImage(*image,exception); 1316 break; 1317 } 1318 if (LocaleCompare("display",option+1) == 0) 1319 { 1320 (void) CloneString(&draw_info->server_name,argv[i+1]); 1321 break; 1322 } 1323 if (LocaleCompare("distort",option+1) == 0) 1324 { 1325 char 1326 *args, 1327 token[MaxTextExtent]; 1328 1329 const char 1330 *p; 1331 1332 DistortImageMethod 1333 method; 1334 1335 double 1336 *arguments; 1337 1338 register ssize_t 1339 x; 1340 1341 size_t 1342 number_arguments; 1343 1344 /* 1345 Distort image. 1346 */ 1347 (void) SyncImageSettings(mogrify_info,*image); 1348 method=(DistortImageMethod) ParseCommandOption(MagickDistortOptions, 1349 MagickFalse,argv[i+1]); 1350 if ( method == ResizeDistortion ) 1351 { 1352 /* Special Case - Argument is actually a resize geometry! 1353 ** Convert that to an appropriate distortion argument array. 1354 */ 1355 double 1356 resize_args[2]; 1357 (void) ParseRegionGeometry(*image,argv[i+2],&geometry, 1358 exception); 1359 resize_args[0]=(double)geometry.width; 1360 resize_args[1]=(double)geometry.height; 1361 mogrify_image=DistortImage(*image,method,(size_t)2, 1362 resize_args,MagickTrue,exception); 1363 break; 1364 } 1365 args=InterpretImageProperties(mogrify_info,*image,argv[i+2], 1366 exception); 1367 if (args == (char *) NULL) 1368 break; 1369 p=(char *) args; 1370 for (x=0; *p != '\0'; x++) 1371 { 1372 GetMagickToken(p,&p,token); 1373 if (*token == ',') 1374 GetMagickToken(p,&p,token); 1375 } 1376 number_arguments=(size_t) x; 1377 arguments=(double *) AcquireQuantumMemory(number_arguments, 1378 sizeof(*arguments)); 1379 if (arguments == (double *) NULL) 1380 ThrowWandFatalException(ResourceLimitFatalError, 1381 "MemoryAllocationFailed",(*image)->filename); 1382 (void) ResetMagickMemory(arguments,0,number_arguments* 1383 sizeof(*arguments)); 1384 p=(char *) args; 1385 for (x=0; (x < (ssize_t) number_arguments) && (*p != '\0'); x++) 1386 { 1387 GetMagickToken(p,&p,token); 1388 if (*token == ',') 1389 GetMagickToken(p,&p,token); 1390 arguments[x]=InterpretLocaleValue(token,(char **) NULL); 1391 } 1392 args=DestroyString(args); 1393 mogrify_image=DistortImage(*image,method,number_arguments,arguments, 1394 (*option == '+') ? MagickTrue : MagickFalse,exception); 1395 arguments=(double *) RelinquishMagickMemory(arguments); 1396 break; 1397 } 1398 if (LocaleCompare("dither",option+1) == 0) 1399 { 1400 if (*option == '+') 1401 { 1402 quantize_info->dither=MagickFalse; 1403 break; 1404 } 1405 quantize_info->dither=MagickTrue; 1406 quantize_info->dither_method=(DitherMethod) ParseCommandOption( 1407 MagickDitherOptions,MagickFalse,argv[i+1]); 1408 if (quantize_info->dither_method == NoDitherMethod) 1409 quantize_info->dither=MagickFalse; 1410 break; 1411 } 1412 if (LocaleCompare("draw",option+1) == 0) 1413 { 1414 /* 1415 Draw image. 1416 */ 1417 (void) SyncImageSettings(mogrify_info,*image); 1418 (void) CloneString(&draw_info->primitive,argv[i+1]); 1419 (void) DrawImage(*image,draw_info,exception); 1420 break; 1421 } 1422 break; 1423 } 1424 case 'e': 1425 { 1426 if (LocaleCompare("edge",option+1) == 0) 1427 { 1428 /* 1429 Enhance edges in the image. 1430 */ 1431 (void) SyncImageSettings(mogrify_info,*image); 1432 flags=ParseGeometry(argv[i+1],&geometry_info); 1433 if ((flags & SigmaValue) == 0) 1434 geometry_info.sigma=1.0; 1435 mogrify_image=EdgeImage(*image,geometry_info.rho, 1436 geometry_info.sigma,exception); 1437 break; 1438 } 1439 if (LocaleCompare("emboss",option+1) == 0) 1440 { 1441 /* 1442 Gaussian embossen image. 1443 */ 1444 (void) SyncImageSettings(mogrify_info,*image); 1445 flags=ParseGeometry(argv[i+1],&geometry_info); 1446 if ((flags & SigmaValue) == 0) 1447 geometry_info.sigma=1.0; 1448 mogrify_image=EmbossImage(*image,geometry_info.rho, 1449 geometry_info.sigma,exception); 1450 break; 1451 } 1452 if (LocaleCompare("encipher",option+1) == 0) 1453 { 1454 StringInfo 1455 *passkey; 1456 1457 /* 1458 Encipher pixels. 1459 */ 1460 (void) SyncImageSettings(mogrify_info,*image); 1461 passkey=FileToStringInfo(argv[i+1],~0,exception); 1462 if (passkey != (StringInfo *) NULL) 1463 { 1464 (void) PasskeyEncipherImage(*image,passkey,exception); 1465 passkey=DestroyStringInfo(passkey); 1466 } 1467 break; 1468 } 1469 if (LocaleCompare("encoding",option+1) == 0) 1470 { 1471 (void) CloneString(&draw_info->encoding,argv[i+1]); 1472 break; 1473 } 1474 if (LocaleCompare("enhance",option+1) == 0) 1475 { 1476 /* 1477 Enhance image. 1478 */ 1479 (void) SyncImageSettings(mogrify_info,*image); 1480 mogrify_image=EnhanceImage(*image,exception); 1481 break; 1482 } 1483 if (LocaleCompare("equalize",option+1) == 0) 1484 { 1485 /* 1486 Equalize image. 1487 */ 1488 (void) SyncImageSettings(mogrify_info,*image); 1489 (void) EqualizeImage(*image,exception); 1490 break; 1491 } 1492 if (LocaleCompare("evaluate",option+1) == 0) 1493 { 1494 double 1495 constant; 1496 1497 MagickEvaluateOperator 1498 op; 1499 1500 (void) SyncImageSettings(mogrify_info,*image); 1501 op=(MagickEvaluateOperator) ParseCommandOption( 1502 MagickEvaluateOptions,MagickFalse,argv[i+1]); 1503 constant=SiPrefixToDouble(argv[i+2],QuantumRange); 1504 (void) EvaluateImage(*image,op,constant,exception); 1505 break; 1506 } 1507 if (LocaleCompare("extent",option+1) == 0) 1508 { 1509 /* 1510 Set the image extent. 1511 */ 1512 (void) SyncImageSettings(mogrify_info,*image); 1513 flags=ParseGravityGeometry(*image,argv[i+1],&geometry,exception); 1514 if (geometry.width == 0) 1515 geometry.width=(*image)->columns; 1516 if (geometry.height == 0) 1517 geometry.height=(*image)->rows; 1518 mogrify_image=ExtentImage(*image,&geometry,exception); 1519 break; 1520 } 1521 break; 1522 } 1523 case 'f': 1524 { 1525 if (LocaleCompare("family",option+1) == 0) 1526 { 1527 if (*option == '+') 1528 { 1529 if (draw_info->family != (char *) NULL) 1530 draw_info->family=DestroyString(draw_info->family); 1531 break; 1532 } 1533 (void) CloneString(&draw_info->family,argv[i+1]); 1534 break; 1535 } 1536 if (LocaleCompare("features",option+1) == 0) 1537 { 1538 if (*option == '+') 1539 { 1540 (void) DeleteImageArtifact(*image,"identify:features"); 1541 break; 1542 } 1543 (void) SetImageArtifact(*image,"identify:features",argv[i+1]); 1544 break; 1545 } 1546 if (LocaleCompare("fill",option+1) == 0) 1547 { 1548 ExceptionInfo 1549 *sans; 1550 1551 GetPixelInfo(*image,&fill); 1552 if (*option == '+') 1553 { 1554 (void) QueryMagickColorCompliance("none",AllCompliance,&fill, 1555 exception); 1556 (void) QueryColorCompliance("none",AllCompliance, 1557 &draw_info->fill,exception); 1558 if (draw_info->fill_pattern != (Image *) NULL) 1559 draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern); 1560 break; 1561 } 1562 sans=AcquireExceptionInfo(); 1563 (void) QueryMagickColorCompliance(argv[i+1],AllCompliance,&fill, 1564 sans); 1565 status=QueryColorCompliance(argv[i+1],AllCompliance, 1566 &draw_info->fill,sans); 1567 sans=DestroyExceptionInfo(sans); 1568 if (status == MagickFalse) 1569 draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1], 1570 exception); 1571 break; 1572 } 1573 if (LocaleCompare("flip",option+1) == 0) 1574 { 1575 /* 1576 Flip image scanlines. 1577 */ 1578 (void) SyncImageSettings(mogrify_info,*image); 1579 mogrify_image=FlipImage(*image,exception); 1580 break; 1581 } 1582 if (LocaleCompare("floodfill",option+1) == 0) 1583 { 1584 PixelInfo 1585 target; 1586 1587 /* 1588 Floodfill image. 1589 */ 1590 (void) SyncImageSettings(mogrify_info,*image); 1591 (void) ParsePageGeometry(*image,argv[i+1],&geometry,exception); 1592 (void) QueryMagickColorCompliance(argv[i+2],AllCompliance,&target, 1593 exception); 1594 (void) FloodfillPaintImage(*image,draw_info,&target,geometry.x, 1595 geometry.y,*option == '-' ? MagickFalse : MagickTrue,exception); 1596 break; 1597 } 1598 if (LocaleCompare("flop",option+1) == 0) 1599 { 1600 /* 1601 Flop image scanlines. 1602 */ 1603 (void) SyncImageSettings(mogrify_info,*image); 1604 mogrify_image=FlopImage(*image,exception); 1605 break; 1606 } 1607 if (LocaleCompare("font",option+1) == 0) 1608 { 1609 if (*option == '+') 1610 { 1611 if (draw_info->font != (char *) NULL) 1612 draw_info->font=DestroyString(draw_info->font); 1613 break; 1614 } 1615 (void) CloneString(&draw_info->font,argv[i+1]); 1616 break; 1617 } 1618 if (LocaleCompare("format",option+1) == 0) 1619 { 1620 format=argv[i+1]; 1621 break; 1622 } 1623 if (LocaleCompare("frame",option+1) == 0) 1624 { 1625 FrameInfo 1626 frame_info; 1627 1628 /* 1629 Surround image with an ornamental border. 1630 */ 1631 (void) SyncImageSettings(mogrify_info,*image); 1632 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 1633 frame_info.width=geometry.width; 1634 frame_info.height=geometry.height; 1635 if ((flags & HeightValue) == 0) 1636 frame_info.height=geometry.width; 1637 frame_info.outer_bevel=geometry.x; 1638 frame_info.inner_bevel=geometry.y; 1639 frame_info.x=(ssize_t) frame_info.width; 1640 frame_info.y=(ssize_t) frame_info.height; 1641 frame_info.width=(*image)->columns+2*frame_info.width; 1642 frame_info.height=(*image)->rows+2*frame_info.height; 1643 mogrify_image=FrameImage(*image,&frame_info,compose,exception); 1644 break; 1645 } 1646 if (LocaleCompare("function",option+1) == 0) 1647 { 1648 char 1649 *arguments, 1650 token[MaxTextExtent]; 1651 1652 const char 1653 *p; 1654 1655 double 1656 *parameters; 1657 1658 MagickFunction 1659 function; 1660 1661 register ssize_t 1662 x; 1663 1664 size_t 1665 number_parameters; 1666 1667 /* 1668 Function Modify Image Values 1669 */ 1670 (void) SyncImageSettings(mogrify_info,*image); 1671 function=(MagickFunction) ParseCommandOption(MagickFunctionOptions, 1672 MagickFalse,argv[i+1]); 1673 arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2], 1674 exception); 1675 if (arguments == (char *) NULL) 1676 break; 1677 p=(char *) arguments; 1678 for (x=0; *p != '\0'; x++) 1679 { 1680 GetMagickToken(p,&p,token); 1681 if (*token == ',') 1682 GetMagickToken(p,&p,token); 1683 } 1684 number_parameters=(size_t) x; 1685 parameters=(double *) AcquireQuantumMemory(number_parameters, 1686 sizeof(*parameters)); 1687 if (parameters == (double *) NULL) 1688 ThrowWandFatalException(ResourceLimitFatalError, 1689 "MemoryAllocationFailed",(*image)->filename); 1690 (void) ResetMagickMemory(parameters,0,number_parameters* 1691 sizeof(*parameters)); 1692 p=(char *) arguments; 1693 for (x=0; (x < (ssize_t) number_parameters) && (*p != '\0'); x++) 1694 { 1695 GetMagickToken(p,&p,token); 1696 if (*token == ',') 1697 GetMagickToken(p,&p,token); 1698 parameters[x]=InterpretLocaleValue(token,(char **) NULL); 1699 } 1700 arguments=DestroyString(arguments); 1701 (void) FunctionImage(*image,function,number_parameters,parameters, 1702 exception); 1703 parameters=(double *) RelinquishMagickMemory(parameters); 1704 break; 1705 } 1706 break; 1707 } 1708 case 'g': 1709 { 1710 if (LocaleCompare("gamma",option+1) == 0) 1711 { 1712 /* 1713 Gamma image. 1714 */ 1715 (void) SyncImageSettings(mogrify_info,*image); 1716 if (*option == '+') 1717 (*image)->gamma=InterpretLocaleValue(argv[i+1],(char **) NULL); 1718 else 1719 (void) GammaImage(*image,InterpretLocaleValue(argv[i+1], 1720 (char **) NULL),exception); 1721 break; 1722 } 1723 if ((LocaleCompare("gaussian-blur",option+1) == 0) || 1724 (LocaleCompare("gaussian",option+1) == 0)) 1725 { 1726 /* 1727 Gaussian blur image. 1728 */ 1729 (void) SyncImageSettings(mogrify_info,*image); 1730 flags=ParseGeometry(argv[i+1],&geometry_info); 1731 if ((flags & SigmaValue) == 0) 1732 geometry_info.sigma=1.0; 1733 if ((flags & XiValue) == 0) 1734 geometry_info.xi=0.0; 1735 mogrify_image=GaussianBlurImage(*image,geometry_info.rho, 1736 geometry_info.sigma,geometry_info.xi,exception); 1737 break; 1738 } 1739 if (LocaleCompare("geometry",option+1) == 0) 1740 { 1741 /* 1742 Record Image offset, Resize last image. 1743 */ 1744 (void) SyncImageSettings(mogrify_info,*image); 1745 if (*option == '+') 1746 { 1747 if ((*image)->geometry != (char *) NULL) 1748 (*image)->geometry=DestroyString((*image)->geometry); 1749 break; 1750 } 1751 flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 1752 if (((flags & XValue) != 0) || ((flags & YValue) != 0)) 1753 (void) CloneString(&(*image)->geometry,argv[i+1]); 1754 else 1755 mogrify_image=ResizeImage(*image,geometry.width,geometry.height, 1756 (*image)->filter,(*image)->blur,exception); 1757 break; 1758 } 1759 if (LocaleCompare("gravity",option+1) == 0) 1760 { 1761 if (*option == '+') 1762 { 1763 draw_info->gravity=UndefinedGravity; 1764 break; 1765 } 1766 draw_info->gravity=(GravityType) ParseCommandOption( 1767 MagickGravityOptions,MagickFalse,argv[i+1]); 1768 break; 1769 } 1770 break; 1771 } 1772 case 'h': 1773 { 1774 if (LocaleCompare("highlight-color",option+1) == 0) 1775 { 1776 (void) SetImageArtifact(*image,option+1,argv[i+1]); 1777 break; 1778 } 1779 break; 1780 } 1781 case 'i': 1782 { 1783 if (LocaleCompare("identify",option+1) == 0) 1784 { 1785 char 1786 *text; 1787 1788 (void) SyncImageSettings(mogrify_info,*image); 1789 if (format == (char *) NULL) 1790 { 1791 (void) IdentifyImage(*image,stdout,mogrify_info->verbose, 1792 exception); 1793 break; 1794 } 1795 text=InterpretImageProperties(mogrify_info,*image,format, 1796 exception); 1797 if (text == (char *) NULL) 1798 break; 1799 (void) fputs(text,stdout); 1800 (void) fputc('\n',stdout); 1801 text=DestroyString(text); 1802 break; 1803 } 1804 if (LocaleCompare("implode",option+1) == 0) 1805 { 1806 /* 1807 Implode image. 1808 */ 1809 (void) SyncImageSettings(mogrify_info,*image); 1810 (void) ParseGeometry(argv[i+1],&geometry_info); 1811 mogrify_image=ImplodeImage(*image,geometry_info.rho, 1812 interpolate_method,exception); 1813 break; 1814 } 1815 if (LocaleCompare("interline-spacing",option+1) == 0) 1816 { 1817 if (*option == '+') 1818 (void) ParseGeometry("0",&geometry_info); 1819 else 1820 (void) ParseGeometry(argv[i+1],&geometry_info); 1821 draw_info->interline_spacing=geometry_info.rho; 1822 break; 1823 } 1824 if (LocaleCompare("interpolate",option+1) == 0) 1825 { 1826 interpolate_method=(PixelInterpolateMethod) ParseCommandOption( 1827 MagickInterpolateOptions,MagickFalse,argv[i+1]); 1828 break; 1829 } 1830 if (LocaleCompare("interword-spacing",option+1) == 0) 1831 { 1832 if (*option == '+') 1833 (void) ParseGeometry("0",&geometry_info); 1834 else 1835 (void) ParseGeometry(argv[i+1],&geometry_info); 1836 draw_info->interword_spacing=geometry_info.rho; 1837 break; 1838 } 1839 break; 1840 } 1841 case 'k': 1842 { 1843 if (LocaleCompare("kerning",option+1) == 0) 1844 { 1845 if (*option == '+') 1846 (void) ParseGeometry("0",&geometry_info); 1847 else 1848 (void) ParseGeometry(argv[i+1],&geometry_info); 1849 draw_info->kerning=geometry_info.rho; 1850 break; 1851 } 1852 break; 1853 } 1854 case 'l': 1855 { 1856 if (LocaleCompare("lat",option+1) == 0) 1857 { 1858 /* 1859 Local adaptive threshold image. 1860 */ 1861 (void) SyncImageSettings(mogrify_info,*image); 1862 flags=ParseGeometry(argv[i+1],&geometry_info); 1863 if ((flags & PercentValue) != 0) 1864 geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0; 1865 mogrify_image=AdaptiveThresholdImage(*image,(size_t) 1866 geometry_info.rho,(size_t) geometry_info.sigma,(double) 1867 geometry_info.xi,exception); 1868 break; 1869 } 1870 if (LocaleCompare("level",option+1) == 0) 1871 { 1872 MagickRealType 1873 black_point, 1874 gamma, 1875 white_point; 1876 1877 MagickStatusType 1878 flags; 1879 1880 /* 1881 Parse levels. 1882 */ 1883 (void) SyncImageSettings(mogrify_info,*image); 1884 flags=ParseGeometry(argv[i+1],&geometry_info); 1885 black_point=geometry_info.rho; 1886 white_point=(MagickRealType) QuantumRange; 1887 if ((flags & SigmaValue) != 0) 1888 white_point=geometry_info.sigma; 1889 gamma=1.0; 1890 if ((flags & XiValue) != 0) 1891 gamma=geometry_info.xi; 1892 if ((flags & PercentValue) != 0) 1893 { 1894 black_point*=(MagickRealType) (QuantumRange/100.0); 1895 white_point*=(MagickRealType) (QuantumRange/100.0); 1896 } 1897 if ((flags & SigmaValue) == 0) 1898 white_point=(MagickRealType) QuantumRange-black_point; 1899 if ((*option == '+') || ((flags & AspectValue) != 0)) 1900 (void) LevelizeImage(*image,black_point,white_point,gamma, 1901 exception); 1902 else 1903 (void) LevelImage(*image,black_point,white_point,gamma, 1904 exception); 1905 InheritException(exception,&(*image)->exception); 1906 break; 1907 } 1908 if (LocaleCompare("level-colors",option+1) == 0) 1909 { 1910 char 1911 token[MaxTextExtent]; 1912 1913 const char 1914 *p; 1915 1916 PixelInfo 1917 black_point, 1918 white_point; 1919 1920 p=(const char *) argv[i+1]; 1921 GetMagickToken(p,&p,token); /* get black point color */ 1922 if ((isalpha((int) *token) != 0) || ((*token == '#') != 0)) 1923 (void) QueryMagickColorCompliance(token,AllCompliance, 1924 &black_point,exception); 1925 else 1926 (void) QueryMagickColorCompliance("#000000",AllCompliance, 1927 &black_point,exception); 1928 if (isalpha((int) token[0]) || (token[0] == '#')) 1929 GetMagickToken(p,&p,token); 1930 if (*token == '\0') 1931 white_point=black_point; /* set everything to that color */ 1932 else 1933 { 1934 if ((isalpha((int) *token) == 0) && ((*token == '#') == 0)) 1935 GetMagickToken(p,&p,token); /* Get white point color. */ 1936 if ((isalpha((int) *token) != 0) || ((*token == '#') != 0)) 1937 (void) QueryMagickColorCompliance(token,AllCompliance, 1938 &white_point,exception); 1939 else 1940 (void) QueryMagickColorCompliance("#ffffff",AllCompliance, 1941 &white_point,exception); 1942 } 1943 (void) LevelImageColors(*image,&black_point,&white_point, 1944 *option == '+' ? MagickTrue : MagickFalse,exception); 1945 break; 1946 } 1947 if (LocaleCompare("linear-stretch",option+1) == 0) 1948 { 1949 double 1950 black_point, 1951 white_point; 1952 1953 MagickStatusType 1954 flags; 1955 1956 (void) SyncImageSettings(mogrify_info,*image); 1957 flags=ParseGeometry(argv[i+1],&geometry_info); 1958 black_point=geometry_info.rho; 1959 white_point=(MagickRealType) (*image)->columns*(*image)->rows; 1960 if ((flags & SigmaValue) != 0) 1961 white_point=geometry_info.sigma; 1962 if ((flags & PercentValue) != 0) 1963 { 1964 black_point*=(double) (*image)->columns*(*image)->rows/100.0; 1965 white_point*=(double) (*image)->columns*(*image)->rows/100.0; 1966 } 1967 if ((flags & SigmaValue) == 0) 1968 white_point=(MagickRealType) (*image)->columns*(*image)->rows- 1969 black_point; 1970 (void) LinearStretchImage(*image,black_point,white_point,exception); 1971 InheritException(exception,&(*image)->exception); 1972 break; 1973 } 1974 if (LocaleCompare("linewidth",option+1) == 0) 1975 { 1976 draw_info->stroke_width=InterpretLocaleValue(argv[i+1], 1977 (char **) NULL); 1978 break; 1979 } 1980 if (LocaleCompare("liquid-rescale",option+1) == 0) 1981 { 1982 /* 1983 Liquid rescale image. 1984 */ 1985 (void) SyncImageSettings(mogrify_info,*image); 1986 flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 1987 if ((flags & XValue) == 0) 1988 geometry.x=1; 1989 if ((flags & YValue) == 0) 1990 geometry.y=0; 1991 mogrify_image=LiquidRescaleImage(*image,geometry.width, 1992 geometry.height,1.0*geometry.x,1.0*geometry.y,exception); 1993 break; 1994 } 1995 if (LocaleCompare("lowlight-color",option+1) == 0) 1996 { 1997 (void) SetImageArtifact(*image,option+1,argv[i+1]); 1998 break; 1999 } 2000 break; 2001 } 2002 case 'm': 2003 { 2004 if (LocaleCompare("map",option+1) == 0) 2005 { 2006 Image 2007 *remap_image; 2008 2009 /* 2010 Transform image colors to match this set of colors. 2011 */ 2012 (void) SyncImageSettings(mogrify_info,*image); 2013 if (*option == '+') 2014 break; 2015 remap_image=GetImageCache(mogrify_info,argv[i+1],exception); 2016 if (remap_image == (Image *) NULL) 2017 break; 2018 (void) RemapImage(quantize_info,*image,remap_image,exception); 2019 remap_image=DestroyImage(remap_image); 2020 break; 2021 } 2022 if (LocaleCompare("mask",option+1) == 0) 2023 { 2024 Image 2025 *mask; 2026 2027 (void) SyncImageSettings(mogrify_info,*image); 2028 if (*option == '+') 2029 { 2030 /* 2031 Remove a mask. 2032 */ 2033 (void) SetImageMask(*image,(Image *) NULL,exception); 2034 break; 2035 } 2036 /* 2037 Set the image mask. 2038 */ 2039 mask=GetImageCache(mogrify_info,argv[i+1],exception); 2040 if (mask == (Image *) NULL) 2041 break; 2042 (void) SetImageMask(*image,mask,exception); 2043 mask=DestroyImage(mask); 2044 break; 2045 } 2046 if (LocaleCompare("matte",option+1) == 0) 2047 { 2048 (void) SetImageAlphaChannel(*image,(*option == '-') ? 2049 SetAlphaChannel : DeactivateAlphaChannel,exception); 2050 break; 2051 } 2052 if (LocaleCompare("median",option+1) == 0) 2053 { 2054 /* 2055 Median filter image. 2056 */ 2057 (void) SyncImageSettings(mogrify_info,*image); 2058 flags=ParseGeometry(argv[i+1],&geometry_info); 2059 if ((flags & SigmaValue) == 0) 2060 geometry_info.sigma=geometry_info.rho; 2061 mogrify_image=StatisticImage(*image,MedianStatistic,(size_t) 2062 geometry_info.rho,(size_t) geometry_info.sigma,exception); 2063 break; 2064 } 2065 if (LocaleCompare("mode",option+1) == 0) 2066 { 2067 /* 2068 Mode image. 2069 */ 2070 (void) SyncImageSettings(mogrify_info,*image); 2071 flags=ParseGeometry(argv[i+1],&geometry_info); 2072 if ((flags & SigmaValue) == 0) 2073 geometry_info.sigma=geometry_info.rho; 2074 mogrify_image=StatisticImage(*image,ModeStatistic,(size_t) 2075 geometry_info.rho,(size_t) geometry_info.sigma,exception); 2076 break; 2077 } 2078 if (LocaleCompare("modulate",option+1) == 0) 2079 { 2080 (void) SyncImageSettings(mogrify_info,*image); 2081 (void) ModulateImage(*image,argv[i+1],exception); 2082 break; 2083 } 2084 if (LocaleCompare("monitor",option+1) == 0) 2085 { 2086 if (*option == '+') 2087 { 2088 (void) SetImageProgressMonitor(*image, 2089 (MagickProgressMonitor) NULL,(void *) NULL); 2090 break; 2091 } 2092 (void) SetImageProgressMonitor(*image,MonitorProgress, 2093 (void *) NULL); 2094 break; 2095 } 2096 if (LocaleCompare("monochrome",option+1) == 0) 2097 { 2098 (void) SyncImageSettings(mogrify_info,*image); 2099 (void) SetImageType(*image,BilevelType,exception); 2100 break; 2101 } 2102 if (LocaleCompare("morphology",option+1) == 0) 2103 { 2104 char 2105 token[MaxTextExtent]; 2106 2107 const char 2108 *p; 2109 2110 KernelInfo 2111 *kernel; 2112 2113 MorphologyMethod 2114 method; 2115 2116 ssize_t 2117 iterations; 2118 2119 /* 2120 Morphological Image Operation 2121 */ 2122 (void) SyncImageSettings(mogrify_info,*image); 2123 p=argv[i+1]; 2124 GetMagickToken(p,&p,token); 2125 method=(MorphologyMethod) ParseCommandOption( 2126 MagickMorphologyOptions,MagickFalse,token); 2127 iterations=1L; 2128 GetMagickToken(p,&p,token); 2129 if ((*p == ':') || (*p == ',')) 2130 GetMagickToken(p,&p,token); 2131 if ((*p != '\0')) 2132 iterations=(ssize_t) StringToLong(p); 2133 kernel=AcquireKernelInfo(argv[i+2]); 2134 if (kernel == (KernelInfo *) NULL) 2135 { 2136 (void) ThrowMagickException(exception,GetMagickModule(), 2137 OptionError,"UnabletoParseKernel","morphology"); 2138 status=MagickFalse; 2139 break; 2140 } 2141 mogrify_image=MorphologyImage(*image,method,iterations,kernel, 2142 exception); 2143 kernel=DestroyKernelInfo(kernel); 2144 break; 2145 } 2146 if (LocaleCompare("motion-blur",option+1) == 0) 2147 { 2148 /* 2149 Motion blur image. 2150 */ 2151 (void) SyncImageSettings(mogrify_info,*image); 2152 flags=ParseGeometry(argv[i+1],&geometry_info); 2153 if ((flags & SigmaValue) == 0) 2154 geometry_info.sigma=1.0; 2155 mogrify_image=MotionBlurImage(*image,geometry_info.rho, 2156 geometry_info.sigma,geometry_info.xi,geometry_info.psi, 2157 exception); 2158 break; 2159 } 2160 break; 2161 } 2162 case 'n': 2163 { 2164 if (LocaleCompare("negate",option+1) == 0) 2165 { 2166 (void) SyncImageSettings(mogrify_info,*image); 2167 (void) NegateImage(*image,*option == '+' ? MagickTrue : 2168 MagickFalse,exception); 2169 break; 2170 } 2171 if (LocaleCompare("noise",option+1) == 0) 2172 { 2173 (void) SyncImageSettings(mogrify_info,*image); 2174 if (*option == '-') 2175 { 2176 flags=ParseGeometry(argv[i+1],&geometry_info); 2177 if ((flags & SigmaValue) == 0) 2178 geometry_info.sigma=geometry_info.rho; 2179 mogrify_image=StatisticImage(*image,NonpeakStatistic,(size_t) 2180 geometry_info.rho,(size_t) geometry_info.sigma,exception); 2181 } 2182 else 2183 { 2184 NoiseType 2185 noise; 2186 2187 noise=(NoiseType) ParseCommandOption(MagickNoiseOptions, 2188 MagickFalse,argv[i+1]); 2189 mogrify_image=AddNoiseImage(*image,noise,exception); 2190 } 2191 break; 2192 } 2193 if (LocaleCompare("normalize",option+1) == 0) 2194 { 2195 (void) SyncImageSettings(mogrify_info,*image); 2196 (void) NormalizeImage(*image,exception); 2197 break; 2198 } 2199 break; 2200 } 2201 case 'o': 2202 { 2203 if (LocaleCompare("opaque",option+1) == 0) 2204 { 2205 PixelInfo 2206 target; 2207 2208 (void) SyncImageSettings(mogrify_info,*image); 2209 (void) QueryMagickColorCompliance(argv[i+1],AllCompliance,&target, 2210 exception); 2211 (void) OpaquePaintImage(*image,&target,&fill,*option == '-' ? 2212 MagickFalse : MagickTrue,exception); 2213 break; 2214 } 2215 if (LocaleCompare("ordered-dither",option+1) == 0) 2216 { 2217 (void) SyncImageSettings(mogrify_info,*image); 2218 (void) OrderedPosterizeImage(*image,argv[i+1],exception); 2219 break; 2220 } 2221 break; 2222 } 2223 case 'p': 2224 { 2225 if (LocaleCompare("paint",option+1) == 0) 2226 { 2227 (void) SyncImageSettings(mogrify_info,*image); 2228 (void) ParseGeometry(argv[i+1],&geometry_info); 2229 mogrify_image=OilPaintImage(*image,geometry_info.rho, 2230 geometry_info.sigma,exception); 2231 break; 2232 } 2233 if (LocaleCompare("pen",option+1) == 0) 2234 { 2235 if (*option == '+') 2236 { 2237 (void) QueryColorCompliance("none",AllCompliance, 2238 &draw_info->fill,exception); 2239 break; 2240 } 2241 (void) QueryColorCompliance(argv[i+1],AllCompliance, 2242 &draw_info->fill,exception); 2243 break; 2244 } 2245 if (LocaleCompare("pointsize",option+1) == 0) 2246 { 2247 if (*option == '+') 2248 (void) ParseGeometry("12",&geometry_info); 2249 else 2250 (void) ParseGeometry(argv[i+1],&geometry_info); 2251 draw_info->pointsize=geometry_info.rho; 2252 break; 2253 } 2254 if (LocaleCompare("polaroid",option+1) == 0) 2255 { 2256 double 2257 angle; 2258 2259 RandomInfo 2260 *random_info; 2261 2262 /* 2263 Simulate a Polaroid picture. 2264 */ 2265 (void) SyncImageSettings(mogrify_info,*image); 2266 random_info=AcquireRandomInfo(); 2267 angle=22.5*(GetPseudoRandomValue(random_info)-0.5); 2268 random_info=DestroyRandomInfo(random_info); 2269 if (*option == '-') 2270 { 2271 SetGeometryInfo(&geometry_info); 2272 flags=ParseGeometry(argv[i+1],&geometry_info); 2273 angle=geometry_info.rho; 2274 } 2275 mogrify_image=PolaroidImage(*image,draw_info,angle, 2276 interpolate_method,exception); 2277 break; 2278 } 2279 if (LocaleCompare("posterize",option+1) == 0) 2280 { 2281 /* 2282 Posterize image. 2283 */ 2284 (void) SyncImageSettings(mogrify_info,*image); 2285 (void) PosterizeImage(*image,StringToUnsignedLong(argv[i+1]), 2286 quantize_info->dither,exception); 2287 break; 2288 } 2289 if (LocaleCompare("preview",option+1) == 0) 2290 { 2291 PreviewType 2292 preview_type; 2293 2294 /* 2295 Preview image. 2296 */ 2297 (void) SyncImageSettings(mogrify_info,*image); 2298 if (*option == '+') 2299 preview_type=UndefinedPreview; 2300 else 2301 preview_type=(PreviewType) ParseCommandOption( 2302 MagickPreviewOptions,MagickFalse,argv[i+1]); 2303 mogrify_image=PreviewImage(*image,preview_type,exception); 2304 break; 2305 } 2306 if (LocaleCompare("profile",option+1) == 0) 2307 { 2308 const char 2309 *name; 2310 2311 const StringInfo 2312 *profile; 2313 2314 Image 2315 *profile_image; 2316 2317 ImageInfo 2318 *profile_info; 2319 2320 (void) SyncImageSettings(mogrify_info,*image); 2321 if (*option == '+') 2322 { 2323 /* 2324 Remove a profile from the image. 2325 */ 2326 (void) ProfileImage(*image,argv[i+1],(const unsigned char *) 2327 NULL,0,MagickTrue); 2328 InheritException(exception,&(*image)->exception); 2329 break; 2330 } 2331 /* 2332 Associate a profile with the image. 2333 */ 2334 profile_info=CloneImageInfo(mogrify_info); 2335 profile=GetImageProfile(*image,"iptc"); 2336 if (profile != (StringInfo *) NULL) 2337 profile_info->profile=(void *) CloneStringInfo(profile); 2338 profile_image=GetImageCache(profile_info,argv[i+1],exception); 2339 profile_info=DestroyImageInfo(profile_info); 2340 if (profile_image == (Image *) NULL) 2341 { 2342 StringInfo 2343 *profile; 2344 2345 profile_info=CloneImageInfo(mogrify_info); 2346 (void) CopyMagickString(profile_info->filename,argv[i+1], 2347 MaxTextExtent); 2348 profile=FileToStringInfo(profile_info->filename,~0UL,exception); 2349 if (profile != (StringInfo *) NULL) 2350 { 2351 (void) ProfileImage(*image,profile_info->magick, 2352 GetStringInfoDatum(profile),(size_t) 2353 GetStringInfoLength(profile),MagickFalse); 2354 profile=DestroyStringInfo(profile); 2355 } 2356 profile_info=DestroyImageInfo(profile_info); 2357 break; 2358 } 2359 ResetImageProfileIterator(profile_image); 2360 name=GetNextImageProfile(profile_image); 2361 while (name != (const char *) NULL) 2362 { 2363 profile=GetImageProfile(profile_image,name); 2364 if (profile != (StringInfo *) NULL) 2365 (void) ProfileImage(*image,name,GetStringInfoDatum(profile), 2366 (size_t) GetStringInfoLength(profile),MagickFalse); 2367 name=GetNextImageProfile(profile_image); 2368 } 2369 profile_image=DestroyImage(profile_image); 2370 break; 2371 } 2372 break; 2373 } 2374 case 'q': 2375 { 2376 if (LocaleCompare("quantize",option+1) == 0) 2377 { 2378 if (*option == '+') 2379 { 2380 quantize_info->colorspace=UndefinedColorspace; 2381 break; 2382 } 2383 quantize_info->colorspace=(ColorspaceType) ParseCommandOption( 2384 MagickColorspaceOptions,MagickFalse,argv[i+1]); 2385 break; 2386 } 2387 break; 2388 } 2389 case 'r': 2390 { 2391 if (LocaleCompare("radial-blur",option+1) == 0) 2392 { 2393 /* 2394 Radial blur image. 2395 */ 2396 (void) SyncImageSettings(mogrify_info,*image); 2397 flags=ParseGeometry(argv[i+1],&geometry_info); 2398 mogrify_image=RadialBlurImage(*image,geometry_info.rho, 2399 geometry_info.sigma,exception); 2400 break; 2401 } 2402 if (LocaleCompare("raise",option+1) == 0) 2403 { 2404 /* 2405 Surround image with a raise of solid color. 2406 */ 2407 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 2408 if ((flags & SigmaValue) == 0) 2409 geometry.height=geometry.width; 2410 (void) RaiseImage(*image,&geometry,*option == '-' ? MagickTrue : 2411 MagickFalse,exception); 2412 break; 2413 } 2414 if (LocaleCompare("random-threshold",option+1) == 0) 2415 { 2416 /* 2417 Threshold image. 2418 */ 2419 (void) SyncImageSettings(mogrify_info,*image); 2420 (void) RandomThresholdImage(*image,argv[i+1],exception); 2421 break; 2422 } 2423 if (LocaleCompare("recolor",option+1) == 0) 2424 { 2425 KernelInfo 2426 *kernel; 2427 2428 (void) SyncImageSettings(mogrify_info,*image); 2429 kernel=AcquireKernelInfo(argv[i+1]); 2430 if (kernel == (KernelInfo *) NULL) 2431 break; 2432 mogrify_image=ColorMatrixImage(*image,kernel,exception); 2433 kernel=DestroyKernelInfo(kernel); 2434 break; 2435 } 2436 if (LocaleCompare("region",option+1) == 0) 2437 { 2438 (void) SyncImageSettings(mogrify_info,*image); 2439 if (region_image != (Image *) NULL) 2440 { 2441 /* 2442 Composite region. 2443 */ 2444 (void) CompositeImage(region_image,region_image->matte != 2445 MagickFalse ? CopyCompositeOp : OverCompositeOp,*image, 2446 region_geometry.x,region_geometry.y); 2447 InheritException(exception,®ion_image->exception); 2448 *image=DestroyImage(*image); 2449 *image=region_image; 2450 region_image = (Image *) NULL; 2451 } 2452 if (*option == '+') 2453 break; 2454 /* 2455 Apply transformations to a selected region of the image. 2456 */ 2457 (void) ParseGravityGeometry(*image,argv[i+1],®ion_geometry, 2458 exception); 2459 mogrify_image=CropImage(*image,®ion_geometry,exception); 2460 if (mogrify_image == (Image *) NULL) 2461 break; 2462 region_image=(*image); 2463 *image=mogrify_image; 2464 mogrify_image=(Image *) NULL; 2465 break; 2466 } 2467 if (LocaleCompare("render",option+1) == 0) 2468 { 2469 (void) SyncImageSettings(mogrify_info,*image); 2470 draw_info->render=(*option == '+') ? MagickTrue : MagickFalse; 2471 break; 2472 } 2473 if (LocaleCompare("remap",option+1) == 0) 2474 { 2475 Image 2476 *remap_image; 2477 2478 /* 2479 Transform image colors to match this set of colors. 2480 */ 2481 (void) SyncImageSettings(mogrify_info,*image); 2482 if (*option == '+') 2483 break; 2484 remap_image=GetImageCache(mogrify_info,argv[i+1],exception); 2485 if (remap_image == (Image *) NULL) 2486 break; 2487 (void) RemapImage(quantize_info,*image,remap_image,exception); 2488 remap_image=DestroyImage(remap_image); 2489 break; 2490 } 2491 if (LocaleCompare("repage",option+1) == 0) 2492 { 2493 if (*option == '+') 2494 { 2495 (void) ParseAbsoluteGeometry("0x0+0+0",&(*image)->page); 2496 break; 2497 } 2498 (void) ResetImagePage(*image,argv[i+1]); 2499 InheritException(exception,&(*image)->exception); 2500 break; 2501 } 2502 if (LocaleCompare("resample",option+1) == 0) 2503 { 2504 /* 2505 Resample image. 2506 */ 2507 (void) SyncImageSettings(mogrify_info,*image); 2508 flags=ParseGeometry(argv[i+1],&geometry_info); 2509 if ((flags & SigmaValue) == 0) 2510 geometry_info.sigma=geometry_info.rho; 2511 mogrify_image=ResampleImage(*image,geometry_info.rho, 2512 geometry_info.sigma,(*image)->filter,(*image)->blur,exception); 2513 break; 2514 } 2515 if (LocaleCompare("resize",option+1) == 0) 2516 { 2517 /* 2518 Resize image. 2519 */ 2520 (void) SyncImageSettings(mogrify_info,*image); 2521 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2522 mogrify_image=ResizeImage(*image,geometry.width,geometry.height, 2523 (*image)->filter,(*image)->blur,exception); 2524 break; 2525 } 2526 if (LocaleCompare("roll",option+1) == 0) 2527 { 2528 /* 2529 Roll image. 2530 */ 2531 (void) SyncImageSettings(mogrify_info,*image); 2532 (void) ParsePageGeometry(*image,argv[i+1],&geometry,exception); 2533 mogrify_image=RollImage(*image,geometry.x,geometry.y,exception); 2534 break; 2535 } 2536 if (LocaleCompare("rotate",option+1) == 0) 2537 { 2538 char 2539 *geometry; 2540 2541 /* 2542 Check for conditional image rotation. 2543 */ 2544 (void) SyncImageSettings(mogrify_info,*image); 2545 if (strchr(argv[i+1],'>') != (char *) NULL) 2546 if ((*image)->columns <= (*image)->rows) 2547 break; 2548 if (strchr(argv[i+1],'<') != (char *) NULL) 2549 if ((*image)->columns >= (*image)->rows) 2550 break; 2551 /* 2552 Rotate image. 2553 */ 2554 geometry=ConstantString(argv[i+1]); 2555 (void) SubstituteString(&geometry,">",""); 2556 (void) SubstituteString(&geometry,"<",""); 2557 (void) ParseGeometry(geometry,&geometry_info); 2558 geometry=DestroyString(geometry); 2559 mogrify_image=RotateImage(*image,geometry_info.rho,exception); 2560 break; 2561 } 2562 break; 2563 } 2564 case 's': 2565 { 2566 if (LocaleCompare("sample",option+1) == 0) 2567 { 2568 /* 2569 Sample image with pixel replication. 2570 */ 2571 (void) SyncImageSettings(mogrify_info,*image); 2572 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2573 mogrify_image=SampleImage(*image,geometry.width,geometry.height, 2574 exception); 2575 break; 2576 } 2577 if (LocaleCompare("scale",option+1) == 0) 2578 { 2579 /* 2580 Resize image. 2581 */ 2582 (void) SyncImageSettings(mogrify_info,*image); 2583 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2584 mogrify_image=ScaleImage(*image,geometry.width,geometry.height, 2585 exception); 2586 break; 2587 } 2588 if (LocaleCompare("selective-blur",option+1) == 0) 2589 { 2590 /* 2591 Selectively blur pixels within a contrast threshold. 2592 */ 2593 (void) SyncImageSettings(mogrify_info,*image); 2594 flags=ParseGeometry(argv[i+1],&geometry_info); 2595 if ((flags & PercentValue) != 0) 2596 geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0; 2597 mogrify_image=SelectiveBlurImage(*image,geometry_info.rho, 2598 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception); 2599 break; 2600 } 2601 if (LocaleCompare("separate",option+1) == 0) 2602 { 2603 /* 2604 Break channels into separate images. 2605 */ 2606 (void) SyncImageSettings(mogrify_info,*image); 2607 mogrify_image=SeparateImages(*image,exception); 2608 break; 2609 } 2610 if (LocaleCompare("sepia-tone",option+1) == 0) 2611 { 2612 double 2613 threshold; 2614 2615 /* 2616 Sepia-tone image. 2617 */ 2618 (void) SyncImageSettings(mogrify_info,*image); 2619 threshold=SiPrefixToDouble(argv[i+1],QuantumRange); 2620 mogrify_image=SepiaToneImage(*image,threshold,exception); 2621 break; 2622 } 2623 if (LocaleCompare("segment",option+1) == 0) 2624 { 2625 /* 2626 Segment image. 2627 */ 2628 (void) SyncImageSettings(mogrify_info,*image); 2629 flags=ParseGeometry(argv[i+1],&geometry_info); 2630 if ((flags & SigmaValue) == 0) 2631 geometry_info.sigma=1.0; 2632 (void) SegmentImage(*image,(*image)->colorspace, 2633 mogrify_info->verbose,geometry_info.rho,geometry_info.sigma, 2634 exception); 2635 break; 2636 } 2637 if (LocaleCompare("set",option+1) == 0) 2638 { 2639 char 2640 *value; 2641 2642 /* 2643 Set image option. 2644 */ 2645 if (*option == '+') 2646 { 2647 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 2648 (void) DeleteImageRegistry(argv[i+1]+9); 2649 else 2650 if (LocaleNCompare(argv[i+1],"option:",7) == 0) 2651 { 2652 (void) DeleteImageOption(mogrify_info,argv[i+1]+7); 2653 (void) DeleteImageArtifact(*image,argv[i+1]+7); 2654 } 2655 else 2656 (void) DeleteImageProperty(*image,argv[i+1]); 2657 break; 2658 } 2659 value=InterpretImageProperties(mogrify_info,*image,argv[i+2], 2660 exception); 2661 if (value == (char *) NULL) 2662 break; 2663 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 2664 (void) SetImageRegistry(StringRegistryType,argv[i+1]+9,value, 2665 exception); 2666 else 2667 if (LocaleNCompare(argv[i+1],"option:",7) == 0) 2668 { 2669 (void) SetImageOption(image_info,argv[i+1]+7,value); 2670 (void) SetImageOption(mogrify_info,argv[i+1]+7,value); 2671 (void) SetImageArtifact(*image,argv[i+1]+7,value); 2672 } 2673 else 2674 (void) SetImageProperty(*image,argv[i+1],value); 2675 value=DestroyString(value); 2676 break; 2677 } 2678 if (LocaleCompare("shade",option+1) == 0) 2679 { 2680 /* 2681 Shade image. 2682 */ 2683 (void) SyncImageSettings(mogrify_info,*image); 2684 flags=ParseGeometry(argv[i+1],&geometry_info); 2685 if ((flags & SigmaValue) == 0) 2686 geometry_info.sigma=1.0; 2687 mogrify_image=ShadeImage(*image,(*option == '-') ? MagickTrue : 2688 MagickFalse,geometry_info.rho,geometry_info.sigma,exception); 2689 break; 2690 } 2691 if (LocaleCompare("shadow",option+1) == 0) 2692 { 2693 /* 2694 Shadow image. 2695 */ 2696 (void) SyncImageSettings(mogrify_info,*image); 2697 flags=ParseGeometry(argv[i+1],&geometry_info); 2698 if ((flags & SigmaValue) == 0) 2699 geometry_info.sigma=1.0; 2700 if ((flags & XiValue) == 0) 2701 geometry_info.xi=4.0; 2702 if ((flags & PsiValue) == 0) 2703 geometry_info.psi=4.0; 2704 mogrify_image=ShadowImage(*image,geometry_info.rho, 2705 geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t) 2706 ceil(geometry_info.psi-0.5),exception); 2707 break; 2708 } 2709 if (LocaleCompare("sharpen",option+1) == 0) 2710 { 2711 /* 2712 Sharpen image. 2713 */ 2714 (void) SyncImageSettings(mogrify_info,*image); 2715 flags=ParseGeometry(argv[i+1],&geometry_info); 2716 if ((flags & SigmaValue) == 0) 2717 geometry_info.sigma=1.0; 2718 if ((flags & XiValue) == 0) 2719 geometry_info.xi=0.0; 2720 mogrify_image=SharpenImage(*image,geometry_info.rho, 2721 geometry_info.sigma,geometry_info.xi,exception); 2722 break; 2723 } 2724 if (LocaleCompare("shave",option+1) == 0) 2725 { 2726 /* 2727 Shave the image edges. 2728 */ 2729 (void) SyncImageSettings(mogrify_info,*image); 2730 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 2731 mogrify_image=ShaveImage(*image,&geometry,exception); 2732 break; 2733 } 2734 if (LocaleCompare("shear",option+1) == 0) 2735 { 2736 /* 2737 Shear image. 2738 */ 2739 (void) SyncImageSettings(mogrify_info,*image); 2740 flags=ParseGeometry(argv[i+1],&geometry_info); 2741 if ((flags & SigmaValue) == 0) 2742 geometry_info.sigma=geometry_info.rho; 2743 mogrify_image=ShearImage(*image,geometry_info.rho, 2744 geometry_info.sigma,exception); 2745 break; 2746 } 2747 if (LocaleCompare("sigmoidal-contrast",option+1) == 0) 2748 { 2749 /* 2750 Sigmoidal non-linearity contrast control. 2751 */ 2752 (void) SyncImageSettings(mogrify_info,*image); 2753 flags=ParseGeometry(argv[i+1],&geometry_info); 2754 if ((flags & SigmaValue) == 0) 2755 geometry_info.sigma=(double) QuantumRange/2.0; 2756 if ((flags & PercentValue) != 0) 2757 geometry_info.sigma=(double) QuantumRange*geometry_info.sigma/ 2758 100.0; 2759 (void) SigmoidalContrastImage(*image,(*option == '-') ? 2760 MagickTrue : MagickFalse,geometry_info.rho,geometry_info.sigma, 2761 exception); 2762 break; 2763 } 2764 if (LocaleCompare("sketch",option+1) == 0) 2765 { 2766 /* 2767 Sketch image. 2768 */ 2769 (void) SyncImageSettings(mogrify_info,*image); 2770 flags=ParseGeometry(argv[i+1],&geometry_info); 2771 if ((flags & SigmaValue) == 0) 2772 geometry_info.sigma=1.0; 2773 mogrify_image=SketchImage(*image,geometry_info.rho, 2774 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception); 2775 break; 2776 } 2777 if (LocaleCompare("solarize",option+1) == 0) 2778 { 2779 double 2780 threshold; 2781 2782 (void) SyncImageSettings(mogrify_info,*image); 2783 threshold=SiPrefixToDouble(argv[i+1],QuantumRange); 2784 (void) SolarizeImage(*image,threshold,exception); 2785 break; 2786 } 2787 if (LocaleCompare("sparse-color",option+1) == 0) 2788 { 2789 SparseColorMethod 2790 method; 2791 2792 char 2793 *arguments; 2794 2795 /* 2796 Sparse Color Interpolated Gradient 2797 */ 2798 (void) SyncImageSettings(mogrify_info,*image); 2799 method=(SparseColorMethod) ParseCommandOption( 2800 MagickSparseColorOptions,MagickFalse,argv[i+1]); 2801 arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2], 2802 exception); 2803 if (arguments == (char *) NULL) 2804 break; 2805 mogrify_image=SparseColorOption(*image,method,arguments, 2806 option[0] == '+' ? MagickTrue : MagickFalse,exception); 2807 arguments=DestroyString(arguments); 2808 break; 2809 } 2810 if (LocaleCompare("splice",option+1) == 0) 2811 { 2812 /* 2813 Splice a solid color into the image. 2814 */ 2815 (void) SyncImageSettings(mogrify_info,*image); 2816 (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception); 2817 mogrify_image=SpliceImage(*image,&geometry,exception); 2818 break; 2819 } 2820 if (LocaleCompare("spread",option+1) == 0) 2821 { 2822 /* 2823 Spread an image. 2824 */ 2825 (void) SyncImageSettings(mogrify_info,*image); 2826 (void) ParseGeometry(argv[i+1],&geometry_info); 2827 mogrify_image=SpreadImage(*image,geometry_info.rho, 2828 interpolate_method,exception); 2829 break; 2830 } 2831 if (LocaleCompare("statistic",option+1) == 0) 2832 { 2833 StatisticType 2834 type; 2835 2836 (void) SyncImageSettings(mogrify_info,*image); 2837 type=(StatisticType) ParseCommandOption(MagickStatisticOptions, 2838 MagickFalse,argv[i+1]); 2839 (void) ParseGeometry(argv[i+2],&geometry_info); 2840 mogrify_image=StatisticImage(*image,type,(size_t) geometry_info.rho, 2841 (size_t) geometry_info.sigma,exception); 2842 break; 2843 } 2844 if (LocaleCompare("stretch",option+1) == 0) 2845 { 2846 if (*option == '+') 2847 { 2848 draw_info->stretch=UndefinedStretch; 2849 break; 2850 } 2851 draw_info->stretch=(StretchType) ParseCommandOption( 2852 MagickStretchOptions,MagickFalse,argv[i+1]); 2853 break; 2854 } 2855 if (LocaleCompare("strip",option+1) == 0) 2856 { 2857 /* 2858 Strip image of profiles and comments. 2859 */ 2860 (void) SyncImageSettings(mogrify_info,*image); 2861 (void) StripImage(*image); 2862 InheritException(exception,&(*image)->exception); 2863 break; 2864 } 2865 if (LocaleCompare("stroke",option+1) == 0) 2866 { 2867 ExceptionInfo 2868 *sans; 2869 2870 if (*option == '+') 2871 { 2872 (void) QueryColorCompliance("none",AllCompliance, 2873 &draw_info->stroke,exception); 2874 if (draw_info->stroke_pattern != (Image *) NULL) 2875 draw_info->stroke_pattern=DestroyImage( 2876 draw_info->stroke_pattern); 2877 break; 2878 } 2879 sans=AcquireExceptionInfo(); 2880 status=QueryColorCompliance(argv[i+1],AllCompliance, 2881 &draw_info->stroke,sans); 2882 sans=DestroyExceptionInfo(sans); 2883 if (status == MagickFalse) 2884 draw_info->stroke_pattern=GetImageCache(mogrify_info,argv[i+1], 2885 exception); 2886 break; 2887 } 2888 if (LocaleCompare("strokewidth",option+1) == 0) 2889 { 2890 draw_info->stroke_width=InterpretLocaleValue(argv[i+1], 2891 (char **) NULL); 2892 break; 2893 } 2894 if (LocaleCompare("style",option+1) == 0) 2895 { 2896 if (*option == '+') 2897 { 2898 draw_info->style=UndefinedStyle; 2899 break; 2900 } 2901 draw_info->style=(StyleType) ParseCommandOption(MagickStyleOptions, 2902 MagickFalse,argv[i+1]); 2903 break; 2904 } 2905 if (LocaleCompare("swirl",option+1) == 0) 2906 { 2907 /* 2908 Swirl image. 2909 */ 2910 (void) SyncImageSettings(mogrify_info,*image); 2911 (void) ParseGeometry(argv[i+1],&geometry_info); 2912 mogrify_image=SwirlImage(*image,geometry_info.rho, 2913 interpolate_method,exception); 2914 break; 2915 } 2916 break; 2917 } 2918 case 't': 2919 { 2920 if (LocaleCompare("threshold",option+1) == 0) 2921 { 2922 double 2923 threshold; 2924 2925 /* 2926 Threshold image. 2927 */ 2928 (void) SyncImageSettings(mogrify_info,*image); 2929 if (*option == '+') 2930 threshold=(double) QuantumRange/2; 2931 else 2932 threshold=SiPrefixToDouble(argv[i+1],QuantumRange); 2933 (void) BilevelImage(*image,threshold); 2934 InheritException(exception,&(*image)->exception); 2935 break; 2936 } 2937 if (LocaleCompare("thumbnail",option+1) == 0) 2938 { 2939 /* 2940 Thumbnail image. 2941 */ 2942 (void) SyncImageSettings(mogrify_info,*image); 2943 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2944 mogrify_image=ThumbnailImage(*image,geometry.width,geometry.height, 2945 exception); 2946 break; 2947 } 2948 if (LocaleCompare("tile",option+1) == 0) 2949 { 2950 if (*option == '+') 2951 { 2952 if (draw_info->fill_pattern != (Image *) NULL) 2953 draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern); 2954 break; 2955 } 2956 draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1], 2957 exception); 2958 break; 2959 } 2960 if (LocaleCompare("tint",option+1) == 0) 2961 { 2962 /* 2963 Tint the image. 2964 */ 2965 (void) SyncImageSettings(mogrify_info,*image); 2966 mogrify_image=TintImage(*image,argv[i+1],&fill,exception); 2967 break; 2968 } 2969 if (LocaleCompare("transform",option+1) == 0) 2970 { 2971 /* 2972 Affine transform image. 2973 */ 2974 (void) SyncImageSettings(mogrify_info,*image); 2975 mogrify_image=AffineTransformImage(*image,&draw_info->affine, 2976 exception); 2977 break; 2978 } 2979 if (LocaleCompare("transparent",option+1) == 0) 2980 { 2981 PixelInfo 2982 target; 2983 2984 (void) SyncImageSettings(mogrify_info,*image); 2985 (void) QueryMagickColorCompliance(argv[i+1],AllCompliance,&target, 2986 exception); 2987 (void) TransparentPaintImage(*image,&target,(Quantum) 2988 TransparentAlpha,*option == '-' ? MagickFalse : MagickTrue, 2989 &(*image)->exception); 2990 break; 2991 } 2992 if (LocaleCompare("transpose",option+1) == 0) 2993 { 2994 /* 2995 Transpose image scanlines. 2996 */ 2997 (void) SyncImageSettings(mogrify_info,*image); 2998 mogrify_image=TransposeImage(*image,exception); 2999 break; 3000 } 3001 if (LocaleCompare("transverse",option+1) == 0) 3002 { 3003 /* 3004 Transverse image scanlines. 3005 */ 3006 (void) SyncImageSettings(mogrify_info,*image); 3007 mogrify_image=TransverseImage(*image,exception); 3008 break; 3009 } 3010 if (LocaleCompare("treedepth",option+1) == 0) 3011 { 3012 quantize_info->tree_depth=StringToUnsignedLong(argv[i+1]); 3013 break; 3014 } 3015 if (LocaleCompare("trim",option+1) == 0) 3016 { 3017 /* 3018 Trim image. 3019 */ 3020 (void) SyncImageSettings(mogrify_info,*image); 3021 mogrify_image=TrimImage(*image,exception); 3022 break; 3023 } 3024 if (LocaleCompare("type",option+1) == 0) 3025 { 3026 ImageType 3027 type; 3028 3029 (void) SyncImageSettings(mogrify_info,*image); 3030 if (*option == '+') 3031 type=UndefinedType; 3032 else 3033 type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse, 3034 argv[i+1]); 3035 (*image)->type=UndefinedType; 3036 (void) SetImageType(*image,type,exception); 3037 break; 3038 } 3039 break; 3040 } 3041 case 'u': 3042 { 3043 if (LocaleCompare("undercolor",option+1) == 0) 3044 { 3045 (void) QueryColorCompliance(argv[i+1],AllCompliance, 3046 &draw_info->undercolor,exception); 3047 break; 3048 } 3049 if (LocaleCompare("unique",option+1) == 0) 3050 { 3051 if (*option == '+') 3052 { 3053 (void) DeleteImageArtifact(*image,"identify:unique-colors"); 3054 break; 3055 } 3056 (void) SetImageArtifact(*image,"identify:unique-colors","true"); 3057 (void) SetImageArtifact(*image,"verbose","true"); 3058 break; 3059 } 3060 if (LocaleCompare("unique-colors",option+1) == 0) 3061 { 3062 /* 3063 Unique image colors. 3064 */ 3065 (void) SyncImageSettings(mogrify_info,*image); 3066 mogrify_image=UniqueImageColors(*image,exception); 3067 break; 3068 } 3069 if (LocaleCompare("unsharp",option+1) == 0) 3070 { 3071 /* 3072 Unsharp mask image. 3073 */ 3074 (void) SyncImageSettings(mogrify_info,*image); 3075 flags=ParseGeometry(argv[i+1],&geometry_info); 3076 if ((flags & SigmaValue) == 0) 3077 geometry_info.sigma=1.0; 3078 if ((flags & XiValue) == 0) 3079 geometry_info.xi=1.0; 3080 if ((flags & PsiValue) == 0) 3081 geometry_info.psi=0.05; 3082 mogrify_image=UnsharpMaskImage(*image,geometry_info.rho, 3083 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception); 3084 break; 3085 } 3086 break; 3087 } 3088 case 'v': 3089 { 3090 if (LocaleCompare("verbose",option+1) == 0) 3091 { 3092 (void) SetImageArtifact(*image,option+1, 3093 *option == '+' ? "false" : "true"); 3094 break; 3095 } 3096 if (LocaleCompare("vignette",option+1) == 0) 3097 { 3098 /* 3099 Vignette image. 3100 */ 3101 (void) SyncImageSettings(mogrify_info,*image); 3102 flags=ParseGeometry(argv[i+1],&geometry_info); 3103 if ((flags & SigmaValue) == 0) 3104 geometry_info.sigma=1.0; 3105 if ((flags & XiValue) == 0) 3106 geometry_info.xi=0.1*(*image)->columns; 3107 if ((flags & PsiValue) == 0) 3108 geometry_info.psi=0.1*(*image)->rows; 3109 mogrify_image=VignetteImage(*image,geometry_info.rho, 3110 geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t) 3111 ceil(geometry_info.psi-0.5),exception); 3112 break; 3113 } 3114 if (LocaleCompare("virtual-pixel",option+1) == 0) 3115 { 3116 if (*option == '+') 3117 { 3118 (void) SetImageVirtualPixelMethod(*image, 3119 UndefinedVirtualPixelMethod); 3120 break; 3121 } 3122 (void) SetImageVirtualPixelMethod(*image,(VirtualPixelMethod) 3123 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse, 3124 argv[i+1])); 3125 break; 3126 } 3127 break; 3128 } 3129 case 'w': 3130 { 3131 if (LocaleCompare("wave",option+1) == 0) 3132 { 3133 /* 3134 Wave image. 3135 */ 3136 (void) SyncImageSettings(mogrify_info,*image); 3137 flags=ParseGeometry(argv[i+1],&geometry_info); 3138 if ((flags & SigmaValue) == 0) 3139 geometry_info.sigma=1.0; 3140 mogrify_image=WaveImage(*image,geometry_info.rho, 3141 geometry_info.sigma,interpolate_method,exception); 3142 break; 3143 } 3144 if (LocaleCompare("weight",option+1) == 0) 3145 { 3146 draw_info->weight=StringToUnsignedLong(argv[i+1]); 3147 if (LocaleCompare(argv[i+1],"all") == 0) 3148 draw_info->weight=0; 3149 if (LocaleCompare(argv[i+1],"bold") == 0) 3150 draw_info->weight=700; 3151 if (LocaleCompare(argv[i+1],"bolder") == 0) 3152 if (draw_info->weight <= 800) 3153 draw_info->weight+=100; 3154 if (LocaleCompare(argv[i+1],"lighter") == 0) 3155 if (draw_info->weight >= 100) 3156 draw_info->weight-=100; 3157 if (LocaleCompare(argv[i+1],"normal") == 0) 3158 draw_info->weight=400; 3159 break; 3160 } 3161 if (LocaleCompare("white-threshold",option+1) == 0) 3162 { 3163 /* 3164 White threshold image. 3165 */ 3166 (void) SyncImageSettings(mogrify_info,*image); 3167 (void) WhiteThresholdImage(*image,argv[i+1],exception); 3168 InheritException(exception,&(*image)->exception); 3169 break; 3170 } 3171 break; 3172 } 3173 default: 3174 break; 3175 } 3176 /* 3177 Replace current image with any image that was generated 3178 */ 3179 if (mogrify_image != (Image *) NULL) 3180 ReplaceImageInListReturnLast(image,mogrify_image); 3181 i+=count; 3182 } 3183 if (region_image != (Image *) NULL) 3184 { 3185 /* 3186 Composite transformed region onto image. 3187 */ 3188 (void) SyncImageSettings(mogrify_info,*image); 3189 (void) CompositeImage(region_image,region_image->matte != 3190 MagickFalse ? CopyCompositeOp : OverCompositeOp,*image, 3191 region_geometry.x,region_geometry.y); 3192 InheritException(exception,®ion_image->exception); 3193 *image=DestroyImage(*image); 3194 *image=region_image; 3195 region_image = (Image *) NULL; 3196 } 3197 /* 3198 Free resources. 3199 */ 3200 quantize_info=DestroyQuantizeInfo(quantize_info); 3201 draw_info=DestroyDrawInfo(draw_info); 3202 mogrify_info=DestroyImageInfo(mogrify_info); 3203 status=(MagickStatusType) ((*image)->exception.severity == 3204 UndefinedException ? 1 : 0); 3205 return(status == 0 ? MagickFalse : MagickTrue); 3206} 3207 3208/* 3209%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3210% % 3211% % 3212% % 3213+ M o g r i f y I m a g e C o m m a n d % 3214% % 3215% % 3216% % 3217%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3218% 3219% MogrifyImageCommand() transforms an image or a sequence of images. These 3220% transforms include image scaling, image rotation, color reduction, and 3221% others. The transmogrified image overwrites the original image. 3222% 3223% The format of the MogrifyImageCommand method is: 3224% 3225% MagickBooleanType MogrifyImageCommand(ImageInfo *image_info,int argc, 3226% const char **argv,char **metadata,ExceptionInfo *exception) 3227% 3228% A description of each parameter follows: 3229% 3230% o image_info: the image info. 3231% 3232% o argc: the number of elements in the argument vector. 3233% 3234% o argv: A text array containing the command line arguments. 3235% 3236% o metadata: any metadata is returned here. 3237% 3238% o exception: return any errors or warnings in this structure. 3239% 3240*/ 3241 3242static MagickBooleanType MogrifyUsage(void) 3243{ 3244 static const char 3245 *miscellaneous[]= 3246 { 3247 "-debug events display copious debugging information", 3248 "-help print program options", 3249 "-list type print a list of supported option arguments", 3250 "-log format format of debugging information", 3251 "-version print version information", 3252 (char *) NULL 3253 }, 3254 *operators[]= 3255 { 3256 "-adaptive-blur geometry", 3257 " adaptively blur pixels; decrease effect near edges", 3258 "-adaptive-resize geometry", 3259 " adaptively resize image using 'mesh' interpolation", 3260 "-adaptive-sharpen geometry", 3261 " adaptively sharpen pixels; increase effect near edges", 3262 "-alpha option on, activate, off, deactivate, set, opaque, copy", 3263 " transparent, extract, background, or shape", 3264 "-annotate geometry text", 3265 " annotate the image with text", 3266 "-auto-gamma automagically adjust gamma level of image", 3267 "-auto-level automagically adjust color levels of image", 3268 "-auto-orient automagically orient (rotate) image", 3269 "-bench iterations measure performance", 3270 "-black-threshold value", 3271 " force all pixels below the threshold into black", 3272 "-blue-shift simulate a scene at nighttime in the moonlight", 3273 "-blur geometry reduce image noise and reduce detail levels", 3274 "-border geometry surround image with a border of color", 3275 "-bordercolor color border color", 3276 "-brightness-contrast geometry", 3277 " improve brightness / contrast of the image", 3278 "-cdl filename color correct with a color decision list", 3279 "-charcoal geometry simulate a charcoal drawing", 3280 "-chop geometry remove pixels from the image interior", 3281 "-clamp restrict pixel range from 0 to the quantum depth", 3282 "-clip clip along the first path from the 8BIM profile", 3283 "-clip-mask filename associate a clip mask with the image", 3284 "-clip-path id clip along a named path from the 8BIM profile", 3285 "-colorize value colorize the image with the fill color", 3286 "-color-matrix matrix apply color correction to the image", 3287 "-contrast enhance or reduce the image contrast", 3288 "-contrast-stretch geometry", 3289 " improve contrast by `stretching' the intensity range", 3290 "-convolve coefficients", 3291 " apply a convolution kernel to the image", 3292 "-cycle amount cycle the image colormap", 3293 "-decipher filename convert cipher pixels to plain pixels", 3294 "-deskew threshold straighten an image", 3295 "-despeckle reduce the speckles within an image", 3296 "-distort method args", 3297 " distort images according to given method ad args", 3298 "-draw string annotate the image with a graphic primitive", 3299 "-edge radius apply a filter to detect edges in the image", 3300 "-encipher filename convert plain pixels to cipher pixels", 3301 "-emboss radius emboss an image", 3302 "-enhance apply a digital filter to enhance a noisy image", 3303 "-equalize perform histogram equalization to an image", 3304 "-evaluate operator value", 3305 " evaluate an arithmetic, relational, or logical expression", 3306 "-extent geometry set the image size", 3307 "-extract geometry extract area from image", 3308 "-fft implements the discrete Fourier transform (DFT)", 3309 "-flip flip image vertically", 3310 "-floodfill geometry color", 3311 " floodfill the image with color", 3312 "-flop flop image horizontally", 3313 "-frame geometry surround image with an ornamental border", 3314 "-function name parameters", 3315 " apply function over image values", 3316 "-gamma value level of gamma correction", 3317 "-gaussian-blur geometry", 3318 " reduce image noise and reduce detail levels", 3319 "-geometry geometry preferred size or location of the image", 3320 "-identify identify the format and characteristics of the image", 3321 "-ift implements the inverse discrete Fourier transform (DFT)", 3322 "-implode amount implode image pixels about the center", 3323 "-lat geometry local adaptive thresholding", 3324 "-layers method optimize, merge, or compare image layers", 3325 "-level value adjust the level of image contrast", 3326 "-level-colors color,color", 3327 " level image with the given colors", 3328 "-linear-stretch geometry", 3329 " improve contrast by `stretching with saturation'", 3330 "-liquid-rescale geometry", 3331 " rescale image with seam-carving", 3332 "-median geometry apply a median filter to the image", 3333 "-mode geometry make each pixel the 'predominant color' of the neighborhood", 3334 "-modulate value vary the brightness, saturation, and hue", 3335 "-monochrome transform image to black and white", 3336 "-morphology method kernel", 3337 " apply a morphology method to the image", 3338 "-motion-blur geometry", 3339 " simulate motion blur", 3340 "-negate replace every pixel with its complementary color ", 3341 "-noise geometry add or reduce noise in an image", 3342 "-normalize transform image to span the full range of colors", 3343 "-opaque color change this color to the fill color", 3344 "-ordered-dither NxN", 3345 " add a noise pattern to the image with specific", 3346 " amplitudes", 3347 "-paint radius simulate an oil painting", 3348 "-polaroid angle simulate a Polaroid picture", 3349 "-posterize levels reduce the image to a limited number of color levels", 3350 "-profile filename add, delete, or apply an image profile", 3351 "-quantize colorspace reduce colors in this colorspace", 3352 "-radial-blur angle radial blur the image", 3353 "-raise value lighten/darken image edges to create a 3-D effect", 3354 "-random-threshold low,high", 3355 " random threshold the image", 3356 "-region geometry apply options to a portion of the image", 3357 "-render render vector graphics", 3358 "-repage geometry size and location of an image canvas", 3359 "-resample geometry change the resolution of an image", 3360 "-resize geometry resize the image", 3361 "-roll geometry roll an image vertically or horizontally", 3362 "-rotate degrees apply Paeth rotation to the image", 3363 "-sample geometry scale image with pixel sampling", 3364 "-scale geometry scale the image", 3365 "-segment values segment an image", 3366 "-selective-blur geometry", 3367 " selectively blur pixels within a contrast threshold", 3368 "-sepia-tone threshold", 3369 " simulate a sepia-toned photo", 3370 "-set property value set an image property", 3371 "-shade degrees shade the image using a distant light source", 3372 "-shadow geometry simulate an image shadow", 3373 "-sharpen geometry sharpen the image", 3374 "-shave geometry shave pixels from the image edges", 3375 "-shear geometry slide one edge of the image along the X or Y axis", 3376 "-sigmoidal-contrast geometry", 3377 " increase the contrast without saturating highlights or shadows", 3378 "-sketch geometry simulate a pencil sketch", 3379 "-solarize threshold negate all pixels above the threshold level", 3380 "-sparse-color method args", 3381 " fill in a image based on a few color points", 3382 "-splice geometry splice the background color into the image", 3383 "-spread radius displace image pixels by a random amount", 3384 "-statistic type radius", 3385 " replace each pixel with corresponding statistic from the neighborhood", 3386 "-strip strip image of all profiles and comments", 3387 "-swirl degrees swirl image pixels about the center", 3388 "-threshold value threshold the image", 3389 "-thumbnail geometry create a thumbnail of the image", 3390 "-tile filename tile image when filling a graphic primitive", 3391 "-tint value tint the image with the fill color", 3392 "-transform affine transform image", 3393 "-transparent color make this color transparent within the image", 3394 "-transpose flip image vertically and rotate 90 degrees", 3395 "-transverse flop image horizontally and rotate 270 degrees", 3396 "-trim trim image edges", 3397 "-type type image type", 3398 "-unique-colors discard all but one of any pixel color", 3399 "-unsharp geometry sharpen the image", 3400 "-vignette geometry soften the edges of the image in vignette style", 3401 "-wave geometry alter an image along a sine wave", 3402 "-white-threshold value", 3403 " force all pixels above the threshold into white", 3404 (char *) NULL 3405 }, 3406 *sequence_operators[]= 3407 { 3408 "-append append an image sequence", 3409 "-clut apply a color lookup table to the image", 3410 "-coalesce merge a sequence of images", 3411 "-combine combine a sequence of images", 3412 "-composite composite image", 3413 "-crop geometry cut out a rectangular region of the image", 3414 "-deconstruct break down an image sequence into constituent parts", 3415 "-evaluate-sequence operator", 3416 " evaluate an arithmetic, relational, or logical expression", 3417 "-flatten flatten a sequence of images", 3418 "-fx expression apply mathematical expression to an image channel(s)", 3419 "-hald-clut apply a Hald color lookup table to the image", 3420 "-morph value morph an image sequence", 3421 "-mosaic create a mosaic from an image sequence", 3422 "-print string interpret string and print to console", 3423 "-process arguments process the image with a custom image filter", 3424 "-separate separate an image channel into a grayscale image", 3425 "-smush geometry smush an image sequence together", 3426 "-write filename write images to this file", 3427 (char *) NULL 3428 }, 3429 *settings[]= 3430 { 3431 "-adjoin join images into a single multi-image file", 3432 "-affine matrix affine transform matrix", 3433 "-alpha option activate, deactivate, reset, or set the alpha channel", 3434 "-antialias remove pixel-aliasing", 3435 "-authenticate password", 3436 " decipher image with this password", 3437 "-attenuate value lessen (or intensify) when adding noise to an image", 3438 "-background color background color", 3439 "-bias value add bias when convolving an image", 3440 "-black-point-compensation", 3441 " use black point compensation", 3442 "-blue-primary point chromaticity blue primary point", 3443 "-bordercolor color border color", 3444 "-caption string assign a caption to an image", 3445 "-channel type apply option to select image channels", 3446 "-colors value preferred number of colors in the image", 3447 "-colorspace type alternate image colorspace", 3448 "-comment string annotate image with comment", 3449 "-compose operator set image composite operator", 3450 "-compress type type of pixel compression when writing the image", 3451 "-define format:option", 3452 " define one or more image format options", 3453 "-delay value display the next image after pausing", 3454 "-density geometry horizontal and vertical density of the image", 3455 "-depth value image depth", 3456 "-direction type render text right-to-left or left-to-right", 3457 "-display server get image or font from this X server", 3458 "-dispose method layer disposal method", 3459 "-dither method apply error diffusion to image", 3460 "-encoding type text encoding type", 3461 "-endian type endianness (MSB or LSB) of the image", 3462 "-family name render text with this font family", 3463 "-fill color color to use when filling a graphic primitive", 3464 "-filter type use this filter when resizing an image", 3465 "-font name render text with this font", 3466 "-format \"string\" output formatted image characteristics", 3467 "-fuzz distance colors within this distance are considered equal", 3468 "-gravity type horizontal and vertical text placement", 3469 "-green-primary point chromaticity green primary point", 3470 "-intent type type of rendering intent when managing the image color", 3471 "-interlace type type of image interlacing scheme", 3472 "-interline-spacing value", 3473 " set the space between two text lines", 3474 "-interpolate method pixel color interpolation method", 3475 "-interword-spacing value", 3476 " set the space between two words", 3477 "-kerning value set the space between two letters", 3478 "-label string assign a label to an image", 3479 "-limit type value pixel cache resource limit", 3480 "-loop iterations add Netscape loop extension to your GIF animation", 3481 "-mask filename associate a mask with the image", 3482 "-mattecolor color frame color", 3483 "-monitor monitor progress", 3484 "-orient type image orientation", 3485 "-page geometry size and location of an image canvas (setting)", 3486 "-ping efficiently determine image attributes", 3487 "-pointsize value font point size", 3488 "-precision value maximum number of significant digits to print", 3489 "-preview type image preview type", 3490 "-quality value JPEG/MIFF/PNG compression level", 3491 "-quiet suppress all warning messages", 3492 "-red-primary point chromaticity red primary point", 3493 "-regard-warnings pay attention to warning messages", 3494 "-remap filename transform image colors to match this set of colors", 3495 "-respect-parentheses settings remain in effect until parenthesis boundary", 3496 "-sampling-factor geometry", 3497 " horizontal and vertical sampling factor", 3498 "-scene value image scene number", 3499 "-seed value seed a new sequence of pseudo-random numbers", 3500 "-size geometry width and height of image", 3501 "-stretch type render text with this font stretch", 3502 "-stroke color graphic primitive stroke color", 3503 "-strokewidth value graphic primitive stroke width", 3504 "-style type render text with this font style", 3505 "-synchronize synchronize image to storage device", 3506 "-taint declare the image as modified", 3507 "-texture filename name of texture to tile onto the image background", 3508 "-tile-offset geometry", 3509 " tile offset", 3510 "-treedepth value color tree depth", 3511 "-transparent-color color", 3512 " transparent color", 3513 "-undercolor color annotation bounding box color", 3514 "-units type the units of image resolution", 3515 "-verbose print detailed information about the image", 3516 "-view FlashPix viewing transforms", 3517 "-virtual-pixel method", 3518 " virtual pixel access method", 3519 "-weight type render text with this font weight", 3520 "-white-point point chromaticity white point", 3521 (char *) NULL 3522 }, 3523 *stack_operators[]= 3524 { 3525 "-delete indexes delete the image from the image sequence", 3526 "-duplicate count,indexes", 3527 " duplicate an image one or more times", 3528 "-insert index insert last image into the image sequence", 3529 "-reverse reverse image sequence", 3530 "-swap indexes swap two images in the image sequence", 3531 (char *) NULL 3532 }; 3533 3534 const char 3535 **p; 3536 3537 (void) printf("Version: %s\n",GetMagickVersion((size_t *) NULL)); 3538 (void) printf("Copyright: %s\n",GetMagickCopyright()); 3539 (void) printf("Features: %s\n\n",GetMagickFeatures()); 3540 (void) printf("Usage: %s [options ...] file [ [options ...] file ...]\n", 3541 GetClientName()); 3542 (void) printf("\nImage Settings:\n"); 3543 for (p=settings; *p != (char *) NULL; p++) 3544 (void) printf(" %s\n",*p); 3545 (void) printf("\nImage Operators:\n"); 3546 for (p=operators; *p != (char *) NULL; p++) 3547 (void) printf(" %s\n",*p); 3548 (void) printf("\nImage Sequence Operators:\n"); 3549 for (p=sequence_operators; *p != (char *) NULL; p++) 3550 (void) printf(" %s\n",*p); 3551 (void) printf("\nImage Stack Operators:\n"); 3552 for (p=stack_operators; *p != (char *) NULL; p++) 3553 (void) printf(" %s\n",*p); 3554 (void) printf("\nMiscellaneous Options:\n"); 3555 for (p=miscellaneous; *p != (char *) NULL; p++) 3556 (void) printf(" %s\n",*p); 3557 (void) printf( 3558 "\nBy default, the image format of `file' is determined by its magic\n"); 3559 (void) printf( 3560 "number. To specify a particular image format, precede the filename\n"); 3561 (void) printf( 3562 "with an image format name and a colon (i.e. ps:image) or specify the\n"); 3563 (void) printf( 3564 "image type as the filename suffix (i.e. image.ps). Specify 'file' as\n"); 3565 (void) printf("'-' for standard input or output.\n"); 3566 return(MagickFalse); 3567} 3568 3569WandExport MagickBooleanType MogrifyImageCommand(ImageInfo *image_info, 3570 int argc,char **argv,char **wand_unused(metadata),ExceptionInfo *exception) 3571{ 3572#define DestroyMogrify() \ 3573{ \ 3574 if (format != (char *) NULL) \ 3575 format=DestroyString(format); \ 3576 if (path != (char *) NULL) \ 3577 path=DestroyString(path); \ 3578 DestroyImageStack(); \ 3579 for (i=0; i < (ssize_t) argc; i++) \ 3580 argv[i]=DestroyString(argv[i]); \ 3581 argv=(char **) RelinquishMagickMemory(argv); \ 3582} 3583#define ThrowMogrifyException(asperity,tag,option) \ 3584{ \ 3585 (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \ 3586 option); \ 3587 DestroyMogrify(); \ 3588 return(MagickFalse); \ 3589} 3590#define ThrowMogrifyInvalidArgumentException(option,argument) \ 3591{ \ 3592 (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \ 3593 "InvalidArgument","`%s': %s",argument,option); \ 3594 DestroyMogrify(); \ 3595 return(MagickFalse); \ 3596} 3597 3598 char 3599 *format, 3600 *option, 3601 *path; 3602 3603 Image 3604 *image; 3605 3606 ImageStack 3607 image_stack[MaxImageStackDepth+1]; 3608 3609 MagickBooleanType 3610 global_colormap; 3611 3612 MagickBooleanType 3613 fire, 3614 pend, 3615 respect_parenthesis; 3616 3617 MagickStatusType 3618 status; 3619 3620 register ssize_t 3621 i; 3622 3623 ssize_t 3624 j, 3625 k; 3626 3627 /* 3628 Set defaults. 3629 */ 3630 assert(image_info != (ImageInfo *) NULL); 3631 assert(image_info->signature == MagickSignature); 3632 if (image_info->debug != MagickFalse) 3633 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); 3634 assert(exception != (ExceptionInfo *) NULL); 3635 if (argc == 2) 3636 { 3637 option=argv[1]; 3638 if ((LocaleCompare("version",option+1) == 0) || 3639 (LocaleCompare("-version",option+1) == 0)) 3640 { 3641 (void) FormatLocaleFile(stdout,"Version: %s\n", 3642 GetMagickVersion((size_t *) NULL)); 3643 (void) FormatLocaleFile(stdout,"Copyright: %s\n", 3644 GetMagickCopyright()); 3645 (void) FormatLocaleFile(stdout,"Features: %s\n\n", 3646 GetMagickFeatures()); 3647 return(MagickFalse); 3648 } 3649 } 3650 if (argc < 2) 3651 return(MogrifyUsage()); 3652 format=(char *) NULL; 3653 path=(char *) NULL; 3654 global_colormap=MagickFalse; 3655 k=0; 3656 j=1; 3657 NewImageStack(); 3658 option=(char *) NULL; 3659 pend=MagickFalse; 3660 respect_parenthesis=MagickFalse; 3661 status=MagickTrue; 3662 /* 3663 Parse command line. 3664 */ 3665 ReadCommandlLine(argc,&argv); 3666 status=ExpandFilenames(&argc,&argv); 3667 if (status == MagickFalse) 3668 ThrowMogrifyException(ResourceLimitError,"MemoryAllocationFailed", 3669 GetExceptionMessage(errno)); 3670 for (i=1; i < (ssize_t) argc; i++) 3671 { 3672 option=argv[i]; 3673 if (LocaleCompare(option,"(") == 0) 3674 { 3675 FireImageStack(MagickFalse,MagickTrue,pend); 3676 if (k == MaxImageStackDepth) 3677 ThrowMogrifyException(OptionError,"ParenthesisNestedTooDeeply", 3678 option); 3679 PushImageStack(); 3680 continue; 3681 } 3682 if (LocaleCompare(option,")") == 0) 3683 { 3684 FireImageStack(MagickFalse,MagickTrue,MagickTrue); 3685 if (k == 0) 3686 ThrowMogrifyException(OptionError,"UnableToParseExpression",option); 3687 PopImageStack(); 3688 continue; 3689 } 3690 if (IsCommandOption(option) == MagickFalse) 3691 { 3692 char 3693 backup_filename[MaxTextExtent], 3694 *filename; 3695 3696 Image 3697 *images; 3698 3699 /* 3700 Option is a file name: begin by reading image from specified file. 3701 */ 3702 FireImageStack(MagickFalse,MagickFalse,pend); 3703 filename=argv[i]; 3704 if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1))) 3705 filename=argv[++i]; 3706 (void) CopyMagickString(image_info->filename,filename,MaxTextExtent); 3707 images=ReadImages(image_info,exception); 3708 status&=(images != (Image *) NULL) && 3709 (exception->severity < ErrorException); 3710 if (images == (Image *) NULL) 3711 continue; 3712 if (format != (char *) NULL) 3713 (void) CopyMagickString(images->filename,images->magick_filename, 3714 MaxTextExtent); 3715 if (path != (char *) NULL) 3716 { 3717 GetPathComponent(option,TailPath,filename); 3718 (void) FormatLocaleString(images->filename,MaxTextExtent,"%s%c%s", 3719 path,*DirectorySeparator,filename); 3720 } 3721 if (format != (char *) NULL) 3722 AppendImageFormat(format,images->filename); 3723 AppendImageStack(images); 3724 FinalizeImageSettings(image_info,image,MagickFalse); 3725 if (global_colormap != MagickFalse) 3726 { 3727 QuantizeInfo 3728 *quantize_info; 3729 3730 quantize_info=AcquireQuantizeInfo(image_info); 3731 (void) RemapImages(quantize_info,images,(Image *) NULL,exception); 3732 quantize_info=DestroyQuantizeInfo(quantize_info); 3733 } 3734 *backup_filename='\0'; 3735 if ((LocaleCompare(image->filename,"-") != 0) && 3736 (IsPathWritable(image->filename) != MagickFalse)) 3737 { 3738 register ssize_t 3739 i; 3740 3741 /* 3742 Rename image file as backup. 3743 */ 3744 (void) CopyMagickString(backup_filename,image->filename, 3745 MaxTextExtent); 3746 for (i=0; i < 6; i++) 3747 { 3748 (void) ConcatenateMagickString(backup_filename,"~",MaxTextExtent); 3749 if (IsPathAccessible(backup_filename) == MagickFalse) 3750 break; 3751 } 3752 if ((IsPathAccessible(backup_filename) != MagickFalse) || 3753 (rename_utf8(image->filename,backup_filename) != 0)) 3754 *backup_filename='\0'; 3755 } 3756 /* 3757 Write transmogrified image to disk. 3758 */ 3759 image_info->synchronize=MagickTrue; 3760 status&=WriteImages(image_info,image,image->filename,exception); 3761 if ((status == MagickFalse) && (*backup_filename != '\0')) 3762 (void) remove_utf8(backup_filename); 3763 RemoveAllImageStack(); 3764 continue; 3765 } 3766 pend=image != (Image *) NULL ? MagickTrue : MagickFalse; 3767 switch (*(option+1)) 3768 { 3769 case 'a': 3770 { 3771 if (LocaleCompare("adaptive-blur",option+1) == 0) 3772 { 3773 i++; 3774 if (i == (ssize_t) argc) 3775 ThrowMogrifyException(OptionError,"MissingArgument",option); 3776 if (IsGeometry(argv[i]) == MagickFalse) 3777 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3778 break; 3779 } 3780 if (LocaleCompare("adaptive-resize",option+1) == 0) 3781 { 3782 i++; 3783 if (i == (ssize_t) argc) 3784 ThrowMogrifyException(OptionError,"MissingArgument",option); 3785 if (IsGeometry(argv[i]) == MagickFalse) 3786 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3787 break; 3788 } 3789 if (LocaleCompare("adaptive-sharpen",option+1) == 0) 3790 { 3791 i++; 3792 if (i == (ssize_t) argc) 3793 ThrowMogrifyException(OptionError,"MissingArgument",option); 3794 if (IsGeometry(argv[i]) == MagickFalse) 3795 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3796 break; 3797 } 3798 if (LocaleCompare("affine",option+1) == 0) 3799 { 3800 if (*option == '+') 3801 break; 3802 i++; 3803 if (i == (ssize_t) argc) 3804 ThrowMogrifyException(OptionError,"MissingArgument",option); 3805 break; 3806 } 3807 if (LocaleCompare("alpha",option+1) == 0) 3808 { 3809 ssize_t 3810 type; 3811 3812 if (*option == '+') 3813 break; 3814 i++; 3815 if (i == (ssize_t) argc) 3816 ThrowMogrifyException(OptionError,"MissingArgument",option); 3817 type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]); 3818 if (type < 0) 3819 ThrowMogrifyException(OptionError,"UnrecognizedAlphaChannelType", 3820 argv[i]); 3821 break; 3822 } 3823 if (LocaleCompare("annotate",option+1) == 0) 3824 { 3825 if (*option == '+') 3826 break; 3827 i++; 3828 if (i == (ssize_t) argc) 3829 ThrowMogrifyException(OptionError,"MissingArgument",option); 3830 if (IsGeometry(argv[i]) == MagickFalse) 3831 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3832 if (i == (ssize_t) argc) 3833 ThrowMogrifyException(OptionError,"MissingArgument",option); 3834 i++; 3835 break; 3836 } 3837 if (LocaleCompare("antialias",option+1) == 0) 3838 break; 3839 if (LocaleCompare("append",option+1) == 0) 3840 break; 3841 if (LocaleCompare("attenuate",option+1) == 0) 3842 { 3843 if (*option == '+') 3844 break; 3845 i++; 3846 if (i == (ssize_t) (argc-1)) 3847 ThrowMogrifyException(OptionError,"MissingArgument",option); 3848 if (IsGeometry(argv[i]) == MagickFalse) 3849 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3850 break; 3851 } 3852 if (LocaleCompare("authenticate",option+1) == 0) 3853 { 3854 if (*option == '+') 3855 break; 3856 i++; 3857 if (i == (ssize_t) argc) 3858 ThrowMogrifyException(OptionError,"MissingArgument",option); 3859 break; 3860 } 3861 if (LocaleCompare("auto-gamma",option+1) == 0) 3862 break; 3863 if (LocaleCompare("auto-level",option+1) == 0) 3864 break; 3865 if (LocaleCompare("auto-orient",option+1) == 0) 3866 break; 3867 if (LocaleCompare("average",option+1) == 0) 3868 break; 3869 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 3870 } 3871 case 'b': 3872 { 3873 if (LocaleCompare("background",option+1) == 0) 3874 { 3875 if (*option == '+') 3876 break; 3877 i++; 3878 if (i == (ssize_t) argc) 3879 ThrowMogrifyException(OptionError,"MissingArgument",option); 3880 break; 3881 } 3882 if (LocaleCompare("bias",option+1) == 0) 3883 { 3884 if (*option == '+') 3885 break; 3886 i++; 3887 if (i == (ssize_t) (argc-1)) 3888 ThrowMogrifyException(OptionError,"MissingArgument",option); 3889 if (IsGeometry(argv[i]) == MagickFalse) 3890 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3891 break; 3892 } 3893 if (LocaleCompare("black-point-compensation",option+1) == 0) 3894 break; 3895 if (LocaleCompare("black-threshold",option+1) == 0) 3896 { 3897 if (*option == '+') 3898 break; 3899 i++; 3900 if (i == (ssize_t) argc) 3901 ThrowMogrifyException(OptionError,"MissingArgument",option); 3902 if (IsGeometry(argv[i]) == MagickFalse) 3903 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3904 break; 3905 } 3906 if (LocaleCompare("blue-primary",option+1) == 0) 3907 { 3908 if (*option == '+') 3909 break; 3910 i++; 3911 if (i == (ssize_t) argc) 3912 ThrowMogrifyException(OptionError,"MissingArgument",option); 3913 if (IsGeometry(argv[i]) == MagickFalse) 3914 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3915 break; 3916 } 3917 if (LocaleCompare("blue-shift",option+1) == 0) 3918 { 3919 i++; 3920 if (i == (ssize_t) argc) 3921 ThrowMogrifyException(OptionError,"MissingArgument",option); 3922 if (IsGeometry(argv[i]) == MagickFalse) 3923 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3924 break; 3925 } 3926 if (LocaleCompare("blur",option+1) == 0) 3927 { 3928 i++; 3929 if (i == (ssize_t) argc) 3930 ThrowMogrifyException(OptionError,"MissingArgument",option); 3931 if (IsGeometry(argv[i]) == MagickFalse) 3932 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3933 break; 3934 } 3935 if (LocaleCompare("border",option+1) == 0) 3936 { 3937 if (*option == '+') 3938 break; 3939 i++; 3940 if (i == (ssize_t) argc) 3941 ThrowMogrifyException(OptionError,"MissingArgument",option); 3942 if (IsGeometry(argv[i]) == MagickFalse) 3943 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3944 break; 3945 } 3946 if (LocaleCompare("bordercolor",option+1) == 0) 3947 { 3948 if (*option == '+') 3949 break; 3950 i++; 3951 if (i == (ssize_t) argc) 3952 ThrowMogrifyException(OptionError,"MissingArgument",option); 3953 break; 3954 } 3955 if (LocaleCompare("box",option+1) == 0) 3956 { 3957 if (*option == '+') 3958 break; 3959 i++; 3960 if (i == (ssize_t) argc) 3961 ThrowMogrifyException(OptionError,"MissingArgument",option); 3962 break; 3963 } 3964 if (LocaleCompare("brightness-contrast",option+1) == 0) 3965 { 3966 i++; 3967 if (i == (ssize_t) argc) 3968 ThrowMogrifyException(OptionError,"MissingArgument",option); 3969 if (IsGeometry(argv[i]) == MagickFalse) 3970 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3971 break; 3972 } 3973 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 3974 } 3975 case 'c': 3976 { 3977 if (LocaleCompare("cache",option+1) == 0) 3978 { 3979 if (*option == '+') 3980 break; 3981 i++; 3982 if (i == (ssize_t) argc) 3983 ThrowMogrifyException(OptionError,"MissingArgument",option); 3984 if (IsGeometry(argv[i]) == MagickFalse) 3985 ThrowMogrifyInvalidArgumentException(option,argv[i]); 3986 break; 3987 } 3988 if (LocaleCompare("caption",option+1) == 0) 3989 { 3990 if (*option == '+') 3991 break; 3992 i++; 3993 if (i == (ssize_t) argc) 3994 ThrowMogrifyException(OptionError,"MissingArgument",option); 3995 break; 3996 } 3997 if (LocaleCompare("channel",option+1) == 0) 3998 { 3999 ssize_t 4000 channel; 4001 4002 if (*option == '+') 4003 break; 4004 i++; 4005 if (i == (ssize_t) (argc-1)) 4006 ThrowMogrifyException(OptionError,"MissingArgument",option); 4007 channel=ParseChannelOption(argv[i]); 4008 if (channel < 0) 4009 ThrowMogrifyException(OptionError,"UnrecognizedChannelType", 4010 argv[i]); 4011 break; 4012 } 4013 if (LocaleCompare("cdl",option+1) == 0) 4014 { 4015 if (*option == '+') 4016 break; 4017 i++; 4018 if (i == (ssize_t) (argc-1)) 4019 ThrowMogrifyException(OptionError,"MissingArgument",option); 4020 break; 4021 } 4022 if (LocaleCompare("charcoal",option+1) == 0) 4023 { 4024 if (*option == '+') 4025 break; 4026 i++; 4027 if (i == (ssize_t) argc) 4028 ThrowMogrifyException(OptionError,"MissingArgument",option); 4029 if (IsGeometry(argv[i]) == MagickFalse) 4030 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4031 break; 4032 } 4033 if (LocaleCompare("chop",option+1) == 0) 4034 { 4035 if (*option == '+') 4036 break; 4037 i++; 4038 if (i == (ssize_t) argc) 4039 ThrowMogrifyException(OptionError,"MissingArgument",option); 4040 if (IsGeometry(argv[i]) == MagickFalse) 4041 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4042 break; 4043 } 4044 if (LocaleCompare("clamp",option+1) == 0) 4045 break; 4046 if (LocaleCompare("clip",option+1) == 0) 4047 break; 4048 if (LocaleCompare("clip-mask",option+1) == 0) 4049 { 4050 if (*option == '+') 4051 break; 4052 i++; 4053 if (i == (ssize_t) argc) 4054 ThrowMogrifyException(OptionError,"MissingArgument",option); 4055 break; 4056 } 4057 if (LocaleCompare("clut",option+1) == 0) 4058 break; 4059 if (LocaleCompare("coalesce",option+1) == 0) 4060 break; 4061 if (LocaleCompare("colorize",option+1) == 0) 4062 { 4063 if (*option == '+') 4064 break; 4065 i++; 4066 if (i == (ssize_t) argc) 4067 ThrowMogrifyException(OptionError,"MissingArgument",option); 4068 if (IsGeometry(argv[i]) == MagickFalse) 4069 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4070 break; 4071 } 4072 if (LocaleCompare("color-matrix",option+1) == 0) 4073 { 4074 KernelInfo 4075 *kernel_info; 4076 4077 if (*option == '+') 4078 break; 4079 i++; 4080 if (i == (ssize_t) (argc-1)) 4081 ThrowMogrifyException(OptionError,"MissingArgument",option); 4082 kernel_info=AcquireKernelInfo(argv[i]); 4083 if (kernel_info == (KernelInfo *) NULL) 4084 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4085 kernel_info=DestroyKernelInfo(kernel_info); 4086 break; 4087 } 4088 if (LocaleCompare("colors",option+1) == 0) 4089 { 4090 if (*option == '+') 4091 break; 4092 i++; 4093 if (i == (ssize_t) argc) 4094 ThrowMogrifyException(OptionError,"MissingArgument",option); 4095 if (IsGeometry(argv[i]) == MagickFalse) 4096 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4097 break; 4098 } 4099 if (LocaleCompare("colorspace",option+1) == 0) 4100 { 4101 ssize_t 4102 colorspace; 4103 4104 if (*option == '+') 4105 break; 4106 i++; 4107 if (i == (ssize_t) argc) 4108 ThrowMogrifyException(OptionError,"MissingArgument",option); 4109 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse, 4110 argv[i]); 4111 if (colorspace < 0) 4112 ThrowMogrifyException(OptionError,"UnrecognizedColorspace", 4113 argv[i]); 4114 break; 4115 } 4116 if (LocaleCompare("combine",option+1) == 0) 4117 break; 4118 if (LocaleCompare("comment",option+1) == 0) 4119 { 4120 if (*option == '+') 4121 break; 4122 i++; 4123 if (i == (ssize_t) argc) 4124 ThrowMogrifyException(OptionError,"MissingArgument",option); 4125 break; 4126 } 4127 if (LocaleCompare("composite",option+1) == 0) 4128 break; 4129 if (LocaleCompare("compress",option+1) == 0) 4130 { 4131 ssize_t 4132 compress; 4133 4134 if (*option == '+') 4135 break; 4136 i++; 4137 if (i == (ssize_t) argc) 4138 ThrowMogrifyException(OptionError,"MissingArgument",option); 4139 compress=ParseCommandOption(MagickCompressOptions,MagickFalse, 4140 argv[i]); 4141 if (compress < 0) 4142 ThrowMogrifyException(OptionError,"UnrecognizedImageCompression", 4143 argv[i]); 4144 break; 4145 } 4146 if (LocaleCompare("concurrent",option+1) == 0) 4147 break; 4148 if (LocaleCompare("contrast",option+1) == 0) 4149 break; 4150 if (LocaleCompare("contrast-stretch",option+1) == 0) 4151 { 4152 i++; 4153 if (i == (ssize_t) argc) 4154 ThrowMogrifyException(OptionError,"MissingArgument",option); 4155 if (IsGeometry(argv[i]) == MagickFalse) 4156 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4157 break; 4158 } 4159 if (LocaleCompare("convolve",option+1) == 0) 4160 { 4161 KernelInfo 4162 *kernel_info; 4163 4164 if (*option == '+') 4165 break; 4166 i++; 4167 if (i == (ssize_t) argc) 4168 ThrowMogrifyException(OptionError,"MissingArgument",option); 4169 kernel_info=AcquireKernelInfo(argv[i]); 4170 if (kernel_info == (KernelInfo *) NULL) 4171 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4172 kernel_info=DestroyKernelInfo(kernel_info); 4173 break; 4174 } 4175 if (LocaleCompare("crop",option+1) == 0) 4176 { 4177 if (*option == '+') 4178 break; 4179 i++; 4180 if (i == (ssize_t) argc) 4181 ThrowMogrifyException(OptionError,"MissingArgument",option); 4182 if (IsGeometry(argv[i]) == MagickFalse) 4183 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4184 break; 4185 } 4186 if (LocaleCompare("cycle",option+1) == 0) 4187 { 4188 if (*option == '+') 4189 break; 4190 i++; 4191 if (i == (ssize_t) argc) 4192 ThrowMogrifyException(OptionError,"MissingArgument",option); 4193 if (IsGeometry(argv[i]) == MagickFalse) 4194 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4195 break; 4196 } 4197 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4198 } 4199 case 'd': 4200 { 4201 if (LocaleCompare("decipher",option+1) == 0) 4202 { 4203 if (*option == '+') 4204 break; 4205 i++; 4206 if (i == (ssize_t) (argc-1)) 4207 ThrowMogrifyException(OptionError,"MissingArgument",option); 4208 break; 4209 } 4210 if (LocaleCompare("deconstruct",option+1) == 0) 4211 break; 4212 if (LocaleCompare("debug",option+1) == 0) 4213 { 4214 ssize_t 4215 event; 4216 4217 if (*option == '+') 4218 break; 4219 i++; 4220 if (i == (ssize_t) argc) 4221 ThrowMogrifyException(OptionError,"MissingArgument",option); 4222 event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]); 4223 if (event < 0) 4224 ThrowMogrifyException(OptionError,"UnrecognizedEventType", 4225 argv[i]); 4226 (void) SetLogEventMask(argv[i]); 4227 break; 4228 } 4229 if (LocaleCompare("define",option+1) == 0) 4230 { 4231 i++; 4232 if (i == (ssize_t) argc) 4233 ThrowMogrifyException(OptionError,"MissingArgument",option); 4234 if (*option == '+') 4235 { 4236 const char 4237 *define; 4238 4239 define=GetImageOption(image_info,argv[i]); 4240 if (define == (const char *) NULL) 4241 ThrowMogrifyException(OptionError,"NoSuchOption",argv[i]); 4242 break; 4243 } 4244 break; 4245 } 4246 if (LocaleCompare("delay",option+1) == 0) 4247 { 4248 if (*option == '+') 4249 break; 4250 i++; 4251 if (i == (ssize_t) argc) 4252 ThrowMogrifyException(OptionError,"MissingArgument",option); 4253 if (IsGeometry(argv[i]) == MagickFalse) 4254 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4255 break; 4256 } 4257 if (LocaleCompare("delete",option+1) == 0) 4258 { 4259 if (*option == '+') 4260 break; 4261 i++; 4262 if (i == (ssize_t) (argc-1)) 4263 ThrowMogrifyException(OptionError,"MissingArgument",option); 4264 if (IsGeometry(argv[i]) == MagickFalse) 4265 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4266 break; 4267 } 4268 if (LocaleCompare("density",option+1) == 0) 4269 { 4270 if (*option == '+') 4271 break; 4272 i++; 4273 if (i == (ssize_t) argc) 4274 ThrowMogrifyException(OptionError,"MissingArgument",option); 4275 if (IsGeometry(argv[i]) == MagickFalse) 4276 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4277 break; 4278 } 4279 if (LocaleCompare("depth",option+1) == 0) 4280 { 4281 if (*option == '+') 4282 break; 4283 i++; 4284 if (i == (ssize_t) argc) 4285 ThrowMogrifyException(OptionError,"MissingArgument",option); 4286 if (IsGeometry(argv[i]) == MagickFalse) 4287 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4288 break; 4289 } 4290 if (LocaleCompare("deskew",option+1) == 0) 4291 { 4292 if (*option == '+') 4293 break; 4294 i++; 4295 if (i == (ssize_t) argc) 4296 ThrowMogrifyException(OptionError,"MissingArgument",option); 4297 if (IsGeometry(argv[i]) == MagickFalse) 4298 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4299 break; 4300 } 4301 if (LocaleCompare("despeckle",option+1) == 0) 4302 break; 4303 if (LocaleCompare("dft",option+1) == 0) 4304 break; 4305 if (LocaleCompare("direction",option+1) == 0) 4306 { 4307 ssize_t 4308 direction; 4309 4310 if (*option == '+') 4311 break; 4312 i++; 4313 if (i == (ssize_t) argc) 4314 ThrowMogrifyException(OptionError,"MissingArgument",option); 4315 direction=ParseCommandOption(MagickDirectionOptions,MagickFalse, 4316 argv[i]); 4317 if (direction < 0) 4318 ThrowMogrifyException(OptionError,"UnrecognizedDirectionType", 4319 argv[i]); 4320 break; 4321 } 4322 if (LocaleCompare("display",option+1) == 0) 4323 { 4324 if (*option == '+') 4325 break; 4326 i++; 4327 if (i == (ssize_t) argc) 4328 ThrowMogrifyException(OptionError,"MissingArgument",option); 4329 break; 4330 } 4331 if (LocaleCompare("dispose",option+1) == 0) 4332 { 4333 ssize_t 4334 dispose; 4335 4336 if (*option == '+') 4337 break; 4338 i++; 4339 if (i == (ssize_t) argc) 4340 ThrowMogrifyException(OptionError,"MissingArgument",option); 4341 dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,argv[i]); 4342 if (dispose < 0) 4343 ThrowMogrifyException(OptionError,"UnrecognizedDisposeMethod", 4344 argv[i]); 4345 break; 4346 } 4347 if (LocaleCompare("distort",option+1) == 0) 4348 { 4349 ssize_t 4350 op; 4351 4352 i++; 4353 if (i == (ssize_t) argc) 4354 ThrowMogrifyException(OptionError,"MissingArgument",option); 4355 op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]); 4356 if (op < 0) 4357 ThrowMogrifyException(OptionError,"UnrecognizedDistortMethod", 4358 argv[i]); 4359 i++; 4360 if (i == (ssize_t) (argc-1)) 4361 ThrowMogrifyException(OptionError,"MissingArgument",option); 4362 break; 4363 } 4364 if (LocaleCompare("dither",option+1) == 0) 4365 { 4366 ssize_t 4367 method; 4368 4369 if (*option == '+') 4370 break; 4371 i++; 4372 if (i == (ssize_t) argc) 4373 ThrowMogrifyException(OptionError,"MissingArgument",option); 4374 method=ParseCommandOption(MagickDitherOptions,MagickFalse,argv[i]); 4375 if (method < 0) 4376 ThrowMogrifyException(OptionError,"UnrecognizedDitherMethod", 4377 argv[i]); 4378 break; 4379 } 4380 if (LocaleCompare("draw",option+1) == 0) 4381 { 4382 if (*option == '+') 4383 break; 4384 i++; 4385 if (i == (ssize_t) argc) 4386 ThrowMogrifyException(OptionError,"MissingArgument",option); 4387 break; 4388 } 4389 if (LocaleCompare("duplicate",option+1) == 0) 4390 { 4391 if (*option == '+') 4392 break; 4393 i++; 4394 if (i == (ssize_t) (argc-1)) 4395 ThrowMogrifyException(OptionError,"MissingArgument",option); 4396 if (IsGeometry(argv[i]) == MagickFalse) 4397 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4398 break; 4399 } 4400 if (LocaleCompare("duration",option+1) == 0) 4401 { 4402 if (*option == '+') 4403 break; 4404 i++; 4405 if (i == (ssize_t) (argc-1)) 4406 ThrowMogrifyException(OptionError,"MissingArgument",option); 4407 if (IsGeometry(argv[i]) == MagickFalse) 4408 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4409 break; 4410 } 4411 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4412 } 4413 case 'e': 4414 { 4415 if (LocaleCompare("edge",option+1) == 0) 4416 { 4417 if (*option == '+') 4418 break; 4419 i++; 4420 if (i == (ssize_t) argc) 4421 ThrowMogrifyException(OptionError,"MissingArgument",option); 4422 if (IsGeometry(argv[i]) == MagickFalse) 4423 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4424 break; 4425 } 4426 if (LocaleCompare("emboss",option+1) == 0) 4427 { 4428 if (*option == '+') 4429 break; 4430 i++; 4431 if (i == (ssize_t) argc) 4432 ThrowMogrifyException(OptionError,"MissingArgument",option); 4433 if (IsGeometry(argv[i]) == MagickFalse) 4434 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4435 break; 4436 } 4437 if (LocaleCompare("encipher",option+1) == 0) 4438 { 4439 if (*option == '+') 4440 break; 4441 i++; 4442 if (i == (ssize_t) argc) 4443 ThrowMogrifyException(OptionError,"MissingArgument",option); 4444 break; 4445 } 4446 if (LocaleCompare("encoding",option+1) == 0) 4447 { 4448 if (*option == '+') 4449 break; 4450 i++; 4451 if (i == (ssize_t) argc) 4452 ThrowMogrifyException(OptionError,"MissingArgument",option); 4453 break; 4454 } 4455 if (LocaleCompare("endian",option+1) == 0) 4456 { 4457 ssize_t 4458 endian; 4459 4460 if (*option == '+') 4461 break; 4462 i++; 4463 if (i == (ssize_t) argc) 4464 ThrowMogrifyException(OptionError,"MissingArgument",option); 4465 endian=ParseCommandOption(MagickEndianOptions,MagickFalse,argv[i]); 4466 if (endian < 0) 4467 ThrowMogrifyException(OptionError,"UnrecognizedEndianType", 4468 argv[i]); 4469 break; 4470 } 4471 if (LocaleCompare("enhance",option+1) == 0) 4472 break; 4473 if (LocaleCompare("equalize",option+1) == 0) 4474 break; 4475 if (LocaleCompare("evaluate",option+1) == 0) 4476 { 4477 ssize_t 4478 op; 4479 4480 if (*option == '+') 4481 break; 4482 i++; 4483 if (i == (ssize_t) argc) 4484 ThrowMogrifyException(OptionError,"MissingArgument",option); 4485 op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]); 4486 if (op < 0) 4487 ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator", 4488 argv[i]); 4489 i++; 4490 if (i == (ssize_t) (argc-1)) 4491 ThrowMogrifyException(OptionError,"MissingArgument",option); 4492 if (IsGeometry(argv[i]) == MagickFalse) 4493 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4494 break; 4495 } 4496 if (LocaleCompare("evaluate-sequence",option+1) == 0) 4497 { 4498 ssize_t 4499 op; 4500 4501 if (*option == '+') 4502 break; 4503 i++; 4504 if (i == (ssize_t) argc) 4505 ThrowMogrifyException(OptionError,"MissingArgument",option); 4506 op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]); 4507 if (op < 0) 4508 ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator", 4509 argv[i]); 4510 break; 4511 } 4512 if (LocaleCompare("extent",option+1) == 0) 4513 { 4514 if (*option == '+') 4515 break; 4516 i++; 4517 if (i == (ssize_t) argc) 4518 ThrowMogrifyException(OptionError,"MissingArgument",option); 4519 if (IsGeometry(argv[i]) == MagickFalse) 4520 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4521 break; 4522 } 4523 if (LocaleCompare("extract",option+1) == 0) 4524 { 4525 if (*option == '+') 4526 break; 4527 i++; 4528 if (i == (ssize_t) argc) 4529 ThrowMogrifyException(OptionError,"MissingArgument",option); 4530 if (IsGeometry(argv[i]) == MagickFalse) 4531 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4532 break; 4533 } 4534 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4535 } 4536 case 'f': 4537 { 4538 if (LocaleCompare("family",option+1) == 0) 4539 { 4540 if (*option == '+') 4541 break; 4542 i++; 4543 if (i == (ssize_t) (argc-1)) 4544 ThrowMogrifyException(OptionError,"MissingArgument",option); 4545 break; 4546 } 4547 if (LocaleCompare("fill",option+1) == 0) 4548 { 4549 if (*option == '+') 4550 break; 4551 i++; 4552 if (i == (ssize_t) argc) 4553 ThrowMogrifyException(OptionError,"MissingArgument",option); 4554 break; 4555 } 4556 if (LocaleCompare("filter",option+1) == 0) 4557 { 4558 ssize_t 4559 filter; 4560 4561 if (*option == '+') 4562 break; 4563 i++; 4564 if (i == (ssize_t) argc) 4565 ThrowMogrifyException(OptionError,"MissingArgument",option); 4566 filter=ParseCommandOption(MagickFilterOptions,MagickFalse,argv[i]); 4567 if (filter < 0) 4568 ThrowMogrifyException(OptionError,"UnrecognizedImageFilter", 4569 argv[i]); 4570 break; 4571 } 4572 if (LocaleCompare("flatten",option+1) == 0) 4573 break; 4574 if (LocaleCompare("flip",option+1) == 0) 4575 break; 4576 if (LocaleCompare("flop",option+1) == 0) 4577 break; 4578 if (LocaleCompare("floodfill",option+1) == 0) 4579 { 4580 if (*option == '+') 4581 break; 4582 i++; 4583 if (i == (ssize_t) argc) 4584 ThrowMogrifyException(OptionError,"MissingArgument",option); 4585 if (IsGeometry(argv[i]) == MagickFalse) 4586 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4587 i++; 4588 if (i == (ssize_t) argc) 4589 ThrowMogrifyException(OptionError,"MissingArgument",option); 4590 break; 4591 } 4592 if (LocaleCompare("font",option+1) == 0) 4593 { 4594 if (*option == '+') 4595 break; 4596 i++; 4597 if (i == (ssize_t) argc) 4598 ThrowMogrifyException(OptionError,"MissingArgument",option); 4599 break; 4600 } 4601 if (LocaleCompare("format",option+1) == 0) 4602 { 4603 (void) CopyMagickString(argv[i]+1,"sans",MaxTextExtent); 4604 (void) CloneString(&format,(char *) NULL); 4605 if (*option == '+') 4606 break; 4607 i++; 4608 if (i == (ssize_t) argc) 4609 ThrowMogrifyException(OptionError,"MissingArgument",option); 4610 (void) CloneString(&format,argv[i]); 4611 (void) CopyMagickString(image_info->filename,format,MaxTextExtent); 4612 (void) ConcatenateMagickString(image_info->filename,":", 4613 MaxTextExtent); 4614 (void) SetImageInfo(image_info,0,exception); 4615 if (*image_info->magick == '\0') 4616 ThrowMogrifyException(OptionError,"UnrecognizedImageFormat", 4617 format); 4618 break; 4619 } 4620 if (LocaleCompare("frame",option+1) == 0) 4621 { 4622 if (*option == '+') 4623 break; 4624 i++; 4625 if (i == (ssize_t) argc) 4626 ThrowMogrifyException(OptionError,"MissingArgument",option); 4627 if (IsGeometry(argv[i]) == MagickFalse) 4628 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4629 break; 4630 } 4631 if (LocaleCompare("function",option+1) == 0) 4632 { 4633 ssize_t 4634 op; 4635 4636 if (*option == '+') 4637 break; 4638 i++; 4639 if (i == (ssize_t) argc) 4640 ThrowMogrifyException(OptionError,"MissingArgument",option); 4641 op=ParseCommandOption(MagickFunctionOptions,MagickFalse,argv[i]); 4642 if (op < 0) 4643 ThrowMogrifyException(OptionError,"UnrecognizedFunction",argv[i]); 4644 i++; 4645 if (i == (ssize_t) (argc-1)) 4646 ThrowMogrifyException(OptionError,"MissingArgument",option); 4647 break; 4648 } 4649 if (LocaleCompare("fuzz",option+1) == 0) 4650 { 4651 if (*option == '+') 4652 break; 4653 i++; 4654 if (i == (ssize_t) argc) 4655 ThrowMogrifyException(OptionError,"MissingArgument",option); 4656 if (IsGeometry(argv[i]) == MagickFalse) 4657 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4658 break; 4659 } 4660 if (LocaleCompare("fx",option+1) == 0) 4661 { 4662 if (*option == '+') 4663 break; 4664 i++; 4665 if (i == (ssize_t) (argc-1)) 4666 ThrowMogrifyException(OptionError,"MissingArgument",option); 4667 break; 4668 } 4669 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4670 } 4671 case 'g': 4672 { 4673 if (LocaleCompare("gamma",option+1) == 0) 4674 { 4675 i++; 4676 if (i == (ssize_t) argc) 4677 ThrowMogrifyException(OptionError,"MissingArgument",option); 4678 if (IsGeometry(argv[i]) == MagickFalse) 4679 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4680 break; 4681 } 4682 if ((LocaleCompare("gaussian-blur",option+1) == 0) || 4683 (LocaleCompare("gaussian",option+1) == 0)) 4684 { 4685 i++; 4686 if (i == (ssize_t) argc) 4687 ThrowMogrifyException(OptionError,"MissingArgument",option); 4688 if (IsGeometry(argv[i]) == MagickFalse) 4689 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4690 break; 4691 } 4692 if (LocaleCompare("geometry",option+1) == 0) 4693 { 4694 if (*option == '+') 4695 break; 4696 i++; 4697 if (i == (ssize_t) argc) 4698 ThrowMogrifyException(OptionError,"MissingArgument",option); 4699 if (IsGeometry(argv[i]) == MagickFalse) 4700 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4701 break; 4702 } 4703 if (LocaleCompare("gravity",option+1) == 0) 4704 { 4705 ssize_t 4706 gravity; 4707 4708 if (*option == '+') 4709 break; 4710 i++; 4711 if (i == (ssize_t) argc) 4712 ThrowMogrifyException(OptionError,"MissingArgument",option); 4713 gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,argv[i]); 4714 if (gravity < 0) 4715 ThrowMogrifyException(OptionError,"UnrecognizedGravityType", 4716 argv[i]); 4717 break; 4718 } 4719 if (LocaleCompare("green-primary",option+1) == 0) 4720 { 4721 if (*option == '+') 4722 break; 4723 i++; 4724 if (i == (ssize_t) argc) 4725 ThrowMogrifyException(OptionError,"MissingArgument",option); 4726 if (IsGeometry(argv[i]) == MagickFalse) 4727 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4728 break; 4729 } 4730 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4731 } 4732 case 'h': 4733 { 4734 if (LocaleCompare("hald-clut",option+1) == 0) 4735 break; 4736 if ((LocaleCompare("help",option+1) == 0) || 4737 (LocaleCompare("-help",option+1) == 0)) 4738 return(MogrifyUsage()); 4739 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4740 } 4741 case 'i': 4742 { 4743 if (LocaleCompare("identify",option+1) == 0) 4744 break; 4745 if (LocaleCompare("idft",option+1) == 0) 4746 break; 4747 if (LocaleCompare("implode",option+1) == 0) 4748 { 4749 if (*option == '+') 4750 break; 4751 i++; 4752 if (i == (ssize_t) argc) 4753 ThrowMogrifyException(OptionError,"MissingArgument",option); 4754 if (IsGeometry(argv[i]) == MagickFalse) 4755 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4756 break; 4757 } 4758 if (LocaleCompare("intent",option+1) == 0) 4759 { 4760 ssize_t 4761 intent; 4762 4763 if (*option == '+') 4764 break; 4765 i++; 4766 if (i == (ssize_t) (argc-1)) 4767 ThrowMogrifyException(OptionError,"MissingArgument",option); 4768 intent=ParseCommandOption(MagickIntentOptions,MagickFalse,argv[i]); 4769 if (intent < 0) 4770 ThrowMogrifyException(OptionError,"UnrecognizedIntentType", 4771 argv[i]); 4772 break; 4773 } 4774 if (LocaleCompare("interlace",option+1) == 0) 4775 { 4776 ssize_t 4777 interlace; 4778 4779 if (*option == '+') 4780 break; 4781 i++; 4782 if (i == (ssize_t) argc) 4783 ThrowMogrifyException(OptionError,"MissingArgument",option); 4784 interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse, 4785 argv[i]); 4786 if (interlace < 0) 4787 ThrowMogrifyException(OptionError,"UnrecognizedInterlaceType", 4788 argv[i]); 4789 break; 4790 } 4791 if (LocaleCompare("interline-spacing",option+1) == 0) 4792 { 4793 if (*option == '+') 4794 break; 4795 i++; 4796 if (i == (ssize_t) (argc-1)) 4797 ThrowMogrifyException(OptionError,"MissingArgument",option); 4798 if (IsGeometry(argv[i]) == MagickFalse) 4799 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4800 break; 4801 } 4802 if (LocaleCompare("interpolate",option+1) == 0) 4803 { 4804 ssize_t 4805 interpolate; 4806 4807 if (*option == '+') 4808 break; 4809 i++; 4810 if (i == (ssize_t) argc) 4811 ThrowMogrifyException(OptionError,"MissingArgument",option); 4812 interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse, 4813 argv[i]); 4814 if (interpolate < 0) 4815 ThrowMogrifyException(OptionError,"UnrecognizedInterpolateMethod", 4816 argv[i]); 4817 break; 4818 } 4819 if (LocaleCompare("interword-spacing",option+1) == 0) 4820 { 4821 if (*option == '+') 4822 break; 4823 i++; 4824 if (i == (ssize_t) (argc-1)) 4825 ThrowMogrifyException(OptionError,"MissingArgument",option); 4826 if (IsGeometry(argv[i]) == MagickFalse) 4827 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4828 break; 4829 } 4830 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4831 } 4832 case 'k': 4833 { 4834 if (LocaleCompare("kerning",option+1) == 0) 4835 { 4836 if (*option == '+') 4837 break; 4838 i++; 4839 if (i == (ssize_t) (argc-1)) 4840 ThrowMogrifyException(OptionError,"MissingArgument",option); 4841 if (IsGeometry(argv[i]) == MagickFalse) 4842 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4843 break; 4844 } 4845 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4846 } 4847 case 'l': 4848 { 4849 if (LocaleCompare("label",option+1) == 0) 4850 { 4851 if (*option == '+') 4852 break; 4853 i++; 4854 if (i == (ssize_t) argc) 4855 ThrowMogrifyException(OptionError,"MissingArgument",option); 4856 break; 4857 } 4858 if (LocaleCompare("lat",option+1) == 0) 4859 { 4860 if (*option == '+') 4861 break; 4862 i++; 4863 if (i == (ssize_t) argc) 4864 ThrowMogrifyException(OptionError,"MissingArgument",option); 4865 if (IsGeometry(argv[i]) == MagickFalse) 4866 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4867 } 4868 if (LocaleCompare("layers",option+1) == 0) 4869 { 4870 ssize_t 4871 type; 4872 4873 if (*option == '+') 4874 break; 4875 i++; 4876 if (i == (ssize_t) (argc-1)) 4877 ThrowMogrifyException(OptionError,"MissingArgument",option); 4878 type=ParseCommandOption(MagickLayerOptions,MagickFalse,argv[i]); 4879 if (type < 0) 4880 ThrowMogrifyException(OptionError,"UnrecognizedLayerMethod", 4881 argv[i]); 4882 break; 4883 } 4884 if (LocaleCompare("level",option+1) == 0) 4885 { 4886 i++; 4887 if (i == (ssize_t) argc) 4888 ThrowMogrifyException(OptionError,"MissingArgument",option); 4889 if (IsGeometry(argv[i]) == MagickFalse) 4890 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4891 break; 4892 } 4893 if (LocaleCompare("level-colors",option+1) == 0) 4894 { 4895 i++; 4896 if (i == (ssize_t) argc) 4897 ThrowMogrifyException(OptionError,"MissingArgument",option); 4898 break; 4899 } 4900 if (LocaleCompare("linewidth",option+1) == 0) 4901 { 4902 if (*option == '+') 4903 break; 4904 i++; 4905 if (i == (ssize_t) argc) 4906 ThrowMogrifyException(OptionError,"MissingArgument",option); 4907 if (IsGeometry(argv[i]) == MagickFalse) 4908 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4909 break; 4910 } 4911 if (LocaleCompare("limit",option+1) == 0) 4912 { 4913 char 4914 *p; 4915 4916 double 4917 value; 4918 4919 ssize_t 4920 resource; 4921 4922 if (*option == '+') 4923 break; 4924 i++; 4925 if (i == (ssize_t) argc) 4926 ThrowMogrifyException(OptionError,"MissingArgument",option); 4927 resource=ParseCommandOption(MagickResourceOptions,MagickFalse, 4928 argv[i]); 4929 if (resource < 0) 4930 ThrowMogrifyException(OptionError,"UnrecognizedResourceType", 4931 argv[i]); 4932 i++; 4933 if (i == (ssize_t) argc) 4934 ThrowMogrifyException(OptionError,"MissingArgument",option); 4935 value=InterpretLocaleValue(argv[i],&p); 4936 (void) value; 4937 if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0)) 4938 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4939 break; 4940 } 4941 if (LocaleCompare("liquid-rescale",option+1) == 0) 4942 { 4943 i++; 4944 if (i == (ssize_t) argc) 4945 ThrowMogrifyException(OptionError,"MissingArgument",option); 4946 if (IsGeometry(argv[i]) == MagickFalse) 4947 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4948 break; 4949 } 4950 if (LocaleCompare("list",option+1) == 0) 4951 { 4952 ssize_t 4953 list; 4954 4955 if (*option == '+') 4956 break; 4957 i++; 4958 if (i == (ssize_t) argc) 4959 ThrowMogrifyException(OptionError,"MissingArgument",option); 4960 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]); 4961 if (list < 0) 4962 ThrowMogrifyException(OptionError,"UnrecognizedListType",argv[i]); 4963 status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **) 4964 argv+j,exception); 4965 return(status != 0 ? MagickFalse : MagickTrue); 4966 } 4967 if (LocaleCompare("log",option+1) == 0) 4968 { 4969 if (*option == '+') 4970 break; 4971 i++; 4972 if ((i == (ssize_t) argc) || 4973 (strchr(argv[i],'%') == (char *) NULL)) 4974 ThrowMogrifyException(OptionError,"MissingArgument",option); 4975 break; 4976 } 4977 if (LocaleCompare("loop",option+1) == 0) 4978 { 4979 if (*option == '+') 4980 break; 4981 i++; 4982 if (i == (ssize_t) argc) 4983 ThrowMogrifyException(OptionError,"MissingArgument",option); 4984 if (IsGeometry(argv[i]) == MagickFalse) 4985 ThrowMogrifyInvalidArgumentException(option,argv[i]); 4986 break; 4987 } 4988 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 4989 } 4990 case 'm': 4991 { 4992 if (LocaleCompare("map",option+1) == 0) 4993 { 4994 global_colormap=(*option == '+') ? MagickTrue : MagickFalse; 4995 if (*option == '+') 4996 break; 4997 i++; 4998 if (i == (ssize_t) argc) 4999 ThrowMogrifyException(OptionError,"MissingArgument",option); 5000 break; 5001 } 5002 if (LocaleCompare("mask",option+1) == 0) 5003 { 5004 if (*option == '+') 5005 break; 5006 i++; 5007 if (i == (ssize_t) argc) 5008 ThrowMogrifyException(OptionError,"MissingArgument",option); 5009 break; 5010 } 5011 if (LocaleCompare("matte",option+1) == 0) 5012 break; 5013 if (LocaleCompare("mattecolor",option+1) == 0) 5014 { 5015 if (*option == '+') 5016 break; 5017 i++; 5018 if (i == (ssize_t) argc) 5019 ThrowMogrifyException(OptionError,"MissingArgument",option); 5020 break; 5021 } 5022 if (LocaleCompare("maximum",option+1) == 0) 5023 break; 5024 if (LocaleCompare("minimum",option+1) == 0) 5025 break; 5026 if (LocaleCompare("modulate",option+1) == 0) 5027 { 5028 if (*option == '+') 5029 break; 5030 i++; 5031 if (i == (ssize_t) argc) 5032 ThrowMogrifyException(OptionError,"MissingArgument",option); 5033 if (IsGeometry(argv[i]) == MagickFalse) 5034 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5035 break; 5036 } 5037 if (LocaleCompare("median",option+1) == 0) 5038 { 5039 if (*option == '+') 5040 break; 5041 i++; 5042 if (i == (ssize_t) argc) 5043 ThrowMogrifyException(OptionError,"MissingArgument",option); 5044 if (IsGeometry(argv[i]) == MagickFalse) 5045 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5046 break; 5047 } 5048 if (LocaleCompare("mode",option+1) == 0) 5049 { 5050 if (*option == '+') 5051 break; 5052 i++; 5053 if (i == (ssize_t) argc) 5054 ThrowMogrifyException(OptionError,"MissingArgument",option); 5055 if (IsGeometry(argv[i]) == MagickFalse) 5056 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5057 break; 5058 } 5059 if (LocaleCompare("monitor",option+1) == 0) 5060 break; 5061 if (LocaleCompare("monochrome",option+1) == 0) 5062 break; 5063 if (LocaleCompare("morph",option+1) == 0) 5064 { 5065 if (*option == '+') 5066 break; 5067 i++; 5068 if (i == (ssize_t) (argc-1)) 5069 ThrowMogrifyException(OptionError,"MissingArgument",option); 5070 if (IsGeometry(argv[i]) == MagickFalse) 5071 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5072 break; 5073 } 5074 if (LocaleCompare("morphology",option+1) == 0) 5075 { 5076 char 5077 token[MaxTextExtent]; 5078 5079 KernelInfo 5080 *kernel_info; 5081 5082 ssize_t 5083 op; 5084 5085 i++; 5086 if (i == (ssize_t) argc) 5087 ThrowMogrifyException(OptionError,"MissingArgument",option); 5088 GetMagickToken(argv[i],NULL,token); 5089 op=ParseCommandOption(MagickMorphologyOptions,MagickFalse,token); 5090 if (op < 0) 5091 ThrowMogrifyException(OptionError,"UnrecognizedMorphologyMethod", 5092 token); 5093 i++; 5094 if (i == (ssize_t) (argc-1)) 5095 ThrowMogrifyException(OptionError,"MissingArgument",option); 5096 kernel_info=AcquireKernelInfo(argv[i]); 5097 if (kernel_info == (KernelInfo *) NULL) 5098 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5099 kernel_info=DestroyKernelInfo(kernel_info); 5100 break; 5101 } 5102 if (LocaleCompare("mosaic",option+1) == 0) 5103 break; 5104 if (LocaleCompare("motion-blur",option+1) == 0) 5105 { 5106 if (*option == '+') 5107 break; 5108 i++; 5109 if (i == (ssize_t) argc) 5110 ThrowMogrifyException(OptionError,"MissingArgument",option); 5111 if (IsGeometry(argv[i]) == MagickFalse) 5112 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5113 break; 5114 } 5115 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5116 } 5117 case 'n': 5118 { 5119 if (LocaleCompare("negate",option+1) == 0) 5120 break; 5121 if (LocaleCompare("noise",option+1) == 0) 5122 { 5123 i++; 5124 if (i == (ssize_t) argc) 5125 ThrowMogrifyException(OptionError,"MissingArgument",option); 5126 if (*option == '+') 5127 { 5128 ssize_t 5129 noise; 5130 5131 noise=ParseCommandOption(MagickNoiseOptions,MagickFalse,argv[i]); 5132 if (noise < 0) 5133 ThrowMogrifyException(OptionError,"UnrecognizedNoiseType", 5134 argv[i]); 5135 break; 5136 } 5137 if (IsGeometry(argv[i]) == MagickFalse) 5138 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5139 break; 5140 } 5141 if (LocaleCompare("noop",option+1) == 0) 5142 break; 5143 if (LocaleCompare("normalize",option+1) == 0) 5144 break; 5145 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5146 } 5147 case 'o': 5148 { 5149 if (LocaleCompare("opaque",option+1) == 0) 5150 { 5151 i++; 5152 if (i == (ssize_t) argc) 5153 ThrowMogrifyException(OptionError,"MissingArgument",option); 5154 break; 5155 } 5156 if (LocaleCompare("ordered-dither",option+1) == 0) 5157 { 5158 if (*option == '+') 5159 break; 5160 i++; 5161 if (i == (ssize_t) argc) 5162 ThrowMogrifyException(OptionError,"MissingArgument",option); 5163 break; 5164 } 5165 if (LocaleCompare("orient",option+1) == 0) 5166 { 5167 ssize_t 5168 orientation; 5169 5170 orientation=UndefinedOrientation; 5171 if (*option == '+') 5172 break; 5173 i++; 5174 if (i == (ssize_t) (argc-1)) 5175 ThrowMogrifyException(OptionError,"MissingArgument",option); 5176 orientation=ParseCommandOption(MagickOrientationOptions,MagickFalse, 5177 argv[i]); 5178 if (orientation < 0) 5179 ThrowMogrifyException(OptionError,"UnrecognizedImageOrientation", 5180 argv[i]); 5181 break; 5182 } 5183 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5184 } 5185 case 'p': 5186 { 5187 if (LocaleCompare("page",option+1) == 0) 5188 { 5189 if (*option == '+') 5190 break; 5191 i++; 5192 if (i == (ssize_t) argc) 5193 ThrowMogrifyException(OptionError,"MissingArgument",option); 5194 break; 5195 } 5196 if (LocaleCompare("paint",option+1) == 0) 5197 { 5198 if (*option == '+') 5199 break; 5200 i++; 5201 if (i == (ssize_t) argc) 5202 ThrowMogrifyException(OptionError,"MissingArgument",option); 5203 if (IsGeometry(argv[i]) == MagickFalse) 5204 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5205 break; 5206 } 5207 if (LocaleCompare("path",option+1) == 0) 5208 { 5209 (void) CloneString(&path,(char *) NULL); 5210 if (*option == '+') 5211 break; 5212 i++; 5213 if (i == (ssize_t) argc) 5214 ThrowMogrifyException(OptionError,"MissingArgument",option); 5215 (void) CloneString(&path,argv[i]); 5216 break; 5217 } 5218 if (LocaleCompare("pointsize",option+1) == 0) 5219 { 5220 if (*option == '+') 5221 break; 5222 i++; 5223 if (i == (ssize_t) argc) 5224 ThrowMogrifyException(OptionError,"MissingArgument",option); 5225 if (IsGeometry(argv[i]) == MagickFalse) 5226 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5227 break; 5228 } 5229 if (LocaleCompare("polaroid",option+1) == 0) 5230 { 5231 if (*option == '+') 5232 break; 5233 i++; 5234 if (i == (ssize_t) argc) 5235 ThrowMogrifyException(OptionError,"MissingArgument",option); 5236 if (IsGeometry(argv[i]) == MagickFalse) 5237 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5238 break; 5239 } 5240 if (LocaleCompare("posterize",option+1) == 0) 5241 { 5242 if (*option == '+') 5243 break; 5244 i++; 5245 if (i == (ssize_t) argc) 5246 ThrowMogrifyException(OptionError,"MissingArgument",option); 5247 if (IsGeometry(argv[i]) == MagickFalse) 5248 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5249 break; 5250 } 5251 if (LocaleCompare("precision",option+1) == 0) 5252 { 5253 if (*option == '+') 5254 break; 5255 i++; 5256 if (i == (ssize_t) argc) 5257 ThrowMogrifyException(OptionError,"MissingArgument",option); 5258 if (IsGeometry(argv[i]) == MagickFalse) 5259 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5260 break; 5261 } 5262 if (LocaleCompare("print",option+1) == 0) 5263 { 5264 if (*option == '+') 5265 break; 5266 i++; 5267 if (i == (ssize_t) argc) 5268 ThrowMogrifyException(OptionError,"MissingArgument",option); 5269 break; 5270 } 5271 if (LocaleCompare("process",option+1) == 0) 5272 { 5273 if (*option == '+') 5274 break; 5275 i++; 5276 if (i == (ssize_t) (argc-1)) 5277 ThrowMogrifyException(OptionError,"MissingArgument",option); 5278 break; 5279 } 5280 if (LocaleCompare("profile",option+1) == 0) 5281 { 5282 i++; 5283 if (i == (ssize_t) argc) 5284 ThrowMogrifyException(OptionError,"MissingArgument",option); 5285 break; 5286 } 5287 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5288 } 5289 case 'q': 5290 { 5291 if (LocaleCompare("quality",option+1) == 0) 5292 { 5293 if (*option == '+') 5294 break; 5295 i++; 5296 if (i == (ssize_t) argc) 5297 ThrowMogrifyException(OptionError,"MissingArgument",option); 5298 if (IsGeometry(argv[i]) == MagickFalse) 5299 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5300 break; 5301 } 5302 if (LocaleCompare("quantize",option+1) == 0) 5303 { 5304 ssize_t 5305 colorspace; 5306 5307 if (*option == '+') 5308 break; 5309 i++; 5310 if (i == (ssize_t) (argc-1)) 5311 ThrowMogrifyException(OptionError,"MissingArgument",option); 5312 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse, 5313 argv[i]); 5314 if (colorspace < 0) 5315 ThrowMogrifyException(OptionError,"UnrecognizedColorspace", 5316 argv[i]); 5317 break; 5318 } 5319 if (LocaleCompare("quiet",option+1) == 0) 5320 break; 5321 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5322 } 5323 case 'r': 5324 { 5325 if (LocaleCompare("radial-blur",option+1) == 0) 5326 { 5327 i++; 5328 if (i == (ssize_t) argc) 5329 ThrowMogrifyException(OptionError,"MissingArgument",option); 5330 if (IsGeometry(argv[i]) == MagickFalse) 5331 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5332 break; 5333 } 5334 if (LocaleCompare("raise",option+1) == 0) 5335 { 5336 i++; 5337 if (i == (ssize_t) argc) 5338 ThrowMogrifyException(OptionError,"MissingArgument",option); 5339 if (IsGeometry(argv[i]) == MagickFalse) 5340 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5341 break; 5342 } 5343 if (LocaleCompare("random-threshold",option+1) == 0) 5344 { 5345 if (*option == '+') 5346 break; 5347 i++; 5348 if (i == (ssize_t) argc) 5349 ThrowMogrifyException(OptionError,"MissingArgument",option); 5350 if (IsGeometry(argv[i]) == MagickFalse) 5351 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5352 break; 5353 } 5354 if (LocaleCompare("recolor",option+1) == 0) 5355 { 5356 if (*option == '+') 5357 break; 5358 i++; 5359 if (i == (ssize_t) (argc-1)) 5360 ThrowMogrifyException(OptionError,"MissingArgument",option); 5361 if (IsGeometry(argv[i]) == MagickFalse) 5362 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5363 break; 5364 } 5365 if (LocaleCompare("red-primary",option+1) == 0) 5366 { 5367 if (*option == '+') 5368 break; 5369 i++; 5370 if (i == (ssize_t) argc) 5371 ThrowMogrifyException(OptionError,"MissingArgument",option); 5372 if (IsGeometry(argv[i]) == MagickFalse) 5373 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5374 } 5375 if (LocaleCompare("regard-warnings",option+1) == 0) 5376 break; 5377 if (LocaleCompare("region",option+1) == 0) 5378 { 5379 if (*option == '+') 5380 break; 5381 i++; 5382 if (i == (ssize_t) argc) 5383 ThrowMogrifyException(OptionError,"MissingArgument",option); 5384 if (IsGeometry(argv[i]) == MagickFalse) 5385 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5386 break; 5387 } 5388 if (LocaleCompare("remap",option+1) == 0) 5389 { 5390 if (*option == '+') 5391 break; 5392 i++; 5393 if (i == (ssize_t) (argc-1)) 5394 ThrowMogrifyException(OptionError,"MissingArgument",option); 5395 break; 5396 } 5397 if (LocaleCompare("render",option+1) == 0) 5398 break; 5399 if (LocaleCompare("repage",option+1) == 0) 5400 { 5401 if (*option == '+') 5402 break; 5403 i++; 5404 if (i == (ssize_t) argc) 5405 ThrowMogrifyException(OptionError,"MissingArgument",option); 5406 if (IsGeometry(argv[i]) == MagickFalse) 5407 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5408 break; 5409 } 5410 if (LocaleCompare("resample",option+1) == 0) 5411 { 5412 if (*option == '+') 5413 break; 5414 i++; 5415 if (i == (ssize_t) argc) 5416 ThrowMogrifyException(OptionError,"MissingArgument",option); 5417 if (IsGeometry(argv[i]) == MagickFalse) 5418 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5419 break; 5420 } 5421 if (LocaleCompare("resize",option+1) == 0) 5422 { 5423 if (*option == '+') 5424 break; 5425 i++; 5426 if (i == (ssize_t) argc) 5427 ThrowMogrifyException(OptionError,"MissingArgument",option); 5428 if (IsGeometry(argv[i]) == MagickFalse) 5429 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5430 break; 5431 } 5432 if (LocaleNCompare("respect-parentheses",option+1,17) == 0) 5433 { 5434 respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse; 5435 break; 5436 } 5437 if (LocaleCompare("reverse",option+1) == 0) 5438 break; 5439 if (LocaleCompare("roll",option+1) == 0) 5440 { 5441 if (*option == '+') 5442 break; 5443 i++; 5444 if (i == (ssize_t) argc) 5445 ThrowMogrifyException(OptionError,"MissingArgument",option); 5446 if (IsGeometry(argv[i]) == MagickFalse) 5447 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5448 break; 5449 } 5450 if (LocaleCompare("rotate",option+1) == 0) 5451 { 5452 i++; 5453 if (i == (ssize_t) argc) 5454 ThrowMogrifyException(OptionError,"MissingArgument",option); 5455 if (IsGeometry(argv[i]) == MagickFalse) 5456 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5457 break; 5458 } 5459 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5460 } 5461 case 's': 5462 { 5463 if (LocaleCompare("sample",option+1) == 0) 5464 { 5465 if (*option == '+') 5466 break; 5467 i++; 5468 if (i == (ssize_t) argc) 5469 ThrowMogrifyException(OptionError,"MissingArgument",option); 5470 if (IsGeometry(argv[i]) == MagickFalse) 5471 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5472 break; 5473 } 5474 if (LocaleCompare("sampling-factor",option+1) == 0) 5475 { 5476 if (*option == '+') 5477 break; 5478 i++; 5479 if (i == (ssize_t) argc) 5480 ThrowMogrifyException(OptionError,"MissingArgument",option); 5481 if (IsGeometry(argv[i]) == MagickFalse) 5482 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5483 break; 5484 } 5485 if (LocaleCompare("scale",option+1) == 0) 5486 { 5487 if (*option == '+') 5488 break; 5489 i++; 5490 if (i == (ssize_t) argc) 5491 ThrowMogrifyException(OptionError,"MissingArgument",option); 5492 if (IsGeometry(argv[i]) == MagickFalse) 5493 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5494 break; 5495 } 5496 if (LocaleCompare("scene",option+1) == 0) 5497 { 5498 if (*option == '+') 5499 break; 5500 i++; 5501 if (i == (ssize_t) argc) 5502 ThrowMogrifyException(OptionError,"MissingArgument",option); 5503 if (IsGeometry(argv[i]) == MagickFalse) 5504 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5505 break; 5506 } 5507 if (LocaleCompare("seed",option+1) == 0) 5508 { 5509 if (*option == '+') 5510 break; 5511 i++; 5512 if (i == (ssize_t) argc) 5513 ThrowMogrifyException(OptionError,"MissingArgument",option); 5514 if (IsGeometry(argv[i]) == MagickFalse) 5515 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5516 break; 5517 } 5518 if (LocaleCompare("segment",option+1) == 0) 5519 { 5520 if (*option == '+') 5521 break; 5522 i++; 5523 if (i == (ssize_t) argc) 5524 ThrowMogrifyException(OptionError,"MissingArgument",option); 5525 if (IsGeometry(argv[i]) == MagickFalse) 5526 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5527 break; 5528 } 5529 if (LocaleCompare("selective-blur",option+1) == 0) 5530 { 5531 i++; 5532 if (i == (ssize_t) argc) 5533 ThrowMogrifyException(OptionError,"MissingArgument",option); 5534 if (IsGeometry(argv[i]) == MagickFalse) 5535 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5536 break; 5537 } 5538 if (LocaleCompare("separate",option+1) == 0) 5539 break; 5540 if (LocaleCompare("sepia-tone",option+1) == 0) 5541 { 5542 if (*option == '+') 5543 break; 5544 i++; 5545 if (i == (ssize_t) argc) 5546 ThrowMogrifyException(OptionError,"MissingArgument",option); 5547 if (IsGeometry(argv[i]) == MagickFalse) 5548 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5549 break; 5550 } 5551 if (LocaleCompare("set",option+1) == 0) 5552 { 5553 i++; 5554 if (i == (ssize_t) argc) 5555 ThrowMogrifyException(OptionError,"MissingArgument",option); 5556 if (*option == '+') 5557 break; 5558 i++; 5559 if (i == (ssize_t) argc) 5560 ThrowMogrifyException(OptionError,"MissingArgument",option); 5561 break; 5562 } 5563 if (LocaleCompare("shade",option+1) == 0) 5564 { 5565 i++; 5566 if (i == (ssize_t) argc) 5567 ThrowMogrifyException(OptionError,"MissingArgument",option); 5568 if (IsGeometry(argv[i]) == MagickFalse) 5569 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5570 break; 5571 } 5572 if (LocaleCompare("shadow",option+1) == 0) 5573 { 5574 if (*option == '+') 5575 break; 5576 i++; 5577 if (i == (ssize_t) argc) 5578 ThrowMogrifyException(OptionError,"MissingArgument",option); 5579 if (IsGeometry(argv[i]) == MagickFalse) 5580 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5581 break; 5582 } 5583 if (LocaleCompare("sharpen",option+1) == 0) 5584 { 5585 i++; 5586 if (i == (ssize_t) argc) 5587 ThrowMogrifyException(OptionError,"MissingArgument",option); 5588 if (IsGeometry(argv[i]) == MagickFalse) 5589 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5590 break; 5591 } 5592 if (LocaleCompare("shave",option+1) == 0) 5593 { 5594 if (*option == '+') 5595 break; 5596 i++; 5597 if (i == (ssize_t) argc) 5598 ThrowMogrifyException(OptionError,"MissingArgument",option); 5599 if (IsGeometry(argv[i]) == MagickFalse) 5600 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5601 break; 5602 } 5603 if (LocaleCompare("shear",option+1) == 0) 5604 { 5605 i++; 5606 if (i == (ssize_t) argc) 5607 ThrowMogrifyException(OptionError,"MissingArgument",option); 5608 if (IsGeometry(argv[i]) == MagickFalse) 5609 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5610 break; 5611 } 5612 if (LocaleCompare("sigmoidal-contrast",option+1) == 0) 5613 { 5614 i++; 5615 if (i == (ssize_t) (argc-1)) 5616 ThrowMogrifyException(OptionError,"MissingArgument",option); 5617 if (IsGeometry(argv[i]) == MagickFalse) 5618 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5619 break; 5620 } 5621 if (LocaleCompare("size",option+1) == 0) 5622 { 5623 if (*option == '+') 5624 break; 5625 i++; 5626 if (i == (ssize_t) argc) 5627 ThrowMogrifyException(OptionError,"MissingArgument",option); 5628 if (IsGeometry(argv[i]) == MagickFalse) 5629 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5630 break; 5631 } 5632 if (LocaleCompare("sketch",option+1) == 0) 5633 { 5634 if (*option == '+') 5635 break; 5636 i++; 5637 if (i == (ssize_t) argc) 5638 ThrowMogrifyException(OptionError,"MissingArgument",option); 5639 if (IsGeometry(argv[i]) == MagickFalse) 5640 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5641 break; 5642 } 5643 if (LocaleCompare("smush",option+1) == 0) 5644 { 5645 i++; 5646 if (i == (ssize_t) argc) 5647 ThrowMogrifyException(OptionError,"MissingArgument",option); 5648 if (IsGeometry(argv[i]) == MagickFalse) 5649 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5650 i++; 5651 break; 5652 } 5653 if (LocaleCompare("solarize",option+1) == 0) 5654 { 5655 if (*option == '+') 5656 break; 5657 i++; 5658 if (i == (ssize_t) argc) 5659 ThrowMogrifyException(OptionError,"MissingArgument",option); 5660 if (IsGeometry(argv[i]) == MagickFalse) 5661 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5662 break; 5663 } 5664 if (LocaleCompare("sparse-color",option+1) == 0) 5665 { 5666 ssize_t 5667 op; 5668 5669 i++; 5670 if (i == (ssize_t) argc) 5671 ThrowMogrifyException(OptionError,"MissingArgument",option); 5672 op=ParseCommandOption(MagickSparseColorOptions,MagickFalse,argv[i]); 5673 if (op < 0) 5674 ThrowMogrifyException(OptionError,"UnrecognizedSparseColorMethod", 5675 argv[i]); 5676 i++; 5677 if (i == (ssize_t) (argc-1)) 5678 ThrowMogrifyException(OptionError,"MissingArgument",option); 5679 break; 5680 } 5681 if (LocaleCompare("spread",option+1) == 0) 5682 { 5683 if (*option == '+') 5684 break; 5685 i++; 5686 if (i == (ssize_t) argc) 5687 ThrowMogrifyException(OptionError,"MissingArgument",option); 5688 if (IsGeometry(argv[i]) == MagickFalse) 5689 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5690 break; 5691 } 5692 if (LocaleCompare("statistic",option+1) == 0) 5693 { 5694 ssize_t 5695 op; 5696 5697 if (*option == '+') 5698 break; 5699 i++; 5700 if (i == (ssize_t) argc) 5701 ThrowMogrifyException(OptionError,"MissingArgument",option); 5702 op=ParseCommandOption(MagickStatisticOptions,MagickFalse,argv[i]); 5703 if (op < 0) 5704 ThrowMogrifyException(OptionError,"UnrecognizedStatisticType", 5705 argv[i]); 5706 i++; 5707 if (i == (ssize_t) (argc-1)) 5708 ThrowMogrifyException(OptionError,"MissingArgument",option); 5709 if (IsGeometry(argv[i]) == MagickFalse) 5710 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5711 break; 5712 } 5713 if (LocaleCompare("stretch",option+1) == 0) 5714 { 5715 ssize_t 5716 stretch; 5717 5718 if (*option == '+') 5719 break; 5720 i++; 5721 if (i == (ssize_t) (argc-1)) 5722 ThrowMogrifyException(OptionError,"MissingArgument",option); 5723 stretch=ParseCommandOption(MagickStretchOptions,MagickFalse,argv[i]); 5724 if (stretch < 0) 5725 ThrowMogrifyException(OptionError,"UnrecognizedStyleType", 5726 argv[i]); 5727 break; 5728 } 5729 if (LocaleCompare("strip",option+1) == 0) 5730 break; 5731 if (LocaleCompare("stroke",option+1) == 0) 5732 { 5733 if (*option == '+') 5734 break; 5735 i++; 5736 if (i == (ssize_t) argc) 5737 ThrowMogrifyException(OptionError,"MissingArgument",option); 5738 break; 5739 } 5740 if (LocaleCompare("strokewidth",option+1) == 0) 5741 { 5742 if (*option == '+') 5743 break; 5744 i++; 5745 if (i == (ssize_t) argc) 5746 ThrowMogrifyException(OptionError,"MissingArgument",option); 5747 if (IsGeometry(argv[i]) == MagickFalse) 5748 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5749 break; 5750 } 5751 if (LocaleCompare("style",option+1) == 0) 5752 { 5753 ssize_t 5754 style; 5755 5756 if (*option == '+') 5757 break; 5758 i++; 5759 if (i == (ssize_t) (argc-1)) 5760 ThrowMogrifyException(OptionError,"MissingArgument",option); 5761 style=ParseCommandOption(MagickStyleOptions,MagickFalse,argv[i]); 5762 if (style < 0) 5763 ThrowMogrifyException(OptionError,"UnrecognizedStyleType", 5764 argv[i]); 5765 break; 5766 } 5767 if (LocaleCompare("swap",option+1) == 0) 5768 { 5769 if (*option == '+') 5770 break; 5771 i++; 5772 if (i == (ssize_t) (argc-1)) 5773 ThrowMogrifyException(OptionError,"MissingArgument",option); 5774 if (IsGeometry(argv[i]) == MagickFalse) 5775 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5776 break; 5777 } 5778 if (LocaleCompare("swirl",option+1) == 0) 5779 { 5780 if (*option == '+') 5781 break; 5782 i++; 5783 if (i == (ssize_t) argc) 5784 ThrowMogrifyException(OptionError,"MissingArgument",option); 5785 if (IsGeometry(argv[i]) == MagickFalse) 5786 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5787 break; 5788 } 5789 if (LocaleCompare("synchronize",option+1) == 0) 5790 break; 5791 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5792 } 5793 case 't': 5794 { 5795 if (LocaleCompare("taint",option+1) == 0) 5796 break; 5797 if (LocaleCompare("texture",option+1) == 0) 5798 { 5799 if (*option == '+') 5800 break; 5801 i++; 5802 if (i == (ssize_t) argc) 5803 ThrowMogrifyException(OptionError,"MissingArgument",option); 5804 break; 5805 } 5806 if (LocaleCompare("tile",option+1) == 0) 5807 { 5808 if (*option == '+') 5809 break; 5810 i++; 5811 if (i == (ssize_t) (argc-1)) 5812 ThrowMogrifyException(OptionError,"MissingArgument",option); 5813 break; 5814 } 5815 if (LocaleCompare("tile-offset",option+1) == 0) 5816 { 5817 if (*option == '+') 5818 break; 5819 i++; 5820 if (i == (ssize_t) argc) 5821 ThrowMogrifyException(OptionError,"MissingArgument",option); 5822 if (IsGeometry(argv[i]) == MagickFalse) 5823 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5824 break; 5825 } 5826 if (LocaleCompare("tint",option+1) == 0) 5827 { 5828 if (*option == '+') 5829 break; 5830 i++; 5831 if (i == (ssize_t) (argc-1)) 5832 ThrowMogrifyException(OptionError,"MissingArgument",option); 5833 if (IsGeometry(argv[i]) == MagickFalse) 5834 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5835 break; 5836 } 5837 if (LocaleCompare("transform",option+1) == 0) 5838 break; 5839 if (LocaleCompare("transpose",option+1) == 0) 5840 break; 5841 if (LocaleCompare("transverse",option+1) == 0) 5842 break; 5843 if (LocaleCompare("threshold",option+1) == 0) 5844 { 5845 if (*option == '+') 5846 break; 5847 i++; 5848 if (i == (ssize_t) argc) 5849 ThrowMogrifyException(OptionError,"MissingArgument",option); 5850 if (IsGeometry(argv[i]) == MagickFalse) 5851 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5852 break; 5853 } 5854 if (LocaleCompare("thumbnail",option+1) == 0) 5855 { 5856 if (*option == '+') 5857 break; 5858 i++; 5859 if (i == (ssize_t) argc) 5860 ThrowMogrifyException(OptionError,"MissingArgument",option); 5861 if (IsGeometry(argv[i]) == MagickFalse) 5862 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5863 break; 5864 } 5865 if (LocaleCompare("transparent",option+1) == 0) 5866 { 5867 i++; 5868 if (i == (ssize_t) argc) 5869 ThrowMogrifyException(OptionError,"MissingArgument",option); 5870 break; 5871 } 5872 if (LocaleCompare("transparent-color",option+1) == 0) 5873 { 5874 if (*option == '+') 5875 break; 5876 i++; 5877 if (i == (ssize_t) (argc-1)) 5878 ThrowMogrifyException(OptionError,"MissingArgument",option); 5879 break; 5880 } 5881 if (LocaleCompare("treedepth",option+1) == 0) 5882 { 5883 if (*option == '+') 5884 break; 5885 i++; 5886 if (i == (ssize_t) argc) 5887 ThrowMogrifyException(OptionError,"MissingArgument",option); 5888 if (IsGeometry(argv[i]) == MagickFalse) 5889 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5890 break; 5891 } 5892 if (LocaleCompare("trim",option+1) == 0) 5893 break; 5894 if (LocaleCompare("type",option+1) == 0) 5895 { 5896 ssize_t 5897 type; 5898 5899 if (*option == '+') 5900 break; 5901 i++; 5902 if (i == (ssize_t) argc) 5903 ThrowMogrifyException(OptionError,"MissingArgument",option); 5904 type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]); 5905 if (type < 0) 5906 ThrowMogrifyException(OptionError,"UnrecognizedImageType", 5907 argv[i]); 5908 break; 5909 } 5910 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5911 } 5912 case 'u': 5913 { 5914 if (LocaleCompare("undercolor",option+1) == 0) 5915 { 5916 if (*option == '+') 5917 break; 5918 i++; 5919 if (i == (ssize_t) argc) 5920 ThrowMogrifyException(OptionError,"MissingArgument",option); 5921 break; 5922 } 5923 if (LocaleCompare("unique-colors",option+1) == 0) 5924 break; 5925 if (LocaleCompare("units",option+1) == 0) 5926 { 5927 ssize_t 5928 units; 5929 5930 if (*option == '+') 5931 break; 5932 i++; 5933 if (i == (ssize_t) argc) 5934 ThrowMogrifyException(OptionError,"MissingArgument",option); 5935 units=ParseCommandOption(MagickResolutionOptions,MagickFalse, 5936 argv[i]); 5937 if (units < 0) 5938 ThrowMogrifyException(OptionError,"UnrecognizedUnitsType", 5939 argv[i]); 5940 break; 5941 } 5942 if (LocaleCompare("unsharp",option+1) == 0) 5943 { 5944 i++; 5945 if (i == (ssize_t) argc) 5946 ThrowMogrifyException(OptionError,"MissingArgument",option); 5947 if (IsGeometry(argv[i]) == MagickFalse) 5948 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5949 break; 5950 } 5951 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 5952 } 5953 case 'v': 5954 { 5955 if (LocaleCompare("verbose",option+1) == 0) 5956 { 5957 image_info->verbose=(*option == '-') ? MagickTrue : MagickFalse; 5958 break; 5959 } 5960 if ((LocaleCompare("version",option+1) == 0) || 5961 (LocaleCompare("-version",option+1) == 0)) 5962 { 5963 (void) FormatLocaleFile(stdout,"Version: %s\n", 5964 GetMagickVersion((size_t *) NULL)); 5965 (void) FormatLocaleFile(stdout,"Copyright: %s\n", 5966 GetMagickCopyright()); 5967 (void) FormatLocaleFile(stdout,"Features: %s\n\n", 5968 GetMagickFeatures()); 5969 break; 5970 } 5971 if (LocaleCompare("view",option+1) == 0) 5972 { 5973 if (*option == '+') 5974 break; 5975 i++; 5976 if (i == (ssize_t) argc) 5977 ThrowMogrifyException(OptionError,"MissingArgument",option); 5978 break; 5979 } 5980 if (LocaleCompare("vignette",option+1) == 0) 5981 { 5982 if (*option == '+') 5983 break; 5984 i++; 5985 if (i == (ssize_t) argc) 5986 ThrowMogrifyException(OptionError,"MissingArgument",option); 5987 if (IsGeometry(argv[i]) == MagickFalse) 5988 ThrowMogrifyInvalidArgumentException(option,argv[i]); 5989 break; 5990 } 5991 if (LocaleCompare("virtual-pixel",option+1) == 0) 5992 { 5993 ssize_t 5994 method; 5995 5996 if (*option == '+') 5997 break; 5998 i++; 5999 if (i == (ssize_t) argc) 6000 ThrowMogrifyException(OptionError,"MissingArgument",option); 6001 method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse, 6002 argv[i]); 6003 if (method < 0) 6004 ThrowMogrifyException(OptionError, 6005 "UnrecognizedVirtualPixelMethod",argv[i]); 6006 break; 6007 } 6008 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 6009 } 6010 case 'w': 6011 { 6012 if (LocaleCompare("wave",option+1) == 0) 6013 { 6014 i++; 6015 if (i == (ssize_t) argc) 6016 ThrowMogrifyException(OptionError,"MissingArgument",option); 6017 if (IsGeometry(argv[i]) == MagickFalse) 6018 ThrowMogrifyInvalidArgumentException(option,argv[i]); 6019 break; 6020 } 6021 if (LocaleCompare("weight",option+1) == 0) 6022 { 6023 if (*option == '+') 6024 break; 6025 i++; 6026 if (i == (ssize_t) (argc-1)) 6027 ThrowMogrifyException(OptionError,"MissingArgument",option); 6028 break; 6029 } 6030 if (LocaleCompare("white-point",option+1) == 0) 6031 { 6032 if (*option == '+') 6033 break; 6034 i++; 6035 if (i == (ssize_t) argc) 6036 ThrowMogrifyException(OptionError,"MissingArgument",option); 6037 if (IsGeometry(argv[i]) == MagickFalse) 6038 ThrowMogrifyInvalidArgumentException(option,argv[i]); 6039 break; 6040 } 6041 if (LocaleCompare("white-threshold",option+1) == 0) 6042 { 6043 if (*option == '+') 6044 break; 6045 i++; 6046 if (i == (ssize_t) argc) 6047 ThrowMogrifyException(OptionError,"MissingArgument",option); 6048 if (IsGeometry(argv[i]) == MagickFalse) 6049 ThrowMogrifyInvalidArgumentException(option,argv[i]); 6050 break; 6051 } 6052 if (LocaleCompare("write",option+1) == 0) 6053 { 6054 i++; 6055 if (i == (ssize_t) (argc-1)) 6056 ThrowMogrifyException(OptionError,"MissingArgument",option); 6057 break; 6058 } 6059 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 6060 } 6061 case '?': 6062 break; 6063 default: 6064 ThrowMogrifyException(OptionError,"UnrecognizedOption",option) 6065 } 6066 fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) & 6067 FireOptionFlag) == 0 ? MagickFalse : MagickTrue; 6068 if (fire != MagickFalse) 6069 FireImageStack(MagickFalse,MagickTrue,MagickTrue); 6070 } 6071 if (k != 0) 6072 ThrowMogrifyException(OptionError,"UnbalancedParenthesis",argv[i]); 6073 if (i != (ssize_t) argc) 6074 ThrowMogrifyException(OptionError,"MissingAnImageFilename",argv[i]); 6075 DestroyMogrify(); 6076 return(status != 0 ? MagickTrue : MagickFalse); 6077} 6078 6079/* 6080%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6081% % 6082% % 6083% % 6084+ M o g r i f y I m a g e I n f o % 6085% % 6086% % 6087% % 6088%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6089% 6090% MogrifyImageInfo() applies image processing settings to the image as 6091% prescribed by command line options. 6092% 6093% The format of the MogrifyImageInfo method is: 6094% 6095% MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,const int argc, 6096% const char **argv,ExceptionInfo *exception) 6097% 6098% A description of each parameter follows: 6099% 6100% o image_info: the image info.. 6101% 6102% o argc: Specifies a pointer to an integer describing the number of 6103% elements in the argument vector. 6104% 6105% o argv: Specifies a pointer to a text array containing the command line 6106% arguments. 6107% 6108% o exception: return any errors or warnings in this structure. 6109% 6110*/ 6111WandExport MagickBooleanType MogrifyImageInfo(ImageInfo *image_info, 6112 const int argc,const char **argv,ExceptionInfo *exception) 6113{ 6114 const char 6115 *option; 6116 6117 GeometryInfo 6118 geometry_info; 6119 6120 ssize_t 6121 count; 6122 6123 register ssize_t 6124 i; 6125 6126 /* 6127 Initialize method variables. 6128 */ 6129 assert(image_info != (ImageInfo *) NULL); 6130 assert(image_info->signature == MagickSignature); 6131 if (image_info->debug != MagickFalse) 6132 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", 6133 image_info->filename); 6134 if (argc < 0) 6135 return(MagickTrue); 6136 /* 6137 Set the image settings. 6138 */ 6139 for (i=0; i < (ssize_t) argc; i++) 6140 { 6141 option=argv[i]; 6142 if (IsCommandOption(option) == MagickFalse) 6143 continue; 6144 count=ParseCommandOption(MagickCommandOptions,MagickFalse,option); 6145 count=MagickMax(count,0L); 6146 if ((i+count) >= (ssize_t) argc) 6147 break; 6148 switch (*(option+1)) 6149 { 6150 case 'a': 6151 { 6152 if (LocaleCompare("adjoin",option+1) == 0) 6153 { 6154 image_info->adjoin=(*option == '-') ? MagickTrue : MagickFalse; 6155 break; 6156 } 6157 if (LocaleCompare("antialias",option+1) == 0) 6158 { 6159 image_info->antialias=(*option == '-') ? MagickTrue : MagickFalse; 6160 break; 6161 } 6162 if (LocaleCompare("attenuate",option+1) == 0) 6163 { 6164 if (*option == '+') 6165 { 6166 (void) DeleteImageOption(image_info,option+1); 6167 break; 6168 } 6169 (void) SetImageOption(image_info,option+1,argv[i+1]); 6170 break; 6171 } 6172 if (LocaleCompare("authenticate",option+1) == 0) 6173 { 6174 if (*option == '+') 6175 (void) CloneString(&image_info->authenticate,(char *) NULL); 6176 else 6177 (void) CloneString(&image_info->authenticate,argv[i+1]); 6178 break; 6179 } 6180 break; 6181 } 6182 case 'b': 6183 { 6184 if (LocaleCompare("background",option+1) == 0) 6185 { 6186 if (*option == '+') 6187 { 6188 (void) DeleteImageOption(image_info,option+1); 6189 (void) QueryColorCompliance(MogrifyBackgroundColor, 6190 AllCompliance,&image_info->background_color,exception); 6191 break; 6192 } 6193 (void) SetImageOption(image_info,option+1,argv[i+1]); 6194 (void) QueryColorCompliance(argv[i+1],AllCompliance, 6195 &image_info->background_color,exception); 6196 break; 6197 } 6198 if (LocaleCompare("bias",option+1) == 0) 6199 { 6200 if (*option == '+') 6201 { 6202 (void) SetImageOption(image_info,option+1,"0.0"); 6203 break; 6204 } 6205 (void) SetImageOption(image_info,option+1,argv[i+1]); 6206 break; 6207 } 6208 if (LocaleCompare("black-point-compensation",option+1) == 0) 6209 { 6210 if (*option == '+') 6211 { 6212 (void) SetImageOption(image_info,option+1,"false"); 6213 break; 6214 } 6215 (void) SetImageOption(image_info,option+1,"true"); 6216 break; 6217 } 6218 if (LocaleCompare("blue-primary",option+1) == 0) 6219 { 6220 if (*option == '+') 6221 { 6222 (void) SetImageOption(image_info,option+1,"0.0"); 6223 break; 6224 } 6225 (void) SetImageOption(image_info,option+1,argv[i+1]); 6226 break; 6227 } 6228 if (LocaleCompare("bordercolor",option+1) == 0) 6229 { 6230 if (*option == '+') 6231 { 6232 (void) DeleteImageOption(image_info,option+1); 6233 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance, 6234 &image_info->border_color,exception); 6235 break; 6236 } 6237 (void) QueryColorCompliance(argv[i+1],AllCompliance, 6238 &image_info->border_color,exception); 6239 (void) SetImageOption(image_info,option+1,argv[i+1]); 6240 break; 6241 } 6242 if (LocaleCompare("box",option+1) == 0) 6243 { 6244 if (*option == '+') 6245 { 6246 (void) SetImageOption(image_info,"undercolor","none"); 6247 break; 6248 } 6249 (void) SetImageOption(image_info,"undercolor",argv[i+1]); 6250 break; 6251 } 6252 break; 6253 } 6254 case 'c': 6255 { 6256 if (LocaleCompare("cache",option+1) == 0) 6257 { 6258 MagickSizeType 6259 limit; 6260 6261 limit=MagickResourceInfinity; 6262 if (LocaleCompare("unlimited",argv[i+1]) != 0) 6263 limit=(MagickSizeType) SiPrefixToDouble(argv[i+1],100.0); 6264 (void) SetMagickResourceLimit(MemoryResource,limit); 6265 (void) SetMagickResourceLimit(MapResource,2*limit); 6266 break; 6267 } 6268 if (LocaleCompare("caption",option+1) == 0) 6269 { 6270 if (*option == '+') 6271 { 6272 (void) DeleteImageOption(image_info,option+1); 6273 break; 6274 } 6275 (void) SetImageOption(image_info,option+1,argv[i+1]); 6276 break; 6277 } 6278 if (LocaleCompare("channel",option+1) == 0) 6279 { 6280 if (*option == '+') 6281 { 6282 image_info->channel=DefaultChannels; 6283 break; 6284 } 6285 image_info->channel=(ChannelType) ParseChannelOption(argv[i+1]); 6286 break; 6287 } 6288 if (LocaleCompare("colors",option+1) == 0) 6289 { 6290 image_info->colors=StringToUnsignedLong(argv[i+1]); 6291 break; 6292 } 6293 if (LocaleCompare("colorspace",option+1) == 0) 6294 { 6295 if (*option == '+') 6296 { 6297 image_info->colorspace=UndefinedColorspace; 6298 (void) SetImageOption(image_info,option+1,"undefined"); 6299 break; 6300 } 6301 image_info->colorspace=(ColorspaceType) ParseCommandOption( 6302 MagickColorspaceOptions,MagickFalse,argv[i+1]); 6303 (void) SetImageOption(image_info,option+1,argv[i+1]); 6304 break; 6305 } 6306 if (LocaleCompare("comment",option+1) == 0) 6307 { 6308 if (*option == '+') 6309 { 6310 (void) DeleteImageOption(image_info,option+1); 6311 break; 6312 } 6313 (void) SetImageOption(image_info,option+1,argv[i+1]); 6314 break; 6315 } 6316 if (LocaleCompare("compose",option+1) == 0) 6317 { 6318 if (*option == '+') 6319 { 6320 (void) SetImageOption(image_info,option+1,"undefined"); 6321 break; 6322 } 6323 (void) SetImageOption(image_info,option+1,argv[i+1]); 6324 break; 6325 } 6326 if (LocaleCompare("compress",option+1) == 0) 6327 { 6328 if (*option == '+') 6329 { 6330 image_info->compression=UndefinedCompression; 6331 (void) SetImageOption(image_info,option+1,"undefined"); 6332 break; 6333 } 6334 image_info->compression=(CompressionType) ParseCommandOption( 6335 MagickCompressOptions,MagickFalse,argv[i+1]); 6336 (void) SetImageOption(image_info,option+1,argv[i+1]); 6337 break; 6338 } 6339 break; 6340 } 6341 case 'd': 6342 { 6343 if (LocaleCompare("debug",option+1) == 0) 6344 { 6345 if (*option == '+') 6346 (void) SetLogEventMask("none"); 6347 else 6348 (void) SetLogEventMask(argv[i+1]); 6349 image_info->debug=IsEventLogging(); 6350 break; 6351 } 6352 if (LocaleCompare("define",option+1) == 0) 6353 { 6354 if (*option == '+') 6355 { 6356 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 6357 (void) DeleteImageRegistry(argv[i+1]+9); 6358 else 6359 (void) DeleteImageOption(image_info,argv[i+1]); 6360 break; 6361 } 6362 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 6363 { 6364 (void) DefineImageRegistry(StringRegistryType,argv[i+1]+9, 6365 exception); 6366 break; 6367 } 6368 (void) DefineImageOption(image_info,argv[i+1]); 6369 break; 6370 } 6371 if (LocaleCompare("delay",option+1) == 0) 6372 { 6373 if (*option == '+') 6374 { 6375 (void) SetImageOption(image_info,option+1,"0"); 6376 break; 6377 } 6378 (void) SetImageOption(image_info,option+1,argv[i+1]); 6379 break; 6380 } 6381 if (LocaleCompare("density",option+1) == 0) 6382 { 6383 /* 6384 Set image density. 6385 */ 6386 if (*option == '+') 6387 { 6388 if (image_info->density != (char *) NULL) 6389 image_info->density=DestroyString(image_info->density); 6390 (void) SetImageOption(image_info,option+1,"72"); 6391 break; 6392 } 6393 (void) CloneString(&image_info->density,argv[i+1]); 6394 (void) SetImageOption(image_info,option+1,argv[i+1]); 6395 break; 6396 } 6397 if (LocaleCompare("depth",option+1) == 0) 6398 { 6399 if (*option == '+') 6400 { 6401 image_info->depth=MAGICKCORE_QUANTUM_DEPTH; 6402 break; 6403 } 6404 image_info->depth=StringToUnsignedLong(argv[i+1]); 6405 break; 6406 } 6407 if (LocaleCompare("direction",option+1) == 0) 6408 { 6409 if (*option == '+') 6410 { 6411 (void) SetImageOption(image_info,option+1,"undefined"); 6412 break; 6413 } 6414 (void) SetImageOption(image_info,option+1,argv[i+1]); 6415 break; 6416 } 6417 if (LocaleCompare("display",option+1) == 0) 6418 { 6419 if (*option == '+') 6420 { 6421 if (image_info->server_name != (char *) NULL) 6422 image_info->server_name=DestroyString( 6423 image_info->server_name); 6424 break; 6425 } 6426 (void) CloneString(&image_info->server_name,argv[i+1]); 6427 break; 6428 } 6429 if (LocaleCompare("dispose",option+1) == 0) 6430 { 6431 if (*option == '+') 6432 { 6433 (void) SetImageOption(image_info,option+1,"undefined"); 6434 break; 6435 } 6436 (void) SetImageOption(image_info,option+1,argv[i+1]); 6437 break; 6438 } 6439 if (LocaleCompare("dither",option+1) == 0) 6440 { 6441 if (*option == '+') 6442 { 6443 image_info->dither=MagickFalse; 6444 (void) SetImageOption(image_info,option+1,"none"); 6445 break; 6446 } 6447 (void) SetImageOption(image_info,option+1,argv[i+1]); 6448 image_info->dither=MagickTrue; 6449 break; 6450 } 6451 break; 6452 } 6453 case 'e': 6454 { 6455 if (LocaleCompare("encoding",option+1) == 0) 6456 { 6457 if (*option == '+') 6458 { 6459 (void) SetImageOption(image_info,option+1,"undefined"); 6460 break; 6461 } 6462 (void) SetImageOption(image_info,option+1,argv[i+1]); 6463 break; 6464 } 6465 if (LocaleCompare("endian",option+1) == 0) 6466 { 6467 if (*option == '+') 6468 { 6469 image_info->endian=UndefinedEndian; 6470 (void) SetImageOption(image_info,option+1,"undefined"); 6471 break; 6472 } 6473 image_info->endian=(EndianType) ParseCommandOption( 6474 MagickEndianOptions,MagickFalse,argv[i+1]); 6475 (void) SetImageOption(image_info,option+1,argv[i+1]); 6476 break; 6477 } 6478 if (LocaleCompare("extract",option+1) == 0) 6479 { 6480 /* 6481 Set image extract geometry. 6482 */ 6483 if (*option == '+') 6484 { 6485 if (image_info->extract != (char *) NULL) 6486 image_info->extract=DestroyString(image_info->extract); 6487 break; 6488 } 6489 (void) CloneString(&image_info->extract,argv[i+1]); 6490 break; 6491 } 6492 break; 6493 } 6494 case 'f': 6495 { 6496 if (LocaleCompare("fill",option+1) == 0) 6497 { 6498 if (*option == '+') 6499 { 6500 (void) SetImageOption(image_info,option+1,"none"); 6501 break; 6502 } 6503 (void) SetImageOption(image_info,option+1,argv[i+1]); 6504 break; 6505 } 6506 if (LocaleCompare("filter",option+1) == 0) 6507 { 6508 if (*option == '+') 6509 { 6510 (void) SetImageOption(image_info,option+1,"undefined"); 6511 break; 6512 } 6513 (void) SetImageOption(image_info,option+1,argv[i+1]); 6514 break; 6515 } 6516 if (LocaleCompare("font",option+1) == 0) 6517 { 6518 if (*option == '+') 6519 { 6520 if (image_info->font != (char *) NULL) 6521 image_info->font=DestroyString(image_info->font); 6522 break; 6523 } 6524 (void) CloneString(&image_info->font,argv[i+1]); 6525 break; 6526 } 6527 if (LocaleCompare("format",option+1) == 0) 6528 { 6529 register const char 6530 *q; 6531 6532 for (q=strchr(argv[i+1],'%'); q != (char *) NULL; q=strchr(q+1,'%')) 6533 if (strchr("Agkrz@[#",*(q+1)) != (char *) NULL) 6534 image_info->ping=MagickFalse; 6535 (void) SetImageOption(image_info,option+1,argv[i+1]); 6536 break; 6537 } 6538 if (LocaleCompare("fuzz",option+1) == 0) 6539 { 6540 if (*option == '+') 6541 { 6542 image_info->fuzz=0.0; 6543 (void) SetImageOption(image_info,option+1,"0"); 6544 break; 6545 } 6546 image_info->fuzz=SiPrefixToDouble(argv[i+1],(double) QuantumRange+ 6547 1.0); 6548 (void) SetImageOption(image_info,option+1,argv[i+1]); 6549 break; 6550 } 6551 break; 6552 } 6553 case 'g': 6554 { 6555 if (LocaleCompare("gravity",option+1) == 0) 6556 { 6557 if (*option == '+') 6558 { 6559 (void) SetImageOption(image_info,option+1,"undefined"); 6560 break; 6561 } 6562 (void) SetImageOption(image_info,option+1,argv[i+1]); 6563 break; 6564 } 6565 if (LocaleCompare("green-primary",option+1) == 0) 6566 { 6567 if (*option == '+') 6568 { 6569 (void) SetImageOption(image_info,option+1,"0.0"); 6570 break; 6571 } 6572 (void) SetImageOption(image_info,option+1,argv[i+1]); 6573 break; 6574 } 6575 break; 6576 } 6577 case 'i': 6578 { 6579 if (LocaleCompare("intent",option+1) == 0) 6580 { 6581 if (*option == '+') 6582 { 6583 (void) SetImageOption(image_info,option+1,"undefined"); 6584 break; 6585 } 6586 (void) SetImageOption(image_info,option+1,argv[i+1]); 6587 break; 6588 } 6589 if (LocaleCompare("interlace",option+1) == 0) 6590 { 6591 if (*option == '+') 6592 { 6593 image_info->interlace=UndefinedInterlace; 6594 (void) SetImageOption(image_info,option+1,"undefined"); 6595 break; 6596 } 6597 image_info->interlace=(InterlaceType) ParseCommandOption( 6598 MagickInterlaceOptions,MagickFalse,argv[i+1]); 6599 (void) SetImageOption(image_info,option+1,argv[i+1]); 6600 break; 6601 } 6602 if (LocaleCompare("interline-spacing",option+1) == 0) 6603 { 6604 if (*option == '+') 6605 { 6606 (void) SetImageOption(image_info,option+1,"undefined"); 6607 break; 6608 } 6609 (void) SetImageOption(image_info,option+1,argv[i+1]); 6610 break; 6611 } 6612 if (LocaleCompare("interpolate",option+1) == 0) 6613 { 6614 if (*option == '+') 6615 { 6616 (void) SetImageOption(image_info,option+1,"undefined"); 6617 break; 6618 } 6619 (void) SetImageOption(image_info,option+1,argv[i+1]); 6620 break; 6621 } 6622 if (LocaleCompare("interword-spacing",option+1) == 0) 6623 { 6624 if (*option == '+') 6625 { 6626 (void) SetImageOption(image_info,option+1,"undefined"); 6627 break; 6628 } 6629 (void) SetImageOption(image_info,option+1,argv[i+1]); 6630 break; 6631 } 6632 break; 6633 } 6634 case 'k': 6635 { 6636 if (LocaleCompare("kerning",option+1) == 0) 6637 { 6638 if (*option == '+') 6639 { 6640 (void) SetImageOption(image_info,option+1,"undefined"); 6641 break; 6642 } 6643 (void) SetImageOption(image_info,option+1,argv[i+1]); 6644 break; 6645 } 6646 break; 6647 } 6648 case 'l': 6649 { 6650 if (LocaleCompare("label",option+1) == 0) 6651 { 6652 if (*option == '+') 6653 { 6654 (void) DeleteImageOption(image_info,option+1); 6655 break; 6656 } 6657 (void) SetImageOption(image_info,option+1,argv[i+1]); 6658 break; 6659 } 6660 if (LocaleCompare("limit",option+1) == 0) 6661 { 6662 MagickSizeType 6663 limit; 6664 6665 ResourceType 6666 type; 6667 6668 if (*option == '+') 6669 break; 6670 type=(ResourceType) ParseCommandOption(MagickResourceOptions, 6671 MagickFalse,argv[i+1]); 6672 limit=MagickResourceInfinity; 6673 if (LocaleCompare("unlimited",argv[i+2]) != 0) 6674 limit=(MagickSizeType) SiPrefixToDouble(argv[i+2],100.0); 6675 (void) SetMagickResourceLimit(type,limit); 6676 break; 6677 } 6678 if (LocaleCompare("list",option+1) == 0) 6679 { 6680 ssize_t 6681 list; 6682 6683 /* 6684 Display configuration list. 6685 */ 6686 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i+1]); 6687 switch (list) 6688 { 6689 case MagickCoderOptions: 6690 { 6691 (void) ListCoderInfo((FILE *) NULL,exception); 6692 break; 6693 } 6694 case MagickColorOptions: 6695 { 6696 (void) ListColorInfo((FILE *) NULL,exception); 6697 break; 6698 } 6699 case MagickConfigureOptions: 6700 { 6701 (void) ListConfigureInfo((FILE *) NULL,exception); 6702 break; 6703 } 6704 case MagickDelegateOptions: 6705 { 6706 (void) ListDelegateInfo((FILE *) NULL,exception); 6707 break; 6708 } 6709 case MagickFontOptions: 6710 { 6711 (void) ListTypeInfo((FILE *) NULL,exception); 6712 break; 6713 } 6714 case MagickFormatOptions: 6715 { 6716 (void) ListMagickInfo((FILE *) NULL,exception); 6717 break; 6718 } 6719 case MagickLocaleOptions: 6720 { 6721 (void) ListLocaleInfo((FILE *) NULL,exception); 6722 break; 6723 } 6724 case MagickLogOptions: 6725 { 6726 (void) ListLogInfo((FILE *) NULL,exception); 6727 break; 6728 } 6729 case MagickMagicOptions: 6730 { 6731 (void) ListMagicInfo((FILE *) NULL,exception); 6732 break; 6733 } 6734 case MagickMimeOptions: 6735 { 6736 (void) ListMimeInfo((FILE *) NULL,exception); 6737 break; 6738 } 6739 case MagickModuleOptions: 6740 { 6741 (void) ListModuleInfo((FILE *) NULL,exception); 6742 break; 6743 } 6744 case MagickPolicyOptions: 6745 { 6746 (void) ListPolicyInfo((FILE *) NULL,exception); 6747 break; 6748 } 6749 case MagickResourceOptions: 6750 { 6751 (void) ListMagickResourceInfo((FILE *) NULL,exception); 6752 break; 6753 } 6754 case MagickThresholdOptions: 6755 { 6756 (void) ListThresholdMaps((FILE *) NULL,exception); 6757 break; 6758 } 6759 default: 6760 { 6761 (void) ListCommandOptions((FILE *) NULL,(CommandOption) list, 6762 exception); 6763 break; 6764 } 6765 } 6766 break; 6767 } 6768 if (LocaleCompare("log",option+1) == 0) 6769 { 6770 if (*option == '+') 6771 break; 6772 (void) SetLogFormat(argv[i+1]); 6773 break; 6774 } 6775 if (LocaleCompare("loop",option+1) == 0) 6776 { 6777 if (*option == '+') 6778 { 6779 (void) SetImageOption(image_info,option+1,"0"); 6780 break; 6781 } 6782 (void) SetImageOption(image_info,option+1,argv[i+1]); 6783 break; 6784 } 6785 break; 6786 } 6787 case 'm': 6788 { 6789 if (LocaleCompare("matte",option+1) == 0) 6790 { 6791 if (*option == '+') 6792 { 6793 (void) SetImageOption(image_info,option+1,"false"); 6794 break; 6795 } 6796 (void) SetImageOption(image_info,option+1,"true"); 6797 break; 6798 } 6799 if (LocaleCompare("mattecolor",option+1) == 0) 6800 { 6801 if (*option == '+') 6802 { 6803 (void) SetImageOption(image_info,option+1,argv[i+1]); 6804 (void) QueryColorCompliance(MogrifyMatteColor,AllCompliance, 6805 &image_info->matte_color,exception); 6806 break; 6807 } 6808 (void) SetImageOption(image_info,option+1,argv[i+1]); 6809 (void) QueryColorCompliance(argv[i+1],AllCompliance, 6810 &image_info->matte_color,exception); 6811 break; 6812 } 6813 if (LocaleCompare("monitor",option+1) == 0) 6814 { 6815 (void) SetImageInfoProgressMonitor(image_info,MonitorProgress, 6816 (void *) NULL); 6817 break; 6818 } 6819 if (LocaleCompare("monochrome",option+1) == 0) 6820 { 6821 image_info->monochrome=(*option == '-') ? MagickTrue : MagickFalse; 6822 break; 6823 } 6824 break; 6825 } 6826 case 'o': 6827 { 6828 if (LocaleCompare("orient",option+1) == 0) 6829 { 6830 if (*option == '+') 6831 { 6832 image_info->orientation=UndefinedOrientation; 6833 (void) SetImageOption(image_info,option+1,"undefined"); 6834 break; 6835 } 6836 image_info->orientation=(OrientationType) ParseCommandOption( 6837 MagickOrientationOptions,MagickFalse,argv[i+1]); 6838 (void) SetImageOption(image_info,option+1,argv[i+1]); 6839 break; 6840 } 6841 } 6842 case 'p': 6843 { 6844 if (LocaleCompare("page",option+1) == 0) 6845 { 6846 char 6847 *canonical_page, 6848 page[MaxTextExtent]; 6849 6850 const char 6851 *image_option; 6852 6853 MagickStatusType 6854 flags; 6855 6856 RectangleInfo 6857 geometry; 6858 6859 if (*option == '+') 6860 { 6861 (void) DeleteImageOption(image_info,option+1); 6862 (void) CloneString(&image_info->page,(char *) NULL); 6863 break; 6864 } 6865 (void) ResetMagickMemory(&geometry,0,sizeof(geometry)); 6866 image_option=GetImageOption(image_info,"page"); 6867 if (image_option != (const char *) NULL) 6868 flags=ParseAbsoluteGeometry(image_option,&geometry); 6869 canonical_page=GetPageGeometry(argv[i+1]); 6870 flags=ParseAbsoluteGeometry(canonical_page,&geometry); 6871 canonical_page=DestroyString(canonical_page); 6872 (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu", 6873 (unsigned long) geometry.width,(unsigned long) geometry.height); 6874 if (((flags & XValue) != 0) || ((flags & YValue) != 0)) 6875 (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu%+ld%+ld", 6876 (unsigned long) geometry.width,(unsigned long) geometry.height, 6877 (long) geometry.x,(long) geometry.y); 6878 (void) SetImageOption(image_info,option+1,page); 6879 (void) CloneString(&image_info->page,page); 6880 break; 6881 } 6882 if (LocaleCompare("pen",option+1) == 0) 6883 { 6884 if (*option == '+') 6885 { 6886 (void) SetImageOption(image_info,option+1,"none"); 6887 break; 6888 } 6889 (void) SetImageOption(image_info,option+1,argv[i+1]); 6890 break; 6891 } 6892 if (LocaleCompare("ping",option+1) == 0) 6893 { 6894 image_info->ping=(*option == '-') ? MagickTrue : MagickFalse; 6895 break; 6896 } 6897 if (LocaleCompare("pointsize",option+1) == 0) 6898 { 6899 if (*option == '+') 6900 geometry_info.rho=0.0; 6901 else 6902 (void) ParseGeometry(argv[i+1],&geometry_info); 6903 image_info->pointsize=geometry_info.rho; 6904 break; 6905 } 6906 if (LocaleCompare("precision",option+1) == 0) 6907 { 6908 (void) SetMagickPrecision(StringToInteger(argv[i+1])); 6909 break; 6910 } 6911 if (LocaleCompare("preview",option+1) == 0) 6912 { 6913 /* 6914 Preview image. 6915 */ 6916 if (*option == '+') 6917 { 6918 image_info->preview_type=UndefinedPreview; 6919 break; 6920 } 6921 image_info->preview_type=(PreviewType) ParseCommandOption( 6922 MagickPreviewOptions,MagickFalse,argv[i+1]); 6923 break; 6924 } 6925 break; 6926 } 6927 case 'q': 6928 { 6929 if (LocaleCompare("quality",option+1) == 0) 6930 { 6931 /* 6932 Set image compression quality. 6933 */ 6934 if (*option == '+') 6935 { 6936 image_info->quality=UndefinedCompressionQuality; 6937 (void) SetImageOption(image_info,option+1,"0"); 6938 break; 6939 } 6940 image_info->quality=StringToUnsignedLong(argv[i+1]); 6941 (void) SetImageOption(image_info,option+1,argv[i+1]); 6942 break; 6943 } 6944 if (LocaleCompare("quiet",option+1) == 0) 6945 { 6946 static WarningHandler 6947 warning_handler = (WarningHandler) NULL; 6948 6949 if (*option == '+') 6950 { 6951 /* 6952 Restore error or warning messages. 6953 */ 6954 warning_handler=SetWarningHandler(warning_handler); 6955 break; 6956 } 6957 /* 6958 Suppress error or warning messages. 6959 */ 6960 warning_handler=SetWarningHandler((WarningHandler) NULL); 6961 break; 6962 } 6963 break; 6964 } 6965 case 'r': 6966 { 6967 if (LocaleCompare("red-primary",option+1) == 0) 6968 { 6969 if (*option == '+') 6970 { 6971 (void) SetImageOption(image_info,option+1,"0.0"); 6972 break; 6973 } 6974 (void) SetImageOption(image_info,option+1,argv[i+1]); 6975 break; 6976 } 6977 break; 6978 } 6979 case 's': 6980 { 6981 if (LocaleCompare("sampling-factor",option+1) == 0) 6982 { 6983 /* 6984 Set image sampling factor. 6985 */ 6986 if (*option == '+') 6987 { 6988 if (image_info->sampling_factor != (char *) NULL) 6989 image_info->sampling_factor=DestroyString( 6990 image_info->sampling_factor); 6991 break; 6992 } 6993 (void) CloneString(&image_info->sampling_factor,argv[i+1]); 6994 break; 6995 } 6996 if (LocaleCompare("scene",option+1) == 0) 6997 { 6998 /* 6999 Set image scene. 7000 */ 7001 if (*option == '+') 7002 { 7003 image_info->scene=0; 7004 (void) SetImageOption(image_info,option+1,"0"); 7005 break; 7006 } 7007 image_info->scene=StringToUnsignedLong(argv[i+1]); 7008 (void) SetImageOption(image_info,option+1,argv[i+1]); 7009 break; 7010 } 7011 if (LocaleCompare("seed",option+1) == 0) 7012 { 7013 size_t 7014 seed; 7015 7016 if (*option == '+') 7017 { 7018 seed=(size_t) time((time_t *) NULL); 7019 SeedPseudoRandomGenerator(seed); 7020 break; 7021 } 7022 seed=StringToUnsignedLong(argv[i+1]); 7023 SeedPseudoRandomGenerator(seed); 7024 break; 7025 } 7026 if (LocaleCompare("size",option+1) == 0) 7027 { 7028 if (*option == '+') 7029 { 7030 if (image_info->size != (char *) NULL) 7031 image_info->size=DestroyString(image_info->size); 7032 break; 7033 } 7034 (void) CloneString(&image_info->size,argv[i+1]); 7035 break; 7036 } 7037 if (LocaleCompare("stroke",option+1) == 0) 7038 { 7039 if (*option == '+') 7040 { 7041 (void) SetImageOption(image_info,option+1,"none"); 7042 break; 7043 } 7044 (void) SetImageOption(image_info,option+1,argv[i+1]); 7045 break; 7046 } 7047 if (LocaleCompare("strokewidth",option+1) == 0) 7048 { 7049 if (*option == '+') 7050 { 7051 (void) SetImageOption(image_info,option+1,"0"); 7052 break; 7053 } 7054 (void) SetImageOption(image_info,option+1,argv[i+1]); 7055 break; 7056 } 7057 if (LocaleCompare("synchronize",option+1) == 0) 7058 { 7059 if (*option == '+') 7060 { 7061 image_info->synchronize=MagickFalse; 7062 break; 7063 } 7064 image_info->synchronize=MagickTrue; 7065 break; 7066 } 7067 break; 7068 } 7069 case 't': 7070 { 7071 if (LocaleCompare("taint",option+1) == 0) 7072 { 7073 if (*option == '+') 7074 { 7075 (void) SetImageOption(image_info,option+1,"false"); 7076 break; 7077 } 7078 (void) SetImageOption(image_info,option+1,"true"); 7079 break; 7080 } 7081 if (LocaleCompare("texture",option+1) == 0) 7082 { 7083 if (*option == '+') 7084 { 7085 if (image_info->texture != (char *) NULL) 7086 image_info->texture=DestroyString(image_info->texture); 7087 break; 7088 } 7089 (void) CloneString(&image_info->texture,argv[i+1]); 7090 break; 7091 } 7092 if (LocaleCompare("tile-offset",option+1) == 0) 7093 { 7094 if (*option == '+') 7095 { 7096 (void) SetImageOption(image_info,option+1,"0"); 7097 break; 7098 } 7099 (void) SetImageOption(image_info,option+1,argv[i+1]); 7100 break; 7101 } 7102 if (LocaleCompare("transparent-color",option+1) == 0) 7103 { 7104 if (*option == '+') 7105 { 7106 (void) QueryColorCompliance("none",AllCompliance, 7107 &image_info->transparent_color,exception); 7108 (void) SetImageOption(image_info,option+1,"none"); 7109 break; 7110 } 7111 (void) QueryColorCompliance(argv[i+1],AllCompliance, 7112 &image_info->transparent_color,exception); 7113 (void) SetImageOption(image_info,option+1,argv[i+1]); 7114 break; 7115 } 7116 if (LocaleCompare("type",option+1) == 0) 7117 { 7118 if (*option == '+') 7119 { 7120 image_info->type=UndefinedType; 7121 (void) SetImageOption(image_info,option+1,"undefined"); 7122 break; 7123 } 7124 image_info->type=(ImageType) ParseCommandOption(MagickTypeOptions, 7125 MagickFalse,argv[i+1]); 7126 (void) SetImageOption(image_info,option+1,argv[i+1]); 7127 break; 7128 } 7129 break; 7130 } 7131 case 'u': 7132 { 7133 if (LocaleCompare("undercolor",option+1) == 0) 7134 { 7135 if (*option == '+') 7136 { 7137 (void) DeleteImageOption(image_info,option+1); 7138 break; 7139 } 7140 (void) SetImageOption(image_info,option+1,argv[i+1]); 7141 break; 7142 } 7143 if (LocaleCompare("units",option+1) == 0) 7144 { 7145 if (*option == '+') 7146 { 7147 image_info->units=UndefinedResolution; 7148 (void) SetImageOption(image_info,option+1,"undefined"); 7149 break; 7150 } 7151 image_info->units=(ResolutionType) ParseCommandOption( 7152 MagickResolutionOptions,MagickFalse,argv[i+1]); 7153 (void) SetImageOption(image_info,option+1,argv[i+1]); 7154 break; 7155 } 7156 break; 7157 } 7158 case 'v': 7159 { 7160 if (LocaleCompare("verbose",option+1) == 0) 7161 { 7162 if (*option == '+') 7163 { 7164 image_info->verbose=MagickFalse; 7165 break; 7166 } 7167 image_info->verbose=MagickTrue; 7168 image_info->ping=MagickFalse; 7169 break; 7170 } 7171 if (LocaleCompare("view",option+1) == 0) 7172 { 7173 if (*option == '+') 7174 { 7175 if (image_info->view != (char *) NULL) 7176 image_info->view=DestroyString(image_info->view); 7177 break; 7178 } 7179 (void) CloneString(&image_info->view,argv[i+1]); 7180 break; 7181 } 7182 if (LocaleCompare("virtual-pixel",option+1) == 0) 7183 { 7184 if (*option == '+') 7185 { 7186 image_info->virtual_pixel_method=UndefinedVirtualPixelMethod; 7187 (void) SetImageOption(image_info,option+1,"undefined"); 7188 break; 7189 } 7190 image_info->virtual_pixel_method=(VirtualPixelMethod) 7191 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse, 7192 argv[i+1]); 7193 (void) SetImageOption(image_info,option+1,argv[i+1]); 7194 break; 7195 } 7196 break; 7197 } 7198 case 'w': 7199 { 7200 if (LocaleCompare("white-point",option+1) == 0) 7201 { 7202 if (*option == '+') 7203 { 7204 (void) SetImageOption(image_info,option+1,"0.0"); 7205 break; 7206 } 7207 (void) SetImageOption(image_info,option+1,argv[i+1]); 7208 break; 7209 } 7210 break; 7211 } 7212 default: 7213 break; 7214 } 7215 i+=count; 7216 } 7217 return(MagickTrue); 7218} 7219 7220/* 7221%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7222% % 7223% % 7224% % 7225+ M o g r i f y I m a g e L i s t % 7226% % 7227% % 7228% % 7229%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7230% 7231% MogrifyImageList() applies any command line options that might affect the 7232% entire image list (e.g. -append, -coalesce, etc.). 7233% 7234% The format of the MogrifyImage method is: 7235% 7236% MagickBooleanType MogrifyImageList(ImageInfo *image_info,const int argc, 7237% const char **argv,Image **images,ExceptionInfo *exception) 7238% 7239% A description of each parameter follows: 7240% 7241% o image_info: the image info.. 7242% 7243% o argc: Specifies a pointer to an integer describing the number of 7244% elements in the argument vector. 7245% 7246% o argv: Specifies a pointer to a text array containing the command line 7247% arguments. 7248% 7249% o images: pointer to pointer of the first image in image list. 7250% 7251% o exception: return any errors or warnings in this structure. 7252% 7253*/ 7254WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info, 7255 const int argc,const char **argv,Image **images,ExceptionInfo *exception) 7256{ 7257 const char 7258 *option; 7259 7260 ImageInfo 7261 *mogrify_info; 7262 7263 MagickStatusType 7264 status; 7265 7266 PixelInterpolateMethod 7267 interpolate_method; 7268 7269 QuantizeInfo 7270 *quantize_info; 7271 7272 register ssize_t 7273 i; 7274 7275 ssize_t 7276 count, 7277 index; 7278 7279 /* 7280 Apply options to the image list. 7281 */ 7282 assert(image_info != (ImageInfo *) NULL); 7283 assert(image_info->signature == MagickSignature); 7284 assert(images != (Image **) NULL); 7285 assert((*images)->previous == (Image *) NULL); 7286 assert((*images)->signature == MagickSignature); 7287 if ((*images)->debug != MagickFalse) 7288 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", 7289 (*images)->filename); 7290 if ((argc <= 0) || (*argv == (char *) NULL)) 7291 return(MagickTrue); 7292 interpolate_method=UndefinedInterpolatePixel; 7293 mogrify_info=CloneImageInfo(image_info); 7294 quantize_info=AcquireQuantizeInfo(mogrify_info); 7295 status=MagickTrue; 7296 for (i=0; i < (ssize_t) argc; i++) 7297 { 7298 if (*images == (Image *) NULL) 7299 break; 7300 option=argv[i]; 7301 if (IsCommandOption(option) == MagickFalse) 7302 continue; 7303 count=ParseCommandOption(MagickCommandOptions,MagickFalse,option); 7304 count=MagickMax(count,0L); 7305 if ((i+count) >= (ssize_t) argc) 7306 break; 7307 status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception); 7308 switch (*(option+1)) 7309 { 7310 case 'a': 7311 { 7312 if (LocaleCompare("affinity",option+1) == 0) 7313 { 7314 (void) SyncImagesSettings(mogrify_info,*images); 7315 if (*option == '+') 7316 { 7317 (void) RemapImages(quantize_info,*images,(Image *) NULL, 7318 exception); 7319 break; 7320 } 7321 i++; 7322 break; 7323 } 7324 if (LocaleCompare("append",option+1) == 0) 7325 { 7326 Image 7327 *append_image; 7328 7329 (void) SyncImagesSettings(mogrify_info,*images); 7330 append_image=AppendImages(*images,*option == '-' ? MagickTrue : 7331 MagickFalse,exception); 7332 if (append_image == (Image *) NULL) 7333 { 7334 status=MagickFalse; 7335 break; 7336 } 7337 *images=DestroyImageList(*images); 7338 *images=append_image; 7339 break; 7340 } 7341 if (LocaleCompare("average",option+1) == 0) 7342 { 7343 Image 7344 *average_image; 7345 7346 /* 7347 Average an image sequence (deprecated). 7348 */ 7349 (void) SyncImagesSettings(mogrify_info,*images); 7350 average_image=EvaluateImages(*images,MeanEvaluateOperator, 7351 exception); 7352 if (average_image == (Image *) NULL) 7353 { 7354 status=MagickFalse; 7355 break; 7356 } 7357 *images=DestroyImageList(*images); 7358 *images=average_image; 7359 break; 7360 } 7361 break; 7362 } 7363 case 'c': 7364 { 7365 if (LocaleCompare("channel",option+1) == 0) 7366 { 7367 ChannelType 7368 channel; 7369 7370 if (*option == '+') 7371 { 7372 channel=DefaultChannels; 7373 break; 7374 } 7375 channel=(ChannelType) ParseChannelOption(argv[i+1]); 7376 SetPixelChannelMap(*images,channel); 7377 break; 7378 } 7379 if (LocaleCompare("clut",option+1) == 0) 7380 { 7381 Image 7382 *clut_image, 7383 *image; 7384 7385 (void) SyncImagesSettings(mogrify_info,*images); 7386 image=RemoveFirstImageFromList(images); 7387 clut_image=RemoveFirstImageFromList(images); 7388 if (clut_image == (Image *) NULL) 7389 { 7390 status=MagickFalse; 7391 break; 7392 } 7393 (void) ClutImage(image,clut_image,interpolate_method,exception); 7394 clut_image=DestroyImage(clut_image); 7395 *images=DestroyImageList(*images); 7396 *images=image; 7397 break; 7398 } 7399 if (LocaleCompare("coalesce",option+1) == 0) 7400 { 7401 Image 7402 *coalesce_image; 7403 7404 (void) SyncImagesSettings(mogrify_info,*images); 7405 coalesce_image=CoalesceImages(*images,exception); 7406 if (coalesce_image == (Image *) NULL) 7407 { 7408 status=MagickFalse; 7409 break; 7410 } 7411 *images=DestroyImageList(*images); 7412 *images=coalesce_image; 7413 break; 7414 } 7415 if (LocaleCompare("combine",option+1) == 0) 7416 { 7417 Image 7418 *combine_image; 7419 7420 (void) SyncImagesSettings(mogrify_info,*images); 7421 combine_image=CombineImages(*images,exception); 7422 if (combine_image == (Image *) NULL) 7423 { 7424 status=MagickFalse; 7425 break; 7426 } 7427 *images=DestroyImageList(*images); 7428 *images=combine_image; 7429 break; 7430 } 7431 if (LocaleCompare("composite",option+1) == 0) 7432 { 7433 Image 7434 *mask_image, 7435 *composite_image, 7436 *image; 7437 7438 RectangleInfo 7439 geometry; 7440 7441 (void) SyncImagesSettings(mogrify_info,*images); 7442 image=RemoveFirstImageFromList(images); 7443 composite_image=RemoveFirstImageFromList(images); 7444 if (composite_image == (Image *) NULL) 7445 { 7446 status=MagickFalse; 7447 break; 7448 } 7449 (void) TransformImage(&composite_image,(char *) NULL, 7450 composite_image->geometry); 7451 SetGeometry(composite_image,&geometry); 7452 (void) ParseAbsoluteGeometry(composite_image->geometry,&geometry); 7453 GravityAdjustGeometry(image->columns,image->rows,image->gravity, 7454 &geometry); 7455 mask_image=RemoveFirstImageFromList(images); 7456 if (mask_image != (Image *) NULL) 7457 { 7458 if ((image->compose == DisplaceCompositeOp) || 7459 (image->compose == DistortCompositeOp)) 7460 { 7461 /* 7462 Merge Y displacement into X displacement image. 7463 */ 7464 (void) CompositeImage(composite_image,CopyGreenCompositeOp, 7465 mask_image,0,0); 7466 mask_image=DestroyImage(mask_image); 7467 } 7468 else 7469 { 7470 /* 7471 Set a blending mask for the composition. 7472 Posible error, what if image->mask already set. 7473 */ 7474 image->mask=mask_image; 7475 (void) NegateImage(image->mask,MagickFalse,exception); 7476 } 7477 } 7478 (void) CompositeImage(image,image->compose,composite_image, 7479 geometry.x,geometry.y); 7480 if (mask_image != (Image *) NULL) 7481 mask_image=image->mask=DestroyImage(image->mask); 7482 composite_image=DestroyImage(composite_image); 7483 InheritException(exception,&image->exception); 7484 *images=DestroyImageList(*images); 7485 *images=image; 7486 break; 7487 } 7488 break; 7489 } 7490 case 'd': 7491 { 7492 if (LocaleCompare("deconstruct",option+1) == 0) 7493 { 7494 Image 7495 *deconstruct_image; 7496 7497 (void) SyncImagesSettings(mogrify_info,*images); 7498 deconstruct_image=CompareImagesLayers(*images,CompareAnyLayer, 7499 exception); 7500 if (deconstruct_image == (Image *) NULL) 7501 { 7502 status=MagickFalse; 7503 break; 7504 } 7505 *images=DestroyImageList(*images); 7506 *images=deconstruct_image; 7507 break; 7508 } 7509 if (LocaleCompare("delete",option+1) == 0) 7510 { 7511 if (*option == '+') 7512 DeleteImages(images,"-1",exception); 7513 else 7514 DeleteImages(images,argv[i+1],exception); 7515 break; 7516 } 7517 if (LocaleCompare("dither",option+1) == 0) 7518 { 7519 if (*option == '+') 7520 { 7521 quantize_info->dither=MagickFalse; 7522 break; 7523 } 7524 quantize_info->dither=MagickTrue; 7525 quantize_info->dither_method=(DitherMethod) ParseCommandOption( 7526 MagickDitherOptions,MagickFalse,argv[i+1]); 7527 break; 7528 } 7529 if (LocaleCompare("duplicate",option+1) == 0) 7530 { 7531 Image 7532 *duplicate_images; 7533 7534 if (*option == '+') 7535 duplicate_images=DuplicateImages(*images,1,"-1",exception); 7536 else 7537 { 7538 const char 7539 *p; 7540 7541 size_t 7542 number_duplicates; 7543 7544 number_duplicates=(size_t) StringToLong(argv[i+1]); 7545 p=strchr(argv[i+1],','); 7546 if (p == (const char *) NULL) 7547 duplicate_images=DuplicateImages(*images,number_duplicates, 7548 "-1",exception); 7549 else 7550 duplicate_images=DuplicateImages(*images,number_duplicates,p, 7551 exception); 7552 } 7553 AppendImageToList(images, duplicate_images); 7554 (void) SyncImagesSettings(mogrify_info,*images); 7555 break; 7556 } 7557 break; 7558 } 7559 case 'e': 7560 { 7561 if (LocaleCompare("evaluate-sequence",option+1) == 0) 7562 { 7563 Image 7564 *evaluate_image; 7565 7566 MagickEvaluateOperator 7567 op; 7568 7569 (void) SyncImageSettings(mogrify_info,*images); 7570 op=(MagickEvaluateOperator) ParseCommandOption( 7571 MagickEvaluateOptions,MagickFalse,argv[i+1]); 7572 evaluate_image=EvaluateImages(*images,op,exception); 7573 if (evaluate_image == (Image *) NULL) 7574 { 7575 status=MagickFalse; 7576 break; 7577 } 7578 *images=DestroyImageList(*images); 7579 *images=evaluate_image; 7580 break; 7581 } 7582 break; 7583 } 7584 case 'f': 7585 { 7586 if (LocaleCompare("fft",option+1) == 0) 7587 { 7588 Image 7589 *fourier_image; 7590 7591 /* 7592 Implements the discrete Fourier transform (DFT). 7593 */ 7594 (void) SyncImageSettings(mogrify_info,*images); 7595 fourier_image=ForwardFourierTransformImage(*images,*option == '-' ? 7596 MagickTrue : MagickFalse,exception); 7597 if (fourier_image == (Image *) NULL) 7598 break; 7599 *images=DestroyImage(*images); 7600 *images=fourier_image; 7601 break; 7602 } 7603 if (LocaleCompare("flatten",option+1) == 0) 7604 { 7605 Image 7606 *flatten_image; 7607 7608 (void) SyncImagesSettings(mogrify_info,*images); 7609 flatten_image=MergeImageLayers(*images,FlattenLayer,exception); 7610 if (flatten_image == (Image *) NULL) 7611 break; 7612 *images=DestroyImageList(*images); 7613 *images=flatten_image; 7614 break; 7615 } 7616 if (LocaleCompare("fx",option+1) == 0) 7617 { 7618 Image 7619 *fx_image; 7620 7621 (void) SyncImagesSettings(mogrify_info,*images); 7622 fx_image=FxImage(*images,argv[i+1],exception); 7623 if (fx_image == (Image *) NULL) 7624 { 7625 status=MagickFalse; 7626 break; 7627 } 7628 *images=DestroyImageList(*images); 7629 *images=fx_image; 7630 break; 7631 } 7632 break; 7633 } 7634 case 'h': 7635 { 7636 if (LocaleCompare("hald-clut",option+1) == 0) 7637 { 7638 Image 7639 *hald_image, 7640 *image; 7641 7642 (void) SyncImagesSettings(mogrify_info,*images); 7643 image=RemoveFirstImageFromList(images); 7644 hald_image=RemoveFirstImageFromList(images); 7645 if (hald_image == (Image *) NULL) 7646 { 7647 status=MagickFalse; 7648 break; 7649 } 7650 (void) HaldClutImage(image,hald_image,exception); 7651 hald_image=DestroyImage(hald_image); 7652 if (*images != (Image *) NULL) 7653 *images=DestroyImageList(*images); 7654 *images=image; 7655 break; 7656 } 7657 break; 7658 } 7659 case 'i': 7660 { 7661 if (LocaleCompare("ift",option+1) == 0) 7662 { 7663 Image 7664 *fourier_image, 7665 *magnitude_image, 7666 *phase_image; 7667 7668 /* 7669 Implements the inverse fourier discrete Fourier transform (DFT). 7670 */ 7671 (void) SyncImagesSettings(mogrify_info,*images); 7672 magnitude_image=RemoveFirstImageFromList(images); 7673 phase_image=RemoveFirstImageFromList(images); 7674 if (phase_image == (Image *) NULL) 7675 { 7676 status=MagickFalse; 7677 break; 7678 } 7679 fourier_image=InverseFourierTransformImage(magnitude_image, 7680 phase_image,*option == '-' ? MagickTrue : MagickFalse,exception); 7681 if (fourier_image == (Image *) NULL) 7682 break; 7683 if (*images != (Image *) NULL) 7684 *images=DestroyImage(*images); 7685 *images=fourier_image; 7686 break; 7687 } 7688 if (LocaleCompare("insert",option+1) == 0) 7689 { 7690 Image 7691 *p, 7692 *q; 7693 7694 index=0; 7695 if (*option != '+') 7696 index=(ssize_t) StringToLong(argv[i+1]); 7697 p=RemoveLastImageFromList(images); 7698 if (p == (Image *) NULL) 7699 { 7700 (void) ThrowMagickException(exception,GetMagickModule(), 7701 OptionError,"NoSuchImage","`%s'",argv[i+1]); 7702 status=MagickFalse; 7703 break; 7704 } 7705 q=p; 7706 if (index == 0) 7707 PrependImageToList(images,q); 7708 else 7709 if (index == (ssize_t) GetImageListLength(*images)) 7710 AppendImageToList(images,q); 7711 else 7712 { 7713 q=GetImageFromList(*images,index-1); 7714 if (q == (Image *) NULL) 7715 { 7716 (void) ThrowMagickException(exception,GetMagickModule(), 7717 OptionError,"NoSuchImage","`%s'",argv[i+1]); 7718 status=MagickFalse; 7719 break; 7720 } 7721 InsertImageInList(&q,p); 7722 } 7723 *images=GetFirstImageInList(q); 7724 break; 7725 } 7726 if (LocaleCompare("interpolate",option+1) == 0) 7727 { 7728 interpolate_method=(PixelInterpolateMethod) ParseCommandOption( 7729 MagickInterpolateOptions,MagickFalse,argv[i+1]); 7730 break; 7731 } 7732 break; 7733 } 7734 case 'l': 7735 { 7736 if (LocaleCompare("layers",option+1) == 0) 7737 { 7738 Image 7739 *layers; 7740 7741 ImageLayerMethod 7742 method; 7743 7744 (void) SyncImagesSettings(mogrify_info,*images); 7745 layers=(Image *) NULL; 7746 method=(ImageLayerMethod) ParseCommandOption(MagickLayerOptions, 7747 MagickFalse,argv[i+1]); 7748 switch (method) 7749 { 7750 case CoalesceLayer: 7751 { 7752 layers=CoalesceImages(*images,exception); 7753 break; 7754 } 7755 case CompareAnyLayer: 7756 case CompareClearLayer: 7757 case CompareOverlayLayer: 7758 default: 7759 { 7760 layers=CompareImagesLayers(*images,method,exception); 7761 break; 7762 } 7763 case MergeLayer: 7764 case FlattenLayer: 7765 case MosaicLayer: 7766 case TrimBoundsLayer: 7767 { 7768 layers=MergeImageLayers(*images,method,exception); 7769 break; 7770 } 7771 case DisposeLayer: 7772 { 7773 layers=DisposeImages(*images,exception); 7774 break; 7775 } 7776 case OptimizeImageLayer: 7777 { 7778 layers=OptimizeImageLayers(*images,exception); 7779 break; 7780 } 7781 case OptimizePlusLayer: 7782 { 7783 layers=OptimizePlusImageLayers(*images,exception); 7784 break; 7785 } 7786 case OptimizeTransLayer: 7787 { 7788 OptimizeImageTransparency(*images,exception); 7789 break; 7790 } 7791 case RemoveDupsLayer: 7792 { 7793 RemoveDuplicateLayers(images,exception); 7794 break; 7795 } 7796 case RemoveZeroLayer: 7797 { 7798 RemoveZeroDelayLayers(images,exception); 7799 break; 7800 } 7801 case OptimizeLayer: 7802 { 7803 /* 7804 General Purpose, GIF Animation Optimizer. 7805 */ 7806 layers=CoalesceImages(*images,exception); 7807 if (layers == (Image *) NULL) 7808 { 7809 status=MagickFalse; 7810 break; 7811 } 7812 *images=DestroyImageList(*images); 7813 *images=layers; 7814 layers=OptimizeImageLayers(*images,exception); 7815 if (layers == (Image *) NULL) 7816 { 7817 status=MagickFalse; 7818 break; 7819 } 7820 *images=DestroyImageList(*images); 7821 *images=layers; 7822 layers=(Image *) NULL; 7823 OptimizeImageTransparency(*images,exception); 7824 (void) RemapImages(quantize_info,*images,(Image *) NULL, 7825 exception); 7826 break; 7827 } 7828 case CompositeLayer: 7829 { 7830 CompositeOperator 7831 compose; 7832 7833 Image 7834 *source; 7835 7836 RectangleInfo 7837 geometry; 7838 7839 /* 7840 Split image sequence at the first 'NULL:' image. 7841 */ 7842 source=(*images); 7843 while (source != (Image *) NULL) 7844 { 7845 source=GetNextImageInList(source); 7846 if ((source != (Image *) NULL) && 7847 (LocaleCompare(source->magick,"NULL") == 0)) 7848 break; 7849 } 7850 if (source != (Image *) NULL) 7851 { 7852 if ((GetPreviousImageInList(source) == (Image *) NULL) || 7853 (GetNextImageInList(source) == (Image *) NULL)) 7854 source=(Image *) NULL; 7855 else 7856 { 7857 /* 7858 Separate the two lists, junk the null: image. 7859 */ 7860 source=SplitImageList(source->previous); 7861 DeleteImageFromList(&source); 7862 } 7863 } 7864 if (source == (Image *) NULL) 7865 { 7866 (void) ThrowMagickException(exception,GetMagickModule(), 7867 OptionError,"MissingNullSeparator","layers Composite"); 7868 status=MagickFalse; 7869 break; 7870 } 7871 /* 7872 Adjust offset with gravity and virtual canvas. 7873 */ 7874 SetGeometry(*images,&geometry); 7875 (void) ParseAbsoluteGeometry((*images)->geometry,&geometry); 7876 geometry.width=source->page.width != 0 ? 7877 source->page.width : source->columns; 7878 geometry.height=source->page.height != 0 ? 7879 source->page.height : source->rows; 7880 GravityAdjustGeometry((*images)->page.width != 0 ? 7881 (*images)->page.width : (*images)->columns, 7882 (*images)->page.height != 0 ? (*images)->page.height : 7883 (*images)->rows,(*images)->gravity,&geometry); 7884 compose=OverCompositeOp; 7885 option=GetImageOption(mogrify_info,"compose"); 7886 if (option != (const char *) NULL) 7887 compose=(CompositeOperator) ParseCommandOption( 7888 MagickComposeOptions,MagickFalse,option); 7889 CompositeLayers(*images,compose,source,geometry.x,geometry.y, 7890 exception); 7891 source=DestroyImageList(source); 7892 break; 7893 } 7894 } 7895 if (layers == (Image *) NULL) 7896 break; 7897 InheritException(exception,&layers->exception); 7898 *images=DestroyImageList(*images); 7899 *images=layers; 7900 break; 7901 } 7902 break; 7903 } 7904 case 'm': 7905 { 7906 if (LocaleCompare("map",option+1) == 0) 7907 { 7908 (void) SyncImagesSettings(mogrify_info,*images); 7909 if (*option == '+') 7910 { 7911 (void) RemapImages(quantize_info,*images,(Image *) NULL, 7912 exception); 7913 break; 7914 } 7915 i++; 7916 break; 7917 } 7918 if (LocaleCompare("maximum",option+1) == 0) 7919 { 7920 Image 7921 *maximum_image; 7922 7923 /* 7924 Maximum image sequence (deprecated). 7925 */ 7926 (void) SyncImagesSettings(mogrify_info,*images); 7927 maximum_image=EvaluateImages(*images,MaxEvaluateOperator,exception); 7928 if (maximum_image == (Image *) NULL) 7929 { 7930 status=MagickFalse; 7931 break; 7932 } 7933 *images=DestroyImageList(*images); 7934 *images=maximum_image; 7935 break; 7936 } 7937 if (LocaleCompare("minimum",option+1) == 0) 7938 { 7939 Image 7940 *minimum_image; 7941 7942 /* 7943 Minimum image sequence (deprecated). 7944 */ 7945 (void) SyncImagesSettings(mogrify_info,*images); 7946 minimum_image=EvaluateImages(*images,MinEvaluateOperator,exception); 7947 if (minimum_image == (Image *) NULL) 7948 { 7949 status=MagickFalse; 7950 break; 7951 } 7952 *images=DestroyImageList(*images); 7953 *images=minimum_image; 7954 break; 7955 } 7956 if (LocaleCompare("morph",option+1) == 0) 7957 { 7958 Image 7959 *morph_image; 7960 7961 (void) SyncImagesSettings(mogrify_info,*images); 7962 morph_image=MorphImages(*images,StringToUnsignedLong(argv[i+1]), 7963 exception); 7964 if (morph_image == (Image *) NULL) 7965 { 7966 status=MagickFalse; 7967 break; 7968 } 7969 *images=DestroyImageList(*images); 7970 *images=morph_image; 7971 break; 7972 } 7973 if (LocaleCompare("mosaic",option+1) == 0) 7974 { 7975 Image 7976 *mosaic_image; 7977 7978 (void) SyncImagesSettings(mogrify_info,*images); 7979 mosaic_image=MergeImageLayers(*images,MosaicLayer,exception); 7980 if (mosaic_image == (Image *) NULL) 7981 { 7982 status=MagickFalse; 7983 break; 7984 } 7985 *images=DestroyImageList(*images); 7986 *images=mosaic_image; 7987 break; 7988 } 7989 break; 7990 } 7991 case 'p': 7992 { 7993 if (LocaleCompare("print",option+1) == 0) 7994 { 7995 char 7996 *string; 7997 7998 (void) SyncImagesSettings(mogrify_info,*images); 7999 string=InterpretImageProperties(mogrify_info,*images,argv[i+1], 8000 exception); 8001 if (string == (char *) NULL) 8002 break; 8003 (void) FormatLocaleFile(stdout,"%s",string); 8004 string=DestroyString(string); 8005 } 8006 if (LocaleCompare("process",option+1) == 0) 8007 { 8008 char 8009 **arguments; 8010 8011 int 8012 j, 8013 number_arguments; 8014 8015 (void) SyncImagesSettings(mogrify_info,*images); 8016 arguments=StringToArgv(argv[i+1],&number_arguments); 8017 if (arguments == (char **) NULL) 8018 break; 8019 if ((argc > 1) && (strchr(arguments[1],'=') != (char *) NULL)) 8020 { 8021 char 8022 breaker, 8023 quote, 8024 *token; 8025 8026 const char 8027 *arguments; 8028 8029 int 8030 next, 8031 status; 8032 8033 size_t 8034 length; 8035 8036 TokenInfo 8037 *token_info; 8038 8039 /* 8040 Support old style syntax, filter="-option arg". 8041 */ 8042 length=strlen(argv[i+1]); 8043 token=(char *) NULL; 8044 if (~length >= (MaxTextExtent-1)) 8045 token=(char *) AcquireQuantumMemory(length+MaxTextExtent, 8046 sizeof(*token)); 8047 if (token == (char *) NULL) 8048 break; 8049 next=0; 8050 arguments=argv[i+1]; 8051 token_info=AcquireTokenInfo(); 8052 status=Tokenizer(token_info,0,token,length,arguments,"","=", 8053 "\"",'\0',&breaker,&next,"e); 8054 token_info=DestroyTokenInfo(token_info); 8055 if (status == 0) 8056 { 8057 const char 8058 *argv; 8059 8060 argv=(&(arguments[next])); 8061 (void) InvokeDynamicImageFilter(token,&(*images),1,&argv, 8062 exception); 8063 } 8064 token=DestroyString(token); 8065 break; 8066 } 8067 (void) SubstituteString(&arguments[1],"-",""); 8068 (void) InvokeDynamicImageFilter(arguments[1],&(*images), 8069 number_arguments-2,(const char **) arguments+2,exception); 8070 for (j=0; j < number_arguments; j++) 8071 arguments[j]=DestroyString(arguments[j]); 8072 arguments=(char **) RelinquishMagickMemory(arguments); 8073 break; 8074 } 8075 break; 8076 } 8077 case 'r': 8078 { 8079 if (LocaleCompare("reverse",option+1) == 0) 8080 { 8081 ReverseImageList(images); 8082 InheritException(exception,&(*images)->exception); 8083 break; 8084 } 8085 break; 8086 } 8087 case 's': 8088 { 8089 if (LocaleCompare("smush",option+1) == 0) 8090 { 8091 Image 8092 *smush_image; 8093 8094 ssize_t 8095 offset; 8096 8097 (void) SyncImagesSettings(mogrify_info,*images); 8098 offset=(ssize_t) StringToLong(argv[i+1]); 8099 smush_image=SmushImages(*images,*option == '-' ? MagickTrue : 8100 MagickFalse,offset,exception); 8101 if (smush_image == (Image *) NULL) 8102 { 8103 status=MagickFalse; 8104 break; 8105 } 8106 *images=DestroyImageList(*images); 8107 *images=smush_image; 8108 break; 8109 } 8110 if (LocaleCompare("swap",option+1) == 0) 8111 { 8112 Image 8113 *p, 8114 *q, 8115 *swap; 8116 8117 ssize_t 8118 swap_index; 8119 8120 index=(-1); 8121 swap_index=(-2); 8122 if (*option != '+') 8123 { 8124 GeometryInfo 8125 geometry_info; 8126 8127 MagickStatusType 8128 flags; 8129 8130 swap_index=(-1); 8131 flags=ParseGeometry(argv[i+1],&geometry_info); 8132 index=(ssize_t) geometry_info.rho; 8133 if ((flags & SigmaValue) != 0) 8134 swap_index=(ssize_t) geometry_info.sigma; 8135 } 8136 p=GetImageFromList(*images,index); 8137 q=GetImageFromList(*images,swap_index); 8138 if ((p == (Image *) NULL) || (q == (Image *) NULL)) 8139 { 8140 (void) ThrowMagickException(exception,GetMagickModule(), 8141 OptionError,"NoSuchImage","`%s'",(*images)->filename); 8142 status=MagickFalse; 8143 break; 8144 } 8145 if (p == q) 8146 break; 8147 swap=CloneImage(p,0,0,MagickTrue,exception); 8148 ReplaceImageInList(&p,CloneImage(q,0,0,MagickTrue,exception)); 8149 ReplaceImageInList(&q,swap); 8150 *images=GetFirstImageInList(q); 8151 break; 8152 } 8153 break; 8154 } 8155 case 'w': 8156 { 8157 if (LocaleCompare("write",option+1) == 0) 8158 { 8159 char 8160 key[MaxTextExtent]; 8161 8162 Image 8163 *write_images; 8164 8165 ImageInfo 8166 *write_info; 8167 8168 (void) SyncImagesSettings(mogrify_info,*images); 8169 (void) FormatLocaleString(key,MaxTextExtent,"cache:%s",argv[i+1]); 8170 (void) DeleteImageRegistry(key); 8171 write_images=(*images); 8172 if (*option == '+') 8173 write_images=CloneImageList(*images,exception); 8174 write_info=CloneImageInfo(mogrify_info); 8175 status&=WriteImages(write_info,write_images,argv[i+1],exception); 8176 write_info=DestroyImageInfo(write_info); 8177 if (*option == '+') 8178 write_images=DestroyImageList(write_images); 8179 break; 8180 } 8181 break; 8182 } 8183 default: 8184 break; 8185 } 8186 i+=count; 8187 } 8188 quantize_info=DestroyQuantizeInfo(quantize_info); 8189 mogrify_info=DestroyImageInfo(mogrify_info); 8190 status&=MogrifyImageInfo(image_info,argc,argv,exception); 8191 return(status != 0 ? MagickTrue : MagickFalse); 8192} 8193 8194/* 8195%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8196% % 8197% % 8198% % 8199+ M o g r i f y I m a g e s % 8200% % 8201% % 8202% % 8203%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8204% 8205% MogrifyImages() applies image processing options to a sequence of images as 8206% prescribed by command line options. 8207% 8208% The format of the MogrifyImage method is: 8209% 8210% MagickBooleanType MogrifyImages(ImageInfo *image_info, 8211% const MagickBooleanType post,const int argc,const char **argv, 8212% Image **images,Exceptioninfo *exception) 8213% 8214% A description of each parameter follows: 8215% 8216% o image_info: the image info.. 8217% 8218% o post: If true, post process image list operators otherwise pre-process. 8219% 8220% o argc: Specifies a pointer to an integer describing the number of 8221% elements in the argument vector. 8222% 8223% o argv: Specifies a pointer to a text array containing the command line 8224% arguments. 8225% 8226% o images: pointer to a pointer of the first image in image list. 8227% 8228% o exception: return any errors or warnings in this structure. 8229% 8230*/ 8231WandExport MagickBooleanType MogrifyImages(ImageInfo *image_info, 8232 const MagickBooleanType post,const int argc,const char **argv, 8233 Image **images,ExceptionInfo *exception) 8234{ 8235#define MogrifyImageTag "Mogrify/Image" 8236 8237 MagickStatusType 8238 status; 8239 8240 MagickBooleanType 8241 proceed; 8242 8243 size_t 8244 n; 8245 8246 register ssize_t 8247 i; 8248 8249 assert(image_info != (ImageInfo *) NULL); 8250 assert(image_info->signature == MagickSignature); 8251 if (images == (Image **) NULL) 8252 return(MogrifyImage(image_info,argc,argv,images,exception)); 8253 assert((*images)->previous == (Image *) NULL); 8254 assert((*images)->signature == MagickSignature); 8255 if ((*images)->debug != MagickFalse) 8256 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", 8257 (*images)->filename); 8258 if ((argc <= 0) || (*argv == (char *) NULL)) 8259 return(MagickTrue); 8260 (void) SetImageInfoProgressMonitor(image_info,(MagickProgressMonitor) NULL, 8261 (void *) NULL); 8262 status=0; 8263 8264#if 0 8265 (void) FormatLocaleFile(stderr, "mogrify start %s %d (%s)\n",argv[0],argc, 8266 post?"post":"pre"); 8267#endif 8268 8269 /* 8270 Pre-process multi-image sequence operators 8271 */ 8272 if (post == MagickFalse) 8273 status&=MogrifyImageList(image_info,argc,argv,images,exception); 8274 /* 8275 For each image, process simple single image operators 8276 */ 8277 i=0; 8278 n=GetImageListLength(*images); 8279 for ( ; ; ) 8280 { 8281#if 0 8282 (void) FormatLocaleFile(stderr,"mogrify %ld of %ld\n",(long) 8283 GetImageIndexInList(*images),(long)GetImageListLength(*images)); 8284#endif 8285 status&=MogrifyImage(image_info,argc,argv,images,exception); 8286 proceed=SetImageProgress(*images,MogrifyImageTag,(MagickOffsetType) i, n); 8287 if (proceed == MagickFalse) 8288 break; 8289 if ( (*images)->next == (Image *) NULL ) 8290 break; 8291 *images=(*images)->next; 8292 i++; 8293 } 8294 assert( *images != (Image *) NULL ); 8295#if 0 8296 (void) FormatLocaleFile(stderr,"mogrify end %ld of %ld\n",(long) 8297 GetImageIndexInList(*images),(long)GetImageListLength(*images)); 8298#endif 8299 8300 /* 8301 Post-process, multi-image sequence operators 8302 */ 8303 *images=GetFirstImageInList(*images); 8304 if (post != MagickFalse) 8305 status&=MogrifyImageList(image_info,argc,argv,images,exception); 8306 return(status != 0 ? MagickTrue : MagickFalse); 8307} 8308