granicus.if.org Git - imagemagick/blob - MagickWand/composite.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %        CCCC    OOO   M   M  PPPP    OOO   SSSSS  IIIII  TTTTT  EEEEE        %
   7 %       C       O   O  MM MM  P   P  O   O  SS       I      T    E            %
   8 %       C       O   O  M M M  PPPP   O   O   SSS     I      T    EEE          %
   9 %       C       O   O  M   M  P      O   O     SS    I      T    E            %
  10 %        CCCC    OOO   M   M  P       OOO   SSSSS  IIIII    T    EEEEE        %
  11 %                                                                             %
  12 %                                                                             %
  13 %                      MagickWand Image Composite Methods                     %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  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 composite program to overlap one image over another.
  37 %
  38 */
  39 \f
  40 /*
  41   Include declarations.
  42 */
  43 #include "MagickWand/studio.h"
  44 #include "MagickWand/MagickWand.h"
  45 #include "MagickWand/mogrify-private.h"
  46 #include "MagickCore/string-private.h"
  47 \f
  48 /*
  49   Typedef declarations.
  50 */
  51 typedef struct _CompositeOptions
  52 {
  53   ChannelType
  54     channel;
  55
  56   char
  57     *compose_args,
  58     *geometry;
  59
  60   CompositeOperator
  61     compose;
  62
  63   GravityType
  64     gravity;
  65
  66   ssize_t
  67     stegano;
  68
  69   RectangleInfo
  70     offset;
  71
  72   MagickBooleanType
  73     stereo,
  74     tile;
  75 } CompositeOptions;
  76 \f
  77 /*
  78 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  79 %                                                                             %
  80 %                                                                             %
  81 %                                                                             %
  82 %  C o m p o s i t e I m a g e C o m m a n d                                  %
  83 %                                                                             %
  84 %                                                                             %
  85 %                                                                             %
  86 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  87 %
  88 %  CompositeImageCommand() reads one or more images and an optional mask and
  89 %  composites them into a new image.
  90 %
  91 %  The format of the CompositeImageCommand method is:
  92 %
  93 %      MagickBooleanType CompositeImageCommand(ImageInfo *image_info,int argc,
  94 %        char **argv,char **metadata,ExceptionInfo *exception)
  95 %
  96 %  A description of each parameter follows:
  97 %
  98 %    o image_info: the image info.
  99 %
 100 %    o argc: the number of elements in the argument vector.
 101 %
 102 %    o argv: A text array containing the command line arguments.
 103 %
 104 %    o metadata: any metadata is returned here.
 105 %
 106 %    o exception: return any errors or warnings in this structure.
 107 %
 108 */
 109
 110 static MagickBooleanType CompositeImageList(ImageInfo *image_info,Image **image,
 111   Image *composite_image,CompositeOptions *composite_options,
 112   ExceptionInfo *exception)
 113 {
 114   ChannelType
 115     channel_mask;
 116
 117   MagickStatusType
 118     status;
 119
 120   assert(image_info != (ImageInfo *) NULL);
 121   assert(image_info->signature == MagickSignature);
 122   assert(image != (Image **) NULL);
 123   assert((*image)->signature == MagickSignature);
 124   if ((*image)->debug != MagickFalse)
 125     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
 126   assert(exception != (ExceptionInfo *) NULL);
 127   status=MagickTrue;
 128   channel_mask=SetPixelChannelMask(composite_image,composite_options->channel);
 129   if (composite_image != (Image *) NULL)
 130     {
 131       assert(composite_image->signature == MagickSignature);
 132       switch (composite_options->compose)
 133       {
 134         case BlendCompositeOp:
 135         case BlurCompositeOp:
 136         case DisplaceCompositeOp:
 137         case DistortCompositeOp:
 138         case DissolveCompositeOp:
 139         case ModulateCompositeOp:
 140         case ThresholdCompositeOp:
 141           (void) SetImageArtifact(composite_image,"compose:args",
 142             composite_options->compose_args);
 143           break;
 144         default:
 145           break;
 146       }
 147       /*
 148         Composite image.
 149       */
 150       if (composite_options->stegano != 0)
 151         {
 152           Image
 153             *stegano_image;
 154
 155           (*image)->offset=composite_options->stegano-1;
 156           stegano_image=SteganoImage(*image,composite_image,exception);
 157           if (stegano_image != (Image *) NULL)
 158             {
 159               *image=DestroyImageList(*image);
 160               *image=stegano_image;
 161             }
 162         }
 163       else
 164         if (composite_options->stereo != MagickFalse)
 165           {
 166             Image
 167               *stereo_image;
 168
 169             stereo_image=StereoAnaglyphImage(*image,composite_image,
 170               composite_options->offset.x,composite_options->offset.y,
 171               exception);
 172             if (stereo_image != (Image *) NULL)
 173               {
 174                 *image=DestroyImageList(*image);
 175                 *image=stereo_image;
 176               }
 177           }
 178         else
 179           if (composite_options->tile != MagickFalse)
 180             {
 181               size_t
 182                 columns;
 183
 184               ssize_t
 185                 x,
 186                 y;
 187
 188               /*
 189                 Tile the composite image.
 190               */
 191               (void) SetImageArtifact(composite_image,"compose:outside-overlay",
 192                 "false");
 193               columns=composite_image->columns;
 194               for (y=0; y < (ssize_t) (*image)->rows; y+=(ssize_t) composite_image->rows)
 195                 for (x=0; x < (ssize_t) (*image)->columns; x+=(ssize_t) columns)
 196                   status&=CompositeImage(*image,composite_options->compose,
 197                     composite_image,x,y);
 198               GetImageException(*image,exception);
 199             }
 200           else
 201             {
 202               RectangleInfo
 203                 geometry;
 204
 205               /*
 206                 Work out gravity Adjustment of Offset
 207               */
 208               SetGeometry(*image,&geometry);
 209               (void) ParseAbsoluteGeometry(composite_options->geometry,
 210                 &geometry);
 211               geometry.width=composite_image->columns;
 212               geometry.height=composite_image->rows;
 213               GravityAdjustGeometry((*image)->columns,(*image)->rows,
 214                 composite_options->gravity, &geometry);
 215               (*image)->gravity=(GravityType) composite_options->gravity;
 216               /*
 217                 Digitally composite image.
 218               */
 219               status&=CompositeImage(*image,composite_options->compose,
 220                 composite_image,geometry.x,geometry.y);
 221               GetImageException(*image,exception);
 222             }
 223     }
 224   (void) SetPixelChannelMap(composite_image,channel_mask);
 225   return(status != 0 ? MagickTrue : MagickFalse);
 226 }
 227
 228 static MagickBooleanType CompositeUsage(void)
 229 {
 230   const char
 231     **p;
 232
 233   static const char
 234     *miscellaneous[]=
 235     {
 236       "-debug events        display copious debugging information",
 237       "-help                print program options",
 238       "-list type           print a list of supported option arguments",
 239       "-log format          format of debugging information",
 240       "-version             print version information",
 241       (char *) NULL
 242     },
 243     *operators[]=
 244     {
 245       "-blend geometry      blend images",
 246       "-border geometry     surround image with a border of color",
 247       "-bordercolor color   border color",
 248       "-colors value        preferred number of colors in the image",
 249       "-decipher filename    convert cipher pixels to plain pixels",
 250       "-displace geometry   shift lookup according to a relative displacement map",
 251       "-dissolve value      dissolve the two images a given percent",
 252       "-distort geometry    shift lookup according to a absolute distortion map",
 253       "-encipher filename   convert plain pixels to cipher pixels",
 254       "-extract geometry    extract area from image",
 255       "-geometry geometry   location of the composite image",
 256       "-identify            identify the format and characteristics of the image",
 257       "-monochrome          transform image to black and white",
 258       "-negate              replace every pixel with its complementary color ",
 259       "-profile filename    add ICM or IPTC information profile to image",
 260       "-quantize colorspace reduce colors in this colorspace",
 261       "-repage geometry     size and location of an image canvas (operator)",
 262       "-rotate degrees      apply Paeth rotation to the image",
 263       "-resize geometry     resize the image",
 264       "-sharpen geometry    sharpen the image",
 265       "-shave geometry      shave pixels from the image edges",
 266       "-stegano offset      hide watermark within an image",
 267       "-stereo geometry     combine two image to create a stereo anaglyph",
 268       "-strip               strip image of all profiles and comments",
 269       "-thumbnail geometry  create a thumbnail of the image",
 270       "-transform           affine transform image",
 271       "-type type           image type",
 272       "-unsharp geometry    sharpen the image",
 273       "-watermark geometry  percent brightness and saturation of a watermark",
 274       "-write filename      write images to this file",
 275       (char *) NULL
 276     },
 277     *settings[]=
 278     {
 279       "-affine matrix       affine transform matrix",
 280       "-alpha option        on, activate, off, deactivate, set, opaque, copy",
 281       "                     transparent, extract, background, or shape",
 282       "-authenticate password",
 283       "                     decipher image with this password",
 284       "-blue-primary point  chromaticity blue primary point",
 285       "-channel type        apply option to select image channels",
 286       "-colorspace type     alternate image colorspace",
 287       "-comment string      annotate image with comment",
 288       "-compose operator    composite operator",
 289       "-compress type       type of pixel compression when writing the image",
 290       "-define format:option",
 291       "                     define one or more image format options",
 292       "-depth value         image depth",
 293       "-density geometry    horizontal and vertical density of the image",
 294       "-display server      get image or font from this X server",
 295       "-dispose method      layer disposal method",
 296       "-dither method       apply error diffusion to image",
 297       "-encoding type       text encoding type",
 298       "-endian type         endianness (MSB or LSB) of the image",
 299       "-filter type         use this filter when resizing an image",
 300       "-font name           render text with this font",
 301       "-format \"string\"     output formatted image characteristics",
 302       "-gravity type        which direction to gravitate towards",
 303       "-green-primary point chromaticity green primary point",
 304       "-interlace type      type of image interlacing scheme",
 305       "-interpolate method  pixel color interpolation method",
 306       "-label string        assign a label to an image",
 307       "-limit type value    pixel cache resource limit",
 308       "-monitor             monitor progress",
 309       "-page geometry       size and location of an image canvas (setting)",
 310       "-pointsize value     font point size",
 311       "-quality value       JPEG/MIFF/PNG compression level",
 312       "-quiet               suppress all warning messages",
 313       "-red-primary point   chromaticity red primary point",
 314       "-regard-warnings     pay attention to warning messages",
 315       "-respect-parentheses settings remain in effect until parenthesis boundary",
 316       "-sampling-factor geometry",
 317       "                     horizontal and vertical sampling factor",
 318       "-scene value         image scene number",
 319       "-seed value          seed a new sequence of pseudo-random numbers",
 320       "-size geometry       width and height of image",
 321       "-synchronize         synchronize image to storage device",
 322       "-taint               declare the image as modified",
 323       "-transparent-color color",
 324       "                     transparent color",
 325       "-treedepth value     color tree depth",
 326       "-tile                repeat composite operation across and down image",
 327       "-units type          the units of image resolution",
 328       "-verbose             print detailed information about the image",
 329       "-virtual-pixel method",
 330       "                     virtual pixel access method",
 331       "-white-point point   chromaticity white point",
 332       (char *) NULL
 333     },
 334     *stack_operators[]=
 335     {
 336       "-swap indexes        swap two images in the image sequence",
 337       (char *) NULL
 338     };
 339
 340
 341   (void) printf("Version: %s\n",GetMagickVersion((size_t *) NULL));
 342   (void) printf("Copyright: %s\n",GetMagickCopyright());
 343   (void) printf("Features: %s\n\n",GetMagickFeatures());
 344   (void) printf("Usage: %s [options ...] image [options ...] composite\n"
 345     "  [ [options ...] mask ] [options ...] composite\n",
 346     GetClientName());
 347   (void) printf("\nImage Settings:\n");
 348   for (p=settings; *p != (char *) NULL; p++)
 349     (void) printf("  %s\n",*p);
 350   (void) printf("\nImage Operators:\n");
 351   for (p=operators; *p != (char *) NULL; p++)
 352     (void) printf("  %s\n",*p);
 353   (void) printf("\nImage Stack Operators:\n");
 354   for (p=stack_operators; *p != (char *) NULL; p++)
 355     (void) printf("  %s\n",*p);
 356   (void) printf("\nMiscellaneous Options:\n");
 357   for (p=miscellaneous; *p != (char *) NULL; p++)
 358     (void) printf("  %s\n",*p);
 359   (void) printf(
 360     "\nBy default, the image format of `file' is determined by its magic\n");
 361   (void) printf(
 362     "number.  To specify a particular image format, precede the filename\n");
 363   (void) printf(
 364     "with an image format name and a colon (i.e. ps:image) or specify the\n");
 365   (void) printf(
 366     "image type as the filename suffix (i.e. image.ps).  Specify 'file' as\n");
 367   (void) printf("'-' for standard input or output.\n");
 368   return(MagickFalse);
 369 }
 370
 371 static void GetCompositeOptions(CompositeOptions *composite_options)
 372 {
 373   (void) ResetMagickMemory(composite_options,0,sizeof(*composite_options));
 374   composite_options->channel=DefaultChannels;
 375   composite_options->compose=OverCompositeOp;
 376 }
 377
 378 static void RelinquishCompositeOptions(CompositeOptions *composite_options)
 379 {
 380   if (composite_options->compose_args != (char *) NULL)
 381     composite_options->compose_args=(char *)
 382       RelinquishMagickMemory(composite_options->compose_args);
 383 }
 384
 385 WandExport MagickBooleanType CompositeImageCommand(ImageInfo *image_info,
 386   int argc,char **argv,char **metadata,ExceptionInfo *exception)
 387 {
 388 #define NotInitialized  (unsigned int) (~0)
 389 #define DestroyComposite() \
 390 { \
 391   RelinquishCompositeOptions(&composite_options); \
 392   DestroyImageStack(); \
 393   for (i=0; i < (ssize_t) argc; i++) \
 394     argv[i]=DestroyString(argv[i]); \
 395   argv=(char **) RelinquishMagickMemory(argv); \
 396 }
 397 #define ThrowCompositeException(asperity,tag,option) \
 398 { \
 399   (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
 400      option == (char *) NULL ? GetExceptionMessage(errno) : option); \
 401   DestroyComposite(); \
 402   return(MagickFalse); \
 403 }
 404 #define ThrowCompositeInvalidArgumentException(option,argument) \
 405 { \
 406   (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
 407     "InvalidArgument","`%s': %s",option,argument); \
 408   DestroyComposite(); \
 409   return(MagickFalse); \
 410 }
 411
 412   char
 413     *filename,
 414     *option;
 415
 416   CompositeOptions
 417     composite_options;
 418
 419   const char
 420     *format;
 421
 422   Image
 423     *composite_image,
 424     *image,
 425     *images,
 426     *mask_image;
 427
 428   ImageStack
 429     image_stack[MaxImageStackDepth+1];
 430
 431   MagickBooleanType
 432     fire,
 433     pend,
 434     respect_parenthesis;
 435
 436   MagickStatusType
 437     status;
 438
 439   register ssize_t
 440     i;
 441
 442   ssize_t
 443     j,
 444     k;
 445
 446   /*
 447     Set default.
 448   */
 449   assert(image_info != (ImageInfo *) NULL);
 450   assert(image_info->signature == MagickSignature);
 451   if (image_info->debug != MagickFalse)
 452     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 453   assert(exception != (ExceptionInfo *) NULL);
 454   if (argc == 2)
 455     {
 456       option=argv[1];
 457       if ((LocaleCompare("version",option+1) == 0) ||
 458           (LocaleCompare("-version",option+1) == 0))
 459         {
 460           (void) FormatLocaleFile(stdout,"Version: %s\n",
 461             GetMagickVersion((size_t *) NULL));
 462           (void) FormatLocaleFile(stdout,"Copyright: %s\n",
 463             GetMagickCopyright());
 464           (void) FormatLocaleFile(stdout,"Features: %s\n\n",
 465             GetMagickFeatures());
 466           return(MagickFalse);
 467         }
 468     }
 469   if (argc < 4)
 470     return(CompositeUsage());
 471   GetCompositeOptions(&composite_options);
 472   filename=(char *) NULL;
 473   format="%w,%h,%m";
 474   j=1;
 475   k=0;
 476   NewImageStack();
 477   option=(char *) NULL;
 478   pend=MagickFalse;
 479   respect_parenthesis=MagickFalse;
 480   status=MagickTrue;
 481   /*
 482     Check command syntax.
 483   */
 484   composite_image=NewImageList();
 485   image=NewImageList();
 486   mask_image=NewImageList();
 487   ReadCommandlLine(argc,&argv);
 488   status=ExpandFilenames(&argc,&argv);
 489   if (status == MagickFalse)
 490     ThrowCompositeException(ResourceLimitError,"MemoryAllocationFailed",
 491       GetExceptionMessage(errno));
 492   for (i=1; i < (ssize_t) (argc-1); i++)
 493   {
 494     option=argv[i];
 495     if (LocaleCompare(option,"(") == 0)
 496       {
 497         FireImageStack(MagickFalse,MagickTrue,pend);
 498         if (k == MaxImageStackDepth)
 499           ThrowCompositeException(OptionError,"ParenthesisNestedTooDeeply",
 500             option);
 501         PushImageStack();
 502         continue;
 503       }
 504     if (LocaleCompare(option,")") == 0)
 505       {
 506         FireImageStack(MagickFalse,MagickTrue,MagickTrue);
 507         if (k == 0)
 508           ThrowCompositeException(OptionError,"UnableToParseExpression",option);
 509         PopImageStack();
 510         continue;
 511       }
 512     if (IsCommandOption(option) == MagickFalse)
 513       {
 514         Image
 515           *images;
 516
 517         /*
 518           Read input image.
 519         */
 520         FireImageStack(MagickFalse,MagickFalse,pend);
 521         filename=argv[i];
 522         if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
 523           filename=argv[++i];
 524         (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
 525         images=ReadImages(image_info,exception);
 526         status&=(images != (Image *) NULL) &&
 527           (exception->severity < ErrorException);
 528         if (images == (Image *) NULL)
 529           continue;
 530         AppendImageStack(images);
 531         continue;
 532       }
 533     pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
 534     switch (*(option+1))
 535     {
 536       case 'a':
 537       {
 538         if (LocaleCompare("affine",option+1) == 0)
 539           {
 540             if (*option == '+')
 541               break;
 542             i++;
 543             if (i == (ssize_t) argc)
 544               ThrowCompositeException(OptionError,"MissingArgument",option);
 545             if (IsGeometry(argv[i]) == MagickFalse)
 546               ThrowCompositeInvalidArgumentException(option,argv[i]);
 547             break;
 548           }
 549         if (LocaleCompare("alpha",option+1) == 0)
 550           {
 551             ssize_t
 552               type;
 553
 554             if (*option == '+')
 555               break;
 556             i++;
 557             if (i == (ssize_t) argc)
 558               ThrowCompositeException(OptionError,"MissingArgument",option);
 559             type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]);
 560             if (type < 0)
 561               ThrowCompositeException(OptionError,
 562                 "UnrecognizedAlphaChannelType",argv[i]);
 563             break;
 564           }
 565         if (LocaleCompare("authenticate",option+1) == 0)
 566           {
 567             if (*option == '+')
 568               break;
 569             i++;
 570             if (i == (ssize_t) argc)
 571               ThrowCompositeException(OptionError,"MissingArgument",option);
 572             break;
 573           }
 574         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
 575       }
 576       case 'b':
 577       {
 578         if (LocaleCompare("background",option+1) == 0)
 579           {
 580             if (*option == '+')
 581               break;
 582             i++;
 583             if (i == (ssize_t) argc)
 584               ThrowCompositeException(OptionError,"MissingArgument",option);
 585             break;
 586           }
 587         if (LocaleCompare("blend",option+1) == 0)
 588           {
 589             (void) CloneString(&composite_options.compose_args,(char *) NULL);
 590             if (*option == '+')
 591               break;
 592             i++;
 593             if (i == (ssize_t) argc)
 594               ThrowCompositeException(OptionError,"MissingArgument",option);
 595             if (IsGeometry(argv[i]) == MagickFalse)
 596               ThrowCompositeInvalidArgumentException(option,argv[i]);
 597             (void) CloneString(&composite_options.compose_args,argv[i]);
 598             composite_options.compose=BlendCompositeOp;
 599             break;
 600           }
 601         if (LocaleCompare("blur",option+1) == 0)
 602           {
 603             (void) CloneString(&composite_options.compose_args,(char *) NULL);
 604             if (*option == '+')
 605               break;
 606             i++;
 607             if (i == (ssize_t) argc)
 608               ThrowCompositeException(OptionError,"MissingArgument",option);
 609             if (IsGeometry(argv[i]) == MagickFalse)
 610               ThrowCompositeInvalidArgumentException(option,argv[i]);
 611             (void) CloneString(&composite_options.compose_args,argv[i]);
 612             composite_options.compose=BlurCompositeOp;
 613             break;
 614           }
 615         if (LocaleCompare("blue-primary",option+1) == 0)
 616           {
 617             if (*option == '+')
 618               break;
 619             i++;
 620             if (i == (ssize_t) argc)
 621               ThrowCompositeException(OptionError,"MissingArgument",option);
 622             if (IsGeometry(argv[i]) == MagickFalse)
 623               ThrowCompositeInvalidArgumentException(option,argv[i]);
 624             break;
 625           }
 626         if (LocaleCompare("border",option+1) == 0)
 627           {
 628             if (*option == '+')
 629               break;
 630             i++;
 631             if (i == (ssize_t) (argc-1))
 632               ThrowCompositeException(OptionError,"MissingArgument",option);
 633             if (IsGeometry(argv[i]) == MagickFalse)
 634               ThrowCompositeInvalidArgumentException(option,argv[i]);
 635             break;
 636           }
 637         if (LocaleCompare("bordercolor",option+1) == 0)
 638           {
 639             if (*option == '+')
 640               break;
 641             i++;
 642             if (i == (ssize_t) (argc-1))
 643               ThrowCompositeException(OptionError,"MissingArgument",option);
 644             break;
 645           }
 646         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
 647       }
 648       case 'c':
 649       {
 650         if (LocaleCompare("cache",option+1) == 0)
 651           {
 652             if (*option == '+')
 653               break;
 654             i++;
 655             if (i == (ssize_t) argc)
 656               ThrowCompositeException(OptionError,"MissingArgument",option);
 657             if (IsGeometry(argv[i]) == MagickFalse)
 658               ThrowCompositeInvalidArgumentException(option,argv[i]);
 659             break;
 660           }
 661         if (LocaleCompare("channel",option+1) == 0)
 662           {
 663             ssize_t
 664               channel;
 665
 666             if (*option == '+')
 667               {
 668                 composite_options.channel=DefaultChannels;
 669                 break;
 670               }
 671             i++;
 672             if (i == (ssize_t) (argc-1))
 673               ThrowCompositeException(OptionError,"MissingArgument",option);
 674             channel=ParseChannelOption(argv[i]);
 675             if (channel < 0)
 676               ThrowCompositeException(OptionError,"UnrecognizedChannelType",
 677                 argv[i]);
 678             composite_options.channel=(ChannelType) channel;
 679             break;
 680           }
 681         if (LocaleCompare("colors",option+1) == 0)
 682           {
 683             if (*option == '+')
 684               break;
 685             i++;
 686             if (i == (ssize_t) argc)
 687               ThrowCompositeException(OptionError,"MissingArgument",option);
 688             if (IsGeometry(argv[i]) == MagickFalse)
 689               ThrowCompositeInvalidArgumentException(option,argv[i]);
 690             break;
 691           }
 692         if (LocaleCompare("colorspace",option+1) == 0)
 693           {
 694             ssize_t
 695               colorspace;
 696
 697             if (*option == '+')
 698               break;
 699             i++;
 700             if (i == (ssize_t) argc)
 701               ThrowCompositeException(OptionError,"MissingArgument",option);
 702             colorspace=ParseCommandOption(MagickColorspaceOptions,
 703               MagickFalse,argv[i]);
 704             if (colorspace < 0)
 705               ThrowCompositeException(OptionError,"UnrecognizedColorspace",
 706                 argv[i]);
 707             break;
 708           }
 709         if (LocaleCompare("comment",option+1) == 0)
 710           {
 711             if (*option == '+')
 712               break;
 713             i++;
 714             if (i == (ssize_t) argc)
 715               ThrowCompositeException(OptionError,"MissingArgument",option);
 716             break;
 717           }
 718         if (LocaleCompare("compose",option+1) == 0)
 719           {
 720             ssize_t
 721               compose;
 722
 723             composite_options.compose=UndefinedCompositeOp;
 724             if (*option == '+')
 725               break;
 726             i++;
 727             if (i == (ssize_t) argc)
 728               ThrowCompositeException(OptionError,"MissingArgument",option);
 729             compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
 730               argv[i]);
 731             if (compose < 0)
 732               ThrowCompositeException(OptionError,"UnrecognizedComposeOperator",
 733                 argv[i]);
 734             composite_options.compose=(CompositeOperator) compose;
 735             break;
 736           }
 737         if (LocaleCompare("compress",option+1) == 0)
 738           {
 739             ssize_t
 740               compress;
 741
 742             if (*option == '+')
 743               break;
 744             i++;
 745             if (i == (ssize_t) argc)
 746               ThrowCompositeException(OptionError,"MissingArgument",option);
 747             compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
 748               argv[i]);
 749             if (compress < 0)
 750               ThrowCompositeException(OptionError,
 751                 "UnrecognizedImageCompression",argv[i]);
 752             break;
 753           }
 754         if (LocaleCompare("concurrent",option+1) == 0)
 755           break;
 756         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
 757       }
 758       case 'd':
 759       {
 760         if (LocaleCompare("debug",option+1) == 0)
 761           {
 762             ssize_t
 763               event;
 764
 765             if (*option == '+')
 766               break;
 767             i++;
 768             if (i == (ssize_t) argc)
 769               ThrowCompositeException(OptionError,"MissingArgument",option);
 770             event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
 771             if (event < 0)
 772               ThrowCompositeException(OptionError,"UnrecognizedEventType",
 773                 argv[i]);
 774             (void) SetLogEventMask(argv[i]);
 775             break;
 776           }
 777         if (LocaleCompare("decipher",option+1) == 0)
 778           {
 779             if (*option == '+')
 780               break;
 781             i++;
 782             if (i == (ssize_t) (argc-1))
 783               ThrowCompositeException(OptionError,"MissingArgument",option);
 784             break;
 785           }
 786         if (LocaleCompare("define",option+1) == 0)
 787           {
 788             i++;
 789             if (i == (ssize_t) argc)
 790               ThrowCompositeException(OptionError,"MissingArgument",option);
 791             if (*option == '+')
 792               {
 793                 const char
 794                   *define;
 795
 796                 define=GetImageOption(image_info,argv[i]);
 797                 if (define == (const char *) NULL)
 798                   ThrowCompositeException(OptionError,"NoSuchOption",argv[i]);
 799                 break;
 800               }
 801             break;
 802           }
 803         if (LocaleCompare("density",option+1) == 0)
 804           {
 805             if (*option == '+')
 806               break;
 807             i++;
 808             if (i == (ssize_t) argc)
 809               ThrowCompositeException(OptionError,"MissingArgument",option);
 810             if (IsGeometry(argv[i]) == MagickFalse)
 811               ThrowCompositeInvalidArgumentException(option,argv[i]);
 812             break;
 813           }
 814         if (LocaleCompare("depth",option+1) == 0)
 815           {
 816             if (*option == '+')
 817               break;
 818             i++;
 819             if (i == (ssize_t) argc)
 820               ThrowCompositeException(OptionError,"MissingArgument",option);
 821             if (IsGeometry(argv[i]) == MagickFalse)
 822               ThrowCompositeInvalidArgumentException(option,argv[i]);
 823             break;
 824           }
 825         if (LocaleCompare("displace",option+1) == 0)
 826           {
 827             (void) CloneString(&composite_options.compose_args,(char *) NULL);
 828             if (*option == '+')
 829               break;
 830             i++;
 831             if (i == (ssize_t) argc)
 832               ThrowCompositeException(OptionError,"MissingArgument",option);
 833             if (IsGeometry(argv[i]) == MagickFalse)
 834               ThrowCompositeInvalidArgumentException(option,argv[i]);
 835             (void) CloneString(&composite_options.compose_args,argv[i]);
 836             composite_options.compose=DisplaceCompositeOp;
 837             break;
 838           }
 839         if (LocaleCompare("display",option+1) == 0)
 840           {
 841             if (*option == '+')
 842               break;
 843             i++;
 844             if (i == (ssize_t) argc)
 845               ThrowCompositeException(OptionError,"MissingArgument",option);
 846             break;
 847           }
 848         if (LocaleCompare("dispose",option+1) == 0)
 849           {
 850             ssize_t
 851               dispose;
 852
 853             if (*option == '+')
 854               break;
 855             i++;
 856             if (i == (ssize_t) argc)
 857               ThrowCompositeException(OptionError,"MissingArgument",option);
 858             dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,argv[i]);
 859             if (dispose < 0)
 860               ThrowCompositeException(OptionError,"UnrecognizedDisposeMethod",
 861                 argv[i]);
 862             break;
 863           }
 864         if (LocaleCompare("dissolve",option+1) == 0)
 865           {
 866             (void) CloneString(&composite_options.compose_args,(char *) NULL);
 867             if (*option == '+')
 868               break;
 869             i++;
 870             if (i == (ssize_t) argc)
 871               ThrowCompositeException(OptionError,"MissingArgument",option);
 872             if (IsGeometry(argv[i]) == MagickFalse)
 873               ThrowCompositeInvalidArgumentException(option,argv[i]);
 874             (void) CloneString(&composite_options.compose_args,argv[i]);
 875             composite_options.compose=DissolveCompositeOp;
 876             break;
 877           }
 878         if (LocaleCompare("distort",option+1) == 0)
 879           {
 880             (void) CloneString(&composite_options.compose_args,(char *) NULL);
 881             if (*option == '+')
 882               break;
 883             i++;
 884             if (i == (ssize_t) argc)
 885               ThrowCompositeException(OptionError,"MissingArgument",option);
 886             if (IsGeometry(argv[i]) == MagickFalse)
 887               ThrowCompositeInvalidArgumentException(option,argv[i]);
 888             (void) CloneString(&composite_options.compose_args,argv[i]);
 889             composite_options.compose=DistortCompositeOp;
 890             break;
 891           }
 892         if (LocaleCompare("dither",option+1) == 0)
 893           {
 894             ssize_t
 895               method;
 896
 897             if (*option == '+')
 898               break;
 899             i++;
 900             if (i == (ssize_t) argc)
 901               ThrowCompositeException(OptionError,"MissingArgument",option);
 902             method=ParseCommandOption(MagickDitherOptions,MagickFalse,argv[i]);
 903             if (method < 0)
 904               ThrowCompositeException(OptionError,"UnrecognizedDitherMethod",
 905                 argv[i]);
 906             break;
 907           }
 908         if (LocaleCompare("duration",option+1) == 0)
 909           {
 910             if (*option == '+')
 911               break;
 912             i++;
 913             if (i == (ssize_t) (argc-1))
 914               ThrowCompositeException(OptionError,"MissingArgument",option);
 915             if (IsGeometry(argv[i]) == MagickFalse)
 916               ThrowCompositeInvalidArgumentException(option,argv[i]);
 917             break;
 918           }
 919         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
 920       }
 921       case 'e':
 922       {
 923         if (LocaleCompare("encipher",option+1) == 0)
 924           {
 925             if (*option == '+')
 926               break;
 927             i++;
 928             if (i == (ssize_t) (argc-1))
 929               ThrowCompositeException(OptionError,"MissingArgument",option);
 930             break;
 931           }
 932         if (LocaleCompare("encoding",option+1) == 0)
 933           {
 934             if (*option == '+')
 935               break;
 936             i++;
 937             if (i == (ssize_t) argc)
 938               ThrowCompositeException(OptionError,"MissingArgument",option);
 939             break;
 940           }
 941         if (LocaleCompare("endian",option+1) == 0)
 942           {
 943             ssize_t
 944               endian;
 945
 946             if (*option == '+')
 947               break;
 948             i++;
 949             if (i == (ssize_t) argc)
 950               ThrowCompositeException(OptionError,"MissingArgument",option);
 951             endian=ParseCommandOption(MagickEndianOptions,MagickFalse,
 952               argv[i]);
 953             if (endian < 0)
 954               ThrowCompositeException(OptionError,"UnrecognizedEndianType",
 955                 argv[i]);
 956             break;
 957           }
 958         if (LocaleCompare("extract",option+1) == 0)
 959           {
 960             if (*option == '+')
 961               break;
 962             i++;
 963             if (i == (ssize_t) argc)
 964               ThrowCompositeException(OptionError,"MissingArgument",option);
 965             if (IsGeometry(argv[i]) == MagickFalse)
 966               ThrowCompositeInvalidArgumentException(option,argv[i]);
 967             break;
 968           }
 969         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
 970       }
 971       case 'f':
 972       {
 973         if (LocaleCompare("filter",option+1) == 0)
 974           {
 975             ssize_t
 976               filter;
 977
 978             if (*option == '+')
 979               break;
 980             i++;
 981             if (i == (ssize_t) argc)
 982               ThrowCompositeException(OptionError,"MissingArgument",option);
 983             filter=ParseCommandOption(MagickFilterOptions,MagickFalse,argv[i]);
 984             if (filter < 0)
 985               ThrowCompositeException(OptionError,"UnrecognizedImageFilter",
 986                 argv[i]);
 987             break;
 988           }
 989         if (LocaleCompare("font",option+1) == 0)
 990           {
 991             if (*option == '+')
 992               break;
 993             i++;
 994             if (i == (ssize_t) argc)
 995               ThrowCompositeException(OptionError,"MissingArgument",option);
 996             break;
 997           }
 998         if (LocaleCompare("format",option+1) == 0)
 999           {
1000             if (*option == '+')
1001               break;
1002             i++;
1003             if (i == (ssize_t) argc)
1004               ThrowCompositeException(OptionError,"MissingArgument",option);
1005             format=argv[i];
1006             break;
1007           }
1008         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1009       }
1010       case 'g':
1011       {
1012         if (LocaleCompare("geometry",option+1) == 0)
1013           {
1014             (void) CloneString(&composite_options.geometry,(char *) NULL);
1015             if (*option == '+')
1016               break;
1017             i++;
1018             if (i == (ssize_t) argc)
1019               ThrowCompositeException(OptionError,"MissingArgument",option);
1020             if (IsGeometry(argv[i]) == MagickFalse)
1021               ThrowCompositeInvalidArgumentException(option,argv[i]);
1022             (void) CloneString(&composite_options.geometry,argv[i]);
1023             break;
1024           }
1025         if (LocaleCompare("gravity",option+1) == 0)
1026           {
1027             ssize_t
1028               gravity;
1029
1030             composite_options.gravity=UndefinedGravity;
1031             if (*option == '+')
1032               break;
1033             i++;
1034             if (i == (ssize_t) argc)
1035               ThrowCompositeException(OptionError,"MissingArgument",option);
1036             gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
1037               argv[i]);
1038             if (gravity < 0)
1039               ThrowCompositeException(OptionError,"UnrecognizedGravityType",
1040                 argv[i]);
1041             composite_options.gravity=(GravityType) gravity;
1042             break;
1043           }
1044         if (LocaleCompare("green-primary",option+1) == 0)
1045           {
1046             if (*option == '+')
1047               break;
1048             i++;
1049             if (i == (ssize_t) argc)
1050               ThrowCompositeException(OptionError,"MissingArgument",option);
1051             if (IsGeometry(argv[i]) == MagickFalse)
1052               ThrowCompositeInvalidArgumentException(option,argv[i]);
1053             break;
1054           }
1055         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1056       }
1057       case 'h':
1058       {
1059         if ((LocaleCompare("help",option+1) == 0) ||
1060             (LocaleCompare("-help",option+1) == 0))
1061           return(CompositeUsage());
1062         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1063       }
1064       case 'i':
1065       {
1066         if (LocaleCompare("identify",option+1) == 0)
1067           break;
1068         if (LocaleCompare("interlace",option+1) == 0)
1069           {
1070             ssize_t
1071               interlace;
1072
1073             if (*option == '+')
1074               break;
1075             i++;
1076             if (i == (ssize_t) argc)
1077               ThrowCompositeException(OptionError,"MissingArgument",option);
1078             interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
1079               argv[i]);
1080             if (interlace < 0)
1081               ThrowCompositeException(OptionError,
1082                 "UnrecognizedInterlaceType",argv[i]);
1083             break;
1084           }
1085         if (LocaleCompare("interpolate",option+1) == 0)
1086           {
1087             ssize_t
1088               interpolate;
1089
1090             if (*option == '+')
1091               break;
1092             i++;
1093             if (i == (ssize_t) argc)
1094               ThrowCompositeException(OptionError,"MissingArgument",option);
1095             interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
1096               argv[i]);
1097             if (interpolate < 0)
1098               ThrowCompositeException(OptionError,
1099                 "UnrecognizedInterpolateMethod",argv[i]);
1100             break;
1101           }
1102         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1103       }
1104       case 'l':
1105       {
1106         if (LocaleCompare("label",option+1) == 0)
1107           {
1108             if (*option == '+')
1109               break;
1110             i++;
1111             if (i == (ssize_t) argc)
1112               ThrowCompositeException(OptionError,"MissingArgument",option);
1113             break;
1114           }
1115         if (LocaleCompare("limit",option+1) == 0)
1116           {
1117             char
1118               *p;
1119
1120             double
1121               value;
1122
1123             ssize_t
1124               resource;
1125
1126             if (*option == '+')
1127               break;
1128             i++;
1129             if (i == (ssize_t) argc)
1130               ThrowCompositeException(OptionError,"MissingArgument",option);
1131             resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
1132               argv[i]);
1133             if (resource < 0)
1134               ThrowCompositeException(OptionError,"UnrecognizedResourceType",
1135                 argv[i]);
1136             i++;
1137             if (i == (ssize_t) argc)
1138               ThrowCompositeException(OptionError,"MissingArgument",option);
1139             value=InterpretLocaleValue(argv[i],&p);
1140             (void) value;
1141             if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
1142               ThrowCompositeInvalidArgumentException(option,argv[i]);
1143             break;
1144           }
1145         if (LocaleCompare("list",option+1) == 0)
1146           {
1147             ssize_t
1148               list;
1149
1150             if (*option == '+')
1151               break;
1152             i++;
1153             if (i == (ssize_t) argc)
1154               ThrowCompositeException(OptionError,"MissingArgument",option);
1155             list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
1156             if (list < 0)
1157               ThrowCompositeException(OptionError,"UnrecognizedListType",
1158                 argv[i]);
1159             status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
1160               argv+j,exception);
1161             DestroyComposite();
1162             return(status != 0 ? MagickFalse : MagickTrue);
1163           }
1164         if (LocaleCompare("log",option+1) == 0)
1165           {
1166             if (*option == '+')
1167               break;
1168             i++;
1169             if ((i == (ssize_t) argc) || (strchr(argv[i],'%') == (char *) NULL))
1170               ThrowCompositeException(OptionError,"MissingArgument",option);
1171             break;
1172           }
1173         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1174       }
1175       case 'm':
1176       {
1177         if (LocaleCompare("matte",option+1) == 0)
1178           break;
1179         if (LocaleCompare("monitor",option+1) == 0)
1180           break;
1181         if (LocaleCompare("monochrome",option+1) == 0)
1182           break;
1183         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1184       }
1185       case 'n':
1186       {
1187         if (LocaleCompare("negate",option+1) == 0)
1188           break;
1189         if (LocaleCompare("noop",option+1) == 0)
1190           break;
1191         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1192       }
1193       case 'p':
1194       {
1195         if (LocaleCompare("page",option+1) == 0)
1196           {
1197             if (*option == '+')
1198               break;
1199             i++;
1200             if (i == (ssize_t) argc)
1201               ThrowCompositeException(OptionError,"MissingArgument",option);
1202             break;
1203           }
1204         if (LocaleCompare("pointsize",option+1) == 0)
1205           {
1206             if (*option == '+')
1207               break;
1208             i++;
1209             if (i == (ssize_t) (argc-1))
1210               ThrowCompositeException(OptionError,"MissingArgument",option);
1211             if (IsGeometry(argv[i]) == MagickFalse)
1212               ThrowCompositeInvalidArgumentException(option,argv[i]);
1213             break;
1214           }
1215         if (LocaleCompare("process",option+1) == 0)
1216           {
1217             if (*option == '+')
1218               break;
1219             i++;
1220             if (i == (ssize_t) argc)
1221               ThrowCompositeException(OptionError,"MissingArgument",option);
1222             break;
1223           }
1224         if (LocaleCompare("profile",option+1) == 0)
1225           {
1226             i++;
1227             if (i == (ssize_t) argc)
1228               ThrowCompositeException(OptionError,"MissingArgument",option);
1229             break;
1230           }
1231         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1232       }
1233       case 'q':
1234       {
1235         if (LocaleCompare("quality",option+1) == 0)
1236           {
1237             if (*option == '+')
1238               break;
1239             i++;
1240             if (i == (ssize_t) argc)
1241               ThrowCompositeException(OptionError,"MissingArgument",option);
1242             if (IsGeometry(argv[i]) == MagickFalse)
1243               ThrowCompositeInvalidArgumentException(option,argv[i]);
1244             break;
1245           }
1246         if (LocaleCompare("quantize",option+1) == 0)
1247           {
1248             ssize_t
1249               colorspace;
1250
1251             if (*option == '+')
1252               break;
1253             i++;
1254             if (i == (ssize_t) (argc-1))
1255               ThrowCompositeException(OptionError,"MissingArgument",option);
1256             colorspace=ParseCommandOption(MagickColorspaceOptions,
1257               MagickFalse,argv[i]);
1258             if (colorspace < 0)
1259               ThrowCompositeException(OptionError,"UnrecognizedColorspace",
1260                 argv[i]);
1261             break;
1262           }
1263         if (LocaleCompare("quiet",option+1) == 0)
1264           break;
1265         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1266       }
1267       case 'r':
1268       {
1269         if (LocaleCompare("red-primary",option+1) == 0)
1270           {
1271             if (*option == '+')
1272               break;
1273             i++;
1274             if (i == (ssize_t) argc)
1275               ThrowCompositeException(OptionError,"MissingArgument",option);
1276             if (IsGeometry(argv[i]) == MagickFalse)
1277               ThrowCompositeInvalidArgumentException(option,argv[i]);
1278             break;
1279           }
1280         if (LocaleCompare("regard-warnings",option+1) == 0)
1281           break;
1282         if (LocaleCompare("render",option+1) == 0)
1283           break;
1284         if (LocaleCompare("repage",option+1) == 0)
1285           {
1286             if (*option == '+')
1287               break;
1288             i++;
1289             if (i == (ssize_t) argc)
1290               ThrowCompositeException(OptionError,"MissingArgument",option);
1291             if (IsGeometry(argv[i]) == MagickFalse)
1292               ThrowCompositeInvalidArgumentException(option,argv[i]);
1293             break;
1294           }
1295         if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
1296           {
1297             respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
1298             break;
1299           }
1300         if (LocaleCompare("resize",option+1) == 0)
1301           {
1302             if (*option == '+')
1303               break;
1304             i++;
1305             if (i == (ssize_t) argc)
1306               ThrowCompositeException(OptionError,"MissingArgument",option);
1307             if (IsGeometry(argv[i]) == MagickFalse)
1308               ThrowCompositeInvalidArgumentException(option,argv[i]);
1309             break;
1310           }
1311         if (LocaleCompare("rotate",option+1) == 0)
1312           {
1313             i++;
1314             if (i == (ssize_t) argc)
1315               ThrowCompositeException(OptionError,"MissingArgument",option);
1316             if (IsGeometry(argv[i]) == MagickFalse)
1317               ThrowCompositeInvalidArgumentException(option,argv[i]);
1318             break;
1319           }
1320         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1321       }
1322       case 's':
1323       {
1324         if (LocaleCompare("sampling-factor",option+1) == 0)
1325           {
1326             if (*option == '+')
1327               break;
1328             i++;
1329             if (i == (ssize_t) argc)
1330               ThrowCompositeException(OptionError,"MissingArgument",option);
1331             if (IsGeometry(argv[i]) == MagickFalse)
1332               ThrowCompositeInvalidArgumentException(option,argv[i]);
1333             break;
1334           }
1335         if (LocaleCompare("scene",option+1) == 0)
1336           {
1337             if (*option == '+')
1338               break;
1339             i++;
1340             if (i == (ssize_t) argc)
1341               ThrowCompositeException(OptionError,"MissingArgument",option);
1342             if (IsGeometry(argv[i]) == MagickFalse)
1343               ThrowCompositeInvalidArgumentException(option,argv[i]);
1344             break;
1345           }
1346         if (LocaleCompare("seed",option+1) == 0)
1347           {
1348             if (*option == '+')
1349               break;
1350             i++;
1351             if (i == (ssize_t) (argc-1))
1352               ThrowCompositeException(OptionError,"MissingArgument",option);
1353             if (IsGeometry(argv[i]) == MagickFalse)
1354               ThrowCompositeInvalidArgumentException(option,argv[i]);
1355             break;
1356           }
1357         if (LocaleCompare("sharpen",option+1) == 0)
1358           {
1359             i++;
1360             if (i == (ssize_t) argc)
1361               ThrowCompositeException(OptionError,"MissingArgument",option);
1362             if (IsGeometry(argv[i]) == MagickFalse)
1363               ThrowCompositeInvalidArgumentException(option,argv[i]);
1364             break;
1365           }
1366         if (LocaleCompare("shave",option+1) == 0)
1367           {
1368             if (*option == '+')
1369               break;
1370             i++;
1371             if (i == (ssize_t) (argc-1))
1372               ThrowCompositeException(OptionError,"MissingArgument",option);
1373             if (IsGeometry(argv[i]) == MagickFalse)
1374               ThrowCompositeInvalidArgumentException(option,argv[i]);
1375             break;
1376           }
1377         if (LocaleCompare("size",option+1) == 0)
1378           {
1379             if (*option == '+')
1380               break;
1381             i++;
1382             if (i == (ssize_t) argc)
1383               ThrowCompositeException(OptionError,"MissingArgument",option);
1384             if (IsGeometry(argv[i]) == MagickFalse)
1385               ThrowCompositeInvalidArgumentException(option,argv[i]);
1386             break;
1387           }
1388         if (LocaleCompare("stegano",option+1) == 0)
1389           {
1390             composite_options.stegano=0;
1391             if (*option == '+')
1392               break;
1393             i++;
1394             if (i == (ssize_t) argc)
1395               ThrowCompositeException(OptionError,"MissingArgument",option);
1396             if (IsGeometry(argv[i]) == MagickFalse)
1397               ThrowCompositeInvalidArgumentException(option,argv[i]);
1398             composite_options.stegano=(ssize_t) StringToLong(argv[i])+1;
1399             break;
1400           }
1401         if (LocaleCompare("stereo",option+1) == 0)
1402           {
1403             MagickStatusType
1404               flags;
1405
1406             composite_options.stereo=MagickFalse;
1407             if (*option == '+')
1408               break;
1409             i++;
1410             if (i == (ssize_t) argc)
1411               ThrowCompositeException(OptionError,"MissingArgument",option);
1412             if (IsGeometry(argv[i]) == MagickFalse)
1413               ThrowCompositeInvalidArgumentException(option,argv[i]);
1414             flags=ParseAbsoluteGeometry(argv[i],&composite_options.offset);
1415             if ((flags & YValue) == 0)
1416               composite_options.offset.y=composite_options.offset.x;
1417             composite_options.stereo=MagickTrue;
1418             break;
1419           }
1420         if (LocaleCompare("strip",option+1) == 0)
1421           break;
1422         if (LocaleCompare("support",option+1) == 0)
1423           {
1424             i++;  /* deprecated */
1425             break;
1426           }
1427         if (LocaleCompare("swap",option+1) == 0)
1428           {
1429             if (*option == '+')
1430               break;
1431             i++;
1432             if (i == (ssize_t) (argc-1))
1433               ThrowCompositeException(OptionError,"MissingArgument",option);
1434             if (IsGeometry(argv[i]) == MagickFalse)
1435               ThrowCompositeInvalidArgumentException(option,argv[i]);
1436             break;
1437           }
1438         if (LocaleCompare("synchronize",option+1) == 0)
1439           break;
1440         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1441       }
1442       case 't':
1443       {
1444         if (LocaleCompare("taint",option+1) == 0)
1445           break;
1446         if (LocaleCompare("thumbnail",option+1) == 0)
1447           {
1448             if (*option == '+')
1449               break;
1450             i++;
1451             if (i == (ssize_t) argc)
1452               ThrowCompositeException(OptionError,"MissingArgument",option);
1453             if (IsGeometry(argv[i]) == MagickFalse)
1454               ThrowCompositeInvalidArgumentException(option,argv[i]);
1455             break;
1456           }
1457         if (LocaleCompare("tile",option+1) == 0)
1458           {
1459             composite_options.tile=(*option == '-') ? MagickTrue : MagickFalse;
1460             (void) CopyMagickString(argv[i]+1,"sans",MaxTextExtent);
1461             break;
1462           }
1463         if (LocaleCompare("transform",option+1) == 0)
1464           break;
1465         if (LocaleCompare("transparent-color",option+1) == 0)
1466           {
1467             if (*option == '+')
1468               break;
1469             i++;
1470             if (i == (ssize_t) (argc-1))
1471               ThrowCompositeException(OptionError,"MissingArgument",option);
1472             break;
1473           }
1474         if (LocaleCompare("treedepth",option+1) == 0)
1475           {
1476             if (*option == '+')
1477               break;
1478             i++;
1479             if (i == (ssize_t) argc)
1480               ThrowCompositeException(OptionError,"MissingArgument",option);
1481             if (IsGeometry(argv[i]) == MagickFalse)
1482               ThrowCompositeInvalidArgumentException(option,argv[i]);
1483             break;
1484           }
1485         if (LocaleCompare("type",option+1) == 0)
1486           {
1487             ssize_t
1488               type;
1489
1490             if (*option == '+')
1491               break;
1492             i++;
1493             if (i == (ssize_t) argc)
1494               ThrowCompositeException(OptionError,"MissingArgument",option);
1495             type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
1496             if (type < 0)
1497               ThrowCompositeException(OptionError,"UnrecognizedImageType",
1498                 argv[i]);
1499             break;
1500           }
1501         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1502       }
1503       case 'u':
1504       {
1505         if (LocaleCompare("units",option+1) == 0)
1506           {
1507             ssize_t
1508               units;
1509
1510             if (*option == '+')
1511               break;
1512             i++;
1513             if (i == (ssize_t) argc)
1514               ThrowCompositeException(OptionError,"MissingArgument",option);
1515             units=ParseCommandOption(MagickResolutionOptions,MagickFalse,
1516               argv[i]);
1517             if (units < 0)
1518               ThrowCompositeException(OptionError,"UnrecognizedUnitsType",
1519                 argv[i]);
1520             break;
1521           }
1522         if (LocaleCompare("unsharp",option+1) == 0)
1523           {
1524             (void) CloneString(&composite_options.compose_args,(char *) NULL);
1525             if (*option == '+')
1526               break;
1527             i++;
1528             if (i == (ssize_t) argc)
1529               ThrowCompositeException(OptionError,"MissingArgument",option);
1530             if (IsGeometry(argv[i]) == MagickFalse)
1531               ThrowCompositeInvalidArgumentException(option,argv[i]);
1532             (void) CloneString(&composite_options.compose_args,argv[i]);
1533             composite_options.compose=ThresholdCompositeOp;
1534             break;
1535           }
1536         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1537       }
1538       case 'v':
1539       {
1540         if (LocaleCompare("verbose",option+1) == 0)
1541           break;
1542         if ((LocaleCompare("version",option+1) == 0) ||
1543             (LocaleCompare("-version",option+1) == 0))
1544           {
1545             (void) FormatLocaleFile(stdout,"Version: %s\n",
1546               GetMagickVersion((size_t *) NULL));
1547             (void) FormatLocaleFile(stdout,"Copyright: %s\n",
1548               GetMagickCopyright());
1549             (void) FormatLocaleFile(stdout,"Features: %s\n\n",
1550               GetMagickFeatures());
1551             break;
1552           }
1553         if (LocaleCompare("virtual-pixel",option+1) == 0)
1554           {
1555             ssize_t
1556               method;
1557
1558             if (*option == '+')
1559               break;
1560             i++;
1561             if (i == (ssize_t) argc)
1562               ThrowCompositeException(OptionError,"MissingArgument",option);
1563             method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
1564               argv[i]);
1565             if (method < 0)
1566               ThrowCompositeException(OptionError,
1567                 "UnrecognizedVirtualPixelMethod",argv[i]);
1568             break;
1569           }
1570         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1571       }
1572       case 'w':
1573       {
1574         if (LocaleCompare("watermark",option+1) == 0)
1575           {
1576             (void) CloneString(&composite_options.compose_args,(char *) NULL);
1577             if (*option == '+')
1578               break;
1579             i++;
1580             if (i == (ssize_t) argc)
1581               ThrowCompositeException(OptionError,"MissingArgument",option);
1582             if (IsGeometry(argv[i]) == MagickFalse)
1583               ThrowCompositeInvalidArgumentException(option,argv[i]);
1584             (void) CloneString(&composite_options.compose_args,argv[i]);
1585             composite_options.compose=ModulateCompositeOp;
1586             break;
1587           }
1588         if (LocaleCompare("white-point",option+1) == 0)
1589           {
1590             if (*option == '+')
1591               break;
1592             i++;
1593             if (i == (ssize_t) argc)
1594               ThrowCompositeException(OptionError,"MissingArgument",option);
1595             if (IsGeometry(argv[i]) == MagickFalse)
1596               ThrowCompositeInvalidArgumentException(option,argv[i]);
1597             break;
1598           }
1599         if (LocaleCompare("write",option+1) == 0)
1600           {
1601             i++;
1602             if (i == (ssize_t) argc)
1603               ThrowCompositeException(OptionError,"MissingArgument",option);
1604             break;
1605           }
1606         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1607       }
1608       case '?':
1609         break;
1610       default:
1611         ThrowCompositeException(OptionError,"UnrecognizedOption",option)
1612     }
1613     fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
1614       FireOptionFlag) == 0 ?  MagickFalse : MagickTrue;
1615     if (fire != MagickFalse)
1616       FireImageStack(MagickFalse,MagickTrue,MagickTrue);
1617   }
1618   if (k != 0)
1619     ThrowCompositeException(OptionError,"UnbalancedParenthesis",argv[i]);
1620   if (i-- != (ssize_t) (argc-1))
1621     ThrowCompositeException(OptionError,"MissingAnImageFilename",argv[i]);
1622   if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
1623     ThrowCompositeException(OptionError,"MissingAnImageFilename",argv[argc-1]);
1624   FinalizeImageSettings(image_info,image,MagickTrue);
1625   if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
1626     ThrowCompositeException(OptionError,"MissingAnImageFilename",argv[argc-1]);
1627   /*
1628     Composite images.
1629   */
1630   RemoveImageStack(composite_image);
1631   RemoveImageStack(images);
1632   (void) TransformImage(&composite_image,(char *) NULL,
1633     composite_image->geometry);
1634   RemoveImageStack(mask_image);
1635   if (mask_image != (Image *) NULL)
1636     {
1637       if ((composite_options.compose == DisplaceCompositeOp) ||
1638           (composite_options.compose == DistortCompositeOp))
1639         {
1640           /*
1641             Merge Y displacement into X displacement image.
1642           */
1643           (void) CompositeImage(composite_image,CopyGreenCompositeOp,mask_image,
1644             0,0);
1645           mask_image=DestroyImage(mask_image);
1646         }
1647       else
1648         {
1649           /*
1650             Set a blending mask for the composition.
1651           */
1652           images->mask=mask_image;
1653           (void) NegateImage(images->mask,MagickFalse,exception);
1654         }
1655     }
1656   status&=CompositeImageList(image_info,&images,composite_image,
1657     &composite_options,exception);
1658   composite_image=DestroyImage(composite_image);
1659   /*
1660     Write composite images.
1661   */
1662   status&=WriteImages(image_info,images,argv[argc-1],exception);
1663   if (metadata != (char **) NULL)
1664     {
1665       char
1666         *text;
1667
1668       text=InterpretImageProperties(image_info,images,format,exception);
1669       if (text == (char *) NULL)
1670         ThrowCompositeException(ResourceLimitError,"MemoryAllocationFailed",
1671           GetExceptionMessage(errno));
1672       (void) ConcatenateString(&(*metadata),text);
1673       (void) ConcatenateString(&(*metadata),"\n");
1674       text=DestroyString(text);
1675     }
1676   images=DestroyImage(images);
1677   RelinquishCompositeOptions(&composite_options);
1678   DestroyComposite();
1679   return(status != 0 ? MagickTrue : MagickFalse);
1680 }