MagickWand  6.9.13-25
Convert, Edit, Or Compose Bitmap Images
identify.c
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % IIIII DDDD EEEEE N N TTTTT IIIII FFFFF Y Y %
7 % I D D E NN N T I F Y Y %
8 % I D D EEE N N N T I FFF Y %
9 % I D D E N NN T I F Y %
10 % IIIII DDDD EEEEE N N T IIIII F Y %
11 % %
12 % %
13 % Identify an Image Format and Characteristics. %
14 % %
15 % Software Design %
16 % Cristy %
17 % September 1994 %
18 % %
19 % %
20 % Copyright 1999 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 % https://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 % The identify program describes the format and characteristics of one or more
37 % image files. It also reports if an image is incomplete or corrupt. The
38 % information returned includes the image number, the file name, the width and
39 % height of the image, whether the image is colormapped or not, the number of
40 % colors in the image, the number of bytes in the image, the format of the
41 % image (JPEG, PNM, etc.), and finally the number of seconds it took to read
42 % and process the image. Many more attributes are available with the verbose
43 % option.
44 %
45 */
46 
47 /*
48  Include declarations.
49 */
50 #include "wand/studio.h"
51 #include "wand/MagickWand.h"
52 #include "wand/mogrify-private.h"
53 #include "magick/string-private.h"
54 
55 /*
56 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
57 % %
58 % %
59 % %
60 + I d e n t i f y I m a g e C o m m a n d %
61 % %
62 % %
63 % %
64 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
65 %
66 % IdentifyImageCommand() describes the format and characteristics of one or
67 % more image files. It will also report if an image is incomplete or corrupt.
68 % The information displayed includes the scene number, the file name, the
69 % width and height of the image, whether the image is colormapped or not,
70 % the number of colors in the image, the number of bytes in the image, the
71 % format of the image (JPEG, PNM, etc.), and finally the number of seconds
72 % it took to read and process the image.
73 %
74 % The format of the IdentifyImageCommand method is:
75 %
76 % MagickBooleanType IdentifyImageCommand(ImageInfo *image_info,int argc,
77 % char **argv,char **metadata,ExceptionInfo *exception)
78 %
79 % A description of each parameter follows:
80 %
81 % o image_info: the image info.
82 %
83 % o argc: the number of elements in the argument vector.
84 %
85 % o argv: A text array containing the command line arguments.
86 %
87 % o metadata: any metadata is returned here.
88 %
89 % o exception: return any errors or warnings in this structure.
90 %
91 */
92 
93 static MagickBooleanType IdentifyUsage(void)
94 {
95  static const char
96  miscellaneous[] =
97  " -debug events display copious debugging information\n"
98  " -help print program options\n"
99  " -list type print a list of supported option arguments\n"
100  " -log format format of debugging information\n"
101  " -version print version information",
102  operators[] =
103  " -auto-orient automagically orient (rotate) image\n"
104  " -grayscale method convert image to grayscale\n"
105  " -negate replace every pixel with its complementary color",
106  settings[] =
107  " -alpha option on, activate, off, deactivate, set, opaque, copy\n"
108  " transparent, extract, background, or shape\n"
109  " -antialias remove pixel-aliasing\n"
110  " -authenticate password\n"
111  " decipher image with this password\n"
112  " -channel type apply option to select image channels\n"
113  " -clip clip along the first path from the 8BIM profile\n"
114  " -clip-mask filename associate a clip mask with the image\n"
115  " -clip-path id clip along a named path from the 8BIM profile\n"
116  " -colorspace type alternate image colorspace\n"
117  " -crop geometry cut out a rectangular region of the image\n"
118  " -define format:option\n"
119  " define one or more image format options\n"
120  " -density geometry horizontal and vertical density of the image\n"
121  " -depth value image depth\n"
122  " -endian type endianness (MSB or LSB) of the image\n"
123  " -extract geometry extract area from image\n"
124  " -features distance analyze image features (e.g. contrast, correlation)\n"
125  " -format \"string\" output formatted image characteristics\n"
126  " -fuzz distance colors within this distance are considered equal\n"
127  " -gamma value of gamma correction\n"
128  " -interlace type type of image interlacing scheme\n"
129  " -interpolate method pixel color interpolation method\n"
130  " -limit type value pixel cache resource limit\n"
131  " -list type Color, Configure, Delegate, Format, Magic, Module,\n"
132  " Resource, or Type\n"
133  " -mask filename associate a mask with the image\n"
134  " -matte store matte channel if the image has one\n"
135  " -moments report image moments\n"
136  " -format \"string\" output formatted image characteristics\n"
137  " -monitor monitor progress\n"
138  " -ping efficiently determine image attributes\n"
139  " -precision value maximum number of significant digits to print\n"
140  " -quiet suppress all warning messages\n"
141  " -regard-warnings pay attention to warning messages\n"
142  " -respect-parentheses settings remain in effect until parenthesis boundary\n"
143  " -sampling-factor geometry\n"
144  " horizontal and vertical sampling factor\n"
145  " -seed value seed a new sequence of pseudo-random numbers\n"
146  " -set attribute value set an image attribute\n"
147  " -size geometry width and height of image\n"
148  " -strip strip image of all profiles and comments\n"
149  " -unique display the number of unique colors in the image\n"
150  " -units type the units of image resolution\n"
151  " -verbose print detailed information about the image\n"
152  " -virtual-pixel method\n"
153  " virtual pixel access method";
154 
155  ListMagickVersion(stdout);
156  (void) printf("Usage: %s [options ...] file [ [options ...] "
157  "file ... ]\n",GetClientName());
158  (void) printf("\nImage Settings:\n");
159  (void) puts(settings);
160  (void) printf("\nImage Operators:\n");
161  (void) puts(operators);
162  (void) printf("\nMiscellaneous Options:\n");
163  (void) puts(miscellaneous);
164  (void) printf(
165  "\nBy default, the image format of `file' is determined by its magic\n");
166  (void) printf(
167  "number. To specify a particular image format, precede the filename\n");
168  (void) printf(
169  "with an image format name and a colon (i.e. ps:image) or specify the\n");
170  (void) printf(
171  "image type as the filename suffix (i.e. image.ps). Specify 'file' as\n");
172  (void) printf("'-' for standard input or output.\n");
173  return(MagickTrue);
174 }
175 
176 WandExport MagickBooleanType IdentifyImageCommand(ImageInfo *image_info,
177  int argc,char **argv,char **metadata,ExceptionInfo *exception)
178 {
179 #define DestroyIdentify() \
180 { \
181  DestroyImageStack(); \
182  for (i=0; i < (ssize_t) argc; i++) \
183  argv[i]=DestroyString(argv[i]); \
184  argv=(char **) RelinquishMagickMemory(argv); \
185 }
186 #define ThrowIdentifyException(asperity,tag,option) \
187 { \
188  (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
189  option); \
190  DestroyIdentify(); \
191  return(MagickFalse); \
192 }
193 #define ThrowIdentifyInvalidArgumentException(option,argument) \
194 { \
195  (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
196  "InvalidArgument","`%s': %s",option,argument); \
197  DestroyIdentify(); \
198  return(MagickFalse); \
199 }
200 
201  const char
202  *format,
203  *option;
204 
205  Image
206  *image;
207 
208  ImageStack
209  image_stack[MaxImageStackDepth+1];
210 
211  MagickBooleanType
212  fire,
213  pend,
214  respect_parenthesis;
215 
216  MagickStatusType
217  status;
218 
219  ssize_t
220  i;
221 
222  size_t
223  count;
224 
225  ssize_t
226  j,
227  k;
228 
229  /*
230  Set defaults.
231  */
232  assert(image_info != (ImageInfo *) NULL);
233  assert(image_info->signature == MagickCoreSignature);
234  assert(exception != (ExceptionInfo *) NULL);
235  if (IsEventLogging() != MagickFalse)
236  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
237  if (argc == 2)
238  {
239  option=argv[1];
240  if ((LocaleCompare("version",option+1) == 0) ||
241  (LocaleCompare("-version",option+1) == 0))
242  {
243  ListMagickVersion(stdout);
244  return(MagickTrue);
245  }
246  }
247  if (argc < 2)
248  {
249  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
250  "MissingArgument","%s","");
251  (void) IdentifyUsage();
252  return(MagickFalse);
253  }
254  count=0;
255  format=NULL;
256  j=1;
257  k=0;
258  NewImageStack();
259  option=(char *) NULL;
260  pend=MagickFalse;
261  respect_parenthesis=MagickFalse;
262  status=MagickTrue;
263  /*
264  Identify an image.
265  */
266  ReadCommandlLine(argc,&argv);
267  status=ExpandFilenames(&argc,&argv);
268  if (status == MagickFalse)
269  ThrowIdentifyException(ResourceLimitError,"MemoryAllocationFailed",
270  GetExceptionMessage(errno));
271  image_info->ping=MagickTrue;
272  for (i=1; i < (ssize_t) argc; i++)
273  {
274  option=argv[i];
275  if (LocaleCompare(option,"(") == 0)
276  {
277  FireImageStack(MagickFalse,MagickTrue,pend);
278  if (k == MaxImageStackDepth)
279  ThrowIdentifyException(OptionError,"ParenthesisNestedTooDeeply",
280  option);
281  PushImageStack();
282  continue;
283  }
284  if (LocaleCompare(option,")") == 0)
285  {
286  FireImageStack(MagickFalse,MagickTrue,MagickTrue);
287  if (k == 0)
288  ThrowIdentifyException(OptionError,"UnableToParseExpression",option);
289  PopImageStack();
290  continue;
291  }
292  if (IsCommandOption(option) == MagickFalse)
293  {
294  char
295  *filename;
296 
297  Image
298  *images;
299 
300  ImageInfo
301  *identify_info;
302 
303  /*
304  Read input image.
305  */
306  FireImageStack(MagickFalse,MagickFalse,pend);
307  identify_info=CloneImageInfo(image_info);
308  identify_info->verbose=MagickFalse;
309  filename=argv[i];
310  if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
311  filename=argv[++i];
312  (void) SetImageOption(image_info,"filename",filename);
313  (void) CopyMagickString(identify_info->filename,filename,MaxTextExtent);
314  if (identify_info->ping != MagickFalse)
315  images=PingImages(identify_info,exception);
316  else
317  images=ReadImages(identify_info,exception);
318  identify_info=DestroyImageInfo(identify_info);
319  status&=(images != (Image *) NULL) &&
320  (exception->severity < ErrorException);
321  if (images == (Image *) NULL)
322  continue;
323  AppendImageStack(images);
324  FinalizeImageSettings(image_info,image,MagickFalse);
325  count=0;
326  for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
327  {
328  if (image->scene == 0)
329  image->scene=count++;
330  if (format == (char *) NULL)
331  {
332  (void) IdentifyImage(image,stdout,image_info->verbose);
333  continue;
334  }
335  if (metadata != (char **) NULL)
336  {
337  char
338  *text;
339 
340  text=InterpretImageProperties(image_info,image,format);
341  InheritException(exception,&image->exception);
342  if (text == (char *) NULL)
343  ThrowIdentifyException(ResourceLimitError,
344  "MemoryAllocationFailed",GetExceptionMessage(errno));
345  (void) ConcatenateString(&(*metadata),text);
346  text=DestroyString(text);
347  }
348  }
349  RemoveAllImageStack();
350  continue;
351  }
352  pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
353  image_info->ping=MagickFalse;
354  switch (*(option+1))
355  {
356  case 'a':
357  {
358  if (LocaleCompare("alpha",option+1) == 0)
359  {
360  ssize_t
361  type;
362 
363  if (*option == '+')
364  break;
365  i++;
366  if (i == (ssize_t) argc)
367  ThrowIdentifyException(OptionError,"MissingArgument",option);
368  type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]);
369  if (type < 0)
370  ThrowIdentifyException(OptionError,"UnrecognizedAlphaChannelType",
371  argv[i]);
372  break;
373  }
374  if (LocaleCompare("antialias",option+1) == 0)
375  break;
376  if (LocaleCompare("authenticate",option+1) == 0)
377  {
378  if (*option == '+')
379  break;
380  i++;
381  if (i == (ssize_t) argc)
382  ThrowIdentifyException(OptionError,"MissingArgument",option);
383  break;
384  }
385  if (LocaleCompare("auto-orient",option+1) == 0)
386  break;
387  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
388  }
389  case 'c':
390  {
391  if (LocaleCompare("cache",option+1) == 0)
392  {
393  if (*option == '+')
394  break;
395  i++;
396  if (i == (ssize_t) argc)
397  ThrowIdentifyException(OptionError,"MissingArgument",option);
398  if (IsGeometry(argv[i]) == MagickFalse)
399  ThrowIdentifyInvalidArgumentException(option,argv[i]);
400  break;
401  }
402  if (LocaleCompare("channel",option+1) == 0)
403  {
404  ssize_t
405  channel;
406 
407  if (*option == '+')
408  break;
409  i++;
410  if (i == (ssize_t) argc)
411  ThrowIdentifyException(OptionError,"MissingArgument",option);
412  channel=ParseChannelOption(argv[i]);
413  if (channel < 0)
414  ThrowIdentifyException(OptionError,"UnrecognizedChannelType",
415  argv[i]);
416  break;
417  }
418  if (LocaleCompare("clip",option+1) == 0)
419  break;
420  if (LocaleCompare("clip-mask",option+1) == 0)
421  {
422  if (*option == '+')
423  break;
424  i++;
425  if (i == (ssize_t) argc)
426  ThrowIdentifyException(OptionError,"MissingArgument",option);
427  break;
428  }
429  if (LocaleCompare("clip-path",option+1) == 0)
430  {
431  i++;
432  if (i == (ssize_t) argc)
433  ThrowIdentifyException(OptionError,"MissingArgument",option);
434  break;
435  }
436  if (LocaleCompare("colorspace",option+1) == 0)
437  {
438  ssize_t
439  colorspace;
440 
441  if (*option == '+')
442  break;
443  i++;
444  if (i == (ssize_t) argc)
445  ThrowIdentifyException(OptionError,"MissingArgument",option);
446  colorspace=ParseCommandOption(MagickColorspaceOptions,
447  MagickFalse,argv[i]);
448  if (colorspace < 0)
449  ThrowIdentifyException(OptionError,"UnrecognizedColorspace",
450  argv[i]);
451  break;
452  }
453  if (LocaleCompare("crop",option+1) == 0)
454  {
455  if (*option == '+')
456  break;
457  i++;
458  if (i == (ssize_t) argc)
459  ThrowIdentifyException(OptionError,"MissingArgument",option);
460  if (IsGeometry(argv[i]) == MagickFalse)
461  ThrowIdentifyInvalidArgumentException(option,argv[i]);
462  break;
463  }
464  if (LocaleCompare("concurrent",option+1) == 0)
465  break;
466  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
467  }
468  case 'd':
469  {
470  if (LocaleCompare("debug",option+1) == 0)
471  {
472  ssize_t
473  event;
474 
475  if (*option == '+')
476  break;
477  i++;
478  if (i == (ssize_t) argc)
479  ThrowIdentifyException(OptionError,"MissingArgument",option);
480  event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
481  if (event < 0)
482  ThrowIdentifyException(OptionError,"UnrecognizedEventType",
483  argv[i]);
484  (void) SetLogEventMask(argv[i]);
485  break;
486  }
487  if (LocaleCompare("define",option+1) == 0)
488  {
489  i++;
490  if (i == (ssize_t) argc)
491  ThrowIdentifyException(OptionError,"MissingArgument",option);
492  if (*option == '+')
493  {
494  const char
495  *define;
496 
497  define=GetImageOption(image_info,argv[i]);
498  if (define == (const char *) NULL)
499  ThrowIdentifyException(OptionError,"NoSuchOption",argv[i]);
500  break;
501  }
502  if (LocaleNCompare("identify:locate",argv[i],15) == 0)
503  image_info->ping=MagickFalse;
504  break;
505  }
506  if (LocaleCompare("density",option+1) == 0)
507  {
508  if (*option == '+')
509  break;
510  i++;
511  if (i == (ssize_t) argc)
512  ThrowIdentifyException(OptionError,"MissingArgument",option);
513  if (IsGeometry(argv[i]) == MagickFalse)
514  ThrowIdentifyInvalidArgumentException(option,argv[i]);
515  break;
516  }
517  if (LocaleCompare("depth",option+1) == 0)
518  {
519  if (*option == '+')
520  break;
521  i++;
522  if (i == (ssize_t) argc)
523  ThrowIdentifyException(OptionError,"MissingArgument",option);
524  if (IsGeometry(argv[i]) == MagickFalse)
525  ThrowIdentifyInvalidArgumentException(option,argv[i]);
526  break;
527  }
528  if (LocaleCompare("duration",option+1) == 0)
529  {
530  if (*option == '+')
531  break;
532  i++;
533  if (i == (ssize_t) argc)
534  ThrowIdentifyException(OptionError,"MissingArgument",option);
535  if (IsGeometry(argv[i]) == MagickFalse)
536  ThrowIdentifyInvalidArgumentException(option,argv[i]);
537  break;
538  }
539  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
540  }
541  case 'e':
542  {
543  if (LocaleCompare("endian",option+1) == 0)
544  {
545  ssize_t
546  endian;
547 
548  if (*option == '+')
549  break;
550  i++;
551  if (i == (ssize_t) argc)
552  ThrowIdentifyException(OptionError,"MissingArgument",option);
553  endian=ParseCommandOption(MagickEndianOptions,MagickFalse,
554  argv[i]);
555  if (endian < 0)
556  ThrowIdentifyException(OptionError,"UnrecognizedEndianType",
557  argv[i]);
558  break;
559  }
560  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
561  }
562  case 'f':
563  {
564  if (LocaleCompare("features",option+1) == 0)
565  {
566  if (*option == '+')
567  break;
568  i++;
569  if (i == (ssize_t) argc)
570  ThrowIdentifyException(OptionError,"MissingArgument",option);
571  if (IsGeometry(argv[i]) == MagickFalse)
572  ThrowIdentifyInvalidArgumentException(option,argv[i]);
573  break;
574  }
575  if (LocaleCompare("format",option+1) == 0)
576  {
577  format=(char *) NULL;
578  if (*option == '+')
579  break;
580  i++;
581  if (i == (ssize_t) argc)
582  ThrowIdentifyException(OptionError,"MissingArgument",option);
583  format=argv[i];
584  image_info->ping=MagickFalse;
585  break;
586  }
587  if (LocaleCompare("fuzz",option+1) == 0)
588  {
589  if (*option == '+')
590  break;
591  i++;
592  if (i == (ssize_t) argc)
593  ThrowIdentifyException(OptionError,"MissingArgument",option);
594  if (IsGeometry(argv[i]) == MagickFalse)
595  ThrowIdentifyInvalidArgumentException(option,argv[i]);
596  break;
597  }
598  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
599  }
600  case 'g':
601  {
602  if (LocaleCompare("gamma",option+1) == 0)
603  {
604  i++;
605  if (i == (ssize_t) argc)
606  ThrowIdentifyException(OptionError,"MissingArgument",option);
607  if (IsGeometry(argv[i]) == MagickFalse)
608  ThrowIdentifyInvalidArgumentException(option,argv[i]);
609  break;
610  }
611  if (LocaleCompare("grayscale",option+1) == 0)
612  {
613  ssize_t
614  method;
615 
616  if (*option == '+')
617  break;
618  i++;
619  if (i == (ssize_t) argc)
620  ThrowIdentifyException(OptionError,"MissingArgument",option);
621  method=ParseCommandOption(MagickPixelIntensityOptions,MagickFalse,
622  argv[i]);
623  if (method < 0)
624  ThrowIdentifyException(OptionError,"UnrecognizedIntensityMethod",
625  argv[i]);
626  break;
627  }
628  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
629  }
630  case 'h':
631  {
632  if ((LocaleCompare("help",option+1) == 0) ||
633  (LocaleCompare("-help",option+1) == 0))
634  {
635  DestroyIdentify();
636  return(IdentifyUsage());
637  }
638  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
639  }
640  case 'i':
641  {
642  if (LocaleCompare("interlace",option+1) == 0)
643  {
644  ssize_t
645  interlace;
646 
647  if (*option == '+')
648  break;
649  i++;
650  if (i == (ssize_t) argc)
651  ThrowIdentifyException(OptionError,"MissingArgument",option);
652  interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
653  argv[i]);
654  if (interlace < 0)
655  ThrowIdentifyException(OptionError,"UnrecognizedInterlaceType",
656  argv[i]);
657  break;
658  }
659  if (LocaleCompare("interpolate",option+1) == 0)
660  {
661  ssize_t
662  interpolate;
663 
664  if (*option == '+')
665  break;
666  i++;
667  if (i == (ssize_t) argc)
668  ThrowIdentifyException(OptionError,"MissingArgument",option);
669  interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
670  argv[i]);
671  if (interpolate < 0)
672  ThrowIdentifyException(OptionError,
673  "UnrecognizedInterpolateMethod",argv[i]);
674  break;
675  }
676  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
677  }
678  case 'l':
679  {
680  if (LocaleCompare("limit",option+1) == 0)
681  {
682  char
683  *p;
684 
685  double
686  value;
687 
688  ssize_t
689  resource;
690 
691  if (*option == '+')
692  break;
693  i++;
694  if (i == (ssize_t) argc)
695  ThrowIdentifyException(OptionError,"MissingArgument",option);
696  resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
697  argv[i]);
698  if (resource < 0)
699  ThrowIdentifyException(OptionError,"UnrecognizedResourceType",
700  argv[i]);
701  i++;
702  if (i == (ssize_t) argc)
703  ThrowIdentifyException(OptionError,"MissingArgument",option);
704  value=StringToDouble(argv[i],&p);
705  (void) value;
706  if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
707  ThrowIdentifyInvalidArgumentException(option,argv[i]);
708  break;
709  }
710  if (LocaleCompare("list",option+1) == 0)
711  {
712  ssize_t
713  list;
714 
715  if (*option == '+')
716  break;
717  i++;
718  if (i == (ssize_t) argc)
719  ThrowIdentifyException(OptionError,"MissingArgument",option);
720  list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
721  if (list < 0)
722  ThrowIdentifyException(OptionError,"UnrecognizedListType",
723  argv[i]);
724  status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
725  argv+j,exception);
726  DestroyIdentify();
727  return(status == 0 ? MagickFalse : MagickTrue);
728  }
729  if (LocaleCompare("log",option+1) == 0)
730  {
731  if (*option == '+')
732  break;
733  i++;
734  if ((i == (ssize_t) argc) ||
735  (strchr(argv[i],'%') == (char *) NULL))
736  ThrowIdentifyException(OptionError,"MissingArgument",option);
737  break;
738  }
739  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
740  }
741  case 'm':
742  {
743  if (LocaleCompare("mask",option+1) == 0)
744  {
745  if (*option == '+')
746  break;
747  i++;
748  if (i == (ssize_t) argc)
749  ThrowIdentifyException(OptionError,"MissingArgument",option);
750  break;
751  }
752  if (LocaleCompare("matte",option+1) == 0)
753  break;
754  if (LocaleCompare("moments",option+1) == 0)
755  break;
756  if (LocaleCompare("monitor",option+1) == 0)
757  break;
758  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
759  }
760  case 'n':
761  {
762  if (LocaleCompare("negate",option+1) == 0)
763  break;
764  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
765  }
766  case 'p':
767  {
768  if (LocaleCompare("ping",option+1) == 0)
769  {
770  image_info->ping=MagickTrue;
771  break;
772  }
773  if (LocaleCompare("precision",option+1) == 0)
774  {
775  if (*option == '+')
776  break;
777  i++;
778  if (i == (ssize_t) argc)
779  ThrowIdentifyException(OptionError,"MissingArgument",option);
780  if (IsGeometry(argv[i]) == MagickFalse)
781  ThrowIdentifyInvalidArgumentException(option,argv[i]);
782  break;
783  }
784  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
785  }
786  case 'q':
787  {
788  if (LocaleCompare("quiet",option+1) == 0)
789  break;
790  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
791  }
792  case 'r':
793  {
794  if (LocaleCompare("regard-warnings",option+1) == 0)
795  break;
796  if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
797  {
798  respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
799  break;
800  }
801  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
802  }
803  case 's':
804  {
805  if (LocaleCompare("sampling-factor",option+1) == 0)
806  {
807  if (*option == '+')
808  break;
809  i++;
810  if (i == (ssize_t) argc)
811  ThrowIdentifyException(OptionError,"MissingArgument",option);
812  if (IsGeometry(argv[i]) == MagickFalse)
813  ThrowIdentifyInvalidArgumentException(option,argv[i]);
814  break;
815  }
816  if (LocaleCompare("seed",option+1) == 0)
817  {
818  if (*option == '+')
819  break;
820  i++;
821  if (i == (ssize_t) argc)
822  ThrowIdentifyException(OptionError,"MissingArgument",option);
823  if (IsGeometry(argv[i]) == MagickFalse)
824  ThrowIdentifyInvalidArgumentException(option,argv[i]);
825  break;
826  }
827  if (LocaleCompare("set",option+1) == 0)
828  {
829  i++;
830  if (i == (ssize_t) argc)
831  ThrowIdentifyException(OptionError,"MissingArgument",option);
832  if (*option == '+')
833  break;
834  i++;
835  if (i == (ssize_t) argc)
836  ThrowIdentifyException(OptionError,"MissingArgument",option);
837  break;
838  }
839  if (LocaleCompare("size",option+1) == 0)
840  {
841  if (*option == '+')
842  break;
843  i++;
844  if (i == (ssize_t) argc)
845  ThrowIdentifyException(OptionError,"MissingArgument",option);
846  if (IsGeometry(argv[i]) == MagickFalse)
847  ThrowIdentifyInvalidArgumentException(option,argv[i]);
848  break;
849  }
850  if (LocaleCompare("strip",option+1) == 0)
851  break;
852  if (LocaleCompare("support",option+1) == 0)
853  {
854  if (*option == '+')
855  break;
856  i++;
857  if (i == (ssize_t) argc)
858  ThrowIdentifyException(OptionError,"MissingArgument",option);
859  if (IsGeometry(argv[i]) == MagickFalse)
860  ThrowIdentifyInvalidArgumentException(option,argv[i]);
861  break;
862  }
863  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
864  }
865  case 'u':
866  {
867  if (LocaleCompare("unique",option+1) == 0)
868  break;
869  if (LocaleCompare("units",option+1) == 0)
870  {
871  ssize_t
872  units;
873 
874  if (*option == '+')
875  break;
876  i++;
877  if (i == (ssize_t) argc)
878  ThrowIdentifyException(OptionError,"MissingArgument",option);
879  units=ParseCommandOption(MagickResolutionOptions,MagickFalse,
880  argv[i]);
881  if (units < 0)
882  ThrowIdentifyException(OptionError,"UnrecognizedUnitsType",
883  argv[i]);
884  break;
885  }
886  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
887  }
888  case 'v':
889  {
890  if (LocaleCompare("verbose",option+1) == 0)
891  break;
892  if (LocaleCompare("virtual-pixel",option+1) == 0)
893  {
894  ssize_t
895  method;
896 
897  if (*option == '+')
898  break;
899  i++;
900  if (i == (ssize_t) argc)
901  ThrowIdentifyException(OptionError,"MissingArgument",option);
902  method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
903  argv[i]);
904  if (method < 0)
905  ThrowIdentifyException(OptionError,
906  "UnrecognizedVirtualPixelMethod",argv[i]);
907  break;
908  }
909  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
910  }
911  case '?':
912  break;
913  default:
914  ThrowIdentifyException(OptionError,"UnrecognizedOption",option)
915  }
916  fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
917  FireOptionFlag) == 0 ? MagickFalse : MagickTrue;
918  if (fire != MagickFalse)
919  FireImageStack(MagickFalse,MagickTrue,MagickTrue);
920  }
921  if (k != 0)
922  ThrowIdentifyException(OptionError,"UnbalancedParenthesis",argv[i]);
923  if (i != (ssize_t) argc)
924  ThrowIdentifyException(OptionError,"MissingAnImageFilename",argv[i]);
925  DestroyIdentify();
926  return(status != 0 ? MagickTrue : MagickFalse);
927 }