mogrify.c revision 9b34e30c86419d1be763b1c415cc548d7771d58d
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/string-private.h" 55#include "MagickCore/thread-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=StringToDouble(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++]=StringToDouble(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++]=StringToDouble(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) QueryColorCompliance(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++]=StringToDouble(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++]=StringToDouble(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++]=StringToDouble(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++]=StringToDouble(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++]=StringToDouble(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 double 629 attenuate; 630 631 DrawInfo 632 *draw_info; 633 634 GeometryInfo 635 geometry_info; 636 637 Image 638 *region_image; 639 640 ImageInfo 641 *mogrify_info; 642 643 MagickStatusType 644 status; 645 646 PixelInfo 647 fill; 648 649 MagickStatusType 650 flags; 651 652 PixelInterpolateMethod 653 interpolate_method; 654 655 QuantizeInfo 656 *quantize_info; 657 658 RectangleInfo 659 geometry, 660 region_geometry; 661 662 register ssize_t 663 i; 664 665 /* 666 Initialize method variables. 667 */ 668 assert(image_info != (const ImageInfo *) NULL); 669 assert(image_info->signature == MagickSignature); 670 assert(image != (Image **) NULL); 671 assert((*image)->signature == MagickSignature); 672 if ((*image)->debug != MagickFalse) 673 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename); 674 if (argc < 0) 675 return(MagickTrue); 676 mogrify_info=CloneImageInfo(image_info); 677 draw_info=CloneDrawInfo(mogrify_info,(DrawInfo *) NULL); 678 quantize_info=AcquireQuantizeInfo(mogrify_info); 679 SetGeometryInfo(&geometry_info); 680 GetPixelInfo(*image,&fill); 681 fill=(*image)->background_color; 682 attenuate=1.0; 683 compose=(*image)->compose; 684 interpolate_method=UndefinedInterpolatePixel; 685 channel=mogrify_info->channel; 686 format=GetImageOption(mogrify_info,"format"); 687 SetGeometry(*image,®ion_geometry); 688 region_image=NewImageList(); 689 /* 690 Transmogrify the image. 691 */ 692 for (i=0; i < (ssize_t) argc; i++) 693 { 694 Image 695 *mogrify_image; 696 697 ssize_t 698 count; 699 700 option=argv[i]; 701 if (IsCommandOption(option) == MagickFalse) 702 continue; 703 count=MagickMax(ParseCommandOption(MagickCommandOptions,MagickFalse,option), 704 0L); 705 if ((i+count) >= (ssize_t) argc) 706 break; 707 status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception); 708 mogrify_image=(Image *)NULL; 709 switch (*(option+1)) 710 { 711 case 'a': 712 { 713 if (LocaleCompare("adaptive-blur",option+1) == 0) 714 { 715 /* 716 Adaptive blur image. 717 */ 718 (void) SyncImageSettings(mogrify_info,*image,exception); 719 flags=ParseGeometry(argv[i+1],&geometry_info); 720 if ((flags & SigmaValue) == 0) 721 geometry_info.sigma=1.0; 722 if ((flags & XiValue) == 0) 723 geometry_info.xi=0.0; 724 mogrify_image=AdaptiveBlurImage(*image,geometry_info.rho, 725 geometry_info.sigma,geometry_info.xi,exception); 726 break; 727 } 728 if (LocaleCompare("adaptive-resize",option+1) == 0) 729 { 730 /* 731 Adaptive resize image. 732 */ 733 (void) SyncImageSettings(mogrify_info,*image,exception); 734 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 735 mogrify_image=AdaptiveResizeImage(*image,geometry.width, 736 geometry.height,interpolate_method,exception); 737 break; 738 } 739 if (LocaleCompare("adaptive-sharpen",option+1) == 0) 740 { 741 /* 742 Adaptive sharpen image. 743 */ 744 (void) SyncImageSettings(mogrify_info,*image,exception); 745 flags=ParseGeometry(argv[i+1],&geometry_info); 746 if ((flags & SigmaValue) == 0) 747 geometry_info.sigma=1.0; 748 if ((flags & XiValue) == 0) 749 geometry_info.xi=0.0; 750 mogrify_image=AdaptiveSharpenImage(*image,geometry_info.rho, 751 geometry_info.sigma,geometry_info.xi,exception); 752 break; 753 } 754 if (LocaleCompare("affine",option+1) == 0) 755 { 756 /* 757 Affine matrix. 758 */ 759 if (*option == '+') 760 { 761 GetAffineMatrix(&draw_info->affine); 762 break; 763 } 764 (void) ParseAffineGeometry(argv[i+1],&draw_info->affine,exception); 765 break; 766 } 767 if (LocaleCompare("alpha",option+1) == 0) 768 { 769 AlphaChannelType 770 alpha_type; 771 772 (void) SyncImageSettings(mogrify_info,*image,exception); 773 alpha_type=(AlphaChannelType) ParseCommandOption(MagickAlphaOptions, 774 MagickFalse,argv[i+1]); 775 (void) SetImageAlphaChannel(*image,alpha_type,exception); 776 break; 777 } 778 if (LocaleCompare("annotate",option+1) == 0) 779 { 780 char 781 *text, 782 geometry[MaxTextExtent]; 783 784 /* 785 Annotate image. 786 */ 787 (void) SyncImageSettings(mogrify_info,*image,exception); 788 SetGeometryInfo(&geometry_info); 789 flags=ParseGeometry(argv[i+1],&geometry_info); 790 if ((flags & SigmaValue) == 0) 791 geometry_info.sigma=geometry_info.rho; 792 text=InterpretImageProperties(mogrify_info,*image,argv[i+2], 793 exception); 794 if (text == (char *) NULL) 795 break; 796 (void) CloneString(&draw_info->text,text); 797 text=DestroyString(text); 798 (void) FormatLocaleString(geometry,MaxTextExtent,"%+f%+f", 799 geometry_info.xi,geometry_info.psi); 800 (void) CloneString(&draw_info->geometry,geometry); 801 draw_info->affine.sx=cos(DegreesToRadians( 802 fmod(geometry_info.rho,360.0))); 803 draw_info->affine.rx=sin(DegreesToRadians( 804 fmod(geometry_info.rho,360.0))); 805 draw_info->affine.ry=(-sin(DegreesToRadians( 806 fmod(geometry_info.sigma,360.0)))); 807 draw_info->affine.sy=cos(DegreesToRadians( 808 fmod(geometry_info.sigma,360.0))); 809 (void) AnnotateImage(*image,draw_info,exception); 810 break; 811 } 812 if (LocaleCompare("antialias",option+1) == 0) 813 { 814 draw_info->stroke_antialias=(*option == '-') ? MagickTrue : 815 MagickFalse; 816 draw_info->text_antialias=(*option == '-') ? MagickTrue : 817 MagickFalse; 818 break; 819 } 820 if (LocaleCompare("attenuate",option+1) == 0) 821 { 822 if (*option == '+') 823 { 824 attenuate=1.0; 825 break; 826 } 827 attenuate=StringToDouble(argv[i+1],(char **) NULL); 828 break; 829 } 830 if (LocaleCompare("auto-gamma",option+1) == 0) 831 { 832 /* 833 Auto Adjust Gamma of image based on its mean 834 */ 835 (void) SyncImageSettings(mogrify_info,*image,exception); 836 (void) AutoGammaImage(*image,exception); 837 break; 838 } 839 if (LocaleCompare("auto-level",option+1) == 0) 840 { 841 /* 842 Perfectly Normalize (max/min stretch) the image 843 */ 844 (void) SyncImageSettings(mogrify_info,*image,exception); 845 (void) AutoLevelImage(*image,exception); 846 break; 847 } 848 if (LocaleCompare("auto-orient",option+1) == 0) 849 { 850 (void) SyncImageSettings(mogrify_info,*image,exception); 851 switch ((*image)->orientation) 852 { 853 case TopRightOrientation: 854 { 855 mogrify_image=FlopImage(*image,exception); 856 break; 857 } 858 case BottomRightOrientation: 859 { 860 mogrify_image=RotateImage(*image,180.0,exception); 861 break; 862 } 863 case BottomLeftOrientation: 864 { 865 mogrify_image=FlipImage(*image,exception); 866 break; 867 } 868 case LeftTopOrientation: 869 { 870 mogrify_image=TransposeImage(*image,exception); 871 break; 872 } 873 case RightTopOrientation: 874 { 875 mogrify_image=RotateImage(*image,90.0,exception); 876 break; 877 } 878 case RightBottomOrientation: 879 { 880 mogrify_image=TransverseImage(*image,exception); 881 break; 882 } 883 case LeftBottomOrientation: 884 { 885 mogrify_image=RotateImage(*image,270.0,exception); 886 break; 887 } 888 default: 889 break; 890 } 891 if (mogrify_image != (Image *) NULL) 892 mogrify_image->orientation=TopLeftOrientation; 893 break; 894 } 895 break; 896 } 897 case 'b': 898 { 899 if (LocaleCompare("black-threshold",option+1) == 0) 900 { 901 /* 902 Black threshold image. 903 */ 904 (void) SyncImageSettings(mogrify_info,*image,exception); 905 (void) BlackThresholdImage(*image,argv[i+1],exception); 906 break; 907 } 908 if (LocaleCompare("blue-shift",option+1) == 0) 909 { 910 /* 911 Blue shift image. 912 */ 913 (void) SyncImageSettings(mogrify_info,*image,exception); 914 geometry_info.rho=1.5; 915 if (*option == '-') 916 flags=ParseGeometry(argv[i+1],&geometry_info); 917 mogrify_image=BlueShiftImage(*image,geometry_info.rho,exception); 918 break; 919 } 920 if (LocaleCompare("blur",option+1) == 0) 921 { 922 /* 923 Gaussian blur image. 924 */ 925 (void) SyncImageSettings(mogrify_info,*image,exception); 926 flags=ParseGeometry(argv[i+1],&geometry_info); 927 if ((flags & SigmaValue) == 0) 928 geometry_info.sigma=1.0; 929 if ((flags & XiValue) == 0) 930 geometry_info.xi=0.0; 931 mogrify_image=BlurImage(*image,geometry_info.rho, 932 geometry_info.sigma,geometry_info.xi,exception); 933 break; 934 } 935 if (LocaleCompare("border",option+1) == 0) 936 { 937 /* 938 Surround image with a border of solid color. 939 */ 940 (void) SyncImageSettings(mogrify_info,*image,exception); 941 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 942 if ((flags & SigmaValue) == 0) 943 geometry.height=geometry.width; 944 mogrify_image=BorderImage(*image,&geometry,compose,exception); 945 break; 946 } 947 if (LocaleCompare("bordercolor",option+1) == 0) 948 { 949 if (*option == '+') 950 { 951 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance, 952 &draw_info->border_color,exception); 953 break; 954 } 955 (void) QueryColorCompliance(argv[i+1],AllCompliance, 956 &draw_info->border_color,exception); 957 break; 958 } 959 if (LocaleCompare("box",option+1) == 0) 960 { 961 (void) QueryColorCompliance(argv[i+1],AllCompliance, 962 &draw_info->undercolor,exception); 963 break; 964 } 965 if (LocaleCompare("brightness-contrast",option+1) == 0) 966 { 967 double 968 brightness, 969 contrast; 970 971 GeometryInfo 972 geometry_info; 973 974 MagickStatusType 975 flags; 976 977 /* 978 Brightness / contrast image. 979 */ 980 (void) SyncImageSettings(mogrify_info,*image,exception); 981 flags=ParseGeometry(argv[i+1],&geometry_info); 982 brightness=geometry_info.rho; 983 contrast=0.0; 984 if ((flags & SigmaValue) != 0) 985 contrast=geometry_info.sigma; 986 (void) BrightnessContrastImage(*image,brightness,contrast, 987 exception); 988 break; 989 } 990 break; 991 } 992 case 'c': 993 { 994 if (LocaleCompare("cdl",option+1) == 0) 995 { 996 char 997 *color_correction_collection; 998 999 /* 1000 Color correct with a color decision list. 1001 */ 1002 (void) SyncImageSettings(mogrify_info,*image,exception); 1003 color_correction_collection=FileToString(argv[i+1],~0,exception); 1004 if (color_correction_collection == (char *) NULL) 1005 break; 1006 (void) ColorDecisionListImage(*image,color_correction_collection, 1007 exception); 1008 break; 1009 } 1010 if (LocaleCompare("channel",option+1) == 0) 1011 { 1012 if (*option == '+') 1013 channel=DefaultChannels; 1014 else 1015 channel=(ChannelType) ParseChannelOption(argv[i+1]); 1016 SetPixelChannelMap(*image,channel); 1017 break; 1018 } 1019 if (LocaleCompare("charcoal",option+1) == 0) 1020 { 1021 /* 1022 Charcoal image. 1023 */ 1024 (void) SyncImageSettings(mogrify_info,*image,exception); 1025 flags=ParseGeometry(argv[i+1],&geometry_info); 1026 if ((flags & SigmaValue) == 0) 1027 geometry_info.sigma=1.0; 1028 if ((flags & XiValue) == 0) 1029 geometry_info.xi=1.0; 1030 mogrify_image=CharcoalImage(*image,geometry_info.rho, 1031 geometry_info.sigma,geometry_info.xi,exception); 1032 break; 1033 } 1034 if (LocaleCompare("chop",option+1) == 0) 1035 { 1036 /* 1037 Chop the image. 1038 */ 1039 (void) SyncImageSettings(mogrify_info,*image,exception); 1040 (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception); 1041 mogrify_image=ChopImage(*image,&geometry,exception); 1042 break; 1043 } 1044 if (LocaleCompare("clamp",option+1) == 0) 1045 { 1046 /* 1047 Clamp image. 1048 */ 1049 (void) SyncImageSettings(mogrify_info,*image,exception); 1050 (void) ClampImage(*image,exception); 1051 break; 1052 } 1053 if (LocaleCompare("clip",option+1) == 0) 1054 { 1055 (void) SyncImageSettings(mogrify_info,*image,exception); 1056 if (*option == '+') 1057 { 1058 (void) SetImageClipMask(*image,(Image *) NULL,exception); 1059 break; 1060 } 1061 (void) ClipImage(*image,exception); 1062 break; 1063 } 1064 if (LocaleCompare("clip-mask",option+1) == 0) 1065 { 1066 CacheView 1067 *mask_view; 1068 1069 Image 1070 *mask_image; 1071 1072 register Quantum 1073 *restrict q; 1074 1075 register ssize_t 1076 x; 1077 1078 ssize_t 1079 y; 1080 1081 (void) SyncImageSettings(mogrify_info,*image,exception); 1082 if (*option == '+') 1083 { 1084 /* 1085 Remove a mask. 1086 */ 1087 (void) SetImageMask(*image,(Image *) NULL,exception); 1088 break; 1089 } 1090 /* 1091 Set the image mask. 1092 FUTURE: This Should Be a SetImageAlphaChannel() call, Or two. 1093 */ 1094 mask_image=GetImageCache(mogrify_info,argv[i+1],exception); 1095 if (mask_image == (Image *) NULL) 1096 break; 1097 if (SetImageStorageClass(mask_image,DirectClass,exception) == MagickFalse) 1098 return(MagickFalse); 1099 mask_view=AcquireCacheView(mask_image); 1100 for (y=0; y < (ssize_t) mask_image->rows; y++) 1101 { 1102 q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1, 1103 exception); 1104 if (q == (Quantum *) NULL) 1105 break; 1106 for (x=0; x < (ssize_t) mask_image->columns; x++) 1107 { 1108 if (mask_image->matte == MagickFalse) 1109 SetPixelAlpha(mask_image,GetPixelIntensity(mask_image,q),q); 1110 SetPixelRed(mask_image,GetPixelAlpha(mask_image,q),q); 1111 SetPixelGreen(mask_image,GetPixelAlpha(mask_image,q),q); 1112 SetPixelBlue(mask_image,GetPixelAlpha(mask_image,q),q); 1113 q+=GetPixelChannels(mask_image); 1114 } 1115 if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse) 1116 break; 1117 } 1118 mask_view=DestroyCacheView(mask_view); 1119 mask_image->matte=MagickTrue; 1120 (void) SetImageClipMask(*image,mask_image,exception); 1121 break; 1122 } 1123 if (LocaleCompare("clip-path",option+1) == 0) 1124 { 1125 (void) SyncImageSettings(mogrify_info,*image,exception); 1126 (void) ClipImagePath(*image,argv[i+1],*option == '-' ? MagickTrue : 1127 MagickFalse,exception); 1128 break; 1129 } 1130 if (LocaleCompare("colorize",option+1) == 0) 1131 { 1132 /* 1133 Colorize the image. 1134 */ 1135 (void) SyncImageSettings(mogrify_info,*image,exception); 1136 mogrify_image=ColorizeImage(*image,argv[i+1],&fill,exception); 1137 break; 1138 } 1139 if (LocaleCompare("color-matrix",option+1) == 0) 1140 { 1141 KernelInfo 1142 *kernel; 1143 1144 (void) SyncImageSettings(mogrify_info,*image,exception); 1145 kernel=AcquireKernelInfo(argv[i+1]); 1146 if (kernel == (KernelInfo *) NULL) 1147 break; 1148 mogrify_image=ColorMatrixImage(*image,kernel,exception); 1149 kernel=DestroyKernelInfo(kernel); 1150 break; 1151 } 1152 if (LocaleCompare("colors",option+1) == 0) 1153 { 1154 /* 1155 Reduce the number of colors in the image. 1156 */ 1157 (void) SyncImageSettings(mogrify_info,*image,exception); 1158 quantize_info->number_colors=StringToUnsignedLong(argv[i+1]); 1159 if (quantize_info->number_colors == 0) 1160 break; 1161 if (((*image)->storage_class == DirectClass) || 1162 (*image)->colors > quantize_info->number_colors) 1163 (void) QuantizeImage(quantize_info,*image,exception); 1164 else 1165 (void) CompressImageColormap(*image,exception); 1166 break; 1167 } 1168 if (LocaleCompare("colorspace",option+1) == 0) 1169 { 1170 ColorspaceType 1171 colorspace; 1172 1173 (void) SyncImageSettings(mogrify_info,*image,exception); 1174 if (*option == '+') 1175 { 1176 (void) TransformImageColorspace(*image,RGBColorspace,exception); 1177 break; 1178 } 1179 colorspace=(ColorspaceType) ParseCommandOption( 1180 MagickColorspaceOptions,MagickFalse,argv[i+1]); 1181 (void) TransformImageColorspace(*image,colorspace,exception); 1182 break; 1183 } 1184 if (LocaleCompare("compose",option+1) == 0) 1185 { 1186 (void) SyncImageSettings(mogrify_info,*image,exception); 1187 compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions, 1188 MagickFalse,argv[i+1]); 1189 break; 1190 } 1191 if (LocaleCompare("contrast",option+1) == 0) 1192 { 1193 (void) SyncImageSettings(mogrify_info,*image,exception); 1194 (void) ContrastImage(*image,(*option == '-') ? MagickTrue : 1195 MagickFalse,exception); 1196 break; 1197 } 1198 if (LocaleCompare("contrast-stretch",option+1) == 0) 1199 { 1200 double 1201 black_point, 1202 white_point; 1203 1204 MagickStatusType 1205 flags; 1206 1207 /* 1208 Contrast stretch image. 1209 */ 1210 (void) SyncImageSettings(mogrify_info,*image,exception); 1211 flags=ParseGeometry(argv[i+1],&geometry_info); 1212 black_point=geometry_info.rho; 1213 white_point=(flags & SigmaValue) != 0 ? geometry_info.sigma : 1214 black_point; 1215 if ((flags & PercentValue) != 0) 1216 { 1217 black_point*=(double) (*image)->columns*(*image)->rows/100.0; 1218 white_point*=(double) (*image)->columns*(*image)->rows/100.0; 1219 } 1220 white_point=(MagickRealType) (*image)->columns*(*image)->rows- 1221 white_point; 1222 (void) ContrastStretchImage(*image,black_point,white_point, 1223 exception); 1224 break; 1225 } 1226 if (LocaleCompare("convolve",option+1) == 0) 1227 { 1228 KernelInfo 1229 *kernel_info; 1230 1231 (void) SyncImageSettings(mogrify_info,*image,exception); 1232 kernel_info=AcquireKernelInfo(argv[i+1]); 1233 if (kernel_info == (KernelInfo *) NULL) 1234 break; 1235 kernel_info->bias=(*image)->bias; 1236 mogrify_image=ConvolveImage(*image,kernel_info,exception); 1237 kernel_info=DestroyKernelInfo(kernel_info); 1238 break; 1239 } 1240 if (LocaleCompare("crop",option+1) == 0) 1241 { 1242 /* 1243 Crop a image to a smaller size 1244 */ 1245 (void) SyncImageSettings(mogrify_info,*image,exception); 1246 mogrify_image=CropImageToTiles(*image,argv[i+1],exception); 1247 break; 1248 } 1249 if (LocaleCompare("cycle",option+1) == 0) 1250 { 1251 /* 1252 Cycle an image colormap. 1253 */ 1254 (void) SyncImageSettings(mogrify_info,*image,exception); 1255 (void) CycleColormapImage(*image,(ssize_t) StringToLong(argv[i+1]), 1256 exception); 1257 break; 1258 } 1259 break; 1260 } 1261 case 'd': 1262 { 1263 if (LocaleCompare("decipher",option+1) == 0) 1264 { 1265 StringInfo 1266 *passkey; 1267 1268 /* 1269 Decipher pixels. 1270 */ 1271 (void) SyncImageSettings(mogrify_info,*image,exception); 1272 passkey=FileToStringInfo(argv[i+1],~0,exception); 1273 if (passkey != (StringInfo *) NULL) 1274 { 1275 (void) PasskeyDecipherImage(*image,passkey,exception); 1276 passkey=DestroyStringInfo(passkey); 1277 } 1278 break; 1279 } 1280 if (LocaleCompare("density",option+1) == 0) 1281 { 1282 /* 1283 Set image density. 1284 */ 1285 (void) CloneString(&draw_info->density,argv[i+1]); 1286 break; 1287 } 1288 if (LocaleCompare("depth",option+1) == 0) 1289 { 1290 (void) SyncImageSettings(mogrify_info,*image,exception); 1291 if (*option == '+') 1292 { 1293 (void) SetImageDepth(*image,MAGICKCORE_QUANTUM_DEPTH,exception); 1294 break; 1295 } 1296 (void) SetImageDepth(*image,StringToUnsignedLong(argv[i+1]), 1297 exception); 1298 break; 1299 } 1300 if (LocaleCompare("deskew",option+1) == 0) 1301 { 1302 double 1303 threshold; 1304 1305 /* 1306 Straighten the image. 1307 */ 1308 (void) SyncImageSettings(mogrify_info,*image,exception); 1309 if (*option == '+') 1310 threshold=40.0*QuantumRange/100.0; 1311 else 1312 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+ 1313 1.0); 1314 mogrify_image=DeskewImage(*image,threshold,exception); 1315 break; 1316 } 1317 if (LocaleCompare("despeckle",option+1) == 0) 1318 { 1319 /* 1320 Reduce the speckles within an image. 1321 */ 1322 (void) SyncImageSettings(mogrify_info,*image,exception); 1323 mogrify_image=DespeckleImage(*image,exception); 1324 break; 1325 } 1326 if (LocaleCompare("display",option+1) == 0) 1327 { 1328 (void) CloneString(&draw_info->server_name,argv[i+1]); 1329 break; 1330 } 1331 if (LocaleCompare("distort",option+1) == 0) 1332 { 1333 char 1334 *args, 1335 token[MaxTextExtent]; 1336 1337 const char 1338 *p; 1339 1340 DistortImageMethod 1341 method; 1342 1343 double 1344 *arguments; 1345 1346 register ssize_t 1347 x; 1348 1349 size_t 1350 number_arguments; 1351 1352 /* 1353 Distort image. 1354 */ 1355 (void) SyncImageSettings(mogrify_info,*image,exception); 1356 method=(DistortImageMethod) ParseCommandOption(MagickDistortOptions, 1357 MagickFalse,argv[i+1]); 1358 if ( method == ResizeDistortion ) 1359 { 1360 /* Special Case - Argument is actually a resize geometry! 1361 ** Convert that to an appropriate distortion argument array. 1362 */ 1363 double 1364 resize_args[2]; 1365 (void) ParseRegionGeometry(*image,argv[i+2],&geometry, 1366 exception); 1367 resize_args[0]=(double)geometry.width; 1368 resize_args[1]=(double)geometry.height; 1369 mogrify_image=DistortImage(*image,method,(size_t)2, 1370 resize_args,MagickTrue,exception); 1371 break; 1372 } 1373 args=InterpretImageProperties(mogrify_info,*image,argv[i+2], 1374 exception); 1375 if (args == (char *) NULL) 1376 break; 1377 p=(char *) args; 1378 for (x=0; *p != '\0'; x++) 1379 { 1380 GetMagickToken(p,&p,token); 1381 if (*token == ',') 1382 GetMagickToken(p,&p,token); 1383 } 1384 number_arguments=(size_t) x; 1385 arguments=(double *) AcquireQuantumMemory(number_arguments, 1386 sizeof(*arguments)); 1387 if (arguments == (double *) NULL) 1388 ThrowWandFatalException(ResourceLimitFatalError, 1389 "MemoryAllocationFailed",(*image)->filename); 1390 (void) ResetMagickMemory(arguments,0,number_arguments* 1391 sizeof(*arguments)); 1392 p=(char *) args; 1393 for (x=0; (x < (ssize_t) number_arguments) && (*p != '\0'); x++) 1394 { 1395 GetMagickToken(p,&p,token); 1396 if (*token == ',') 1397 GetMagickToken(p,&p,token); 1398 arguments[x]=StringToDouble(token,(char **) NULL); 1399 } 1400 args=DestroyString(args); 1401 mogrify_image=DistortImage(*image,method,number_arguments,arguments, 1402 (*option == '+') ? MagickTrue : MagickFalse,exception); 1403 arguments=(double *) RelinquishMagickMemory(arguments); 1404 break; 1405 } 1406 if (LocaleCompare("dither",option+1) == 0) 1407 { 1408 if (*option == '+') 1409 { 1410 quantize_info->dither=MagickFalse; 1411 break; 1412 } 1413 quantize_info->dither=MagickTrue; 1414 quantize_info->dither_method=(DitherMethod) ParseCommandOption( 1415 MagickDitherOptions,MagickFalse,argv[i+1]); 1416 if (quantize_info->dither_method == NoDitherMethod) 1417 quantize_info->dither=MagickFalse; 1418 break; 1419 } 1420 if (LocaleCompare("draw",option+1) == 0) 1421 { 1422 /* 1423 Draw image. 1424 */ 1425 (void) SyncImageSettings(mogrify_info,*image,exception); 1426 (void) CloneString(&draw_info->primitive,argv[i+1]); 1427 (void) DrawImage(*image,draw_info,exception); 1428 break; 1429 } 1430 break; 1431 } 1432 case 'e': 1433 { 1434 if (LocaleCompare("edge",option+1) == 0) 1435 { 1436 /* 1437 Enhance edges in the image. 1438 */ 1439 (void) SyncImageSettings(mogrify_info,*image,exception); 1440 flags=ParseGeometry(argv[i+1],&geometry_info); 1441 if ((flags & SigmaValue) == 0) 1442 geometry_info.sigma=1.0; 1443 mogrify_image=EdgeImage(*image,geometry_info.rho, 1444 geometry_info.sigma,exception); 1445 break; 1446 } 1447 if (LocaleCompare("emboss",option+1) == 0) 1448 { 1449 /* 1450 Gaussian embossen image. 1451 */ 1452 (void) SyncImageSettings(mogrify_info,*image,exception); 1453 flags=ParseGeometry(argv[i+1],&geometry_info); 1454 if ((flags & SigmaValue) == 0) 1455 geometry_info.sigma=1.0; 1456 mogrify_image=EmbossImage(*image,geometry_info.rho, 1457 geometry_info.sigma,exception); 1458 break; 1459 } 1460 if (LocaleCompare("encipher",option+1) == 0) 1461 { 1462 StringInfo 1463 *passkey; 1464 1465 /* 1466 Encipher pixels. 1467 */ 1468 (void) SyncImageSettings(mogrify_info,*image,exception); 1469 passkey=FileToStringInfo(argv[i+1],~0,exception); 1470 if (passkey != (StringInfo *) NULL) 1471 { 1472 (void) PasskeyEncipherImage(*image,passkey,exception); 1473 passkey=DestroyStringInfo(passkey); 1474 } 1475 break; 1476 } 1477 if (LocaleCompare("encoding",option+1) == 0) 1478 { 1479 (void) CloneString(&draw_info->encoding,argv[i+1]); 1480 break; 1481 } 1482 if (LocaleCompare("enhance",option+1) == 0) 1483 { 1484 /* 1485 Enhance image. 1486 */ 1487 (void) SyncImageSettings(mogrify_info,*image,exception); 1488 mogrify_image=EnhanceImage(*image,exception); 1489 break; 1490 } 1491 if (LocaleCompare("equalize",option+1) == 0) 1492 { 1493 /* 1494 Equalize image. 1495 */ 1496 (void) SyncImageSettings(mogrify_info,*image,exception); 1497 (void) EqualizeImage(*image,exception); 1498 break; 1499 } 1500 if (LocaleCompare("evaluate",option+1) == 0) 1501 { 1502 double 1503 constant; 1504 1505 MagickEvaluateOperator 1506 op; 1507 1508 (void) SyncImageSettings(mogrify_info,*image,exception); 1509 op=(MagickEvaluateOperator) ParseCommandOption( 1510 MagickEvaluateOptions,MagickFalse,argv[i+1]); 1511 constant=StringToDoubleInterval(argv[i+2],(double) QuantumRange+ 1512 1.0); 1513 (void) EvaluateImage(*image,op,constant,exception); 1514 break; 1515 } 1516 if (LocaleCompare("extent",option+1) == 0) 1517 { 1518 /* 1519 Set the image extent. 1520 */ 1521 (void) SyncImageSettings(mogrify_info,*image,exception); 1522 flags=ParseGravityGeometry(*image,argv[i+1],&geometry,exception); 1523 if (geometry.width == 0) 1524 geometry.width=(*image)->columns; 1525 if (geometry.height == 0) 1526 geometry.height=(*image)->rows; 1527 mogrify_image=ExtentImage(*image,&geometry,exception); 1528 break; 1529 } 1530 break; 1531 } 1532 case 'f': 1533 { 1534 if (LocaleCompare("family",option+1) == 0) 1535 { 1536 if (*option == '+') 1537 { 1538 if (draw_info->family != (char *) NULL) 1539 draw_info->family=DestroyString(draw_info->family); 1540 break; 1541 } 1542 (void) CloneString(&draw_info->family,argv[i+1]); 1543 break; 1544 } 1545 if (LocaleCompare("features",option+1) == 0) 1546 { 1547 if (*option == '+') 1548 { 1549 (void) DeleteImageArtifact(*image,"identify:features"); 1550 break; 1551 } 1552 (void) SetImageArtifact(*image,"identify:features",argv[i+1]); 1553 break; 1554 } 1555 if (LocaleCompare("fill",option+1) == 0) 1556 { 1557 ExceptionInfo 1558 *sans; 1559 1560 GetPixelInfo(*image,&fill); 1561 if (*option == '+') 1562 { 1563 (void) QueryColorCompliance("none",AllCompliance,&fill, 1564 exception); 1565 (void) QueryColorCompliance("none",AllCompliance, 1566 &draw_info->fill,exception); 1567 if (draw_info->fill_pattern != (Image *) NULL) 1568 draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern); 1569 break; 1570 } 1571 sans=AcquireExceptionInfo(); 1572 (void) QueryColorCompliance(argv[i+1],AllCompliance,&fill, 1573 sans); 1574 status=QueryColorCompliance(argv[i+1],AllCompliance, 1575 &draw_info->fill,sans); 1576 sans=DestroyExceptionInfo(sans); 1577 if (status == MagickFalse) 1578 draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1], 1579 exception); 1580 break; 1581 } 1582 if (LocaleCompare("flip",option+1) == 0) 1583 { 1584 /* 1585 Flip image scanlines. 1586 */ 1587 (void) SyncImageSettings(mogrify_info,*image,exception); 1588 mogrify_image=FlipImage(*image,exception); 1589 break; 1590 } 1591 if (LocaleCompare("floodfill",option+1) == 0) 1592 { 1593 PixelInfo 1594 target; 1595 1596 /* 1597 Floodfill image. 1598 */ 1599 (void) SyncImageSettings(mogrify_info,*image,exception); 1600 (void) ParsePageGeometry(*image,argv[i+1],&geometry,exception); 1601 (void) QueryColorCompliance(argv[i+2],AllCompliance,&target, 1602 exception); 1603 (void) FloodfillPaintImage(*image,draw_info,&target,geometry.x, 1604 geometry.y,*option == '-' ? MagickFalse : MagickTrue,exception); 1605 break; 1606 } 1607 if (LocaleCompare("flop",option+1) == 0) 1608 { 1609 /* 1610 Flop image scanlines. 1611 */ 1612 (void) SyncImageSettings(mogrify_info,*image,exception); 1613 mogrify_image=FlopImage(*image,exception); 1614 break; 1615 } 1616 if (LocaleCompare("font",option+1) == 0) 1617 { 1618 if (*option == '+') 1619 { 1620 if (draw_info->font != (char *) NULL) 1621 draw_info->font=DestroyString(draw_info->font); 1622 break; 1623 } 1624 (void) CloneString(&draw_info->font,argv[i+1]); 1625 break; 1626 } 1627 if (LocaleCompare("format",option+1) == 0) 1628 { 1629 format=argv[i+1]; 1630 break; 1631 } 1632 if (LocaleCompare("frame",option+1) == 0) 1633 { 1634 FrameInfo 1635 frame_info; 1636 1637 /* 1638 Surround image with an ornamental border. 1639 */ 1640 (void) SyncImageSettings(mogrify_info,*image,exception); 1641 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 1642 frame_info.width=geometry.width; 1643 frame_info.height=geometry.height; 1644 if ((flags & HeightValue) == 0) 1645 frame_info.height=geometry.width; 1646 frame_info.outer_bevel=geometry.x; 1647 frame_info.inner_bevel=geometry.y; 1648 frame_info.x=(ssize_t) frame_info.width; 1649 frame_info.y=(ssize_t) frame_info.height; 1650 frame_info.width=(*image)->columns+2*frame_info.width; 1651 frame_info.height=(*image)->rows+2*frame_info.height; 1652 mogrify_image=FrameImage(*image,&frame_info,compose,exception); 1653 break; 1654 } 1655 if (LocaleCompare("function",option+1) == 0) 1656 { 1657 char 1658 *arguments, 1659 token[MaxTextExtent]; 1660 1661 const char 1662 *p; 1663 1664 double 1665 *parameters; 1666 1667 MagickFunction 1668 function; 1669 1670 register ssize_t 1671 x; 1672 1673 size_t 1674 number_parameters; 1675 1676 /* 1677 Function Modify Image Values 1678 */ 1679 (void) SyncImageSettings(mogrify_info,*image,exception); 1680 function=(MagickFunction) ParseCommandOption(MagickFunctionOptions, 1681 MagickFalse,argv[i+1]); 1682 arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2], 1683 exception); 1684 if (arguments == (char *) NULL) 1685 break; 1686 p=(char *) arguments; 1687 for (x=0; *p != '\0'; x++) 1688 { 1689 GetMagickToken(p,&p,token); 1690 if (*token == ',') 1691 GetMagickToken(p,&p,token); 1692 } 1693 number_parameters=(size_t) x; 1694 parameters=(double *) AcquireQuantumMemory(number_parameters, 1695 sizeof(*parameters)); 1696 if (parameters == (double *) NULL) 1697 ThrowWandFatalException(ResourceLimitFatalError, 1698 "MemoryAllocationFailed",(*image)->filename); 1699 (void) ResetMagickMemory(parameters,0,number_parameters* 1700 sizeof(*parameters)); 1701 p=(char *) arguments; 1702 for (x=0; (x < (ssize_t) number_parameters) && (*p != '\0'); x++) 1703 { 1704 GetMagickToken(p,&p,token); 1705 if (*token == ',') 1706 GetMagickToken(p,&p,token); 1707 parameters[x]=StringToDouble(token,(char **) NULL); 1708 } 1709 arguments=DestroyString(arguments); 1710 (void) FunctionImage(*image,function,number_parameters,parameters, 1711 exception); 1712 parameters=(double *) RelinquishMagickMemory(parameters); 1713 break; 1714 } 1715 break; 1716 } 1717 case 'g': 1718 { 1719 if (LocaleCompare("gamma",option+1) == 0) 1720 { 1721 /* 1722 Gamma image. 1723 */ 1724 (void) SyncImageSettings(mogrify_info,*image,exception); 1725 if (*option == '+') 1726 (*image)->gamma=StringToDouble(argv[i+1],(char **) NULL); 1727 else 1728 (void) GammaImage(*image,StringToDouble(argv[i+1], 1729 (char **) NULL),exception); 1730 break; 1731 } 1732 if ((LocaleCompare("gaussian-blur",option+1) == 0) || 1733 (LocaleCompare("gaussian",option+1) == 0)) 1734 { 1735 /* 1736 Gaussian blur image. 1737 */ 1738 (void) SyncImageSettings(mogrify_info,*image,exception); 1739 flags=ParseGeometry(argv[i+1],&geometry_info); 1740 if ((flags & SigmaValue) == 0) 1741 geometry_info.sigma=1.0; 1742 if ((flags & XiValue) == 0) 1743 geometry_info.xi=0.0; 1744 mogrify_image=GaussianBlurImage(*image,geometry_info.rho, 1745 geometry_info.sigma,geometry_info.xi,exception); 1746 break; 1747 } 1748 if (LocaleCompare("geometry",option+1) == 0) 1749 { 1750 /* 1751 Record Image offset, Resize last image. 1752 */ 1753 (void) SyncImageSettings(mogrify_info,*image,exception); 1754 if (*option == '+') 1755 { 1756 if ((*image)->geometry != (char *) NULL) 1757 (*image)->geometry=DestroyString((*image)->geometry); 1758 break; 1759 } 1760 flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 1761 if (((flags & XValue) != 0) || ((flags & YValue) != 0)) 1762 (void) CloneString(&(*image)->geometry,argv[i+1]); 1763 else 1764 mogrify_image=ResizeImage(*image,geometry.width,geometry.height, 1765 (*image)->filter,(*image)->blur,exception); 1766 break; 1767 } 1768 if (LocaleCompare("gravity",option+1) == 0) 1769 { 1770 if (*option == '+') 1771 { 1772 draw_info->gravity=UndefinedGravity; 1773 break; 1774 } 1775 draw_info->gravity=(GravityType) ParseCommandOption( 1776 MagickGravityOptions,MagickFalse,argv[i+1]); 1777 break; 1778 } 1779 break; 1780 } 1781 case 'h': 1782 { 1783 if (LocaleCompare("highlight-color",option+1) == 0) 1784 { 1785 (void) SetImageArtifact(*image,option+1,argv[i+1]); 1786 break; 1787 } 1788 break; 1789 } 1790 case 'i': 1791 { 1792 if (LocaleCompare("identify",option+1) == 0) 1793 { 1794 char 1795 *text; 1796 1797 (void) SyncImageSettings(mogrify_info,*image,exception); 1798 if (format == (char *) NULL) 1799 { 1800 (void) IdentifyImage(*image,stdout,mogrify_info->verbose, 1801 exception); 1802 break; 1803 } 1804 text=InterpretImageProperties(mogrify_info,*image,format, 1805 exception); 1806 if (text == (char *) NULL) 1807 break; 1808 (void) fputs(text,stdout); 1809 (void) fputc('\n',stdout); 1810 text=DestroyString(text); 1811 break; 1812 } 1813 if (LocaleCompare("implode",option+1) == 0) 1814 { 1815 /* 1816 Implode image. 1817 */ 1818 (void) SyncImageSettings(mogrify_info,*image,exception); 1819 (void) ParseGeometry(argv[i+1],&geometry_info); 1820 mogrify_image=ImplodeImage(*image,geometry_info.rho, 1821 interpolate_method,exception); 1822 break; 1823 } 1824 if (LocaleCompare("interline-spacing",option+1) == 0) 1825 { 1826 if (*option == '+') 1827 (void) ParseGeometry("0",&geometry_info); 1828 else 1829 (void) ParseGeometry(argv[i+1],&geometry_info); 1830 draw_info->interline_spacing=geometry_info.rho; 1831 break; 1832 } 1833 if (LocaleCompare("interpolate",option+1) == 0) 1834 { 1835 interpolate_method=(PixelInterpolateMethod) ParseCommandOption( 1836 MagickInterpolateOptions,MagickFalse,argv[i+1]); 1837 break; 1838 } 1839 if (LocaleCompare("interword-spacing",option+1) == 0) 1840 { 1841 if (*option == '+') 1842 (void) ParseGeometry("0",&geometry_info); 1843 else 1844 (void) ParseGeometry(argv[i+1],&geometry_info); 1845 draw_info->interword_spacing=geometry_info.rho; 1846 break; 1847 } 1848 break; 1849 } 1850 case 'k': 1851 { 1852 if (LocaleCompare("kerning",option+1) == 0) 1853 { 1854 if (*option == '+') 1855 (void) ParseGeometry("0",&geometry_info); 1856 else 1857 (void) ParseGeometry(argv[i+1],&geometry_info); 1858 draw_info->kerning=geometry_info.rho; 1859 break; 1860 } 1861 break; 1862 } 1863 case 'l': 1864 { 1865 if (LocaleCompare("lat",option+1) == 0) 1866 { 1867 /* 1868 Local adaptive threshold image. 1869 */ 1870 (void) SyncImageSettings(mogrify_info,*image,exception); 1871 flags=ParseGeometry(argv[i+1],&geometry_info); 1872 if ((flags & PercentValue) != 0) 1873 geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0; 1874 mogrify_image=AdaptiveThresholdImage(*image,(size_t) 1875 geometry_info.rho,(size_t) geometry_info.sigma,(double) 1876 geometry_info.xi,exception); 1877 break; 1878 } 1879 if (LocaleCompare("level",option+1) == 0) 1880 { 1881 MagickRealType 1882 black_point, 1883 gamma, 1884 white_point; 1885 1886 MagickStatusType 1887 flags; 1888 1889 /* 1890 Parse levels. 1891 */ 1892 (void) SyncImageSettings(mogrify_info,*image,exception); 1893 flags=ParseGeometry(argv[i+1],&geometry_info); 1894 black_point=geometry_info.rho; 1895 white_point=(MagickRealType) QuantumRange; 1896 if ((flags & SigmaValue) != 0) 1897 white_point=geometry_info.sigma; 1898 gamma=1.0; 1899 if ((flags & XiValue) != 0) 1900 gamma=geometry_info.xi; 1901 if ((flags & PercentValue) != 0) 1902 { 1903 black_point*=(MagickRealType) (QuantumRange/100.0); 1904 white_point*=(MagickRealType) (QuantumRange/100.0); 1905 } 1906 if ((flags & SigmaValue) == 0) 1907 white_point=(MagickRealType) QuantumRange-black_point; 1908 if ((*option == '+') || ((flags & AspectValue) != 0)) 1909 (void) LevelizeImage(*image,black_point,white_point,gamma, 1910 exception); 1911 else 1912 (void) LevelImage(*image,black_point,white_point,gamma, 1913 exception); 1914 break; 1915 } 1916 if (LocaleCompare("level-colors",option+1) == 0) 1917 { 1918 char 1919 token[MaxTextExtent]; 1920 1921 const char 1922 *p; 1923 1924 PixelInfo 1925 black_point, 1926 white_point; 1927 1928 p=(const char *) argv[i+1]; 1929 GetMagickToken(p,&p,token); /* get black point color */ 1930 if ((isalpha((int) *token) != 0) || ((*token == '#') != 0)) 1931 (void) QueryColorCompliance(token,AllCompliance, 1932 &black_point,exception); 1933 else 1934 (void) QueryColorCompliance("#000000",AllCompliance, 1935 &black_point,exception); 1936 if (isalpha((int) token[0]) || (token[0] == '#')) 1937 GetMagickToken(p,&p,token); 1938 if (*token == '\0') 1939 white_point=black_point; /* set everything to that color */ 1940 else 1941 { 1942 if ((isalpha((int) *token) == 0) && ((*token == '#') == 0)) 1943 GetMagickToken(p,&p,token); /* Get white point color. */ 1944 if ((isalpha((int) *token) != 0) || ((*token == '#') != 0)) 1945 (void) QueryColorCompliance(token,AllCompliance, 1946 &white_point,exception); 1947 else 1948 (void) QueryColorCompliance("#ffffff",AllCompliance, 1949 &white_point,exception); 1950 } 1951 (void) LevelImageColors(*image,&black_point,&white_point, 1952 *option == '+' ? MagickTrue : MagickFalse,exception); 1953 break; 1954 } 1955 if (LocaleCompare("linear-stretch",option+1) == 0) 1956 { 1957 double 1958 black_point, 1959 white_point; 1960 1961 MagickStatusType 1962 flags; 1963 1964 (void) SyncImageSettings(mogrify_info,*image,exception); 1965 flags=ParseGeometry(argv[i+1],&geometry_info); 1966 black_point=geometry_info.rho; 1967 white_point=(MagickRealType) (*image)->columns*(*image)->rows; 1968 if ((flags & SigmaValue) != 0) 1969 white_point=geometry_info.sigma; 1970 if ((flags & PercentValue) != 0) 1971 { 1972 black_point*=(double) (*image)->columns*(*image)->rows/100.0; 1973 white_point*=(double) (*image)->columns*(*image)->rows/100.0; 1974 } 1975 if ((flags & SigmaValue) == 0) 1976 white_point=(MagickRealType) (*image)->columns*(*image)->rows- 1977 black_point; 1978 (void) LinearStretchImage(*image,black_point,white_point,exception); 1979 break; 1980 } 1981 if (LocaleCompare("linewidth",option+1) == 0) 1982 { 1983 draw_info->stroke_width=StringToDouble(argv[i+1],(char **) NULL); 1984 break; 1985 } 1986 if (LocaleCompare("liquid-rescale",option+1) == 0) 1987 { 1988 /* 1989 Liquid rescale image. 1990 */ 1991 (void) SyncImageSettings(mogrify_info,*image,exception); 1992 flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 1993 if ((flags & XValue) == 0) 1994 geometry.x=1; 1995 if ((flags & YValue) == 0) 1996 geometry.y=0; 1997 mogrify_image=LiquidRescaleImage(*image,geometry.width, 1998 geometry.height,1.0*geometry.x,1.0*geometry.y,exception); 1999 break; 2000 } 2001 if (LocaleCompare("lowlight-color",option+1) == 0) 2002 { 2003 (void) SetImageArtifact(*image,option+1,argv[i+1]); 2004 break; 2005 } 2006 break; 2007 } 2008 case 'm': 2009 { 2010 if (LocaleCompare("map",option+1) == 0) 2011 { 2012 Image 2013 *remap_image; 2014 2015 /* 2016 Transform image colors to match this set of colors. 2017 */ 2018 (void) SyncImageSettings(mogrify_info,*image,exception); 2019 if (*option == '+') 2020 break; 2021 remap_image=GetImageCache(mogrify_info,argv[i+1],exception); 2022 if (remap_image == (Image *) NULL) 2023 break; 2024 (void) RemapImage(quantize_info,*image,remap_image,exception); 2025 remap_image=DestroyImage(remap_image); 2026 break; 2027 } 2028 if (LocaleCompare("mask",option+1) == 0) 2029 { 2030 Image 2031 *mask; 2032 2033 (void) SyncImageSettings(mogrify_info,*image,exception); 2034 if (*option == '+') 2035 { 2036 /* 2037 Remove a mask. 2038 */ 2039 (void) SetImageMask(*image,(Image *) NULL,exception); 2040 break; 2041 } 2042 /* 2043 Set the image mask. 2044 */ 2045 mask=GetImageCache(mogrify_info,argv[i+1],exception); 2046 if (mask == (Image *) NULL) 2047 break; 2048 (void) SetImageMask(*image,mask,exception); 2049 mask=DestroyImage(mask); 2050 break; 2051 } 2052 if (LocaleCompare("matte",option+1) == 0) 2053 { 2054 (void) SetImageAlphaChannel(*image,(*option == '-') ? 2055 SetAlphaChannel : DeactivateAlphaChannel,exception); 2056 break; 2057 } 2058 if (LocaleCompare("median",option+1) == 0) 2059 { 2060 /* 2061 Median filter image. 2062 */ 2063 (void) SyncImageSettings(mogrify_info,*image,exception); 2064 flags=ParseGeometry(argv[i+1],&geometry_info); 2065 if ((flags & SigmaValue) == 0) 2066 geometry_info.sigma=geometry_info.rho; 2067 mogrify_image=StatisticImage(*image,MedianStatistic,(size_t) 2068 geometry_info.rho,(size_t) geometry_info.sigma,exception); 2069 break; 2070 } 2071 if (LocaleCompare("mode",option+1) == 0) 2072 { 2073 /* 2074 Mode image. 2075 */ 2076 (void) SyncImageSettings(mogrify_info,*image,exception); 2077 flags=ParseGeometry(argv[i+1],&geometry_info); 2078 if ((flags & SigmaValue) == 0) 2079 geometry_info.sigma=geometry_info.rho; 2080 mogrify_image=StatisticImage(*image,ModeStatistic,(size_t) 2081 geometry_info.rho,(size_t) geometry_info.sigma,exception); 2082 break; 2083 } 2084 if (LocaleCompare("modulate",option+1) == 0) 2085 { 2086 (void) SyncImageSettings(mogrify_info,*image,exception); 2087 (void) ModulateImage(*image,argv[i+1],exception); 2088 break; 2089 } 2090 if (LocaleCompare("monitor",option+1) == 0) 2091 { 2092 if (*option == '+') 2093 { 2094 (void) SetImageProgressMonitor(*image, 2095 (MagickProgressMonitor) NULL,(void *) NULL); 2096 break; 2097 } 2098 (void) SetImageProgressMonitor(*image,MonitorProgress, 2099 (void *) NULL); 2100 break; 2101 } 2102 if (LocaleCompare("monochrome",option+1) == 0) 2103 { 2104 (void) SyncImageSettings(mogrify_info,*image,exception); 2105 (void) SetImageType(*image,BilevelType,exception); 2106 break; 2107 } 2108 if (LocaleCompare("morphology",option+1) == 0) 2109 { 2110 char 2111 token[MaxTextExtent]; 2112 2113 const char 2114 *p; 2115 2116 KernelInfo 2117 *kernel; 2118 2119 MorphologyMethod 2120 method; 2121 2122 ssize_t 2123 iterations; 2124 2125 /* 2126 Morphological Image Operation 2127 */ 2128 (void) SyncImageSettings(mogrify_info,*image,exception); 2129 p=argv[i+1]; 2130 GetMagickToken(p,&p,token); 2131 method=(MorphologyMethod) ParseCommandOption( 2132 MagickMorphologyOptions,MagickFalse,token); 2133 iterations=1L; 2134 GetMagickToken(p,&p,token); 2135 if ((*p == ':') || (*p == ',')) 2136 GetMagickToken(p,&p,token); 2137 if ((*p != '\0')) 2138 iterations=(ssize_t) StringToLong(p); 2139 kernel=AcquireKernelInfo(argv[i+2]); 2140 if (kernel == (KernelInfo *) NULL) 2141 { 2142 (void) ThrowMagickException(exception,GetMagickModule(), 2143 OptionError,"UnabletoParseKernel","morphology"); 2144 status=MagickFalse; 2145 break; 2146 } 2147 mogrify_image=MorphologyImage(*image,method,iterations,kernel, 2148 exception); 2149 kernel=DestroyKernelInfo(kernel); 2150 break; 2151 } 2152 if (LocaleCompare("motion-blur",option+1) == 0) 2153 { 2154 /* 2155 Motion blur image. 2156 */ 2157 (void) SyncImageSettings(mogrify_info,*image,exception); 2158 flags=ParseGeometry(argv[i+1],&geometry_info); 2159 if ((flags & SigmaValue) == 0) 2160 geometry_info.sigma=1.0; 2161 mogrify_image=MotionBlurImage(*image,geometry_info.rho, 2162 geometry_info.sigma,geometry_info.xi,geometry_info.psi, 2163 exception); 2164 break; 2165 } 2166 break; 2167 } 2168 case 'n': 2169 { 2170 if (LocaleCompare("negate",option+1) == 0) 2171 { 2172 (void) SyncImageSettings(mogrify_info,*image,exception); 2173 (void) NegateImage(*image,*option == '+' ? MagickTrue : 2174 MagickFalse,exception); 2175 break; 2176 } 2177 if (LocaleCompare("noise",option+1) == 0) 2178 { 2179 (void) SyncImageSettings(mogrify_info,*image,exception); 2180 if (*option == '-') 2181 { 2182 flags=ParseGeometry(argv[i+1],&geometry_info); 2183 if ((flags & SigmaValue) == 0) 2184 geometry_info.sigma=geometry_info.rho; 2185 mogrify_image=StatisticImage(*image,NonpeakStatistic,(size_t) 2186 geometry_info.rho,(size_t) geometry_info.sigma,exception); 2187 } 2188 else 2189 { 2190 NoiseType 2191 noise; 2192 2193 noise=(NoiseType) ParseCommandOption(MagickNoiseOptions, 2194 MagickFalse,argv[i+1]); 2195 mogrify_image=AddNoiseImage(*image,noise,attenuate,exception); 2196 } 2197 break; 2198 } 2199 if (LocaleCompare("normalize",option+1) == 0) 2200 { 2201 (void) SyncImageSettings(mogrify_info,*image,exception); 2202 (void) NormalizeImage(*image,exception); 2203 break; 2204 } 2205 break; 2206 } 2207 case 'o': 2208 { 2209 if (LocaleCompare("opaque",option+1) == 0) 2210 { 2211 PixelInfo 2212 target; 2213 2214 (void) SyncImageSettings(mogrify_info,*image,exception); 2215 (void) QueryColorCompliance(argv[i+1],AllCompliance,&target, 2216 exception); 2217 (void) OpaquePaintImage(*image,&target,&fill,*option == '-' ? 2218 MagickFalse : MagickTrue,exception); 2219 break; 2220 } 2221 if (LocaleCompare("ordered-dither",option+1) == 0) 2222 { 2223 (void) SyncImageSettings(mogrify_info,*image,exception); 2224 (void) OrderedPosterizeImage(*image,argv[i+1],exception); 2225 break; 2226 } 2227 break; 2228 } 2229 case 'p': 2230 { 2231 if (LocaleCompare("paint",option+1) == 0) 2232 { 2233 (void) SyncImageSettings(mogrify_info,*image,exception); 2234 (void) ParseGeometry(argv[i+1],&geometry_info); 2235 mogrify_image=OilPaintImage(*image,geometry_info.rho, 2236 geometry_info.sigma,exception); 2237 break; 2238 } 2239 if (LocaleCompare("pen",option+1) == 0) 2240 { 2241 if (*option == '+') 2242 { 2243 (void) QueryColorCompliance("none",AllCompliance, 2244 &draw_info->fill,exception); 2245 break; 2246 } 2247 (void) QueryColorCompliance(argv[i+1],AllCompliance, 2248 &draw_info->fill,exception); 2249 break; 2250 } 2251 if (LocaleCompare("pointsize",option+1) == 0) 2252 { 2253 if (*option == '+') 2254 (void) ParseGeometry("12",&geometry_info); 2255 else 2256 (void) ParseGeometry(argv[i+1],&geometry_info); 2257 draw_info->pointsize=geometry_info.rho; 2258 break; 2259 } 2260 if (LocaleCompare("polaroid",option+1) == 0) 2261 { 2262 double 2263 angle; 2264 2265 RandomInfo 2266 *random_info; 2267 2268 /* 2269 Simulate a Polaroid picture. 2270 */ 2271 (void) SyncImageSettings(mogrify_info,*image,exception); 2272 random_info=AcquireRandomInfo(); 2273 angle=22.5*(GetPseudoRandomValue(random_info)-0.5); 2274 random_info=DestroyRandomInfo(random_info); 2275 if (*option == '-') 2276 { 2277 SetGeometryInfo(&geometry_info); 2278 flags=ParseGeometry(argv[i+1],&geometry_info); 2279 angle=geometry_info.rho; 2280 } 2281 mogrify_image=PolaroidImage(*image,draw_info,angle, 2282 interpolate_method,exception); 2283 break; 2284 } 2285 if (LocaleCompare("posterize",option+1) == 0) 2286 { 2287 /* 2288 Posterize image. 2289 */ 2290 (void) SyncImageSettings(mogrify_info,*image,exception); 2291 (void) PosterizeImage(*image,StringToUnsignedLong(argv[i+1]), 2292 quantize_info->dither,exception); 2293 break; 2294 } 2295 if (LocaleCompare("preview",option+1) == 0) 2296 { 2297 PreviewType 2298 preview_type; 2299 2300 /* 2301 Preview image. 2302 */ 2303 (void) SyncImageSettings(mogrify_info,*image,exception); 2304 if (*option == '+') 2305 preview_type=UndefinedPreview; 2306 else 2307 preview_type=(PreviewType) ParseCommandOption( 2308 MagickPreviewOptions,MagickFalse,argv[i+1]); 2309 mogrify_image=PreviewImage(*image,preview_type,exception); 2310 break; 2311 } 2312 if (LocaleCompare("profile",option+1) == 0) 2313 { 2314 const char 2315 *name; 2316 2317 const StringInfo 2318 *profile; 2319 2320 Image 2321 *profile_image; 2322 2323 ImageInfo 2324 *profile_info; 2325 2326 (void) SyncImageSettings(mogrify_info,*image,exception); 2327 if (*option == '+') 2328 { 2329 /* 2330 Remove a profile from the image. 2331 */ 2332 (void) ProfileImage(*image,argv[i+1],(const unsigned char *) 2333 NULL,0,exception); 2334 break; 2335 } 2336 /* 2337 Associate a profile with the image. 2338 */ 2339 profile_info=CloneImageInfo(mogrify_info); 2340 profile=GetImageProfile(*image,"iptc"); 2341 if (profile != (StringInfo *) NULL) 2342 profile_info->profile=(void *) CloneStringInfo(profile); 2343 profile_image=GetImageCache(profile_info,argv[i+1],exception); 2344 profile_info=DestroyImageInfo(profile_info); 2345 if (profile_image == (Image *) NULL) 2346 { 2347 StringInfo 2348 *profile; 2349 2350 profile_info=CloneImageInfo(mogrify_info); 2351 (void) CopyMagickString(profile_info->filename,argv[i+1], 2352 MaxTextExtent); 2353 profile=FileToStringInfo(profile_info->filename,~0UL,exception); 2354 if (profile != (StringInfo *) NULL) 2355 { 2356 (void) ProfileImage(*image,profile_info->magick, 2357 GetStringInfoDatum(profile),(size_t) 2358 GetStringInfoLength(profile),MagickFalse); 2359 profile=DestroyStringInfo(profile); 2360 } 2361 profile_info=DestroyImageInfo(profile_info); 2362 break; 2363 } 2364 ResetImageProfileIterator(profile_image); 2365 name=GetNextImageProfile(profile_image); 2366 while (name != (const char *) NULL) 2367 { 2368 profile=GetImageProfile(profile_image,name); 2369 if (profile != (StringInfo *) NULL) 2370 (void) ProfileImage(*image,name,GetStringInfoDatum(profile), 2371 (size_t) GetStringInfoLength(profile),MagickFalse); 2372 name=GetNextImageProfile(profile_image); 2373 } 2374 profile_image=DestroyImage(profile_image); 2375 break; 2376 } 2377 break; 2378 } 2379 case 'q': 2380 { 2381 if (LocaleCompare("quantize",option+1) == 0) 2382 { 2383 if (*option == '+') 2384 { 2385 quantize_info->colorspace=UndefinedColorspace; 2386 break; 2387 } 2388 quantize_info->colorspace=(ColorspaceType) ParseCommandOption( 2389 MagickColorspaceOptions,MagickFalse,argv[i+1]); 2390 break; 2391 } 2392 break; 2393 } 2394 case 'r': 2395 { 2396 if (LocaleCompare("radial-blur",option+1) == 0) 2397 { 2398 /* 2399 Radial blur image. 2400 */ 2401 (void) SyncImageSettings(mogrify_info,*image,exception); 2402 flags=ParseGeometry(argv[i+1],&geometry_info); 2403 mogrify_image=RadialBlurImage(*image,geometry_info.rho, 2404 geometry_info.sigma,exception); 2405 break; 2406 } 2407 if (LocaleCompare("raise",option+1) == 0) 2408 { 2409 /* 2410 Surround image with a raise of solid color. 2411 */ 2412 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 2413 if ((flags & SigmaValue) == 0) 2414 geometry.height=geometry.width; 2415 (void) RaiseImage(*image,&geometry,*option == '-' ? MagickTrue : 2416 MagickFalse,exception); 2417 break; 2418 } 2419 if (LocaleCompare("random-threshold",option+1) == 0) 2420 { 2421 /* 2422 Threshold image. 2423 */ 2424 (void) SyncImageSettings(mogrify_info,*image,exception); 2425 (void) RandomThresholdImage(*image,argv[i+1],exception); 2426 break; 2427 } 2428 if (LocaleCompare("recolor",option+1) == 0) 2429 { 2430 KernelInfo 2431 *kernel; 2432 2433 (void) SyncImageSettings(mogrify_info,*image,exception); 2434 kernel=AcquireKernelInfo(argv[i+1]); 2435 if (kernel == (KernelInfo *) NULL) 2436 break; 2437 mogrify_image=ColorMatrixImage(*image,kernel,exception); 2438 kernel=DestroyKernelInfo(kernel); 2439 break; 2440 } 2441 if (LocaleCompare("region",option+1) == 0) 2442 { 2443 (void) SyncImageSettings(mogrify_info,*image,exception); 2444 if (region_image != (Image *) NULL) 2445 { 2446 /* 2447 Composite region. 2448 */ 2449 (void) CompositeImage(region_image,region_image->matte != 2450 MagickFalse ? CopyCompositeOp : OverCompositeOp,*image, 2451 region_geometry.x,region_geometry.y,exception); 2452 *image=DestroyImage(*image); 2453 *image=region_image; 2454 region_image = (Image *) NULL; 2455 } 2456 if (*option == '+') 2457 break; 2458 /* 2459 Apply transformations to a selected region of the image. 2460 */ 2461 (void) ParseGravityGeometry(*image,argv[i+1],®ion_geometry, 2462 exception); 2463 mogrify_image=CropImage(*image,®ion_geometry,exception); 2464 if (mogrify_image == (Image *) NULL) 2465 break; 2466 region_image=(*image); 2467 *image=mogrify_image; 2468 mogrify_image=(Image *) NULL; 2469 break; 2470 } 2471 if (LocaleCompare("render",option+1) == 0) 2472 { 2473 (void) SyncImageSettings(mogrify_info,*image,exception); 2474 draw_info->render=(*option == '+') ? MagickTrue : MagickFalse; 2475 break; 2476 } 2477 if (LocaleCompare("remap",option+1) == 0) 2478 { 2479 Image 2480 *remap_image; 2481 2482 /* 2483 Transform image colors to match this set of colors. 2484 */ 2485 (void) SyncImageSettings(mogrify_info,*image,exception); 2486 if (*option == '+') 2487 break; 2488 remap_image=GetImageCache(mogrify_info,argv[i+1],exception); 2489 if (remap_image == (Image *) NULL) 2490 break; 2491 (void) RemapImage(quantize_info,*image,remap_image,exception); 2492 remap_image=DestroyImage(remap_image); 2493 break; 2494 } 2495 if (LocaleCompare("repage",option+1) == 0) 2496 { 2497 if (*option == '+') 2498 { 2499 (void) ParseAbsoluteGeometry("0x0+0+0",&(*image)->page); 2500 break; 2501 } 2502 (void) ResetImagePage(*image,argv[i+1]); 2503 break; 2504 } 2505 if (LocaleCompare("resample",option+1) == 0) 2506 { 2507 /* 2508 Resample image. 2509 */ 2510 (void) SyncImageSettings(mogrify_info,*image,exception); 2511 flags=ParseGeometry(argv[i+1],&geometry_info); 2512 if ((flags & SigmaValue) == 0) 2513 geometry_info.sigma=geometry_info.rho; 2514 mogrify_image=ResampleImage(*image,geometry_info.rho, 2515 geometry_info.sigma,(*image)->filter,(*image)->blur,exception); 2516 break; 2517 } 2518 if (LocaleCompare("resize",option+1) == 0) 2519 { 2520 /* 2521 Resize image. 2522 */ 2523 (void) SyncImageSettings(mogrify_info,*image,exception); 2524 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2525 mogrify_image=ResizeImage(*image,geometry.width,geometry.height, 2526 (*image)->filter,(*image)->blur,exception); 2527 break; 2528 } 2529 if (LocaleCompare("roll",option+1) == 0) 2530 { 2531 /* 2532 Roll image. 2533 */ 2534 (void) SyncImageSettings(mogrify_info,*image,exception); 2535 (void) ParsePageGeometry(*image,argv[i+1],&geometry,exception); 2536 mogrify_image=RollImage(*image,geometry.x,geometry.y,exception); 2537 break; 2538 } 2539 if (LocaleCompare("rotate",option+1) == 0) 2540 { 2541 char 2542 *geometry; 2543 2544 /* 2545 Check for conditional image rotation. 2546 */ 2547 (void) SyncImageSettings(mogrify_info,*image,exception); 2548 if (strchr(argv[i+1],'>') != (char *) NULL) 2549 if ((*image)->columns <= (*image)->rows) 2550 break; 2551 if (strchr(argv[i+1],'<') != (char *) NULL) 2552 if ((*image)->columns >= (*image)->rows) 2553 break; 2554 /* 2555 Rotate image. 2556 */ 2557 geometry=ConstantString(argv[i+1]); 2558 (void) SubstituteString(&geometry,">",""); 2559 (void) SubstituteString(&geometry,"<",""); 2560 (void) ParseGeometry(geometry,&geometry_info); 2561 geometry=DestroyString(geometry); 2562 mogrify_image=RotateImage(*image,geometry_info.rho,exception); 2563 break; 2564 } 2565 break; 2566 } 2567 case 's': 2568 { 2569 if (LocaleCompare("sample",option+1) == 0) 2570 { 2571 /* 2572 Sample image with pixel replication. 2573 */ 2574 (void) SyncImageSettings(mogrify_info,*image,exception); 2575 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2576 mogrify_image=SampleImage(*image,geometry.width,geometry.height, 2577 exception); 2578 break; 2579 } 2580 if (LocaleCompare("scale",option+1) == 0) 2581 { 2582 /* 2583 Resize image. 2584 */ 2585 (void) SyncImageSettings(mogrify_info,*image,exception); 2586 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2587 mogrify_image=ScaleImage(*image,geometry.width,geometry.height, 2588 exception); 2589 break; 2590 } 2591 if (LocaleCompare("selective-blur",option+1) == 0) 2592 { 2593 /* 2594 Selectively blur pixels within a contrast threshold. 2595 */ 2596 (void) SyncImageSettings(mogrify_info,*image,exception); 2597 flags=ParseGeometry(argv[i+1],&geometry_info); 2598 if ((flags & PercentValue) != 0) 2599 geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0; 2600 mogrify_image=SelectiveBlurImage(*image,geometry_info.rho, 2601 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception); 2602 break; 2603 } 2604 if (LocaleCompare("separate",option+1) == 0) 2605 { 2606 /* 2607 Break channels into separate images. 2608 */ 2609 (void) SyncImageSettings(mogrify_info,*image,exception); 2610 mogrify_image=SeparateImages(*image,exception); 2611 break; 2612 } 2613 if (LocaleCompare("sepia-tone",option+1) == 0) 2614 { 2615 double 2616 threshold; 2617 2618 /* 2619 Sepia-tone image. 2620 */ 2621 (void) SyncImageSettings(mogrify_info,*image,exception); 2622 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+ 2623 1.0); 2624 mogrify_image=SepiaToneImage(*image,threshold,exception); 2625 break; 2626 } 2627 if (LocaleCompare("segment",option+1) == 0) 2628 { 2629 /* 2630 Segment image. 2631 */ 2632 (void) SyncImageSettings(mogrify_info,*image,exception); 2633 flags=ParseGeometry(argv[i+1],&geometry_info); 2634 if ((flags & SigmaValue) == 0) 2635 geometry_info.sigma=1.0; 2636 (void) SegmentImage(*image,(*image)->colorspace, 2637 mogrify_info->verbose,geometry_info.rho,geometry_info.sigma, 2638 exception); 2639 break; 2640 } 2641 if (LocaleCompare("set",option+1) == 0) 2642 { 2643 char 2644 *value; 2645 2646 /* 2647 Set image option. 2648 */ 2649 if (*option == '+') 2650 { 2651 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 2652 (void) DeleteImageRegistry(argv[i+1]+9); 2653 else 2654 if (LocaleNCompare(argv[i+1],"option:",7) == 0) 2655 { 2656 (void) DeleteImageOption(mogrify_info,argv[i+1]+7); 2657 (void) DeleteImageArtifact(*image,argv[i+1]+7); 2658 } 2659 else 2660 (void) DeleteImageProperty(*image,argv[i+1]); 2661 break; 2662 } 2663 value=InterpretImageProperties(mogrify_info,*image,argv[i+2], 2664 exception); 2665 if (value == (char *) NULL) 2666 break; 2667 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 2668 (void) SetImageRegistry(StringRegistryType,argv[i+1]+9,value, 2669 exception); 2670 else 2671 if (LocaleNCompare(argv[i+1],"option:",7) == 0) 2672 { 2673 (void) SetImageOption(image_info,argv[i+1]+7,value); 2674 (void) SetImageOption(mogrify_info,argv[i+1]+7,value); 2675 (void) SetImageArtifact(*image,argv[i+1]+7,value); 2676 } 2677 else 2678 (void) SetImageProperty(*image,argv[i+1],value,exception); 2679 value=DestroyString(value); 2680 break; 2681 } 2682 if (LocaleCompare("shade",option+1) == 0) 2683 { 2684 /* 2685 Shade image. 2686 */ 2687 (void) SyncImageSettings(mogrify_info,*image,exception); 2688 flags=ParseGeometry(argv[i+1],&geometry_info); 2689 if ((flags & SigmaValue) == 0) 2690 geometry_info.sigma=1.0; 2691 mogrify_image=ShadeImage(*image,(*option == '-') ? MagickTrue : 2692 MagickFalse,geometry_info.rho,geometry_info.sigma,exception); 2693 break; 2694 } 2695 if (LocaleCompare("shadow",option+1) == 0) 2696 { 2697 /* 2698 Shadow image. 2699 */ 2700 (void) SyncImageSettings(mogrify_info,*image,exception); 2701 flags=ParseGeometry(argv[i+1],&geometry_info); 2702 if ((flags & SigmaValue) == 0) 2703 geometry_info.sigma=1.0; 2704 if ((flags & XiValue) == 0) 2705 geometry_info.xi=4.0; 2706 if ((flags & PsiValue) == 0) 2707 geometry_info.psi=4.0; 2708 mogrify_image=ShadowImage(*image,geometry_info.rho, 2709 geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t) 2710 ceil(geometry_info.psi-0.5),exception); 2711 break; 2712 } 2713 if (LocaleCompare("sharpen",option+1) == 0) 2714 { 2715 /* 2716 Sharpen image. 2717 */ 2718 (void) SyncImageSettings(mogrify_info,*image,exception); 2719 flags=ParseGeometry(argv[i+1],&geometry_info); 2720 if ((flags & SigmaValue) == 0) 2721 geometry_info.sigma=1.0; 2722 if ((flags & XiValue) == 0) 2723 geometry_info.xi=0.0; 2724 mogrify_image=SharpenImage(*image,geometry_info.rho, 2725 geometry_info.sigma,geometry_info.xi,exception); 2726 break; 2727 } 2728 if (LocaleCompare("shave",option+1) == 0) 2729 { 2730 /* 2731 Shave the image edges. 2732 */ 2733 (void) SyncImageSettings(mogrify_info,*image,exception); 2734 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception); 2735 mogrify_image=ShaveImage(*image,&geometry,exception); 2736 break; 2737 } 2738 if (LocaleCompare("shear",option+1) == 0) 2739 { 2740 /* 2741 Shear image. 2742 */ 2743 (void) SyncImageSettings(mogrify_info,*image,exception); 2744 flags=ParseGeometry(argv[i+1],&geometry_info); 2745 if ((flags & SigmaValue) == 0) 2746 geometry_info.sigma=geometry_info.rho; 2747 mogrify_image=ShearImage(*image,geometry_info.rho, 2748 geometry_info.sigma,exception); 2749 break; 2750 } 2751 if (LocaleCompare("sigmoidal-contrast",option+1) == 0) 2752 { 2753 /* 2754 Sigmoidal non-linearity contrast control. 2755 */ 2756 (void) SyncImageSettings(mogrify_info,*image,exception); 2757 flags=ParseGeometry(argv[i+1],&geometry_info); 2758 if ((flags & SigmaValue) == 0) 2759 geometry_info.sigma=(double) QuantumRange/2.0; 2760 if ((flags & PercentValue) != 0) 2761 geometry_info.sigma=(double) QuantumRange*geometry_info.sigma/ 2762 100.0; 2763 (void) SigmoidalContrastImage(*image,(*option == '-') ? 2764 MagickTrue : MagickFalse,geometry_info.rho,geometry_info.sigma, 2765 exception); 2766 break; 2767 } 2768 if (LocaleCompare("sketch",option+1) == 0) 2769 { 2770 /* 2771 Sketch image. 2772 */ 2773 (void) SyncImageSettings(mogrify_info,*image,exception); 2774 flags=ParseGeometry(argv[i+1],&geometry_info); 2775 if ((flags & SigmaValue) == 0) 2776 geometry_info.sigma=1.0; 2777 mogrify_image=SketchImage(*image,geometry_info.rho, 2778 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception); 2779 break; 2780 } 2781 if (LocaleCompare("solarize",option+1) == 0) 2782 { 2783 double 2784 threshold; 2785 2786 (void) SyncImageSettings(mogrify_info,*image,exception); 2787 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+ 2788 1.0); 2789 (void) SolarizeImage(*image,threshold,exception); 2790 break; 2791 } 2792 if (LocaleCompare("sparse-color",option+1) == 0) 2793 { 2794 SparseColorMethod 2795 method; 2796 2797 char 2798 *arguments; 2799 2800 /* 2801 Sparse Color Interpolated Gradient 2802 */ 2803 (void) SyncImageSettings(mogrify_info,*image,exception); 2804 method=(SparseColorMethod) ParseCommandOption( 2805 MagickSparseColorOptions,MagickFalse,argv[i+1]); 2806 arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2], 2807 exception); 2808 if (arguments == (char *) NULL) 2809 break; 2810 mogrify_image=SparseColorOption(*image,method,arguments, 2811 option[0] == '+' ? MagickTrue : MagickFalse,exception); 2812 arguments=DestroyString(arguments); 2813 break; 2814 } 2815 if (LocaleCompare("splice",option+1) == 0) 2816 { 2817 /* 2818 Splice a solid color into the image. 2819 */ 2820 (void) SyncImageSettings(mogrify_info,*image,exception); 2821 (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception); 2822 mogrify_image=SpliceImage(*image,&geometry,exception); 2823 break; 2824 } 2825 if (LocaleCompare("spread",option+1) == 0) 2826 { 2827 /* 2828 Spread an image. 2829 */ 2830 (void) SyncImageSettings(mogrify_info,*image,exception); 2831 (void) ParseGeometry(argv[i+1],&geometry_info); 2832 mogrify_image=SpreadImage(*image,geometry_info.rho, 2833 interpolate_method,exception); 2834 break; 2835 } 2836 if (LocaleCompare("statistic",option+1) == 0) 2837 { 2838 StatisticType 2839 type; 2840 2841 (void) SyncImageSettings(mogrify_info,*image,exception); 2842 type=(StatisticType) ParseCommandOption(MagickStatisticOptions, 2843 MagickFalse,argv[i+1]); 2844 (void) ParseGeometry(argv[i+2],&geometry_info); 2845 mogrify_image=StatisticImage(*image,type,(size_t) geometry_info.rho, 2846 (size_t) geometry_info.sigma,exception); 2847 break; 2848 } 2849 if (LocaleCompare("stretch",option+1) == 0) 2850 { 2851 if (*option == '+') 2852 { 2853 draw_info->stretch=UndefinedStretch; 2854 break; 2855 } 2856 draw_info->stretch=(StretchType) ParseCommandOption( 2857 MagickStretchOptions,MagickFalse,argv[i+1]); 2858 break; 2859 } 2860 if (LocaleCompare("strip",option+1) == 0) 2861 { 2862 /* 2863 Strip image of profiles and comments. 2864 */ 2865 (void) SyncImageSettings(mogrify_info,*image,exception); 2866 (void) StripImage(*image,exception); 2867 break; 2868 } 2869 if (LocaleCompare("stroke",option+1) == 0) 2870 { 2871 ExceptionInfo 2872 *sans; 2873 2874 if (*option == '+') 2875 { 2876 (void) QueryColorCompliance("none",AllCompliance, 2877 &draw_info->stroke,exception); 2878 if (draw_info->stroke_pattern != (Image *) NULL) 2879 draw_info->stroke_pattern=DestroyImage( 2880 draw_info->stroke_pattern); 2881 break; 2882 } 2883 sans=AcquireExceptionInfo(); 2884 status=QueryColorCompliance(argv[i+1],AllCompliance, 2885 &draw_info->stroke,sans); 2886 sans=DestroyExceptionInfo(sans); 2887 if (status == MagickFalse) 2888 draw_info->stroke_pattern=GetImageCache(mogrify_info,argv[i+1], 2889 exception); 2890 break; 2891 } 2892 if (LocaleCompare("strokewidth",option+1) == 0) 2893 { 2894 draw_info->stroke_width=StringToDouble(argv[i+1],(char **) NULL); 2895 break; 2896 } 2897 if (LocaleCompare("style",option+1) == 0) 2898 { 2899 if (*option == '+') 2900 { 2901 draw_info->style=UndefinedStyle; 2902 break; 2903 } 2904 draw_info->style=(StyleType) ParseCommandOption(MagickStyleOptions, 2905 MagickFalse,argv[i+1]); 2906 break; 2907 } 2908 if (LocaleCompare("swirl",option+1) == 0) 2909 { 2910 /* 2911 Swirl image. 2912 */ 2913 (void) SyncImageSettings(mogrify_info,*image,exception); 2914 (void) ParseGeometry(argv[i+1],&geometry_info); 2915 mogrify_image=SwirlImage(*image,geometry_info.rho, 2916 interpolate_method,exception); 2917 break; 2918 } 2919 break; 2920 } 2921 case 't': 2922 { 2923 if (LocaleCompare("threshold",option+1) == 0) 2924 { 2925 double 2926 threshold; 2927 2928 /* 2929 Threshold image. 2930 */ 2931 (void) SyncImageSettings(mogrify_info,*image,exception); 2932 if (*option == '+') 2933 threshold=(double) QuantumRange/2; 2934 else 2935 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+ 2936 1.0); 2937 (void) BilevelImage(*image,threshold,exception); 2938 break; 2939 } 2940 if (LocaleCompare("thumbnail",option+1) == 0) 2941 { 2942 /* 2943 Thumbnail image. 2944 */ 2945 (void) SyncImageSettings(mogrify_info,*image,exception); 2946 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception); 2947 mogrify_image=ThumbnailImage(*image,geometry.width,geometry.height, 2948 exception); 2949 break; 2950 } 2951 if (LocaleCompare("tile",option+1) == 0) 2952 { 2953 if (*option == '+') 2954 { 2955 if (draw_info->fill_pattern != (Image *) NULL) 2956 draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern); 2957 break; 2958 } 2959 draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1], 2960 exception); 2961 break; 2962 } 2963 if (LocaleCompare("tint",option+1) == 0) 2964 { 2965 /* 2966 Tint the image. 2967 */ 2968 (void) SyncImageSettings(mogrify_info,*image,exception); 2969 mogrify_image=TintImage(*image,argv[i+1],&fill,exception); 2970 break; 2971 } 2972 if (LocaleCompare("transform",option+1) == 0) 2973 { 2974 /* 2975 Affine transform image. 2976 */ 2977 (void) SyncImageSettings(mogrify_info,*image,exception); 2978 mogrify_image=AffineTransformImage(*image,&draw_info->affine, 2979 exception); 2980 break; 2981 } 2982 if (LocaleCompare("transparent",option+1) == 0) 2983 { 2984 PixelInfo 2985 target; 2986 2987 (void) SyncImageSettings(mogrify_info,*image,exception); 2988 (void) QueryColorCompliance(argv[i+1],AllCompliance,&target, 2989 exception); 2990 (void) TransparentPaintImage(*image,&target,(Quantum) 2991 TransparentAlpha,*option == '-' ? MagickFalse : MagickTrue, 2992 exception); 2993 break; 2994 } 2995 if (LocaleCompare("transpose",option+1) == 0) 2996 { 2997 /* 2998 Transpose image scanlines. 2999 */ 3000 (void) SyncImageSettings(mogrify_info,*image,exception); 3001 mogrify_image=TransposeImage(*image,exception); 3002 break; 3003 } 3004 if (LocaleCompare("transverse",option+1) == 0) 3005 { 3006 /* 3007 Transverse image scanlines. 3008 */ 3009 (void) SyncImageSettings(mogrify_info,*image,exception); 3010 mogrify_image=TransverseImage(*image,exception); 3011 break; 3012 } 3013 if (LocaleCompare("treedepth",option+1) == 0) 3014 { 3015 quantize_info->tree_depth=StringToUnsignedLong(argv[i+1]); 3016 break; 3017 } 3018 if (LocaleCompare("trim",option+1) == 0) 3019 { 3020 /* 3021 Trim image. 3022 */ 3023 (void) SyncImageSettings(mogrify_info,*image,exception); 3024 mogrify_image=TrimImage(*image,exception); 3025 break; 3026 } 3027 if (LocaleCompare("type",option+1) == 0) 3028 { 3029 ImageType 3030 type; 3031 3032 (void) SyncImageSettings(mogrify_info,*image,exception); 3033 if (*option == '+') 3034 type=UndefinedType; 3035 else 3036 type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse, 3037 argv[i+1]); 3038 (*image)->type=UndefinedType; 3039 (void) SetImageType(*image,type,exception); 3040 break; 3041 } 3042 break; 3043 } 3044 case 'u': 3045 { 3046 if (LocaleCompare("undercolor",option+1) == 0) 3047 { 3048 (void) QueryColorCompliance(argv[i+1],AllCompliance, 3049 &draw_info->undercolor,exception); 3050 break; 3051 } 3052 if (LocaleCompare("unique",option+1) == 0) 3053 { 3054 if (*option == '+') 3055 { 3056 (void) DeleteImageArtifact(*image,"identify:unique-colors"); 3057 break; 3058 } 3059 (void) SetImageArtifact(*image,"identify:unique-colors","true"); 3060 (void) SetImageArtifact(*image,"verbose","true"); 3061 break; 3062 } 3063 if (LocaleCompare("unique-colors",option+1) == 0) 3064 { 3065 /* 3066 Unique image colors. 3067 */ 3068 (void) SyncImageSettings(mogrify_info,*image,exception); 3069 mogrify_image=UniqueImageColors(*image,exception); 3070 break; 3071 } 3072 if (LocaleCompare("unsharp",option+1) == 0) 3073 { 3074 /* 3075 Unsharp mask image. 3076 */ 3077 (void) SyncImageSettings(mogrify_info,*image,exception); 3078 flags=ParseGeometry(argv[i+1],&geometry_info); 3079 if ((flags & SigmaValue) == 0) 3080 geometry_info.sigma=1.0; 3081 if ((flags & XiValue) == 0) 3082 geometry_info.xi=1.0; 3083 if ((flags & PsiValue) == 0) 3084 geometry_info.psi=0.05; 3085 mogrify_image=UnsharpMaskImage(*image,geometry_info.rho, 3086 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception); 3087 break; 3088 } 3089 break; 3090 } 3091 case 'v': 3092 { 3093 if (LocaleCompare("verbose",option+1) == 0) 3094 { 3095 (void) SetImageArtifact(*image,option+1, 3096 *option == '+' ? "false" : "true"); 3097 break; 3098 } 3099 if (LocaleCompare("vignette",option+1) == 0) 3100 { 3101 /* 3102 Vignette image. 3103 */ 3104 (void) SyncImageSettings(mogrify_info,*image,exception); 3105 flags=ParseGeometry(argv[i+1],&geometry_info); 3106 if ((flags & SigmaValue) == 0) 3107 geometry_info.sigma=1.0; 3108 if ((flags & XiValue) == 0) 3109 geometry_info.xi=0.1*(*image)->columns; 3110 if ((flags & PsiValue) == 0) 3111 geometry_info.psi=0.1*(*image)->rows; 3112 mogrify_image=VignetteImage(*image,geometry_info.rho, 3113 geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t) 3114 ceil(geometry_info.psi-0.5),exception); 3115 break; 3116 } 3117 if (LocaleCompare("virtual-pixel",option+1) == 0) 3118 { 3119 if (*option == '+') 3120 { 3121 (void) SetImageVirtualPixelMethod(*image, 3122 UndefinedVirtualPixelMethod); 3123 break; 3124 } 3125 (void) SetImageVirtualPixelMethod(*image,(VirtualPixelMethod) 3126 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse, 3127 argv[i+1])); 3128 break; 3129 } 3130 break; 3131 } 3132 case 'w': 3133 { 3134 if (LocaleCompare("wave",option+1) == 0) 3135 { 3136 /* 3137 Wave image. 3138 */ 3139 (void) SyncImageSettings(mogrify_info,*image,exception); 3140 flags=ParseGeometry(argv[i+1],&geometry_info); 3141 if ((flags & SigmaValue) == 0) 3142 geometry_info.sigma=1.0; 3143 mogrify_image=WaveImage(*image,geometry_info.rho, 3144 geometry_info.sigma,interpolate_method,exception); 3145 break; 3146 } 3147 if (LocaleCompare("weight",option+1) == 0) 3148 { 3149 draw_info->weight=StringToUnsignedLong(argv[i+1]); 3150 if (LocaleCompare(argv[i+1],"all") == 0) 3151 draw_info->weight=0; 3152 if (LocaleCompare(argv[i+1],"bold") == 0) 3153 draw_info->weight=700; 3154 if (LocaleCompare(argv[i+1],"bolder") == 0) 3155 if (draw_info->weight <= 800) 3156 draw_info->weight+=100; 3157 if (LocaleCompare(argv[i+1],"lighter") == 0) 3158 if (draw_info->weight >= 100) 3159 draw_info->weight-=100; 3160 if (LocaleCompare(argv[i+1],"normal") == 0) 3161 draw_info->weight=400; 3162 break; 3163 } 3164 if (LocaleCompare("white-threshold",option+1) == 0) 3165 { 3166 /* 3167 White threshold image. 3168 */ 3169 (void) SyncImageSettings(mogrify_info,*image,exception); 3170 (void) WhiteThresholdImage(*image,argv[i+1],exception); 3171 break; 3172 } 3173 break; 3174 } 3175 default: 3176 break; 3177 } 3178 /* 3179 Replace current image with any image that was generated 3180 */ 3181 if (mogrify_image != (Image *) NULL) 3182 ReplaceImageInListReturnLast(image,mogrify_image); 3183 i+=count; 3184 } 3185 if (region_image != (Image *) NULL) 3186 { 3187 /* 3188 Composite transformed region onto image. 3189 */ 3190 (void) SyncImageSettings(mogrify_info,*image,exception); 3191 (void) CompositeImage(region_image,region_image->matte != 3192 MagickFalse ? CopyCompositeOp : OverCompositeOp,*image, 3193 region_geometry.x,region_geometry.y,exception); 3194 *image=DestroyImage(*image); 3195 *image=region_image; 3196 region_image = (Image *) NULL; 3197 } 3198 /* 3199 Free resources. 3200 */ 3201 quantize_info=DestroyQuantizeInfo(quantize_info); 3202 draw_info=DestroyDrawInfo(draw_info); 3203 mogrify_info=DestroyImageInfo(mogrify_info); 3204 status=(MagickStatusType) (exception->severity == 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=StringToDouble(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("authenticate",option+1) == 0) 6163 { 6164 if (*option == '+') 6165 (void) DeleteImageOption(image_info,option+1); 6166 else 6167 (void) SetImageOption(image_info,option+1,argv[i+1]); 6168 break; 6169 } 6170 break; 6171 } 6172 case 'b': 6173 { 6174 if (LocaleCompare("background",option+1) == 0) 6175 { 6176 if (*option == '+') 6177 { 6178 (void) DeleteImageOption(image_info,option+1); 6179 (void) QueryColorCompliance(MogrifyBackgroundColor, 6180 AllCompliance,&image_info->background_color,exception); 6181 break; 6182 } 6183 (void) SetImageOption(image_info,option+1,argv[i+1]); 6184 (void) QueryColorCompliance(argv[i+1],AllCompliance, 6185 &image_info->background_color,exception); 6186 break; 6187 } 6188 if (LocaleCompare("bias",option+1) == 0) 6189 { 6190 if (*option == '+') 6191 { 6192 (void) SetImageOption(image_info,option+1,"0.0"); 6193 break; 6194 } 6195 (void) SetImageOption(image_info,option+1,argv[i+1]); 6196 break; 6197 } 6198 if (LocaleCompare("black-point-compensation",option+1) == 0) 6199 { 6200 if (*option == '+') 6201 { 6202 (void) SetImageOption(image_info,option+1,"false"); 6203 break; 6204 } 6205 (void) SetImageOption(image_info,option+1,"true"); 6206 break; 6207 } 6208 if (LocaleCompare("blue-primary",option+1) == 0) 6209 { 6210 if (*option == '+') 6211 { 6212 (void) SetImageOption(image_info,option+1,"0.0"); 6213 break; 6214 } 6215 (void) SetImageOption(image_info,option+1,argv[i+1]); 6216 break; 6217 } 6218 if (LocaleCompare("bordercolor",option+1) == 0) 6219 { 6220 if (*option == '+') 6221 { 6222 (void) DeleteImageOption(image_info,option+1); 6223 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance, 6224 &image_info->border_color,exception); 6225 break; 6226 } 6227 (void) QueryColorCompliance(argv[i+1],AllCompliance, 6228 &image_info->border_color,exception); 6229 (void) SetImageOption(image_info,option+1,argv[i+1]); 6230 break; 6231 } 6232 if (LocaleCompare("box",option+1) == 0) 6233 { 6234 if (*option == '+') 6235 { 6236 (void) SetImageOption(image_info,"undercolor","none"); 6237 break; 6238 } 6239 (void) SetImageOption(image_info,"undercolor",argv[i+1]); 6240 break; 6241 } 6242 break; 6243 } 6244 case 'c': 6245 { 6246 if (LocaleCompare("cache",option+1) == 0) 6247 { 6248 MagickSizeType 6249 limit; 6250 6251 limit=MagickResourceInfinity; 6252 if (LocaleCompare("unlimited",argv[i+1]) != 0) 6253 limit=(MagickSizeType) SiPrefixToDoubleInterval(argv[i+1], 6254 100.0); 6255 (void) SetMagickResourceLimit(MemoryResource,limit); 6256 (void) SetMagickResourceLimit(MapResource,2*limit); 6257 break; 6258 } 6259 if (LocaleCompare("caption",option+1) == 0) 6260 { 6261 if (*option == '+') 6262 { 6263 (void) DeleteImageOption(image_info,option+1); 6264 break; 6265 } 6266 (void) SetImageOption(image_info,option+1,argv[i+1]); 6267 break; 6268 } 6269 if (LocaleCompare("channel",option+1) == 0) 6270 { 6271 if (*option == '+') 6272 { 6273 image_info->channel=DefaultChannels; 6274 break; 6275 } 6276 image_info->channel=(ChannelType) ParseChannelOption(argv[i+1]); 6277 break; 6278 } 6279 if (LocaleCompare("colorspace",option+1) == 0) 6280 { 6281 if (*option == '+') 6282 { 6283 image_info->colorspace=UndefinedColorspace; 6284 (void) SetImageOption(image_info,option+1,"undefined"); 6285 break; 6286 } 6287 image_info->colorspace=(ColorspaceType) ParseCommandOption( 6288 MagickColorspaceOptions,MagickFalse,argv[i+1]); 6289 (void) SetImageOption(image_info,option+1,argv[i+1]); 6290 break; 6291 } 6292 if (LocaleCompare("comment",option+1) == 0) 6293 { 6294 if (*option == '+') 6295 { 6296 (void) DeleteImageOption(image_info,option+1); 6297 break; 6298 } 6299 (void) SetImageOption(image_info,option+1,argv[i+1]); 6300 break; 6301 } 6302 if (LocaleCompare("compose",option+1) == 0) 6303 { 6304 if (*option == '+') 6305 { 6306 (void) SetImageOption(image_info,option+1,"undefined"); 6307 break; 6308 } 6309 (void) SetImageOption(image_info,option+1,argv[i+1]); 6310 break; 6311 } 6312 if (LocaleCompare("compress",option+1) == 0) 6313 { 6314 if (*option == '+') 6315 { 6316 image_info->compression=UndefinedCompression; 6317 (void) SetImageOption(image_info,option+1,"undefined"); 6318 break; 6319 } 6320 image_info->compression=(CompressionType) ParseCommandOption( 6321 MagickCompressOptions,MagickFalse,argv[i+1]); 6322 (void) SetImageOption(image_info,option+1,argv[i+1]); 6323 break; 6324 } 6325 break; 6326 } 6327 case 'd': 6328 { 6329 if (LocaleCompare("debug",option+1) == 0) 6330 { 6331 if (*option == '+') 6332 (void) SetLogEventMask("none"); 6333 else 6334 (void) SetLogEventMask(argv[i+1]); 6335 image_info->debug=IsEventLogging(); 6336 break; 6337 } 6338 if (LocaleCompare("define",option+1) == 0) 6339 { 6340 if (*option == '+') 6341 { 6342 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 6343 (void) DeleteImageRegistry(argv[i+1]+9); 6344 else 6345 (void) DeleteImageOption(image_info,argv[i+1]); 6346 break; 6347 } 6348 if (LocaleNCompare(argv[i+1],"registry:",9) == 0) 6349 { 6350 (void) DefineImageRegistry(StringRegistryType,argv[i+1]+9, 6351 exception); 6352 break; 6353 } 6354 (void) DefineImageOption(image_info,argv[i+1]); 6355 break; 6356 } 6357 if (LocaleCompare("delay",option+1) == 0) 6358 { 6359 if (*option == '+') 6360 { 6361 (void) SetImageOption(image_info,option+1,"0"); 6362 break; 6363 } 6364 (void) SetImageOption(image_info,option+1,argv[i+1]); 6365 break; 6366 } 6367 if (LocaleCompare("density",option+1) == 0) 6368 { 6369 /* 6370 Set image density. 6371 */ 6372 if (*option == '+') 6373 { 6374 if (image_info->density != (char *) NULL) 6375 image_info->density=DestroyString(image_info->density); 6376 (void) SetImageOption(image_info,option+1,"72"); 6377 break; 6378 } 6379 (void) CloneString(&image_info->density,argv[i+1]); 6380 (void) SetImageOption(image_info,option+1,argv[i+1]); 6381 break; 6382 } 6383 if (LocaleCompare("depth",option+1) == 0) 6384 { 6385 if (*option == '+') 6386 { 6387 image_info->depth=MAGICKCORE_QUANTUM_DEPTH; 6388 break; 6389 } 6390 image_info->depth=StringToUnsignedLong(argv[i+1]); 6391 break; 6392 } 6393 if (LocaleCompare("direction",option+1) == 0) 6394 { 6395 if (*option == '+') 6396 { 6397 (void) SetImageOption(image_info,option+1,"undefined"); 6398 break; 6399 } 6400 (void) SetImageOption(image_info,option+1,argv[i+1]); 6401 break; 6402 } 6403 if (LocaleCompare("display",option+1) == 0) 6404 { 6405 if (*option == '+') 6406 { 6407 if (image_info->server_name != (char *) NULL) 6408 image_info->server_name=DestroyString( 6409 image_info->server_name); 6410 break; 6411 } 6412 (void) CloneString(&image_info->server_name,argv[i+1]); 6413 break; 6414 } 6415 if (LocaleCompare("dispose",option+1) == 0) 6416 { 6417 if (*option == '+') 6418 { 6419 (void) SetImageOption(image_info,option+1,"undefined"); 6420 break; 6421 } 6422 (void) SetImageOption(image_info,option+1,argv[i+1]); 6423 break; 6424 } 6425 if (LocaleCompare("dither",option+1) == 0) 6426 { 6427 if (*option == '+') 6428 { 6429 image_info->dither=MagickFalse; 6430 (void) SetImageOption(image_info,option+1,"none"); 6431 break; 6432 } 6433 (void) SetImageOption(image_info,option+1,argv[i+1]); 6434 image_info->dither=MagickTrue; 6435 break; 6436 } 6437 break; 6438 } 6439 case 'e': 6440 { 6441 if (LocaleCompare("encoding",option+1) == 0) 6442 { 6443 if (*option == '+') 6444 { 6445 (void) SetImageOption(image_info,option+1,"undefined"); 6446 break; 6447 } 6448 (void) SetImageOption(image_info,option+1,argv[i+1]); 6449 break; 6450 } 6451 if (LocaleCompare("endian",option+1) == 0) 6452 { 6453 if (*option == '+') 6454 { 6455 image_info->endian=UndefinedEndian; 6456 (void) SetImageOption(image_info,option+1,"undefined"); 6457 break; 6458 } 6459 image_info->endian=(EndianType) ParseCommandOption( 6460 MagickEndianOptions,MagickFalse,argv[i+1]); 6461 (void) SetImageOption(image_info,option+1,argv[i+1]); 6462 break; 6463 } 6464 if (LocaleCompare("extract",option+1) == 0) 6465 { 6466 /* 6467 Set image extract geometry. 6468 */ 6469 if (*option == '+') 6470 { 6471 if (image_info->extract != (char *) NULL) 6472 image_info->extract=DestroyString(image_info->extract); 6473 break; 6474 } 6475 (void) CloneString(&image_info->extract,argv[i+1]); 6476 break; 6477 } 6478 break; 6479 } 6480 case 'f': 6481 { 6482 if (LocaleCompare("fill",option+1) == 0) 6483 { 6484 if (*option == '+') 6485 { 6486 (void) SetImageOption(image_info,option+1,"none"); 6487 break; 6488 } 6489 (void) SetImageOption(image_info,option+1,argv[i+1]); 6490 break; 6491 } 6492 if (LocaleCompare("filter",option+1) == 0) 6493 { 6494 if (*option == '+') 6495 { 6496 (void) SetImageOption(image_info,option+1,"undefined"); 6497 break; 6498 } 6499 (void) SetImageOption(image_info,option+1,argv[i+1]); 6500 break; 6501 } 6502 if (LocaleCompare("font",option+1) == 0) 6503 { 6504 if (*option == '+') 6505 { 6506 if (image_info->font != (char *) NULL) 6507 image_info->font=DestroyString(image_info->font); 6508 break; 6509 } 6510 (void) CloneString(&image_info->font,argv[i+1]); 6511 break; 6512 } 6513 if (LocaleCompare("format",option+1) == 0) 6514 { 6515 register const char 6516 *q; 6517 6518 for (q=strchr(argv[i+1],'%'); q != (char *) NULL; q=strchr(q+1,'%')) 6519 if (strchr("Agkrz@[#",*(q+1)) != (char *) NULL) 6520 image_info->ping=MagickFalse; 6521 (void) SetImageOption(image_info,option+1,argv[i+1]); 6522 break; 6523 } 6524 if (LocaleCompare("fuzz",option+1) == 0) 6525 { 6526 if (*option == '+') 6527 { 6528 image_info->fuzz=0.0; 6529 (void) SetImageOption(image_info,option+1,"0"); 6530 break; 6531 } 6532 image_info->fuzz=StringToDoubleInterval(argv[i+1],(double) 6533 QuantumRange+1.0); 6534 (void) SetImageOption(image_info,option+1,argv[i+1]); 6535 break; 6536 } 6537 break; 6538 } 6539 case 'g': 6540 { 6541 if (LocaleCompare("gravity",option+1) == 0) 6542 { 6543 if (*option == '+') 6544 { 6545 (void) SetImageOption(image_info,option+1,"undefined"); 6546 break; 6547 } 6548 (void) SetImageOption(image_info,option+1,argv[i+1]); 6549 break; 6550 } 6551 if (LocaleCompare("green-primary",option+1) == 0) 6552 { 6553 if (*option == '+') 6554 { 6555 (void) SetImageOption(image_info,option+1,"0.0"); 6556 break; 6557 } 6558 (void) SetImageOption(image_info,option+1,argv[i+1]); 6559 break; 6560 } 6561 break; 6562 } 6563 case 'i': 6564 { 6565 if (LocaleCompare("intent",option+1) == 0) 6566 { 6567 if (*option == '+') 6568 { 6569 (void) SetImageOption(image_info,option+1,"undefined"); 6570 break; 6571 } 6572 (void) SetImageOption(image_info,option+1,argv[i+1]); 6573 break; 6574 } 6575 if (LocaleCompare("interlace",option+1) == 0) 6576 { 6577 if (*option == '+') 6578 { 6579 image_info->interlace=UndefinedInterlace; 6580 (void) SetImageOption(image_info,option+1,"undefined"); 6581 break; 6582 } 6583 image_info->interlace=(InterlaceType) ParseCommandOption( 6584 MagickInterlaceOptions,MagickFalse,argv[i+1]); 6585 (void) SetImageOption(image_info,option+1,argv[i+1]); 6586 break; 6587 } 6588 if (LocaleCompare("interline-spacing",option+1) == 0) 6589 { 6590 if (*option == '+') 6591 { 6592 (void) SetImageOption(image_info,option+1,"undefined"); 6593 break; 6594 } 6595 (void) SetImageOption(image_info,option+1,argv[i+1]); 6596 break; 6597 } 6598 if (LocaleCompare("interpolate",option+1) == 0) 6599 { 6600 if (*option == '+') 6601 { 6602 (void) SetImageOption(image_info,option+1,"undefined"); 6603 break; 6604 } 6605 (void) SetImageOption(image_info,option+1,argv[i+1]); 6606 break; 6607 } 6608 if (LocaleCompare("interword-spacing",option+1) == 0) 6609 { 6610 if (*option == '+') 6611 { 6612 (void) SetImageOption(image_info,option+1,"undefined"); 6613 break; 6614 } 6615 (void) SetImageOption(image_info,option+1,argv[i+1]); 6616 break; 6617 } 6618 break; 6619 } 6620 case 'k': 6621 { 6622 if (LocaleCompare("kerning",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 'l': 6635 { 6636 if (LocaleCompare("label",option+1) == 0) 6637 { 6638 if (*option == '+') 6639 { 6640 (void) DeleteImageOption(image_info,option+1); 6641 break; 6642 } 6643 (void) SetImageOption(image_info,option+1,argv[i+1]); 6644 break; 6645 } 6646 if (LocaleCompare("limit",option+1) == 0) 6647 { 6648 MagickSizeType 6649 limit; 6650 6651 ResourceType 6652 type; 6653 6654 if (*option == '+') 6655 break; 6656 type=(ResourceType) ParseCommandOption(MagickResourceOptions, 6657 MagickFalse,argv[i+1]); 6658 limit=MagickResourceInfinity; 6659 if (LocaleCompare("unlimited",argv[i+2]) != 0) 6660 limit=(MagickSizeType) SiPrefixToDoubleInterval(argv[i+2], 6661 100.0); 6662 (void) SetMagickResourceLimit(type,limit); 6663 break; 6664 } 6665 if (LocaleCompare("list",option+1) == 0) 6666 { 6667 ssize_t 6668 list; 6669 6670 /* 6671 Display configuration list. 6672 */ 6673 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i+1]); 6674 switch (list) 6675 { 6676 case MagickCoderOptions: 6677 { 6678 (void) ListCoderInfo((FILE *) NULL,exception); 6679 break; 6680 } 6681 case MagickColorOptions: 6682 { 6683 (void) ListColorInfo((FILE *) NULL,exception); 6684 break; 6685 } 6686 case MagickConfigureOptions: 6687 { 6688 (void) ListConfigureInfo((FILE *) NULL,exception); 6689 break; 6690 } 6691 case MagickDelegateOptions: 6692 { 6693 (void) ListDelegateInfo((FILE *) NULL,exception); 6694 break; 6695 } 6696 case MagickFontOptions: 6697 { 6698 (void) ListTypeInfo((FILE *) NULL,exception); 6699 break; 6700 } 6701 case MagickFormatOptions: 6702 { 6703 (void) ListMagickInfo((FILE *) NULL,exception); 6704 break; 6705 } 6706 case MagickLocaleOptions: 6707 { 6708 (void) ListLocaleInfo((FILE *) NULL,exception); 6709 break; 6710 } 6711 case MagickLogOptions: 6712 { 6713 (void) ListLogInfo((FILE *) NULL,exception); 6714 break; 6715 } 6716 case MagickMagicOptions: 6717 { 6718 (void) ListMagicInfo((FILE *) NULL,exception); 6719 break; 6720 } 6721 case MagickMimeOptions: 6722 { 6723 (void) ListMimeInfo((FILE *) NULL,exception); 6724 break; 6725 } 6726 case MagickModuleOptions: 6727 { 6728 (void) ListModuleInfo((FILE *) NULL,exception); 6729 break; 6730 } 6731 case MagickPolicyOptions: 6732 { 6733 (void) ListPolicyInfo((FILE *) NULL,exception); 6734 break; 6735 } 6736 case MagickResourceOptions: 6737 { 6738 (void) ListMagickResourceInfo((FILE *) NULL,exception); 6739 break; 6740 } 6741 case MagickThresholdOptions: 6742 { 6743 (void) ListThresholdMaps((FILE *) NULL,exception); 6744 break; 6745 } 6746 default: 6747 { 6748 (void) ListCommandOptions((FILE *) NULL,(CommandOption) list, 6749 exception); 6750 break; 6751 } 6752 } 6753 break; 6754 } 6755 if (LocaleCompare("log",option+1) == 0) 6756 { 6757 if (*option == '+') 6758 break; 6759 (void) SetLogFormat(argv[i+1]); 6760 break; 6761 } 6762 if (LocaleCompare("loop",option+1) == 0) 6763 { 6764 if (*option == '+') 6765 { 6766 (void) SetImageOption(image_info,option+1,"0"); 6767 break; 6768 } 6769 (void) SetImageOption(image_info,option+1,argv[i+1]); 6770 break; 6771 } 6772 break; 6773 } 6774 case 'm': 6775 { 6776 if (LocaleCompare("matte",option+1) == 0) 6777 { 6778 if (*option == '+') 6779 { 6780 (void) SetImageOption(image_info,option+1,"false"); 6781 break; 6782 } 6783 (void) SetImageOption(image_info,option+1,"true"); 6784 break; 6785 } 6786 if (LocaleCompare("mattecolor",option+1) == 0) 6787 { 6788 if (*option == '+') 6789 { 6790 (void) SetImageOption(image_info,option+1,argv[i+1]); 6791 (void) QueryColorCompliance(MogrifyMatteColor,AllCompliance, 6792 &image_info->matte_color,exception); 6793 break; 6794 } 6795 (void) SetImageOption(image_info,option+1,argv[i+1]); 6796 (void) QueryColorCompliance(argv[i+1],AllCompliance, 6797 &image_info->matte_color,exception); 6798 break; 6799 } 6800 if (LocaleCompare("monitor",option+1) == 0) 6801 { 6802 (void) SetImageInfoProgressMonitor(image_info,MonitorProgress, 6803 (void *) NULL); 6804 break; 6805 } 6806 if (LocaleCompare("monochrome",option+1) == 0) 6807 { 6808 image_info->monochrome=(*option == '-') ? MagickTrue : MagickFalse; 6809 break; 6810 } 6811 break; 6812 } 6813 case 'o': 6814 { 6815 if (LocaleCompare("orient",option+1) == 0) 6816 { 6817 if (*option == '+') 6818 { 6819 image_info->orientation=UndefinedOrientation; 6820 (void) SetImageOption(image_info,option+1,"undefined"); 6821 break; 6822 } 6823 image_info->orientation=(OrientationType) ParseCommandOption( 6824 MagickOrientationOptions,MagickFalse,argv[i+1]); 6825 (void) SetImageOption(image_info,option+1,argv[i+1]); 6826 break; 6827 } 6828 } 6829 case 'p': 6830 { 6831 if (LocaleCompare("page",option+1) == 0) 6832 { 6833 char 6834 *canonical_page, 6835 page[MaxTextExtent]; 6836 6837 const char 6838 *image_option; 6839 6840 MagickStatusType 6841 flags; 6842 6843 RectangleInfo 6844 geometry; 6845 6846 if (*option == '+') 6847 { 6848 (void) DeleteImageOption(image_info,option+1); 6849 (void) CloneString(&image_info->page,(char *) NULL); 6850 break; 6851 } 6852 (void) ResetMagickMemory(&geometry,0,sizeof(geometry)); 6853 image_option=GetImageOption(image_info,"page"); 6854 if (image_option != (const char *) NULL) 6855 flags=ParseAbsoluteGeometry(image_option,&geometry); 6856 canonical_page=GetPageGeometry(argv[i+1]); 6857 flags=ParseAbsoluteGeometry(canonical_page,&geometry); 6858 canonical_page=DestroyString(canonical_page); 6859 (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu", 6860 (unsigned long) geometry.width,(unsigned long) geometry.height); 6861 if (((flags & XValue) != 0) || ((flags & YValue) != 0)) 6862 (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu%+ld%+ld", 6863 (unsigned long) geometry.width,(unsigned long) geometry.height, 6864 (long) geometry.x,(long) geometry.y); 6865 (void) SetImageOption(image_info,option+1,page); 6866 (void) CloneString(&image_info->page,page); 6867 break; 6868 } 6869 if (LocaleCompare("pen",option+1) == 0) 6870 { 6871 if (*option == '+') 6872 { 6873 (void) SetImageOption(image_info,option+1,"none"); 6874 break; 6875 } 6876 (void) SetImageOption(image_info,option+1,argv[i+1]); 6877 break; 6878 } 6879 if (LocaleCompare("ping",option+1) == 0) 6880 { 6881 image_info->ping=(*option == '-') ? MagickTrue : MagickFalse; 6882 break; 6883 } 6884 if (LocaleCompare("pointsize",option+1) == 0) 6885 { 6886 if (*option == '+') 6887 geometry_info.rho=0.0; 6888 else 6889 (void) ParseGeometry(argv[i+1],&geometry_info); 6890 image_info->pointsize=geometry_info.rho; 6891 break; 6892 } 6893 if (LocaleCompare("precision",option+1) == 0) 6894 { 6895 (void) SetMagickPrecision(StringToInteger(argv[i+1])); 6896 break; 6897 } 6898 if (LocaleCompare("preview",option+1) == 0) 6899 { 6900 /* 6901 Preview image. 6902 */ 6903 if (*option == '+') 6904 { 6905 image_info->preview_type=UndefinedPreview; 6906 break; 6907 } 6908 image_info->preview_type=(PreviewType) ParseCommandOption( 6909 MagickPreviewOptions,MagickFalse,argv[i+1]); 6910 break; 6911 } 6912 break; 6913 } 6914 case 'q': 6915 { 6916 if (LocaleCompare("quality",option+1) == 0) 6917 { 6918 /* 6919 Set image compression quality. 6920 */ 6921 if (*option == '+') 6922 { 6923 image_info->quality=UndefinedCompressionQuality; 6924 (void) SetImageOption(image_info,option+1,"0"); 6925 break; 6926 } 6927 image_info->quality=StringToUnsignedLong(argv[i+1]); 6928 (void) SetImageOption(image_info,option+1,argv[i+1]); 6929 break; 6930 } 6931 if (LocaleCompare("quiet",option+1) == 0) 6932 { 6933 static WarningHandler 6934 warning_handler = (WarningHandler) NULL; 6935 6936 if (*option == '+') 6937 { 6938 /* 6939 Restore error or warning messages. 6940 */ 6941 warning_handler=SetWarningHandler(warning_handler); 6942 break; 6943 } 6944 /* 6945 Suppress error or warning messages. 6946 */ 6947 warning_handler=SetWarningHandler((WarningHandler) NULL); 6948 break; 6949 } 6950 break; 6951 } 6952 case 'r': 6953 { 6954 if (LocaleCompare("red-primary",option+1) == 0) 6955 { 6956 if (*option == '+') 6957 { 6958 (void) SetImageOption(image_info,option+1,"0.0"); 6959 break; 6960 } 6961 (void) SetImageOption(image_info,option+1,argv[i+1]); 6962 break; 6963 } 6964 break; 6965 } 6966 case 's': 6967 { 6968 if (LocaleCompare("sampling-factor",option+1) == 0) 6969 { 6970 /* 6971 Set image sampling factor. 6972 */ 6973 if (*option == '+') 6974 { 6975 if (image_info->sampling_factor != (char *) NULL) 6976 image_info->sampling_factor=DestroyString( 6977 image_info->sampling_factor); 6978 break; 6979 } 6980 (void) CloneString(&image_info->sampling_factor,argv[i+1]); 6981 break; 6982 } 6983 if (LocaleCompare("scene",option+1) == 0) 6984 { 6985 /* 6986 Set image scene. 6987 */ 6988 if (*option == '+') 6989 { 6990 image_info->scene=0; 6991 (void) SetImageOption(image_info,option+1,"0"); 6992 break; 6993 } 6994 image_info->scene=StringToUnsignedLong(argv[i+1]); 6995 (void) SetImageOption(image_info,option+1,argv[i+1]); 6996 break; 6997 } 6998 if (LocaleCompare("seed",option+1) == 0) 6999 { 7000 size_t 7001 seed; 7002 7003 if (*option == '+') 7004 { 7005 seed=(size_t) time((time_t *) NULL); 7006 SeedPseudoRandomGenerator(seed); 7007 break; 7008 } 7009 seed=StringToUnsignedLong(argv[i+1]); 7010 SeedPseudoRandomGenerator(seed); 7011 break; 7012 } 7013 if (LocaleCompare("size",option+1) == 0) 7014 { 7015 if (*option == '+') 7016 { 7017 if (image_info->size != (char *) NULL) 7018 image_info->size=DestroyString(image_info->size); 7019 break; 7020 } 7021 (void) CloneString(&image_info->size,argv[i+1]); 7022 break; 7023 } 7024 if (LocaleCompare("stroke",option+1) == 0) 7025 { 7026 if (*option == '+') 7027 { 7028 (void) SetImageOption(image_info,option+1,"none"); 7029 break; 7030 } 7031 (void) SetImageOption(image_info,option+1,argv[i+1]); 7032 break; 7033 } 7034 if (LocaleCompare("strokewidth",option+1) == 0) 7035 { 7036 if (*option == '+') 7037 { 7038 (void) SetImageOption(image_info,option+1,"0"); 7039 break; 7040 } 7041 (void) SetImageOption(image_info,option+1,argv[i+1]); 7042 break; 7043 } 7044 if (LocaleCompare("synchronize",option+1) == 0) 7045 { 7046 if (*option == '+') 7047 { 7048 image_info->synchronize=MagickFalse; 7049 break; 7050 } 7051 image_info->synchronize=MagickTrue; 7052 break; 7053 } 7054 break; 7055 } 7056 case 't': 7057 { 7058 if (LocaleCompare("taint",option+1) == 0) 7059 { 7060 if (*option == '+') 7061 { 7062 (void) SetImageOption(image_info,option+1,"false"); 7063 break; 7064 } 7065 (void) SetImageOption(image_info,option+1,"true"); 7066 break; 7067 } 7068 if (LocaleCompare("texture",option+1) == 0) 7069 { 7070 if (*option == '+') 7071 { 7072 if (image_info->texture != (char *) NULL) 7073 image_info->texture=DestroyString(image_info->texture); 7074 break; 7075 } 7076 (void) CloneString(&image_info->texture,argv[i+1]); 7077 break; 7078 } 7079 if (LocaleCompare("tile-offset",option+1) == 0) 7080 { 7081 if (*option == '+') 7082 { 7083 (void) SetImageOption(image_info,option+1,"0"); 7084 break; 7085 } 7086 (void) SetImageOption(image_info,option+1,argv[i+1]); 7087 break; 7088 } 7089 if (LocaleCompare("transparent-color",option+1) == 0) 7090 { 7091 if (*option == '+') 7092 { 7093 (void) QueryColorCompliance("none",AllCompliance, 7094 &image_info->transparent_color,exception); 7095 (void) SetImageOption(image_info,option+1,"none"); 7096 break; 7097 } 7098 (void) QueryColorCompliance(argv[i+1],AllCompliance, 7099 &image_info->transparent_color,exception); 7100 (void) SetImageOption(image_info,option+1,argv[i+1]); 7101 break; 7102 } 7103 if (LocaleCompare("type",option+1) == 0) 7104 { 7105 if (*option == '+') 7106 { 7107 image_info->type=UndefinedType; 7108 (void) SetImageOption(image_info,option+1,"undefined"); 7109 break; 7110 } 7111 image_info->type=(ImageType) ParseCommandOption(MagickTypeOptions, 7112 MagickFalse,argv[i+1]); 7113 (void) SetImageOption(image_info,option+1,argv[i+1]); 7114 break; 7115 } 7116 break; 7117 } 7118 case 'u': 7119 { 7120 if (LocaleCompare("undercolor",option+1) == 0) 7121 { 7122 if (*option == '+') 7123 { 7124 (void) DeleteImageOption(image_info,option+1); 7125 break; 7126 } 7127 (void) SetImageOption(image_info,option+1,argv[i+1]); 7128 break; 7129 } 7130 if (LocaleCompare("units",option+1) == 0) 7131 { 7132 if (*option == '+') 7133 { 7134 image_info->units=UndefinedResolution; 7135 (void) SetImageOption(image_info,option+1,"undefined"); 7136 break; 7137 } 7138 image_info->units=(ResolutionType) ParseCommandOption( 7139 MagickResolutionOptions,MagickFalse,argv[i+1]); 7140 (void) SetImageOption(image_info,option+1,argv[i+1]); 7141 break; 7142 } 7143 break; 7144 } 7145 case 'v': 7146 { 7147 if (LocaleCompare("verbose",option+1) == 0) 7148 { 7149 if (*option == '+') 7150 { 7151 image_info->verbose=MagickFalse; 7152 break; 7153 } 7154 image_info->verbose=MagickTrue; 7155 image_info->ping=MagickFalse; 7156 break; 7157 } 7158 if (LocaleCompare("view",option+1) == 0) 7159 { 7160 if (*option == '+') 7161 { 7162 if (image_info->view != (char *) NULL) 7163 image_info->view=DestroyString(image_info->view); 7164 break; 7165 } 7166 (void) CloneString(&image_info->view,argv[i+1]); 7167 break; 7168 } 7169 if (LocaleCompare("virtual-pixel",option+1) == 0) 7170 { 7171 if (*option == '+') 7172 { 7173 image_info->virtual_pixel_method=UndefinedVirtualPixelMethod; 7174 (void) SetImageOption(image_info,option+1,"undefined"); 7175 break; 7176 } 7177 image_info->virtual_pixel_method=(VirtualPixelMethod) 7178 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse, 7179 argv[i+1]); 7180 (void) SetImageOption(image_info,option+1,argv[i+1]); 7181 break; 7182 } 7183 break; 7184 } 7185 case 'w': 7186 { 7187 if (LocaleCompare("white-point",option+1) == 0) 7188 { 7189 if (*option == '+') 7190 { 7191 (void) SetImageOption(image_info,option+1,"0.0"); 7192 break; 7193 } 7194 (void) SetImageOption(image_info,option+1,argv[i+1]); 7195 break; 7196 } 7197 break; 7198 } 7199 default: 7200 break; 7201 } 7202 i+=count; 7203 } 7204 return(MagickTrue); 7205} 7206 7207/* 7208%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7209% % 7210% % 7211% % 7212+ M o g r i f y I m a g e L i s t % 7213% % 7214% % 7215% % 7216%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7217% 7218% MogrifyImageList() applies any command line options that might affect the 7219% entire image list (e.g. -append, -coalesce, etc.). 7220% 7221% The format of the MogrifyImage method is: 7222% 7223% MagickBooleanType MogrifyImageList(ImageInfo *image_info,const int argc, 7224% const char **argv,Image **images,ExceptionInfo *exception) 7225% 7226% A description of each parameter follows: 7227% 7228% o image_info: the image info.. 7229% 7230% o argc: Specifies a pointer to an integer describing the number of 7231% elements in the argument vector. 7232% 7233% o argv: Specifies a pointer to a text array containing the command line 7234% arguments. 7235% 7236% o images: pointer to pointer of the first image in image list. 7237% 7238% o exception: return any errors or warnings in this structure. 7239% 7240*/ 7241WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info, 7242 const int argc,const char **argv,Image **images,ExceptionInfo *exception) 7243{ 7244 const char 7245 *option; 7246 7247 ImageInfo 7248 *mogrify_info; 7249 7250 MagickStatusType 7251 status; 7252 7253 PixelInterpolateMethod 7254 interpolate_method; 7255 7256 QuantizeInfo 7257 *quantize_info; 7258 7259 register ssize_t 7260 i; 7261 7262 ssize_t 7263 count, 7264 index; 7265 7266 /* 7267 Apply options to the image list. 7268 */ 7269 assert(image_info != (ImageInfo *) NULL); 7270 assert(image_info->signature == MagickSignature); 7271 assert(images != (Image **) NULL); 7272 assert((*images)->previous == (Image *) NULL); 7273 assert((*images)->signature == MagickSignature); 7274 if ((*images)->debug != MagickFalse) 7275 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", 7276 (*images)->filename); 7277 if ((argc <= 0) || (*argv == (char *) NULL)) 7278 return(MagickTrue); 7279 interpolate_method=UndefinedInterpolatePixel; 7280 mogrify_info=CloneImageInfo(image_info); 7281 quantize_info=AcquireQuantizeInfo(mogrify_info); 7282 status=MagickTrue; 7283 for (i=0; i < (ssize_t) argc; i++) 7284 { 7285 if (*images == (Image *) NULL) 7286 break; 7287 option=argv[i]; 7288 if (IsCommandOption(option) == MagickFalse) 7289 continue; 7290 count=ParseCommandOption(MagickCommandOptions,MagickFalse,option); 7291 count=MagickMax(count,0L); 7292 if ((i+count) >= (ssize_t) argc) 7293 break; 7294 status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception); 7295 switch (*(option+1)) 7296 { 7297 case 'a': 7298 { 7299 if (LocaleCompare("affinity",option+1) == 0) 7300 { 7301 (void) SyncImagesSettings(mogrify_info,*images,exception); 7302 if (*option == '+') 7303 { 7304 (void) RemapImages(quantize_info,*images,(Image *) NULL, 7305 exception); 7306 break; 7307 } 7308 i++; 7309 break; 7310 } 7311 if (LocaleCompare("append",option+1) == 0) 7312 { 7313 Image 7314 *append_image; 7315 7316 (void) SyncImagesSettings(mogrify_info,*images,exception); 7317 append_image=AppendImages(*images,*option == '-' ? MagickTrue : 7318 MagickFalse,exception); 7319 if (append_image == (Image *) NULL) 7320 { 7321 status=MagickFalse; 7322 break; 7323 } 7324 *images=DestroyImageList(*images); 7325 *images=append_image; 7326 break; 7327 } 7328 if (LocaleCompare("average",option+1) == 0) 7329 { 7330 Image 7331 *average_image; 7332 7333 /* 7334 Average an image sequence (deprecated). 7335 */ 7336 (void) SyncImagesSettings(mogrify_info,*images,exception); 7337 average_image=EvaluateImages(*images,MeanEvaluateOperator, 7338 exception); 7339 if (average_image == (Image *) NULL) 7340 { 7341 status=MagickFalse; 7342 break; 7343 } 7344 *images=DestroyImageList(*images); 7345 *images=average_image; 7346 break; 7347 } 7348 break; 7349 } 7350 case 'c': 7351 { 7352 if (LocaleCompare("channel",option+1) == 0) 7353 { 7354 ChannelType 7355 channel; 7356 7357 if (*option == '+') 7358 { 7359 channel=DefaultChannels; 7360 break; 7361 } 7362 channel=(ChannelType) ParseChannelOption(argv[i+1]); 7363 SetPixelChannelMap(*images,channel); 7364 break; 7365 } 7366 if (LocaleCompare("clut",option+1) == 0) 7367 { 7368 Image 7369 *clut_image, 7370 *image; 7371 7372 (void) SyncImagesSettings(mogrify_info,*images,exception); 7373 image=RemoveFirstImageFromList(images); 7374 clut_image=RemoveFirstImageFromList(images); 7375 if (clut_image == (Image *) NULL) 7376 { 7377 status=MagickFalse; 7378 break; 7379 } 7380 (void) ClutImage(image,clut_image,interpolate_method,exception); 7381 clut_image=DestroyImage(clut_image); 7382 *images=DestroyImageList(*images); 7383 *images=image; 7384 break; 7385 } 7386 if (LocaleCompare("coalesce",option+1) == 0) 7387 { 7388 Image 7389 *coalesce_image; 7390 7391 (void) SyncImagesSettings(mogrify_info,*images,exception); 7392 coalesce_image=CoalesceImages(*images,exception); 7393 if (coalesce_image == (Image *) NULL) 7394 { 7395 status=MagickFalse; 7396 break; 7397 } 7398 *images=DestroyImageList(*images); 7399 *images=coalesce_image; 7400 break; 7401 } 7402 if (LocaleCompare("combine",option+1) == 0) 7403 { 7404 Image 7405 *combine_image; 7406 7407 (void) SyncImagesSettings(mogrify_info,*images,exception); 7408 combine_image=CombineImages(*images,exception); 7409 if (combine_image == (Image *) NULL) 7410 { 7411 status=MagickFalse; 7412 break; 7413 } 7414 *images=DestroyImageList(*images); 7415 *images=combine_image; 7416 break; 7417 } 7418 if (LocaleCompare("composite",option+1) == 0) 7419 { 7420 Image 7421 *mask_image, 7422 *composite_image, 7423 *image; 7424 7425 RectangleInfo 7426 geometry; 7427 7428 (void) SyncImagesSettings(mogrify_info,*images,exception); 7429 image=RemoveFirstImageFromList(images); 7430 composite_image=RemoveFirstImageFromList(images); 7431 if (composite_image == (Image *) NULL) 7432 { 7433 status=MagickFalse; 7434 break; 7435 } 7436 (void) TransformImage(&composite_image,(char *) NULL, 7437 composite_image->geometry,exception); 7438 SetGeometry(composite_image,&geometry); 7439 (void) ParseAbsoluteGeometry(composite_image->geometry,&geometry); 7440 GravityAdjustGeometry(image->columns,image->rows,image->gravity, 7441 &geometry); 7442 mask_image=RemoveFirstImageFromList(images); 7443 if (mask_image != (Image *) NULL) 7444 { 7445 if ((image->compose == DisplaceCompositeOp) || 7446 (image->compose == DistortCompositeOp)) 7447 { 7448 /* 7449 Merge Y displacement into X displacement image. 7450 */ 7451 (void) CompositeImage(composite_image,CopyGreenCompositeOp, 7452 mask_image,0,0,exception); 7453 mask_image=DestroyImage(mask_image); 7454 } 7455 else 7456 { 7457 /* 7458 Set a blending mask for the composition. 7459 Posible error, what if image->mask already set. 7460 */ 7461 image->mask=mask_image; 7462 (void) NegateImage(image->mask,MagickFalse,exception); 7463 } 7464 } 7465 (void) CompositeImage(image,image->compose,composite_image, 7466 geometry.x,geometry.y,exception); 7467 if (mask_image != (Image *) NULL) 7468 mask_image=image->mask=DestroyImage(image->mask); 7469 composite_image=DestroyImage(composite_image); 7470 *images=DestroyImageList(*images); 7471 *images=image; 7472 break; 7473 } 7474 break; 7475 } 7476 case 'd': 7477 { 7478 if (LocaleCompare("deconstruct",option+1) == 0) 7479 { 7480 Image 7481 *deconstruct_image; 7482 7483 (void) SyncImagesSettings(mogrify_info,*images,exception); 7484 deconstruct_image=CompareImagesLayers(*images,CompareAnyLayer, 7485 exception); 7486 if (deconstruct_image == (Image *) NULL) 7487 { 7488 status=MagickFalse; 7489 break; 7490 } 7491 *images=DestroyImageList(*images); 7492 *images=deconstruct_image; 7493 break; 7494 } 7495 if (LocaleCompare("delete",option+1) == 0) 7496 { 7497 if (*option == '+') 7498 DeleteImages(images,"-1",exception); 7499 else 7500 DeleteImages(images,argv[i+1],exception); 7501 break; 7502 } 7503 if (LocaleCompare("dither",option+1) == 0) 7504 { 7505 if (*option == '+') 7506 { 7507 quantize_info->dither=MagickFalse; 7508 break; 7509 } 7510 quantize_info->dither=MagickTrue; 7511 quantize_info->dither_method=(DitherMethod) ParseCommandOption( 7512 MagickDitherOptions,MagickFalse,argv[i+1]); 7513 break; 7514 } 7515 if (LocaleCompare("duplicate",option+1) == 0) 7516 { 7517 Image 7518 *duplicate_images; 7519 7520 if (*option == '+') 7521 duplicate_images=DuplicateImages(*images,1,"-1",exception); 7522 else 7523 { 7524 const char 7525 *p; 7526 7527 size_t 7528 number_duplicates; 7529 7530 number_duplicates=(size_t) StringToLong(argv[i+1]); 7531 p=strchr(argv[i+1],','); 7532 if (p == (const char *) NULL) 7533 duplicate_images=DuplicateImages(*images,number_duplicates, 7534 "-1",exception); 7535 else 7536 duplicate_images=DuplicateImages(*images,number_duplicates,p, 7537 exception); 7538 } 7539 AppendImageToList(images, duplicate_images); 7540 (void) SyncImagesSettings(mogrify_info,*images,exception); 7541 break; 7542 } 7543 break; 7544 } 7545 case 'e': 7546 { 7547 if (LocaleCompare("evaluate-sequence",option+1) == 0) 7548 { 7549 Image 7550 *evaluate_image; 7551 7552 MagickEvaluateOperator 7553 op; 7554 7555 (void) SyncImageSettings(mogrify_info,*images,exception); 7556 op=(MagickEvaluateOperator) ParseCommandOption( 7557 MagickEvaluateOptions,MagickFalse,argv[i+1]); 7558 evaluate_image=EvaluateImages(*images,op,exception); 7559 if (evaluate_image == (Image *) NULL) 7560 { 7561 status=MagickFalse; 7562 break; 7563 } 7564 *images=DestroyImageList(*images); 7565 *images=evaluate_image; 7566 break; 7567 } 7568 break; 7569 } 7570 case 'f': 7571 { 7572 if (LocaleCompare("fft",option+1) == 0) 7573 { 7574 Image 7575 *fourier_image; 7576 7577 /* 7578 Implements the discrete Fourier transform (DFT). 7579 */ 7580 (void) SyncImageSettings(mogrify_info,*images,exception); 7581 fourier_image=ForwardFourierTransformImage(*images,*option == '-' ? 7582 MagickTrue : MagickFalse,exception); 7583 if (fourier_image == (Image *) NULL) 7584 break; 7585 *images=DestroyImage(*images); 7586 *images=fourier_image; 7587 break; 7588 } 7589 if (LocaleCompare("flatten",option+1) == 0) 7590 { 7591 Image 7592 *flatten_image; 7593 7594 (void) SyncImagesSettings(mogrify_info,*images,exception); 7595 flatten_image=MergeImageLayers(*images,FlattenLayer,exception); 7596 if (flatten_image == (Image *) NULL) 7597 break; 7598 *images=DestroyImageList(*images); 7599 *images=flatten_image; 7600 break; 7601 } 7602 if (LocaleCompare("fx",option+1) == 0) 7603 { 7604 Image 7605 *fx_image; 7606 7607 (void) SyncImagesSettings(mogrify_info,*images,exception); 7608 fx_image=FxImage(*images,argv[i+1],exception); 7609 if (fx_image == (Image *) NULL) 7610 { 7611 status=MagickFalse; 7612 break; 7613 } 7614 *images=DestroyImageList(*images); 7615 *images=fx_image; 7616 break; 7617 } 7618 break; 7619 } 7620 case 'h': 7621 { 7622 if (LocaleCompare("hald-clut",option+1) == 0) 7623 { 7624 Image 7625 *hald_image, 7626 *image; 7627 7628 (void) SyncImagesSettings(mogrify_info,*images,exception); 7629 image=RemoveFirstImageFromList(images); 7630 hald_image=RemoveFirstImageFromList(images); 7631 if (hald_image == (Image *) NULL) 7632 { 7633 status=MagickFalse; 7634 break; 7635 } 7636 (void) HaldClutImage(image,hald_image,exception); 7637 hald_image=DestroyImage(hald_image); 7638 if (*images != (Image *) NULL) 7639 *images=DestroyImageList(*images); 7640 *images=image; 7641 break; 7642 } 7643 break; 7644 } 7645 case 'i': 7646 { 7647 if (LocaleCompare("ift",option+1) == 0) 7648 { 7649 Image 7650 *fourier_image, 7651 *magnitude_image, 7652 *phase_image; 7653 7654 /* 7655 Implements the inverse fourier discrete Fourier transform (DFT). 7656 */ 7657 (void) SyncImagesSettings(mogrify_info,*images,exception); 7658 magnitude_image=RemoveFirstImageFromList(images); 7659 phase_image=RemoveFirstImageFromList(images); 7660 if (phase_image == (Image *) NULL) 7661 { 7662 status=MagickFalse; 7663 break; 7664 } 7665 fourier_image=InverseFourierTransformImage(magnitude_image, 7666 phase_image,*option == '-' ? MagickTrue : MagickFalse,exception); 7667 if (fourier_image == (Image *) NULL) 7668 break; 7669 if (*images != (Image *) NULL) 7670 *images=DestroyImage(*images); 7671 *images=fourier_image; 7672 break; 7673 } 7674 if (LocaleCompare("insert",option+1) == 0) 7675 { 7676 Image 7677 *p, 7678 *q; 7679 7680 index=0; 7681 if (*option != '+') 7682 index=(ssize_t) StringToLong(argv[i+1]); 7683 p=RemoveLastImageFromList(images); 7684 if (p == (Image *) NULL) 7685 { 7686 (void) ThrowMagickException(exception,GetMagickModule(), 7687 OptionError,"NoSuchImage","`%s'",argv[i+1]); 7688 status=MagickFalse; 7689 break; 7690 } 7691 q=p; 7692 if (index == 0) 7693 PrependImageToList(images,q); 7694 else 7695 if (index == (ssize_t) GetImageListLength(*images)) 7696 AppendImageToList(images,q); 7697 else 7698 { 7699 q=GetImageFromList(*images,index-1); 7700 if (q == (Image *) NULL) 7701 { 7702 (void) ThrowMagickException(exception,GetMagickModule(), 7703 OptionError,"NoSuchImage","`%s'",argv[i+1]); 7704 status=MagickFalse; 7705 break; 7706 } 7707 InsertImageInList(&q,p); 7708 } 7709 *images=GetFirstImageInList(q); 7710 break; 7711 } 7712 if (LocaleCompare("interpolate",option+1) == 0) 7713 { 7714 interpolate_method=(PixelInterpolateMethod) ParseCommandOption( 7715 MagickInterpolateOptions,MagickFalse,argv[i+1]); 7716 break; 7717 } 7718 break; 7719 } 7720 case 'l': 7721 { 7722 if (LocaleCompare("layers",option+1) == 0) 7723 { 7724 Image 7725 *layers; 7726 7727 ImageLayerMethod 7728 method; 7729 7730 (void) SyncImagesSettings(mogrify_info,*images,exception); 7731 layers=(Image *) NULL; 7732 method=(ImageLayerMethod) ParseCommandOption(MagickLayerOptions, 7733 MagickFalse,argv[i+1]); 7734 switch (method) 7735 { 7736 case CoalesceLayer: 7737 { 7738 layers=CoalesceImages(*images,exception); 7739 break; 7740 } 7741 case CompareAnyLayer: 7742 case CompareClearLayer: 7743 case CompareOverlayLayer: 7744 default: 7745 { 7746 layers=CompareImagesLayers(*images,method,exception); 7747 break; 7748 } 7749 case MergeLayer: 7750 case FlattenLayer: 7751 case MosaicLayer: 7752 case TrimBoundsLayer: 7753 { 7754 layers=MergeImageLayers(*images,method,exception); 7755 break; 7756 } 7757 case DisposeLayer: 7758 { 7759 layers=DisposeImages(*images,exception); 7760 break; 7761 } 7762 case OptimizeImageLayer: 7763 { 7764 layers=OptimizeImageLayers(*images,exception); 7765 break; 7766 } 7767 case OptimizePlusLayer: 7768 { 7769 layers=OptimizePlusImageLayers(*images,exception); 7770 break; 7771 } 7772 case OptimizeTransLayer: 7773 { 7774 OptimizeImageTransparency(*images,exception); 7775 break; 7776 } 7777 case RemoveDupsLayer: 7778 { 7779 RemoveDuplicateLayers(images,exception); 7780 break; 7781 } 7782 case RemoveZeroLayer: 7783 { 7784 RemoveZeroDelayLayers(images,exception); 7785 break; 7786 } 7787 case OptimizeLayer: 7788 { 7789 /* 7790 General Purpose, GIF Animation Optimizer. 7791 */ 7792 layers=CoalesceImages(*images,exception); 7793 if (layers == (Image *) NULL) 7794 { 7795 status=MagickFalse; 7796 break; 7797 } 7798 *images=DestroyImageList(*images); 7799 *images=layers; 7800 layers=OptimizeImageLayers(*images,exception); 7801 if (layers == (Image *) NULL) 7802 { 7803 status=MagickFalse; 7804 break; 7805 } 7806 *images=DestroyImageList(*images); 7807 *images=layers; 7808 layers=(Image *) NULL; 7809 OptimizeImageTransparency(*images,exception); 7810 (void) RemapImages(quantize_info,*images,(Image *) NULL, 7811 exception); 7812 break; 7813 } 7814 case CompositeLayer: 7815 { 7816 CompositeOperator 7817 compose; 7818 7819 Image 7820 *source; 7821 7822 RectangleInfo 7823 geometry; 7824 7825 /* 7826 Split image sequence at the first 'NULL:' image. 7827 */ 7828 source=(*images); 7829 while (source != (Image *) NULL) 7830 { 7831 source=GetNextImageInList(source); 7832 if ((source != (Image *) NULL) && 7833 (LocaleCompare(source->magick,"NULL") == 0)) 7834 break; 7835 } 7836 if (source != (Image *) NULL) 7837 { 7838 if ((GetPreviousImageInList(source) == (Image *) NULL) || 7839 (GetNextImageInList(source) == (Image *) NULL)) 7840 source=(Image *) NULL; 7841 else 7842 { 7843 /* 7844 Separate the two lists, junk the null: image. 7845 */ 7846 source=SplitImageList(source->previous); 7847 DeleteImageFromList(&source); 7848 } 7849 } 7850 if (source == (Image *) NULL) 7851 { 7852 (void) ThrowMagickException(exception,GetMagickModule(), 7853 OptionError,"MissingNullSeparator","layers Composite"); 7854 status=MagickFalse; 7855 break; 7856 } 7857 /* 7858 Adjust offset with gravity and virtual canvas. 7859 */ 7860 SetGeometry(*images,&geometry); 7861 (void) ParseAbsoluteGeometry((*images)->geometry,&geometry); 7862 geometry.width=source->page.width != 0 ? 7863 source->page.width : source->columns; 7864 geometry.height=source->page.height != 0 ? 7865 source->page.height : source->rows; 7866 GravityAdjustGeometry((*images)->page.width != 0 ? 7867 (*images)->page.width : (*images)->columns, 7868 (*images)->page.height != 0 ? (*images)->page.height : 7869 (*images)->rows,(*images)->gravity,&geometry); 7870 compose=OverCompositeOp; 7871 option=GetImageOption(mogrify_info,"compose"); 7872 if (option != (const char *) NULL) 7873 compose=(CompositeOperator) ParseCommandOption( 7874 MagickComposeOptions,MagickFalse,option); 7875 CompositeLayers(*images,compose,source,geometry.x,geometry.y, 7876 exception); 7877 source=DestroyImageList(source); 7878 break; 7879 } 7880 } 7881 if (layers == (Image *) NULL) 7882 break; 7883 *images=DestroyImageList(*images); 7884 *images=layers; 7885 break; 7886 } 7887 break; 7888 } 7889 case 'm': 7890 { 7891 if (LocaleCompare("map",option+1) == 0) 7892 { 7893 (void) SyncImagesSettings(mogrify_info,*images,exception); 7894 if (*option == '+') 7895 { 7896 (void) RemapImages(quantize_info,*images,(Image *) NULL, 7897 exception); 7898 break; 7899 } 7900 i++; 7901 break; 7902 } 7903 if (LocaleCompare("maximum",option+1) == 0) 7904 { 7905 Image 7906 *maximum_image; 7907 7908 /* 7909 Maximum image sequence (deprecated). 7910 */ 7911 (void) SyncImagesSettings(mogrify_info,*images,exception); 7912 maximum_image=EvaluateImages(*images,MaxEvaluateOperator,exception); 7913 if (maximum_image == (Image *) NULL) 7914 { 7915 status=MagickFalse; 7916 break; 7917 } 7918 *images=DestroyImageList(*images); 7919 *images=maximum_image; 7920 break; 7921 } 7922 if (LocaleCompare("minimum",option+1) == 0) 7923 { 7924 Image 7925 *minimum_image; 7926 7927 /* 7928 Minimum image sequence (deprecated). 7929 */ 7930 (void) SyncImagesSettings(mogrify_info,*images,exception); 7931 minimum_image=EvaluateImages(*images,MinEvaluateOperator,exception); 7932 if (minimum_image == (Image *) NULL) 7933 { 7934 status=MagickFalse; 7935 break; 7936 } 7937 *images=DestroyImageList(*images); 7938 *images=minimum_image; 7939 break; 7940 } 7941 if (LocaleCompare("morph",option+1) == 0) 7942 { 7943 Image 7944 *morph_image; 7945 7946 (void) SyncImagesSettings(mogrify_info,*images,exception); 7947 morph_image=MorphImages(*images,StringToUnsignedLong(argv[i+1]), 7948 exception); 7949 if (morph_image == (Image *) NULL) 7950 { 7951 status=MagickFalse; 7952 break; 7953 } 7954 *images=DestroyImageList(*images); 7955 *images=morph_image; 7956 break; 7957 } 7958 if (LocaleCompare("mosaic",option+1) == 0) 7959 { 7960 Image 7961 *mosaic_image; 7962 7963 (void) SyncImagesSettings(mogrify_info,*images,exception); 7964 mosaic_image=MergeImageLayers(*images,MosaicLayer,exception); 7965 if (mosaic_image == (Image *) NULL) 7966 { 7967 status=MagickFalse; 7968 break; 7969 } 7970 *images=DestroyImageList(*images); 7971 *images=mosaic_image; 7972 break; 7973 } 7974 break; 7975 } 7976 case 'p': 7977 { 7978 if (LocaleCompare("print",option+1) == 0) 7979 { 7980 char 7981 *string; 7982 7983 (void) SyncImagesSettings(mogrify_info,*images,exception); 7984 string=InterpretImageProperties(mogrify_info,*images,argv[i+1], 7985 exception); 7986 if (string == (char *) NULL) 7987 break; 7988 (void) FormatLocaleFile(stdout,"%s",string); 7989 string=DestroyString(string); 7990 } 7991 if (LocaleCompare("process",option+1) == 0) 7992 { 7993 char 7994 **arguments; 7995 7996 int 7997 j, 7998 number_arguments; 7999 8000 (void) SyncImagesSettings(mogrify_info,*images,exception); 8001 arguments=StringToArgv(argv[i+1],&number_arguments); 8002 if (arguments == (char **) NULL) 8003 break; 8004 if ((argc > 1) && (strchr(arguments[1],'=') != (char *) NULL)) 8005 { 8006 char 8007 breaker, 8008 quote, 8009 *token; 8010 8011 const char 8012 *arguments; 8013 8014 int 8015 next, 8016 status; 8017 8018 size_t 8019 length; 8020 8021 TokenInfo 8022 *token_info; 8023 8024 /* 8025 Support old style syntax, filter="-option arg". 8026 */ 8027 length=strlen(argv[i+1]); 8028 token=(char *) NULL; 8029 if (~length >= (MaxTextExtent-1)) 8030 token=(char *) AcquireQuantumMemory(length+MaxTextExtent, 8031 sizeof(*token)); 8032 if (token == (char *) NULL) 8033 break; 8034 next=0; 8035 arguments=argv[i+1]; 8036 token_info=AcquireTokenInfo(); 8037 status=Tokenizer(token_info,0,token,length,arguments,"","=", 8038 "\"",'\0',&breaker,&next,"e); 8039 token_info=DestroyTokenInfo(token_info); 8040 if (status == 0) 8041 { 8042 const char 8043 *argv; 8044 8045 argv=(&(arguments[next])); 8046 (void) InvokeDynamicImageFilter(token,&(*images),1,&argv, 8047 exception); 8048 } 8049 token=DestroyString(token); 8050 break; 8051 } 8052 (void) SubstituteString(&arguments[1],"-",""); 8053 (void) InvokeDynamicImageFilter(arguments[1],&(*images), 8054 number_arguments-2,(const char **) arguments+2,exception); 8055 for (j=0; j < number_arguments; j++) 8056 arguments[j]=DestroyString(arguments[j]); 8057 arguments=(char **) RelinquishMagickMemory(arguments); 8058 break; 8059 } 8060 break; 8061 } 8062 case 'r': 8063 { 8064 if (LocaleCompare("reverse",option+1) == 0) 8065 { 8066 ReverseImageList(images); 8067 break; 8068 } 8069 break; 8070 } 8071 case 's': 8072 { 8073 if (LocaleCompare("smush",option+1) == 0) 8074 { 8075 Image 8076 *smush_image; 8077 8078 ssize_t 8079 offset; 8080 8081 (void) SyncImagesSettings(mogrify_info,*images,exception); 8082 offset=(ssize_t) StringToLong(argv[i+1]); 8083 smush_image=SmushImages(*images,*option == '-' ? MagickTrue : 8084 MagickFalse,offset,exception); 8085 if (smush_image == (Image *) NULL) 8086 { 8087 status=MagickFalse; 8088 break; 8089 } 8090 *images=DestroyImageList(*images); 8091 *images=smush_image; 8092 break; 8093 } 8094 if (LocaleCompare("swap",option+1) == 0) 8095 { 8096 Image 8097 *p, 8098 *q, 8099 *swap; 8100 8101 ssize_t 8102 swap_index; 8103 8104 index=(-1); 8105 swap_index=(-2); 8106 if (*option != '+') 8107 { 8108 GeometryInfo 8109 geometry_info; 8110 8111 MagickStatusType 8112 flags; 8113 8114 swap_index=(-1); 8115 flags=ParseGeometry(argv[i+1],&geometry_info); 8116 index=(ssize_t) geometry_info.rho; 8117 if ((flags & SigmaValue) != 0) 8118 swap_index=(ssize_t) geometry_info.sigma; 8119 } 8120 p=GetImageFromList(*images,index); 8121 q=GetImageFromList(*images,swap_index); 8122 if ((p == (Image *) NULL) || (q == (Image *) NULL)) 8123 { 8124 (void) ThrowMagickException(exception,GetMagickModule(), 8125 OptionError,"NoSuchImage","`%s'",(*images)->filename); 8126 status=MagickFalse; 8127 break; 8128 } 8129 if (p == q) 8130 break; 8131 swap=CloneImage(p,0,0,MagickTrue,exception); 8132 ReplaceImageInList(&p,CloneImage(q,0,0,MagickTrue,exception)); 8133 ReplaceImageInList(&q,swap); 8134 *images=GetFirstImageInList(q); 8135 break; 8136 } 8137 break; 8138 } 8139 case 'w': 8140 { 8141 if (LocaleCompare("write",option+1) == 0) 8142 { 8143 char 8144 key[MaxTextExtent]; 8145 8146 Image 8147 *write_images; 8148 8149 ImageInfo 8150 *write_info; 8151 8152 (void) SyncImagesSettings(mogrify_info,*images,exception); 8153 (void) FormatLocaleString(key,MaxTextExtent,"cache:%s",argv[i+1]); 8154 (void) DeleteImageRegistry(key); 8155 write_images=(*images); 8156 if (*option == '+') 8157 write_images=CloneImageList(*images,exception); 8158 write_info=CloneImageInfo(mogrify_info); 8159 status&=WriteImages(write_info,write_images,argv[i+1],exception); 8160 write_info=DestroyImageInfo(write_info); 8161 if (*option == '+') 8162 write_images=DestroyImageList(write_images); 8163 break; 8164 } 8165 break; 8166 } 8167 default: 8168 break; 8169 } 8170 i+=count; 8171 } 8172 quantize_info=DestroyQuantizeInfo(quantize_info); 8173 mogrify_info=DestroyImageInfo(mogrify_info); 8174 status&=MogrifyImageInfo(image_info,argc,argv,exception); 8175 return(status != 0 ? MagickTrue : MagickFalse); 8176} 8177 8178/* 8179%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8180% % 8181% % 8182% % 8183+ M o g r i f y I m a g e s % 8184% % 8185% % 8186% % 8187%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8188% 8189% MogrifyImages() applies image processing options to a sequence of images as 8190% prescribed by command line options. 8191% 8192% The format of the MogrifyImage method is: 8193% 8194% MagickBooleanType MogrifyImages(ImageInfo *image_info, 8195% const MagickBooleanType post,const int argc,const char **argv, 8196% Image **images,Exceptioninfo *exception) 8197% 8198% A description of each parameter follows: 8199% 8200% o image_info: the image info.. 8201% 8202% o post: If true, post process image list operators otherwise pre-process. 8203% 8204% o argc: Specifies a pointer to an integer describing the number of 8205% elements in the argument vector. 8206% 8207% o argv: Specifies a pointer to a text array containing the command line 8208% arguments. 8209% 8210% o images: pointer to a pointer of the first image in image list. 8211% 8212% o exception: return any errors or warnings in this structure. 8213% 8214*/ 8215WandExport MagickBooleanType MogrifyImages(ImageInfo *image_info, 8216 const MagickBooleanType post,const int argc,const char **argv, 8217 Image **images,ExceptionInfo *exception) 8218{ 8219#define MogrifyImageTag "Mogrify/Image" 8220 8221 MagickStatusType 8222 status; 8223 8224 MagickBooleanType 8225 proceed; 8226 8227 size_t 8228 n; 8229 8230 register ssize_t 8231 i; 8232 8233 assert(image_info != (ImageInfo *) NULL); 8234 assert(image_info->signature == MagickSignature); 8235 if (images == (Image **) NULL) 8236 return(MogrifyImage(image_info,argc,argv,images,exception)); 8237 assert((*images)->previous == (Image *) NULL); 8238 assert((*images)->signature == MagickSignature); 8239 if ((*images)->debug != MagickFalse) 8240 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", 8241 (*images)->filename); 8242 if ((argc <= 0) || (*argv == (char *) NULL)) 8243 return(MagickTrue); 8244 (void) SetImageInfoProgressMonitor(image_info,(MagickProgressMonitor) NULL, 8245 (void *) NULL); 8246 status=0; 8247 8248#if 0 8249 (void) FormatLocaleFile(stderr, "mogrify start %s %d (%s)\n",argv[0],argc, 8250 post?"post":"pre"); 8251#endif 8252 8253 /* 8254 Pre-process multi-image sequence operators 8255 */ 8256 if (post == MagickFalse) 8257 status&=MogrifyImageList(image_info,argc,argv,images,exception); 8258 /* 8259 For each image, process simple single image operators 8260 */ 8261 i=0; 8262 n=GetImageListLength(*images); 8263 for ( ; ; ) 8264 { 8265#if 0 8266 (void) FormatLocaleFile(stderr,"mogrify %ld of %ld\n",(long) 8267 GetImageIndexInList(*images),(long)GetImageListLength(*images)); 8268#endif 8269 status&=MogrifyImage(image_info,argc,argv,images,exception); 8270 proceed=SetImageProgress(*images,MogrifyImageTag,(MagickOffsetType) i, n); 8271 if (proceed == MagickFalse) 8272 break; 8273 if ( (*images)->next == (Image *) NULL ) 8274 break; 8275 *images=(*images)->next; 8276 i++; 8277 } 8278 assert( *images != (Image *) NULL ); 8279#if 0 8280 (void) FormatLocaleFile(stderr,"mogrify end %ld of %ld\n",(long) 8281 GetImageIndexInList(*images),(long)GetImageListLength(*images)); 8282#endif 8283 8284 /* 8285 Post-process, multi-image sequence operators 8286 */ 8287 *images=GetFirstImageInList(*images); 8288 if (post != MagickFalse) 8289 status&=MogrifyImageList(image_info,argc,argv,images,exception); 8290 return(status != 0 ? MagickTrue : MagickFalse); 8291} 8292