MagickCore  6.9.12-72
Convert, Edit, Or Compose Bitmap Images
 All Data Structures
image.c
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % IIIII M M AAA GGGG EEEEE %
7 % I MM MM A A G E %
8 % I M M M AAAAA G GG EEE %
9 % I M M A A G G E %
10 % IIIII M M A A GGGG EEEEE %
11 % %
12 % %
13 % MagickCore Image Methods %
14 % %
15 % Software Design %
16 % Cristy %
17 % July 1992 %
18 % %
19 % %
20 % Copyright 1999-2021 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 %
37 %
38 */
39 
40 /*
41  Include declarations.
42 */
43 #include "magick/studio.h"
44 #include "magick/animate.h"
45 #include "magick/artifact.h"
46 #include "magick/blob.h"
47 #include "magick/blob-private.h"
48 #include "magick/cache.h"
49 #include "magick/cache-private.h"
50 #include "magick/cache-view.h"
51 #include "magick/channel.h"
52 #include "magick/client.h"
53 #include "magick/color.h"
54 #include "magick/color-private.h"
55 #include "magick/colormap.h"
56 #include "magick/colorspace.h"
57 #include "magick/colorspace-private.h"
58 #include "magick/composite.h"
59 #include "magick/composite-private.h"
60 #include "magick/compress.h"
61 #include "magick/constitute.h"
62 #include "magick/delegate.h"
63 #include "magick/deprecate.h"
64 #include "magick/display.h"
65 #include "magick/draw.h"
66 #include "magick/enhance.h"
67 #include "magick/exception.h"
68 #include "magick/exception-private.h"
69 #include "magick/gem.h"
70 #include "magick/geometry.h"
71 #include "magick/histogram.h"
72 #include "magick/image-private.h"
73 #include "magick/list.h"
74 #include "magick/magic.h"
75 #include "magick/magick.h"
76 #include "magick/memory_.h"
77 #include "magick/memory-private.h"
78 #include "magick/module.h"
79 #include "magick/monitor.h"
80 #include "magick/monitor-private.h"
81 #include "magick/option.h"
82 #include "magick/paint.h"
83 #include "magick/pixel-accessor.h"
84 #include "magick/pixel-private.h"
85 #include "magick/profile.h"
86 #include "magick/property.h"
87 #include "magick/quantize.h"
88 #include "magick/random_.h"
89 #include "magick/resource_.h"
90 #include "magick/segment.h"
91 #include "magick/semaphore.h"
92 #include "magick/signature-private.h"
93 #include "magick/statistic.h"
94 #include "magick/string_.h"
95 #include "magick/string-private.h"
96 #include "magick/thread-private.h"
97 #include "magick/threshold.h"
98 #include "magick/timer.h"
99 #include "magick/timer-private.h"
100 #include "magick/token.h"
101 #include "magick/token-private.h"
102 #include "magick/utility.h"
103 #include "magick/version.h"
104 #include "magick/xwindow-private.h"
105 
106 /*
107 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
108 % %
109 % %
110 % %
111 % A c q u i r e I m a g e %
112 % %
113 % %
114 % %
115 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
116 %
117 % AcquireImage() returns a pointer to an image structure initialized to
118 % default values.
119 %
120 % The format of the AcquireImage method is:
121 %
122 % Image *AcquireImage(const ImageInfo *image_info)
123 %
124 % A description of each parameter follows:
125 %
126 % o image_info: Many of the image default values are set from this
127 % structure. For example, filename, compression, depth, background color,
128 % and others.
129 %
130 */
131 MagickExport Image *AcquireImage(const ImageInfo *image_info)
132 {
133  const char
134  *option;
135 
136  Image
137  *image;
138 
139  MagickStatusType
140  flags;
141 
142  /*
143  Allocate image structure.
144  */
145  if (IsEventLogging() != MagickFalse)
146  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
147  image=(Image *) AcquireCriticalMemory(sizeof(*image));
148  (void) memset(image,0,sizeof(*image));
149  /*
150  Initialize Image structure.
151  */
152  (void) CopyMagickString(image->magick,"MIFF",MaxTextExtent);
153  image->storage_class=DirectClass;
154  image->depth=MAGICKCORE_QUANTUM_DEPTH;
155  image->colorspace=sRGBColorspace;
156  image->rendering_intent=PerceptualIntent;
157  image->gamma=1.000f/2.200f;
158  image->chromaticity.red_primary.x=0.6400f;
159  image->chromaticity.red_primary.y=0.3300f;
160  image->chromaticity.red_primary.z=0.0300f;
161  image->chromaticity.green_primary.x=0.3000f;
162  image->chromaticity.green_primary.y=0.6000f;
163  image->chromaticity.green_primary.z=0.1000f;
164  image->chromaticity.blue_primary.x=0.1500f;
165  image->chromaticity.blue_primary.y=0.0600f;
166  image->chromaticity.blue_primary.z=0.7900f;
167  image->chromaticity.white_point.x=0.3127f;
168  image->chromaticity.white_point.y=0.3290f;
169  image->chromaticity.white_point.z=0.3583f;
170  image->interlace=NoInterlace;
171  image->ticks_per_second=UndefinedTicksPerSecond;
172  image->compose=OverCompositeOp;
173  image->blur=1.0;
174  GetPixelPacketRGBA(BackgroundColorRGBA,&image->background_color);
175  GetPixelPacketRGBA(BorderColorRGBA,&image->border_color);
176  GetPixelPacketRGBA(MatteColorRGBA,&image->matte_color);
177  GetPixelPacketRGBA(TransparentColorRGBA,&image->transparent_color);
178  GetTimerInfo(&image->timer);
179  image->ping=MagickFalse;
180  image->cache=AcquirePixelCache(0);
181  image->blob=CloneBlobInfo((BlobInfo *) NULL);
182  InitializeExceptionInfo(&image->exception);
183  image->timestamp=GetMagickTime();
184  image->debug=(GetLogEventMask() & (ImageEvent | TransformEvent | CoderEvent))
185  != 0 ? MagickTrue : MagickFalse;
186  image->reference_count=1;
187  image->semaphore=AllocateSemaphoreInfo();
188  image->signature=MagickCoreSignature;
189  if (image_info == (ImageInfo *) NULL)
190  return(image);
191  /*
192  Transfer image info.
193  */
194  SetBlobExempt(image,image_info->file != (FILE *) NULL ? MagickTrue :
195  MagickFalse);
196  (void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent);
197  (void) CopyMagickString(image->magick_filename,image_info->filename,
198  MaxTextExtent);
199  (void) CopyMagickString(image->magick,image_info->magick,MaxTextExtent);
200  if (image_info->size != (char *) NULL)
201  {
202  (void) ParseAbsoluteGeometry(image_info->size,&image->extract_info);
203  image->columns=image->extract_info.width;
204  image->rows=image->extract_info.height;
205  image->offset=image->extract_info.x;
206  image->extract_info.x=0;
207  image->extract_info.y=0;
208  }
209  if (image_info->extract != (char *) NULL)
210  {
212  geometry;
213 
214  (void) memset(&geometry,0,sizeof(geometry));
215  flags=ParseAbsoluteGeometry(image_info->extract,&geometry);
216  if (((flags & XValue) != 0) || ((flags & YValue) != 0))
217  {
218  image->extract_info=geometry;
219  Swap(image->columns,image->extract_info.width);
220  Swap(image->rows,image->extract_info.height);
221  }
222  }
223  image->compression=image_info->compression;
224  image->quality=image_info->quality;
225  image->endian=image_info->endian;
226  image->interlace=image_info->interlace;
227  image->units=image_info->units;
228  if (image_info->density != (char *) NULL)
229  {
231  geometry_info;
232 
233  flags=ParseGeometry(image_info->density,&geometry_info);
234  if ((flags & RhoValue) != 0)
235  image->x_resolution=geometry_info.rho;
236  image->y_resolution=image->x_resolution;
237  if ((flags & SigmaValue) != 0)
238  image->y_resolution=geometry_info.sigma;
239  }
240  if (image_info->page != (char *) NULL)
241  {
242  char
243  *geometry;
244 
245  image->page=image->extract_info;
246  geometry=GetPageGeometry(image_info->page);
247  (void) ParseAbsoluteGeometry(geometry,&image->page);
248  geometry=DestroyString(geometry);
249  }
250  if (image_info->depth != 0)
251  image->depth=image_info->depth;
252  image->dither=image_info->dither;
253  image->background_color=image_info->background_color;
254  image->border_color=image_info->border_color;
255  image->matte_color=image_info->matte_color;
256  image->transparent_color=image_info->transparent_color;
257  image->ping=image_info->ping;
258  image->progress_monitor=image_info->progress_monitor;
259  image->client_data=image_info->client_data;
260  if (image_info->cache != (void *) NULL)
261  ClonePixelCacheMethods(image->cache,image_info->cache);
262  (void) SyncImageSettings(image_info,image);
263  option=GetImageOption(image_info,"delay");
264  if (option != (const char *) NULL)
265  {
267  geometry_info;
268 
269  flags=ParseGeometry(option,&geometry_info);
270  if ((flags & GreaterValue) != 0)
271  {
272  if ((double) image->delay > floor(geometry_info.rho+0.5))
273  image->delay=(size_t) CastDoubleToLong(floor(
274  geometry_info.rho+0.5));
275  }
276  else
277  if ((flags & LessValue) != 0)
278  {
279  if ((double) image->delay < floor(geometry_info.rho+0.5))
280  image->ticks_per_second=CastDoubleToLong(floor(
281  geometry_info.sigma+0.5));
282  }
283  else
284  image->delay=(size_t) CastDoubleToLong(floor(
285  geometry_info.rho+0.5));
286  if ((flags & SigmaValue) != 0)
287  image->ticks_per_second=CastDoubleToLong(floor(
288  geometry_info.sigma+0.5));
289  }
290  option=GetImageOption(image_info,"dispose");
291  if (option != (const char *) NULL)
292  image->dispose=(DisposeType) ParseCommandOption(MagickDisposeOptions,
293  MagickFalse,option);
294  return(image);
295 }
296 
297 /*
298 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
299 % %
300 % %
301 % %
302 % A c q u i r e I m a g e I n f o %
303 % %
304 % %
305 % %
306 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
307 %
308 % AcquireImageInfo() allocates the ImageInfo structure.
309 %
310 % The format of the AcquireImageInfo method is:
311 %
312 % ImageInfo *AcquireImageInfo(void)
313 %
314 */
315 MagickExport ImageInfo *AcquireImageInfo(void)
316 {
317  ImageInfo
318  *image_info;
319 
320  image_info=(ImageInfo *) AcquireMagickMemory(sizeof(*image_info));
321  if (image_info == (ImageInfo *) NULL)
322  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
323  GetImageInfo(image_info);
324  return(image_info);
325 }
326 
327 /*
328 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
329 % %
330 % %
331 % %
332 % A c q u i r e N e x t I m a g e %
333 % %
334 % %
335 % %
336 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
337 %
338 % AcquireNextImage() initializes the next image in a sequence to
339 % default values. The next member of image points to the newly allocated
340 % image. If there is a memory shortage, next is assigned NULL.
341 %
342 % The format of the AcquireNextImage method is:
343 %
344 % void AcquireNextImage(const ImageInfo *image_info,Image *image)
345 %
346 % A description of each parameter follows:
347 %
348 % o image_info: Many of the image default values are set from this
349 % structure. For example, filename, compression, depth, background color,
350 % and others.
351 %
352 % o image: the image.
353 %
354 */
355 MagickExport void AcquireNextImage(const ImageInfo *image_info,Image *image)
356 {
357  /*
358  Allocate image structure.
359  */
360  assert(image != (Image *) NULL);
361  assert(image->signature == MagickCoreSignature);
362  if (IsEventLogging() != MagickFalse)
363  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
364  image->next=AcquireImage(image_info);
365  if (GetNextImageInList(image) == (Image *) NULL)
366  return;
367  (void) CopyMagickString(GetNextImageInList(image)->filename,image->filename,
368  MaxTextExtent);
369  if (image_info != (ImageInfo *) NULL)
370  (void) CopyMagickString(GetNextImageInList(image)->filename,
371  image_info->filename,MaxTextExtent);
372  DestroyBlob(GetNextImageInList(image));
373  image->next->blob=ReferenceBlob(image->blob);
374  image->next->endian=image->endian;
375  image->next->scene=image->scene+1;
376  image->next->previous=image;
377 }
378 
379 /*
380 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
381 % %
382 % %
383 % %
384 % A p p e n d I m a g e s %
385 % %
386 % %
387 % %
388 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
389 %
390 % AppendImages() takes all images from the current image pointer to the end
391 % of the image list and appends them to each other top-to-bottom if the
392 % stack parameter is true, otherwise left-to-right.
393 %
394 % The current gravity setting now effects how the image is justified in the
395 % final image.
396 %
397 % The format of the AppendImages method is:
398 %
399 % Image *AppendImages(const Image *images,const MagickBooleanType stack,
400 % ExceptionInfo *exception)
401 %
402 % A description of each parameter follows:
403 %
404 % o images: the image sequence.
405 %
406 % o stack: A value other than 0 stacks the images top-to-bottom.
407 %
408 % o exception: return any errors or warnings in this structure.
409 %
410 */
411 MagickExport Image *AppendImages(const Image *images,
412  const MagickBooleanType stack,ExceptionInfo *exception)
413 {
414 #define AppendImageTag "Append/Image"
415 
416  CacheView
417  *append_view;
418 
419  Image
420  *append_image;
421 
422  MagickBooleanType
423  homogeneous_colorspace,
424  matte,
425  status;
426 
427  MagickOffsetType
428  n;
429 
431  geometry;
432 
433  const Image
434  *next;
435 
436  size_t
437  depth,
438  height,
439  number_images,
440  width;
441 
442  ssize_t
443  x_offset,
444  y,
445  y_offset;
446 
447  /*
448  Compute maximum area of appended area.
449  */
450  assert(images != (Image *) NULL);
451  assert(images->signature == MagickCoreSignature);
452  assert(exception != (ExceptionInfo *) NULL);
453  assert(exception->signature == MagickCoreSignature);
454  if (IsEventLogging() != MagickFalse)
455  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
456  matte=images->matte;
457  number_images=1;
458  width=images->columns;
459  height=images->rows;
460  depth=images->depth;
461  homogeneous_colorspace=MagickTrue;
462  next=GetNextImageInList(images);
463  for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
464  {
465  if (next->depth > depth)
466  depth=next->depth;
467  if (next->colorspace != images->colorspace)
468  homogeneous_colorspace=MagickFalse;
469  if (next->matte != MagickFalse)
470  matte=MagickTrue;
471  number_images++;
472  if (stack != MagickFalse)
473  {
474  if (next->columns > width)
475  width=next->columns;
476  height+=next->rows;
477  continue;
478  }
479  width+=next->columns;
480  if (next->rows > height)
481  height=next->rows;
482  }
483  /*
484  Append images.
485  */
486  append_image=CloneImage(images,width,height,MagickTrue,exception);
487  if (append_image == (Image *) NULL)
488  return((Image *) NULL);
489  if (SetImageStorageClass(append_image,DirectClass) == MagickFalse)
490  {
491  InheritException(exception,&append_image->exception);
492  append_image=DestroyImage(append_image);
493  return((Image *) NULL);
494  }
495  if (homogeneous_colorspace == MagickFalse)
496  (void) SetImageColorspace(append_image,sRGBColorspace);
497  append_image->depth=depth;
498  append_image->matte=matte;
499  append_image->page=images->page;
500  (void) SetImageBackgroundColor(append_image);
501  status=MagickTrue;
502  x_offset=0;
503  y_offset=0;
504  next=images;
505  append_view=AcquireAuthenticCacheView(append_image,exception);
506  for (n=0; n < (MagickOffsetType) number_images; n++)
507  {
508  CacheView
509  *image_view;
510 
511  MagickBooleanType
512  proceed;
513 
514  SetGeometry(append_image,&geometry);
515  GravityAdjustGeometry(next->columns,next->rows,next->gravity,&geometry);
516  if (stack != MagickFalse)
517  x_offset-=geometry.x;
518  else
519  y_offset-=geometry.y;
520  image_view=AcquireVirtualCacheView(next,exception);
521 #if defined(MAGICKCORE_OPENMP_SUPPORT)
522  #pragma omp parallel for schedule(static) shared(status) \
523  magick_number_threads(next,next,next->rows,1)
524 #endif
525  for (y=0; y < (ssize_t) next->rows; y++)
526  {
527  MagickBooleanType
528  sync;
529 
530  const IndexPacket
531  *magick_restrict indexes;
532 
533  const PixelPacket
534  *magick_restrict p;
535 
536  IndexPacket
537  *magick_restrict append_indexes;
538 
540  *magick_restrict q;
541 
542  ssize_t
543  x;
544 
545  if (status == MagickFalse)
546  continue;
547  p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);
548  q=QueueCacheViewAuthenticPixels(append_view,x_offset,y+y_offset,
549  next->columns,1,exception);
550  if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
551  {
552  status=MagickFalse;
553  continue;
554  }
555  indexes=GetCacheViewVirtualIndexQueue(image_view);
556  append_indexes=GetCacheViewAuthenticIndexQueue(append_view);
557  for (x=0; x < (ssize_t) next->columns; x++)
558  {
559  SetPixelRed(q,GetPixelRed(p));
560  SetPixelGreen(q,GetPixelGreen(p));
561  SetPixelBlue(q,GetPixelBlue(p));
562  SetPixelOpacity(q,OpaqueOpacity);
563  if (next->matte != MagickFalse)
564  SetPixelOpacity(q,GetPixelOpacity(p));
565  if ((next->colorspace == CMYKColorspace) &&
566  (append_image->colorspace == CMYKColorspace))
567  SetPixelIndex(append_indexes+x,GetPixelIndex(indexes+x));
568  p++;
569  q++;
570  }
571  sync=SyncCacheViewAuthenticPixels(append_view,exception);
572  if (sync == MagickFalse)
573  status=MagickFalse;
574  }
575  image_view=DestroyCacheView(image_view);
576  if (stack == MagickFalse)
577  {
578  x_offset+=(ssize_t) next->columns;
579  y_offset=0;
580  }
581  else
582  {
583  x_offset=0;
584  y_offset+=(ssize_t) next->rows;
585  }
586  proceed=SetImageProgress(append_image,AppendImageTag,n,number_images);
587  if (proceed == MagickFalse)
588  break;
589  next=GetNextImageInList(next);
590  }
591  append_view=DestroyCacheView(append_view);
592  if (status == MagickFalse)
593  append_image=DestroyImage(append_image);
594  return(append_image);
595 }
596 
597 /*
598 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
599 % %
600 % %
601 % %
602 % C a t c h I m a g e E x c e p t i o n %
603 % %
604 % %
605 % %
606 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
607 %
608 % CatchImageException() returns if no exceptions are found in the image
609 % sequence, otherwise it determines the most severe exception and reports
610 % it as a warning or error depending on the severity.
611 %
612 % The format of the CatchImageException method is:
613 %
614 % ExceptionType CatchImageException(Image *image)
615 %
616 % A description of each parameter follows:
617 %
618 % o image: An image sequence.
619 %
620 */
621 MagickExport ExceptionType CatchImageException(Image *image)
622 {
624  *exception;
625 
626  ExceptionType
627  severity;
628 
629  assert(image != (const Image *) NULL);
630  assert(image->signature == MagickCoreSignature);
631  if (IsEventLogging() != MagickFalse)
632  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
633  exception=AcquireExceptionInfo();
634  GetImageException(image,exception);
635  CatchException(exception);
636  severity=exception->severity;
637  exception=DestroyExceptionInfo(exception);
638  return(severity);
639 }
640 
641 /*
642 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
643 % %
644 % %
645 % %
646 % C l i p I m a g e P a t h %
647 % %
648 % %
649 % %
650 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
651 %
652 % ClipImagePath() sets the image clip mask based any clipping path information
653 % if it exists.
654 %
655 % The format of the ClipImagePath method is:
656 %
657 % MagickBooleanType ClipImagePath(Image *image,const char *pathname,
658 % const MagickBooleanType inside)
659 %
660 % A description of each parameter follows:
661 %
662 % o image: the image.
663 %
664 % o pathname: name of clipping path resource. If name is preceded by #, use
665 % clipping path numbered by name.
666 %
667 % o inside: if non-zero, later operations take effect inside clipping path.
668 % Otherwise later operations take effect outside clipping path.
669 %
670 */
671 
672 MagickExport MagickBooleanType ClipImage(Image *image)
673 {
674  return(ClipImagePath(image,"#1",MagickTrue));
675 }
676 
677 MagickExport MagickBooleanType ClipImagePath(Image *image,const char *pathname,
678  const MagickBooleanType inside)
679 {
680 #define ClipImagePathTag "ClipPath/Image"
681 
682  char
683  *property;
684 
685  const char
686  *value;
687 
688  Image
689  *clip_mask;
690 
691  ImageInfo
692  *image_info;
693 
694  assert(image != (const Image *) NULL);
695  assert(image->signature == MagickCoreSignature);
696  assert(pathname != NULL);
697  if (IsEventLogging() != MagickFalse)
698  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
699  property=AcquireString(pathname);
700  (void) FormatLocaleString(property,MaxTextExtent,"8BIM:1999,2998:%s",
701  pathname);
702  value=GetImageProperty(image,property);
703  property=DestroyString(property);
704  if (value == (const char *) NULL)
705  {
706  ThrowFileException(&image->exception,OptionError,"NoClipPathDefined",
707  image->filename);
708  return(MagickFalse);
709  }
710  image_info=AcquireImageInfo();
711  (void) CopyMagickString(image_info->filename,image->filename,MaxTextExtent);
712  (void) ConcatenateMagickString(image_info->filename,pathname,MaxTextExtent);
713  clip_mask=BlobToImage(image_info,value,strlen(value),&image->exception);
714  image_info=DestroyImageInfo(image_info);
715  if (clip_mask == (Image *) NULL)
716  return(MagickFalse);
717  if (clip_mask->storage_class == PseudoClass)
718  {
719  (void) SyncImage(clip_mask);
720  if (SetImageStorageClass(clip_mask,DirectClass) == MagickFalse)
721  return(MagickFalse);
722  }
723  if (inside == MagickFalse)
724  (void) NegateImage(clip_mask,MagickFalse);
725  (void) FormatLocaleString(clip_mask->magick_filename,MaxTextExtent,
726  "8BIM:1999,2998:%s\nPS",pathname);
727  (void) SetImageClipMask(image,clip_mask);
728  clip_mask=DestroyImage(clip_mask);
729  return(MagickTrue);
730 }
731 
732 /*
733 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
734 % %
735 % %
736 % %
737 % C l o n e I m a g e %
738 % %
739 % %
740 % %
741 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
742 %
743 % CloneImage() copies an image and returns the copy as a new image object.
744 %
745 % If the specified columns and rows is 0, an exact copy of the image is
746 % returned, otherwise the pixel data is undefined and must be initialized
747 % with the QueueAuthenticPixels() and SyncAuthenticPixels() methods. On
748 % failure, a NULL image is returned and exception describes the reason for the
749 % failure.
750 %
751 % The format of the CloneImage method is:
752 %
753 % Image *CloneImage(const Image *image,const size_t columns,
754 % const size_t rows,const MagickBooleanType orphan,
755 % ExceptionInfo *exception)
756 %
757 % A description of each parameter follows:
758 %
759 % o image: the image.
760 %
761 % o columns: the number of columns in the cloned image.
762 %
763 % o rows: the number of rows in the cloned image.
764 %
765 % o detach: With a value other than 0, the cloned image is detached from
766 % its parent I/O stream.
767 %
768 % o exception: return any errors or warnings in this structure.
769 %
770 */
771 MagickExport Image *CloneImage(const Image *image,const size_t columns,
772  const size_t rows,const MagickBooleanType detach,ExceptionInfo *exception)
773 {
774  double
775  scale_x,
776  scale_y;
777 
778  Image
779  *clone_image;
780 
781  size_t
782  length;
783 
784  /*
785  Clone the image.
786  */
787  assert(image != (const Image *) NULL);
788  assert(image->signature == MagickCoreSignature);
789  assert(exception != (ExceptionInfo *) NULL);
790  assert(exception->signature == MagickCoreSignature);
791  if (IsEventLogging() != MagickFalse)
792  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
793  if ((image->columns == 0) || (image->rows == 0))
794  {
795  (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
796  "NegativeOrZeroImageSize","`%s'",image->filename);
797  return((Image *) NULL);
798  }
799  clone_image=(Image *) AcquireCriticalMemory(sizeof(*clone_image));
800  (void) memset(clone_image,0,sizeof(*clone_image));
801  clone_image->signature=MagickCoreSignature;
802  clone_image->storage_class=image->storage_class;
803  clone_image->channels=image->channels;
804  clone_image->colorspace=image->colorspace;
805  clone_image->matte=image->matte;
806  clone_image->columns=image->columns;
807  clone_image->rows=image->rows;
808  clone_image->dither=image->dither;
809  (void) CloneImageProfiles(clone_image,image);
810  (void) CloneImageProperties(clone_image,image);
811  (void) CloneImageArtifacts(clone_image,image);
812  GetTimerInfo(&clone_image->timer);
813  InitializeExceptionInfo(&clone_image->exception);
814  InheritException(&clone_image->exception,&image->exception);
815  if (image->ascii85 != (void *) NULL)
816  Ascii85Initialize(clone_image);
817  clone_image->extent=image->extent;
818  clone_image->magick_columns=image->magick_columns;
819  clone_image->magick_rows=image->magick_rows;
820  clone_image->type=image->type;
821  (void) CopyMagickString(clone_image->magick_filename,image->magick_filename,
822  MaxTextExtent);
823  (void) CopyMagickString(clone_image->magick,image->magick,MaxTextExtent);
824  (void) CopyMagickString(clone_image->filename,image->filename,MaxTextExtent);
825  clone_image->progress_monitor=image->progress_monitor;
826  clone_image->client_data=image->client_data;
827  clone_image->reference_count=1;
828  clone_image->next=image->next;
829  clone_image->previous=image->previous;
830  clone_image->list=NewImageList();
831  clone_image->clip_mask=NewImageList();
832  clone_image->mask=NewImageList();
833  if (detach == MagickFalse)
834  clone_image->blob=ReferenceBlob(image->blob);
835  else
836  {
837  clone_image->next=NewImageList();
838  clone_image->previous=NewImageList();
839  clone_image->blob=CloneBlobInfo((BlobInfo *) NULL);
840  }
841  clone_image->ping=image->ping;
842  clone_image->debug=image->debug;
843  clone_image->semaphore=AllocateSemaphoreInfo();
844  if (image->colormap != (PixelPacket *) NULL)
845  {
846  /*
847  Allocate and copy the image colormap.
848  */
849  clone_image->colors=image->colors;
850  length=(size_t) image->colors;
851  clone_image->colormap=(PixelPacket *) AcquireQuantumMemory(length+1,
852  sizeof(*clone_image->colormap));
853  if (clone_image->colormap == (PixelPacket *) NULL)
854  {
855  clone_image=DestroyImage(clone_image);
856  ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
857  }
858  (void) memcpy(clone_image->colormap,image->colormap,length*
859  sizeof(*clone_image->colormap));
860  }
861  if ((columns == 0) || (rows == 0))
862  {
863  if (image->montage != (char *) NULL)
864  (void) CloneString(&clone_image->montage,image->montage);
865  if (image->directory != (char *) NULL)
866  (void) CloneString(&clone_image->directory,image->directory);
867  if (image->clip_mask != (Image *) NULL)
868  clone_image->clip_mask=CloneImage(image->clip_mask,0,0,MagickTrue,
869  exception);
870  if (image->mask != (Image *) NULL)
871  clone_image->mask=CloneImage(image->mask,0,0,MagickTrue,exception);
872  clone_image->cache=ReferencePixelCache(image->cache);
873  return(clone_image);
874  }
875  if ((columns == image->columns) && (rows == image->rows))
876  {
877  if (image->clip_mask != (Image *) NULL)
878  clone_image->clip_mask=CloneImage(image->clip_mask,0,0,MagickTrue,
879  exception);
880  if (image->mask != (Image *) NULL)
881  clone_image->mask=CloneImage(image->mask,0,0,MagickTrue,exception);
882  }
883  scale_x=1.0;
884  scale_y=1.0;
885  if (image->columns != 0)
886  scale_x=(double) columns/(double) image->columns;
887  if (image->rows != 0)
888  scale_y=(double) rows/(double) image->rows;
889  clone_image->page.width=(size_t) CastDoubleToLong(floor(scale_x*
890  image->page.width+0.5));
891  clone_image->page.height=(size_t) CastDoubleToLong(floor(scale_y*
892  image->page.height+0.5));
893  if (MagickAbsoluteValue(scale_x-scale_y) < 2.0)
894  scale_x=scale_y=MagickMin(scale_x,scale_y);
895  clone_image->page.x=CastDoubleToLong(ceil(scale_x*image->page.x-0.5));
896  clone_image->tile_offset.x=CastDoubleToLong(ceil(scale_x*
897  image->tile_offset.x-0.5));
898  clone_image->page.y=CastDoubleToLong(ceil(scale_y*image->page.y-0.5));
899  clone_image->tile_offset.y=CastDoubleToLong(ceil(scale_y*
900  image->tile_offset.y-0.5));
901  clone_image->cache=ClonePixelCache(image->cache);
902  if (SetImageExtent(clone_image,columns,rows) == MagickFalse)
903  {
904  InheritException(exception,&clone_image->exception);
905  clone_image=DestroyImage(clone_image);
906  }
907  return(clone_image);
908 }
909 
910 /*
911 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
912 % %
913 % %
914 % %
915 % C l o n e I m a g e I n f o %
916 % %
917 % %
918 % %
919 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
920 %
921 % CloneImageInfo() makes a copy of the given image info structure. If
922 % NULL is specified, a new image info structure is created initialized to
923 % default values.
924 %
925 % The format of the CloneImageInfo method is:
926 %
927 % ImageInfo *CloneImageInfo(const ImageInfo *image_info)
928 %
929 % A description of each parameter follows:
930 %
931 % o image_info: the image info.
932 %
933 */
934 MagickExport ImageInfo *CloneImageInfo(const ImageInfo *image_info)
935 {
936  ImageInfo
937  *clone_info;
938 
939  clone_info=AcquireImageInfo();
940  if (image_info == (ImageInfo *) NULL)
941  return(clone_info);
942  clone_info->compression=image_info->compression;
943  clone_info->temporary=image_info->temporary;
944  clone_info->adjoin=image_info->adjoin;
945  clone_info->antialias=image_info->antialias;
946  clone_info->scene=image_info->scene;
947  clone_info->number_scenes=image_info->number_scenes;
948  clone_info->depth=image_info->depth;
949  if (image_info->size != (char *) NULL)
950  (void) CloneString(&clone_info->size,image_info->size);
951  if (image_info->extract != (char *) NULL)
952  (void) CloneString(&clone_info->extract,image_info->extract);
953  if (image_info->scenes != (char *) NULL)
954  (void) CloneString(&clone_info->scenes,image_info->scenes);
955  if (image_info->page != (char *) NULL)
956  (void) CloneString(&clone_info->page,image_info->page);
957  clone_info->interlace=image_info->interlace;
958  clone_info->endian=image_info->endian;
959  clone_info->units=image_info->units;
960  clone_info->quality=image_info->quality;
961  if (image_info->sampling_factor != (char *) NULL)
962  (void) CloneString(&clone_info->sampling_factor,
963  image_info->sampling_factor);
964  if (image_info->server_name != (char *) NULL)
965  (void) CloneString(&clone_info->server_name,image_info->server_name);
966  if (image_info->font != (char *) NULL)
967  (void) CloneString(&clone_info->font,image_info->font);
968  if (image_info->texture != (char *) NULL)
969  (void) CloneString(&clone_info->texture,image_info->texture);
970  if (image_info->density != (char *) NULL)
971  (void) CloneString(&clone_info->density,image_info->density);
972  clone_info->pointsize=image_info->pointsize;
973  clone_info->fuzz=image_info->fuzz;
974  clone_info->pen=image_info->pen;
975  clone_info->background_color=image_info->background_color;
976  clone_info->border_color=image_info->border_color;
977  clone_info->matte_color=image_info->matte_color;
978  clone_info->transparent_color=image_info->transparent_color;
979  clone_info->dither=image_info->dither;
980  clone_info->monochrome=image_info->monochrome;
981  clone_info->colors=image_info->colors;
982  clone_info->colorspace=image_info->colorspace;
983  clone_info->type=image_info->type;
984  clone_info->orientation=image_info->orientation;
985  clone_info->preview_type=image_info->preview_type;
986  clone_info->group=image_info->group;
987  clone_info->ping=image_info->ping;
988  clone_info->verbose=image_info->verbose;
989  if (image_info->view != (char *) NULL)
990  (void) CloneString(&clone_info->view,image_info->view);
991  if (image_info->authenticate != (char *) NULL)
992  (void) CloneString(&clone_info->authenticate,image_info->authenticate);
993  (void) CloneImageOptions(clone_info,image_info);
994  clone_info->progress_monitor=image_info->progress_monitor;
995  clone_info->client_data=image_info->client_data;
996  clone_info->cache=image_info->cache;
997  if (image_info->cache != (void *) NULL)
998  clone_info->cache=ReferencePixelCache(image_info->cache);
999  if (image_info->profile != (void *) NULL)
1000  clone_info->profile=(void *) CloneStringInfo((StringInfo *)
1001  image_info->profile);
1002  SetImageInfoFile(clone_info,image_info->file);
1003  SetImageInfoBlob(clone_info,image_info->blob,image_info->length);
1004  clone_info->stream=image_info->stream;
1005  clone_info->virtual_pixel_method=image_info->virtual_pixel_method;
1006  (void) CopyMagickString(clone_info->magick,image_info->magick,MaxTextExtent);
1007  (void) CopyMagickString(clone_info->unique,image_info->unique,MaxTextExtent);
1008  (void) CopyMagickString(clone_info->zero,image_info->zero,MaxTextExtent);
1009  (void) CopyMagickString(clone_info->filename,image_info->filename,
1010  MaxTextExtent);
1011  clone_info->subimage=image_info->scene; /* deprecated */
1012  clone_info->subrange=image_info->number_scenes; /* deprecated */
1013  clone_info->channel=image_info->channel;
1014  clone_info->debug=image_info->debug;
1015  clone_info->signature=image_info->signature;
1016  return(clone_info);
1017 }
1018 
1019 /*
1020 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1021 % %
1022 % %
1023 % %
1024 % C o p y I m a g e P i x e l s %
1025 % %
1026 % %
1027 % %
1028 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1029 %
1030 % CopyImagePixels() copies pixels from the source image as defined by the
1031 % geometry the destination image at the specified offset.
1032 %
1033 % The format of the CopyImagePixels method is:
1034 %
1035 % MagickBooleanType CopyImagePixels(Image *image,const Image *source_image,
1036 % const RectangleInfo *geometry,const OffsetInfo *offset,
1037 % ExceptionInfo *exception)
1038 %
1039 % A description of each parameter follows:
1040 %
1041 % o image: the destination image.
1042 %
1043 % o source_image: the source image.
1044 %
1045 % o geometry: define the dimensions of the source pixel rectangle.
1046 %
1047 % o offset: define the offset in the destination image.
1048 %
1049 % o exception: return the highest severity exception.
1050 %
1051 */
1052 MagickExport MagickBooleanType CopyImagePixels(Image *image,
1053  const Image *source_image,const RectangleInfo *geometry,
1054  const OffsetInfo *offset,ExceptionInfo *exception)
1055 {
1056 #define CopyImageTag "Copy/Image"
1057 
1058  CacheView
1059  *image_view,
1060  *source_view;
1061 
1062  MagickBooleanType
1063  status;
1064 
1065  MagickOffsetType
1066  progress;
1067 
1068  ssize_t
1069  y;
1070 
1071  assert(image != (Image *) NULL);
1072  assert(source_image != (Image *) NULL);
1073  assert(geometry != (RectangleInfo *) NULL);
1074  assert(offset != (OffsetInfo *) NULL);
1075  if (IsEventLogging() != MagickFalse)
1076  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1077  if ((offset->x < 0) || (offset->y < 0) ||
1078  ((ssize_t) (offset->x+geometry->width) > (ssize_t) image->columns) ||
1079  ((ssize_t) (offset->y+geometry->height) > (ssize_t) image->rows))
1080  ThrowBinaryException(OptionError,"GeometryDoesNotContainImage",
1081  image->filename);
1082  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1083  return(MagickFalse);
1084  /*
1085  Copy image pixels.
1086  */
1087  status=MagickTrue;
1088  progress=0;
1089  source_view=AcquireVirtualCacheView(source_image,exception);
1090  image_view=AcquireAuthenticCacheView(image,exception);
1091 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1092  #pragma omp parallel for schedule(static) shared(progress,status) \
1093  magick_number_threads(source_image,image,geometry->height,1)
1094 #endif
1095  for (y=0; y < (ssize_t) geometry->height; y++)
1096  {
1097  const IndexPacket
1098  *magick_restrict source_indexes;
1099 
1100  const PixelPacket
1101  *magick_restrict p;
1102 
1103  IndexPacket
1104  *magick_restrict indexes;
1105 
1106  PixelPacket
1107  *magick_restrict q;
1108 
1109  ssize_t
1110  x;
1111 
1112  if (status == MagickFalse)
1113  continue;
1114  p=GetCacheViewVirtualPixels(source_view,geometry->x,y+geometry->y,
1115  geometry->width,1,exception);
1116  q=GetCacheViewAuthenticPixels(image_view,offset->x,y+offset->y,
1117  geometry->width,1,exception);
1118  if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
1119  {
1120  status=MagickFalse;
1121  continue;
1122  }
1123  source_indexes=GetCacheViewVirtualIndexQueue(source_view);
1124  indexes=GetCacheViewAuthenticIndexQueue(image_view);
1125  for (x=0; x < (ssize_t) geometry->width; x++)
1126  {
1127  *q=(*p);
1128  if (image->colorspace == CMYKColorspace)
1129  indexes[x]=source_indexes[x];
1130  p++;
1131  q++;
1132  }
1133  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1134  status=MagickFalse;
1135  if (image->progress_monitor != (MagickProgressMonitor) NULL)
1136  {
1137  MagickBooleanType
1138  proceed;
1139 
1140 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1141  #pragma omp atomic
1142 #endif
1143  progress++;
1144  proceed=SetImageProgress(image,CopyImageTag,progress,image->rows);
1145  if (proceed == MagickFalse)
1146  status=MagickFalse;
1147  }
1148  }
1149  image_view=DestroyCacheView(image_view);
1150  source_view=DestroyCacheView(source_view);
1151  return(status);
1152 }
1153 
1154 /*
1155 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1156 % %
1157 % %
1158 % %
1159 % D e s t r o y I m a g e %
1160 % %
1161 % %
1162 % %
1163 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1164 %
1165 % DestroyImage() dereferences an image, deallocating memory associated with
1166 % the image if the reference count becomes zero.
1167 %
1168 % The format of the DestroyImage method is:
1169 %
1170 % Image *DestroyImage(Image *image)
1171 %
1172 % A description of each parameter follows:
1173 %
1174 % o image: the image.
1175 %
1176 */
1177 MagickExport Image *DestroyImage(Image *image)
1178 {
1179  MagickBooleanType
1180  destroy;
1181 
1182  /*
1183  Dereference image.
1184  */
1185  assert(image != (Image *) NULL);
1186  assert(image->signature == MagickCoreSignature);
1187  if (IsEventLogging() != MagickFalse)
1188  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1189  destroy=MagickFalse;
1190  LockSemaphoreInfo(image->semaphore);
1191  image->reference_count--;
1192  if (image->reference_count == 0)
1193  destroy=MagickTrue;
1194  UnlockSemaphoreInfo(image->semaphore);
1195  if (destroy == MagickFalse)
1196  return((Image *) NULL);
1197  /*
1198  Destroy image.
1199  */
1200  DestroyImagePixels(image);
1201  if (image->clip_mask != (Image *) NULL)
1202  image->clip_mask=DestroyImage(image->clip_mask);
1203  if (image->mask != (Image *) NULL)
1204  image->mask=DestroyImage(image->mask);
1205  if (image->montage != (char *) NULL)
1206  image->montage=DestroyString(image->montage);
1207  if (image->directory != (char *) NULL)
1208  image->directory=DestroyString(image->directory);
1209  if (image->colormap != (PixelPacket *) NULL)
1210  image->colormap=(PixelPacket *) RelinquishMagickMemory(image->colormap);
1211  if (image->geometry != (char *) NULL)
1212  image->geometry=DestroyString(image->geometry);
1213  DestroyImageProfiles(image);
1214  DestroyImageProperties(image);
1215  DestroyImageArtifacts(image);
1216  if (image->ascii85 != (Ascii85Info*) NULL)
1217  image->ascii85=(Ascii85Info *) RelinquishMagickMemory(image->ascii85);
1218  DestroyBlob(image);
1219  (void) ClearExceptionInfo(&image->exception,MagickTrue);
1220  if (image->semaphore != (SemaphoreInfo *) NULL)
1221  DestroySemaphoreInfo(&image->semaphore);
1222  image->signature=(~MagickCoreSignature);
1223  image=(Image *) RelinquishMagickMemory(image);
1224  return(image);
1225 }
1226 
1227 /*
1228 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1229 % %
1230 % %
1231 % %
1232 % D e s t r o y I m a g e I n f o %
1233 % %
1234 % %
1235 % %
1236 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1237 %
1238 % DestroyImageInfo() deallocates memory associated with an ImageInfo
1239 % structure.
1240 %
1241 % The format of the DestroyImageInfo method is:
1242 %
1243 % ImageInfo *DestroyImageInfo(ImageInfo *image_info)
1244 %
1245 % A description of each parameter follows:
1246 %
1247 % o image_info: the image info.
1248 %
1249 */
1250 MagickExport ImageInfo *DestroyImageInfo(ImageInfo *image_info)
1251 {
1252  assert(image_info != (ImageInfo *) NULL);
1253  assert(image_info->signature == MagickCoreSignature);
1254  if (IsEventLogging() != MagickFalse)
1255  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1256  image_info->filename);
1257  if (image_info->size != (char *) NULL)
1258  image_info->size=DestroyString(image_info->size);
1259  if (image_info->extract != (char *) NULL)
1260  image_info->extract=DestroyString(image_info->extract);
1261  if (image_info->scenes != (char *) NULL)
1262  image_info->scenes=DestroyString(image_info->scenes);
1263  if (image_info->page != (char *) NULL)
1264  image_info->page=DestroyString(image_info->page);
1265  if (image_info->sampling_factor != (char *) NULL)
1266  image_info->sampling_factor=DestroyString(
1267  image_info->sampling_factor);
1268  if (image_info->server_name != (char *) NULL)
1269  image_info->server_name=DestroyString(
1270  image_info->server_name);
1271  if (image_info->font != (char *) NULL)
1272  image_info->font=DestroyString(image_info->font);
1273  if (image_info->texture != (char *) NULL)
1274  image_info->texture=DestroyString(image_info->texture);
1275  if (image_info->density != (char *) NULL)
1276  image_info->density=DestroyString(image_info->density);
1277  if (image_info->view != (char *) NULL)
1278  image_info->view=DestroyString(image_info->view);
1279  if (image_info->authenticate != (char *) NULL)
1280  image_info->authenticate=DestroyString(
1281  image_info->authenticate);
1282  DestroyImageOptions(image_info);
1283  if (image_info->cache != (void *) NULL)
1284  image_info->cache=DestroyPixelCache(image_info->cache);
1285  if (image_info->profile != (StringInfo *) NULL)
1286  image_info->profile=(void *) DestroyStringInfo((StringInfo *)
1287  image_info->profile);
1288  image_info->signature=(~MagickCoreSignature);
1289  image_info=(ImageInfo *) RelinquishMagickMemory(image_info);
1290  return(image_info);
1291 }
1292 
1293 /*
1294 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1295 % %
1296 % %
1297 % %
1298 + D i s a s s o c i a t e I m a g e S t r e a m %
1299 % %
1300 % %
1301 % %
1302 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1303 %
1304 % DisassociateImageStream() disassociates the image stream. It checks if the
1305 % blob of the specified image is referenced by other images. If the reference
1306 % count is higher then 1 a new blob is assigned to the specified image.
1307 %
1308 % The format of the DisassociateImageStream method is:
1309 %
1310 % void DisassociateImageStream(const Image *image)
1311 %
1312 % A description of each parameter follows:
1313 %
1314 % o image: the image.
1315 %
1316 */
1317 MagickExport void DisassociateImageStream(Image *image)
1318 {
1319  assert(image != (Image *) NULL);
1320  assert(image->signature == MagickCoreSignature);
1321  if (IsEventLogging() != MagickFalse)
1322  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1323  DisassociateBlob(image);
1324 }
1325 
1326 /*
1327 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1328 % %
1329 % %
1330 % %
1331 % G e t I m a g e C l i p M a s k %
1332 % %
1333 % %
1334 % %
1335 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1336 %
1337 % GetImageClipMask() returns the clip path associated with the image.
1338 %
1339 % The format of the GetImageClipMask method is:
1340 %
1341 % Image *GetImageClipMask(const Image *image,ExceptionInfo *exception)
1342 %
1343 % A description of each parameter follows:
1344 %
1345 % o image: the image.
1346 %
1347 */
1348 MagickExport Image *GetImageClipMask(const Image *image,
1349  ExceptionInfo *exception)
1350 {
1351  assert(image != (const Image *) NULL);
1352  assert(image->signature == MagickCoreSignature);
1353  if (IsEventLogging() != MagickFalse)
1354  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1355  if (image->clip_mask == (Image *) NULL)
1356  return((Image *) NULL);
1357  return(CloneImage(image->clip_mask,0,0,MagickTrue,exception));
1358 }
1359 
1360 /*
1361 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1362 % %
1363 % %
1364 % %
1365 % G e t I m a g e E x c e p t i o n %
1366 % %
1367 % %
1368 % %
1369 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1370 %
1371 % GetImageException() traverses an image sequence and returns any
1372 % error more severe than noted by the exception parameter.
1373 %
1374 % The format of the GetImageException method is:
1375 %
1376 % void GetImageException(Image *image,ExceptionInfo *exception)
1377 %
1378 % A description of each parameter follows:
1379 %
1380 % o image: Specifies a pointer to a list of one or more images.
1381 %
1382 % o exception: return the highest severity exception.
1383 %
1384 */
1385 MagickExport void GetImageException(Image *image,ExceptionInfo *exception)
1386 {
1387  Image
1388  *next;
1389 
1390  assert(image != (Image *) NULL);
1391  assert(image->signature == MagickCoreSignature);
1392  assert(exception != (ExceptionInfo *) NULL);
1393  assert(exception->signature == MagickCoreSignature);
1394  if (IsEventLogging() != MagickFalse)
1395  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1396  for (next=image; next != (Image *) NULL; next=GetNextImageInList(next))
1397  {
1398  if (next->exception.severity == UndefinedException)
1399  continue;
1400  if (next->exception.severity > exception->severity)
1401  InheritException(exception,&next->exception);
1402  next->exception.severity=UndefinedException;
1403  }
1404 }
1405 
1406 /*
1407 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1408 % %
1409 % %
1410 % %
1411 % G e t I m a g e I n f o %
1412 % %
1413 % %
1414 % %
1415 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1416 %
1417 % GetImageInfo() initializes image_info to default values.
1418 %
1419 % The format of the GetImageInfo method is:
1420 %
1421 % void GetImageInfo(ImageInfo *image_info)
1422 %
1423 % A description of each parameter follows:
1424 %
1425 % o image_info: the image info.
1426 %
1427 */
1428 MagickExport void GetImageInfo(ImageInfo *image_info)
1429 {
1430  char
1431  *synchronize;
1432 
1433  /*
1434  File and image dimension members.
1435  */
1436  assert(image_info != (ImageInfo *) NULL);
1437  if (IsEventLogging() != MagickFalse)
1438  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1439  (void) memset(image_info,0,sizeof(*image_info));
1440  image_info->adjoin=MagickTrue;
1441  image_info->interlace=NoInterlace;
1442  image_info->channel=DefaultChannels;
1443  image_info->quality=UndefinedCompressionQuality;
1444  image_info->antialias=MagickTrue;
1445  image_info->dither=MagickTrue;
1446  synchronize=GetEnvironmentValue("MAGICK_SYNCHRONIZE");
1447  if (synchronize != (const char *) NULL)
1448  {
1449  image_info->synchronize=IsStringTrue(synchronize);
1450  synchronize=DestroyString(synchronize);
1451  }
1452  GetPixelPacketRGBA(BackgroundColorRGBA,&image_info->background_color);
1453  GetPixelPacketRGBA(BorderColorRGBA,&image_info->border_color);
1454  GetPixelPacketRGBA(MatteColorRGBA,&image_info->matte_color);
1455  GetPixelPacketRGBA(TransparentColorRGBA,&image_info->transparent_color);
1456  image_info->debug=(GetLogEventMask() & ImageEvent) != 0 ? MagickTrue :
1457  MagickFalse;
1458  image_info->signature=MagickCoreSignature;
1459 }
1460 
1461 /*
1462 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1463 % %
1464 % %
1465 % %
1466 % G e t I m a g e I n f o F i l e %
1467 % %
1468 % %
1469 % %
1470 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1471 %
1472 % GetImageInfoFile() returns the image info file member.
1473 %
1474 % The format of the GetImageInfoFile method is:
1475 %
1476 % FILE *GetImageInfoFile(const ImageInfo *image_info)
1477 %
1478 % A description of each parameter follows:
1479 %
1480 % o image_info: the image info.
1481 %
1482 */
1483 MagickExport FILE *GetImageInfoFile(const ImageInfo *image_info)
1484 {
1485  return(image_info->file);
1486 }
1487 
1488 /*
1489 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1490 % %
1491 % %
1492 % %
1493 % G e t I m a g e M a s k %
1494 % %
1495 % %
1496 % %
1497 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1498 %
1499 % GetImageMask() returns the mask associated with the image.
1500 %
1501 % The format of the GetImageMask method is:
1502 %
1503 % Image *GetImageMask(const Image *image,ExceptionInfo *exception)
1504 %
1505 % A description of each parameter follows:
1506 %
1507 % o image: the image.
1508 %
1509 */
1510 MagickExport Image *GetImageMask(const Image *image,ExceptionInfo *exception)
1511 {
1512  assert(image != (const Image *) NULL);
1513  assert(image->signature == MagickCoreSignature);
1514  if (IsEventLogging() != MagickFalse)
1515  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1516  if (image->mask == (Image *) NULL)
1517  return((Image *) NULL);
1518  return(CloneImage(image->mask,0,0,MagickTrue,exception));
1519 }
1520 
1521 /*
1522 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1523 % %
1524 % %
1525 % %
1526 % G e t I m a g e C h a n n e l s %
1527 % %
1528 % %
1529 % %
1530 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1531 %
1532 % GetImageChannels() returns the number of pixel channels associated with the
1533 % specified image.
1534 %
1535 % The format of the GetChannels method is:
1536 %
1537 % size_t GetImageChannels(Image *image)
1538 %
1539 % A description of each parameter follows:
1540 %
1541 % o image: the image.
1542 %
1543 */
1544 MagickExport size_t GetImageChannels(Image *image)
1545 {
1546  assert(image != (Image *) NULL);
1547  assert(image->signature == MagickCoreSignature);
1548  if (IsEventLogging() != MagickFalse)
1549  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1550  return(image->channels);
1551 }
1552 
1553 /*
1554 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1555 % %
1556 % %
1557 % %
1558 + G e t I m a g e R e f e r e n c e C o u n t %
1559 % %
1560 % %
1561 % %
1562 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1563 %
1564 % GetImageReferenceCount() returns the image reference count.
1565 %
1566 % The format of the GetReferenceCount method is:
1567 %
1568 % ssize_t GetImageReferenceCount(Image *image)
1569 %
1570 % A description of each parameter follows:
1571 %
1572 % o image: the image.
1573 %
1574 */
1575 MagickExport ssize_t GetImageReferenceCount(Image *image)
1576 {
1577  ssize_t
1578  reference_count;
1579 
1580  assert(image != (Image *) NULL);
1581  assert(image->signature == MagickCoreSignature);
1582  if (IsEventLogging() != MagickFalse)
1583  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1584  LockSemaphoreInfo(image->semaphore);
1585  reference_count=image->reference_count;
1586  UnlockSemaphoreInfo(image->semaphore);
1587  return(reference_count);
1588 }
1589 
1590 /*
1591 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1592 % %
1593 % %
1594 % %
1595 % G e t I m a g e V i r t u a l P i x e l M e t h o d %
1596 % %
1597 % %
1598 % %
1599 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1600 %
1601 % GetImageVirtualPixelMethod() gets the "virtual pixels" method for the
1602 % image. A virtual pixel is any pixel access that is outside the boundaries
1603 % of the image cache.
1604 %
1605 % The format of the GetImageVirtualPixelMethod() method is:
1606 %
1607 % VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image)
1608 %
1609 % A description of each parameter follows:
1610 %
1611 % o image: the image.
1612 %
1613 */
1614 MagickExport VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image)
1615 {
1616  assert(image != (Image *) NULL);
1617  assert(image->signature == MagickCoreSignature);
1618  if (IsEventLogging() != MagickFalse)
1619  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1620  return(GetPixelCacheVirtualMethod(image));
1621 }
1622 
1623 /*
1624 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1625 % %
1626 % %
1627 % %
1628 % I n t e r p r e t I m a g e F i l e n a m e %
1629 % %
1630 % %
1631 % %
1632 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1633 %
1634 % InterpretImageFilename() interprets embedded characters in an image filename.
1635 % The filename length is returned.
1636 %
1637 % The format of the InterpretImageFilename method is:
1638 %
1639 % size_t InterpretImageFilename(const ImageInfo *image_info,Image *image,
1640 % const char *format,int value,char *filename)
1641 %
1642 % A description of each parameter follows.
1643 %
1644 % o image_info: the image info..
1645 %
1646 % o image: the image.
1647 %
1648 % o format: A filename describing the format to use to write the numeric
1649 % argument. Only the first numeric format identifier is replaced.
1650 %
1651 % o value: Numeric value to substitute into format filename.
1652 %
1653 % o filename: return the formatted filename in this character buffer.
1654 %
1655 */
1656 MagickExport size_t InterpretImageFilename(const ImageInfo *image_info,
1657  Image *image,const char *format,int value,char *filename)
1658 {
1659  char
1660  *q;
1661 
1662  const char
1663  *p;
1664 
1665  int
1666  c;
1667 
1668  MagickBooleanType
1669  canonical;
1670 
1671  ssize_t
1672  field_width,
1673  offset;
1674 
1675  canonical=MagickFalse;
1676  offset=0;
1677  (void) CopyMagickString(filename,format,MaxTextExtent);
1678  if (IsStringTrue(GetImageOption(image_info,"filename:literal")) != MagickFalse)
1679  return(strlen(filename));
1680  for (p=strchr(format,'%'); p != (char *) NULL; p=strchr(p+1,'%'))
1681  {
1682  q=(char *) p+1;
1683  if (*q == '%')
1684  {
1685  p=q+1;
1686  continue;
1687  }
1688  field_width=0;
1689  if (*q == '0')
1690  field_width=(ssize_t) strtol(q,&q,10);
1691  switch (*q)
1692  {
1693  case 'd':
1694  case 'o':
1695  case 'x':
1696  {
1697  q++;
1698  c=(*q);
1699  *q='\0';
1700  (void) FormatLocaleString(filename+(p-format-offset),(size_t)
1701  (MaxTextExtent-(p-format-offset)),p,value);
1702  offset+=(4-field_width);
1703  *q=c;
1704  (void) ConcatenateMagickString(filename,q,MaxTextExtent);
1705  canonical=MagickTrue;
1706  if (*(q-1) != '%')
1707  break;
1708  p++;
1709  break;
1710  }
1711  case '[':
1712  {
1713  char
1714  pattern[MaxTextExtent];
1715 
1716  const char
1717  *value;
1718 
1719  char
1720  *r;
1721 
1722  ssize_t
1723  i;
1724 
1725  ssize_t
1726  depth;
1727 
1728  /*
1729  Image option.
1730  */
1731  if (strchr(p,']') == (char *) NULL)
1732  break;
1733  depth=1;
1734  r=q+1;
1735  for (i=0; (i < (MaxTextExtent-1L)) && (*r != '\0'); i++)
1736  {
1737  if (*r == '[')
1738  depth++;
1739  if (*r == ']')
1740  depth--;
1741  if (depth <= 0)
1742  break;
1743  pattern[i]=(*r++);
1744  }
1745  pattern[i]='\0';
1746  if (LocaleNCompare(pattern,"filename:",9) != 0)
1747  break;
1748  value=(const char *) NULL;
1749  if (image != (Image *) NULL)
1750  value=GetImageProperty(image,pattern);
1751  if ((value == (const char *) NULL) &&
1752  (image != (Image *) NULL))
1753  value=GetImageArtifact(image,pattern);
1754  if ((value == (const char *) NULL) &&
1755  (image_info != (ImageInfo *) NULL))
1756  value=GetImageOption(image_info,pattern);
1757  if (value == (const char *) NULL)
1758  break;
1759  q--;
1760  c=(*q);
1761  *q='\0';
1762  (void) CopyMagickString(filename+(p-format-offset),value,(size_t)
1763  (MaxTextExtent-(p-format-offset)));
1764  offset+=strlen(pattern)-strlen(value)+3;
1765  *q=c;
1766  (void) ConcatenateMagickString(filename,r+1,MaxTextExtent);
1767  canonical=MagickTrue;
1768  if (*(q-1) != '%')
1769  break;
1770  p++;
1771  break;
1772  }
1773  default:
1774  break;
1775  }
1776  }
1777  if (canonical == MagickFalse)
1778  (void) CopyMagickString(filename,format,MaxTextExtent);
1779  else
1780  for (q=filename; *q != '\0'; q++)
1781  if ((*q == '%') && (*(q+1) == '%'))
1782  (void) CopyMagickString(q,q+1,(size_t) (MaxTextExtent-(q-filename)));
1783  return(strlen(filename));
1784 }
1785 
1786 /*
1787 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1788 % %
1789 % %
1790 % %
1791 % I s H i g h D y n a m i c R a n g e I m a g e %
1792 % %
1793 % %
1794 % %
1795 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1796 %
1797 % IsHighDynamicRangeImage() returns MagickTrue if any pixel component is
1798 % non-integer or exceeds the bounds of the quantum depth (e.g. for Q16
1799 % 0..65535.
1800 %
1801 % The format of the IsHighDynamicRangeImage method is:
1802 %
1803 % MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1804 % ExceptionInfo *exception)
1805 %
1806 % A description of each parameter follows:
1807 %
1808 % o image: the image.
1809 %
1810 % o exception: return any errors or warnings in this structure.
1811 %
1812 */
1813 MagickExport MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1814  ExceptionInfo *exception)
1815 {
1816 #if !defined(MAGICKCORE_HDRI_SUPPORT)
1817  (void) image;
1818  (void) exception;
1819  return(MagickFalse);
1820 #else
1821  CacheView
1822  *image_view;
1823 
1824  MagickBooleanType
1825  status;
1826 
1828  zero;
1829 
1830  ssize_t
1831  y;
1832 
1833  assert(image != (Image *) NULL);
1834  assert(image->signature == MagickCoreSignature);
1835  if (IsEventLogging() != MagickFalse)
1836  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1837  status=MagickTrue;
1838  GetMagickPixelPacket(image,&zero);
1839  image_view=AcquireVirtualCacheView(image,exception);
1840 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1841  #pragma omp parallel for schedule(static) shared(status) \
1842  magick_number_threads(image,image,image->rows,1)
1843 #endif
1844  for (y=0; y < (ssize_t) image->rows; y++)
1845  {
1847  pixel;
1848 
1849  const IndexPacket
1850  *indexes;
1851 
1852  const PixelPacket
1853  *p;
1854 
1855  ssize_t
1856  x;
1857 
1858  if (status == MagickFalse)
1859  continue;
1860  p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1861  if (p == (const PixelPacket *) NULL)
1862  {
1863  status=MagickFalse;
1864  continue;
1865  }
1866  indexes=GetCacheViewVirtualIndexQueue(image_view);
1867  pixel=zero;
1868  for (x=0; x < (ssize_t) image->columns; x++)
1869  {
1870  SetMagickPixelPacket(image,p,indexes+x,&pixel);
1871  if ((pixel.red < 0.0) || (pixel.red > QuantumRange) ||
1872  (pixel.red != (QuantumAny) pixel.red))
1873  break;
1874  if ((pixel.green < 0.0) || (pixel.green > QuantumRange) ||
1875  (pixel.green != (QuantumAny) pixel.green))
1876  break;
1877  if ((pixel.blue < 0.0) || (pixel.blue > QuantumRange) ||
1878  (pixel.blue != (QuantumAny) pixel.blue))
1879  break;
1880  if (pixel.matte != MagickFalse)
1881  {
1882  if ((pixel.opacity < 0.0) || (pixel.opacity > QuantumRange) ||
1883  (pixel.opacity != (QuantumAny) pixel.opacity))
1884  break;
1885  }
1886  if (pixel.colorspace == CMYKColorspace)
1887  {
1888  if ((pixel.index < 0.0) || (pixel.index > QuantumRange) ||
1889  (pixel.index != (QuantumAny) pixel.index))
1890  break;
1891  }
1892  p++;
1893  }
1894  if (x < (ssize_t) image->columns)
1895  status=MagickFalse;
1896  }
1897  image_view=DestroyCacheView(image_view);
1898  return(status != MagickFalse ? MagickFalse : MagickTrue);
1899 #endif
1900 }
1901 
1902 /*
1903 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1904 % %
1905 % %
1906 % %
1907 % I s I m a g e O b j e c t %
1908 % %
1909 % %
1910 % %
1911 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1912 %
1913 % IsImageObject() returns MagickTrue if the image sequence contains a valid
1914 % set of image objects.
1915 %
1916 % The format of the IsImageObject method is:
1917 %
1918 % MagickBooleanType IsImageObject(const Image *image)
1919 %
1920 % A description of each parameter follows:
1921 %
1922 % o image: the image.
1923 %
1924 */
1925 MagickExport MagickBooleanType IsImageObject(const Image *image)
1926 {
1927  const Image
1928  *p;
1929 
1930  assert(image != (Image *) NULL);
1931  if (IsEventLogging() != MagickFalse)
1932  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1933  for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
1934  if (p->signature != MagickCoreSignature)
1935  return(MagickFalse);
1936  return(MagickTrue);
1937 }
1938 
1939 /*
1940 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1941 % %
1942 % %
1943 % %
1944 % I s T a i n t I m a g e %
1945 % %
1946 % %
1947 % %
1948 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1949 %
1950 % IsTaintImage() returns MagickTrue any pixel in the image has been altered
1951 % since it was first constituted.
1952 %
1953 % The format of the IsTaintImage method is:
1954 %
1955 % MagickBooleanType IsTaintImage(const Image *image)
1956 %
1957 % A description of each parameter follows:
1958 %
1959 % o image: the image.
1960 %
1961 */
1962 MagickExport MagickBooleanType IsTaintImage(const Image *image)
1963 {
1964  char
1965  magick[MaxTextExtent],
1966  filename[MaxTextExtent];
1967 
1968  const Image
1969  *p;
1970 
1971  assert(image != (Image *) NULL);
1972  assert(image->signature == MagickCoreSignature);
1973  if (IsEventLogging() != MagickFalse)
1974  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1975  (void) CopyMagickString(magick,image->magick,MaxTextExtent);
1976  (void) CopyMagickString(filename,image->filename,MaxTextExtent);
1977  for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
1978  {
1979  if (p->taint != MagickFalse)
1980  return(MagickTrue);
1981  if (LocaleCompare(p->magick,magick) != 0)
1982  return(MagickTrue);
1983  if (LocaleCompare(p->filename,filename) != 0)
1984  return(MagickTrue);
1985  }
1986  return(MagickFalse);
1987 }
1988 
1989 /*
1990 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1991 % %
1992 % %
1993 % %
1994 % M o d i f y I m a g e %
1995 % %
1996 % %
1997 % %
1998 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1999 %
2000 % ModifyImage() ensures that there is only a single reference to the image
2001 % to be modified, updating the provided image pointer to point to a clone of
2002 % the original image if necessary.
2003 %
2004 % The format of the ModifyImage method is:
2005 %
2006 % MagickBooleanType ModifyImage(Image *image,ExceptionInfo *exception)
2007 %
2008 % A description of each parameter follows:
2009 %
2010 % o image: the image.
2011 %
2012 % o exception: return any errors or warnings in this structure.
2013 %
2014 */
2015 MagickExport MagickBooleanType ModifyImage(Image **image,
2016  ExceptionInfo *exception)
2017 {
2018  Image
2019  *clone_image;
2020 
2021  assert(image != (Image **) NULL);
2022  assert(*image != (Image *) NULL);
2023  assert((*image)->signature == MagickCoreSignature);
2024  if (IsEventLogging() != MagickFalse)
2025  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
2026  if (GetImageReferenceCount(*image) <= 1)
2027  return(MagickTrue);
2028  clone_image=CloneImage(*image,0,0,MagickTrue,exception);
2029  LockSemaphoreInfo((*image)->semaphore);
2030  (*image)->reference_count--;
2031  UnlockSemaphoreInfo((*image)->semaphore);
2032  *image=clone_image;
2033  return(MagickTrue);
2034 }
2035 
2036 /*
2037 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2038 % %
2039 % %
2040 % %
2041 % N e w M a g i c k I m a g e %
2042 % %
2043 % %
2044 % %
2045 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2046 %
2047 % NewMagickImage() creates a blank image canvas of the specified size and
2048 % background color.
2049 %
2050 % The format of the NewMagickImage method is:
2051 %
2052 % Image *NewMagickImage(const ImageInfo *image_info,const size_t width,
2053 % const size_t height,const MagickPixelPacket *background)
2054 %
2055 % A description of each parameter follows:
2056 %
2057 % o image: the image.
2058 %
2059 % o width: the image width.
2060 %
2061 % o height: the image height.
2062 %
2063 % o background: the image color.
2064 %
2065 */
2066 MagickExport Image *NewMagickImage(const ImageInfo *image_info,
2067  const size_t width,const size_t height,const MagickPixelPacket *background)
2068 {
2069  CacheView
2070  *image_view;
2071 
2073  *exception;
2074 
2075  Image
2076  *image;
2077 
2078  ssize_t
2079  y;
2080 
2081  MagickBooleanType
2082  status;
2083 
2084  assert(image_info != (const ImageInfo *) NULL);
2085  assert(image_info->signature == MagickCoreSignature);
2086  assert(background != (const MagickPixelPacket *) NULL);
2087  if (IsEventLogging() != MagickFalse)
2088  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2089  image=AcquireImage(image_info);
2090  image->columns=width;
2091  image->rows=height;
2092  image->colorspace=background->colorspace;
2093  image->matte=background->matte;
2094  image->fuzz=background->fuzz;
2095  image->depth=background->depth;
2096  status=MagickTrue;
2097  exception=(&image->exception);
2098  image_view=AcquireAuthenticCacheView(image,exception);
2099 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2100  #pragma omp parallel for schedule(static) shared(status) \
2101  magick_number_threads(image,image,image->rows,1)
2102 #endif
2103  for (y=0; y < (ssize_t) image->rows; y++)
2104  {
2105  IndexPacket
2106  *magick_restrict indexes;
2107 
2108  PixelPacket
2109  *magick_restrict q;
2110 
2111  ssize_t
2112  x;
2113 
2114  if (status == MagickFalse)
2115  continue;
2116  q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2117  if (q == (PixelPacket *) NULL)
2118  {
2119  status=MagickFalse;
2120  continue;
2121  }
2122  indexes=GetCacheViewAuthenticIndexQueue(image_view);
2123  for (x=0; x < (ssize_t) image->columns; x++)
2124  {
2125  SetPixelPacket(image,background,q,indexes+x);
2126  q++;
2127  }
2128  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2129  status=MagickFalse;
2130  }
2131  image_view=DestroyCacheView(image_view);
2132  if (status == MagickFalse)
2133  image=DestroyImage(image);
2134  return(image);
2135 }
2136 
2137 /*
2138 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2139 % %
2140 % %
2141 % %
2142 % R e f e r e n c e I m a g e %
2143 % %
2144 % %
2145 % %
2146 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2147 %
2148 % ReferenceImage() increments the reference count associated with an image
2149 % returning a pointer to the image.
2150 %
2151 % The format of the ReferenceImage method is:
2152 %
2153 % Image *ReferenceImage(Image *image)
2154 %
2155 % A description of each parameter follows:
2156 %
2157 % o image: the image.
2158 %
2159 */
2160 MagickExport Image *ReferenceImage(Image *image)
2161 {
2162  assert(image != (Image *) NULL);
2163  assert(image->signature == MagickCoreSignature);
2164  if (IsEventLogging() != MagickFalse)
2165  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2166  LockSemaphoreInfo(image->semaphore);
2167  image->reference_count++;
2168  UnlockSemaphoreInfo(image->semaphore);
2169  return(image);
2170 }
2171 
2172 /*
2173 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2174 % %
2175 % %
2176 % %
2177 % R e s e t I m a g e P a g e %
2178 % %
2179 % %
2180 % %
2181 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2182 %
2183 % ResetImagePage() resets the image page canvas and position.
2184 %
2185 % The format of the ResetImagePage method is:
2186 %
2187 % MagickBooleanType ResetImagePage(Image *image,const char *page)
2188 %
2189 % A description of each parameter follows:
2190 %
2191 % o image: the image.
2192 %
2193 % o page: the relative page specification.
2194 %
2195 */
2196 MagickExport MagickBooleanType ResetImagePage(Image *image,const char *page)
2197 {
2198  MagickStatusType
2199  flags;
2200 
2202  geometry;
2203 
2204  assert(image != (Image *) NULL);
2205  assert(image->signature == MagickCoreSignature);
2206  if (IsEventLogging() != MagickFalse)
2207  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2208  flags=ParseAbsoluteGeometry(page,&geometry);
2209  if ((flags & WidthValue) != 0)
2210  {
2211  if ((flags & HeightValue) == 0)
2212  geometry.height=geometry.width;
2213  image->page.width=geometry.width;
2214  image->page.height=geometry.height;
2215  }
2216  if ((flags & AspectValue) != 0)
2217  {
2218  if ((flags & XValue) != 0)
2219  image->page.x+=geometry.x;
2220  if ((flags & YValue) != 0)
2221  image->page.y+=geometry.y;
2222  }
2223  else
2224  {
2225  if ((flags & XValue) != 0)
2226  {
2227  image->page.x=geometry.x;
2228  if ((image->page.width == 0) && (geometry.x > 0))
2229  image->page.width=image->columns+geometry.x;
2230  }
2231  if ((flags & YValue) != 0)
2232  {
2233  image->page.y=geometry.y;
2234  if ((image->page.height == 0) && (geometry.y > 0))
2235  image->page.height=image->rows+geometry.y;
2236  }
2237  }
2238  return(MagickTrue);
2239 }
2240 
2241 /*
2242 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2243 % %
2244 % %
2245 % %
2246 % R e s e t I m a g e P i x e l s %
2247 % %
2248 % %
2249 % %
2250 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2251 %
2252 % ResetImagePixels() reset the image pixels, that is, all the pixel components
2253 % are zeroed.
2254 %
2255 % The format of the SetImage method is:
2256 %
2257 % MagickBooleanType ResetImagePixels(Image *image,
2258 % ExceptionInfo *exception)
2259 %
2260 % A description of each parameter follows:
2261 %
2262 % o image: the image.
2263 %
2264 % o exception: return any errors or warnings in this structure.
2265 %
2266 */
2267 MagickExport MagickBooleanType ResetImagePixels(Image *image,
2268  ExceptionInfo *exception)
2269 {
2270  CacheView
2271  *image_view;
2272 
2273  const void
2274  *pixels;
2275 
2276  MagickBooleanType
2277  status;
2278 
2279  MagickSizeType
2280  length;
2281 
2282  ssize_t
2283  y;
2284 
2285  assert(image != (Image *) NULL);
2286  assert(image->signature == MagickCoreSignature);
2287  if (IsEventLogging() != MagickFalse)
2288  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2289  pixels=AcquirePixelCachePixels(image,&length,exception);
2290  if (pixels != (void *) NULL)
2291  {
2292  /*
2293  Reset in-core image pixels.
2294  */
2295  (void) memset((void *) pixels,0,(size_t) length);
2296  return(MagickTrue);
2297  }
2298  /*
2299  Reset image pixels.
2300  */
2301  status=MagickTrue;
2302  image_view=AcquireAuthenticCacheView(image,exception);
2303 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2304  #pragma omp parallel for schedule(static) shared(status) \
2305  magick_number_threads(image,image,image->rows,1)
2306 #endif
2307  for (y=0; y < (ssize_t) image->rows; y++)
2308  {
2309  IndexPacket
2310  *magick_restrict indexes;
2311 
2312  PixelPacket
2313  *magick_restrict q;
2314 
2315  ssize_t
2316  x;
2317 
2318  if (status == MagickFalse)
2319  continue;
2320  q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2321  if (q == (PixelPacket *) NULL)
2322  {
2323  status=MagickFalse;
2324  continue;
2325  }
2326  indexes=GetCacheViewAuthenticIndexQueue(image_view);
2327  for (x=0; x < (ssize_t) image->columns; x++)
2328  {
2329  (void) memset(q,0,sizeof(PixelPacket));
2330  if ((image->storage_class == PseudoClass) ||
2331  (image->colorspace == CMYKColorspace))
2332  indexes[x]=0;
2333  q++;
2334  }
2335  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2336  status=MagickFalse;
2337  }
2338  image_view=DestroyCacheView(image_view);
2339  return(status);
2340 }
2341 
2342 /*
2343 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2344 % %
2345 % %
2346 % %
2347 % S e t I m a g e B a c k g r o u n d C o l o r %
2348 % %
2349 % %
2350 % %
2351 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2352 %
2353 % SetImageBackgroundColor() initializes the image pixels to the image
2354 % background color. The background color is defined by the background_color
2355 % member of the image structure.
2356 %
2357 % The format of the SetImage method is:
2358 %
2359 % MagickBooleanType SetImageBackgroundColor(Image *image)
2360 %
2361 % A description of each parameter follows:
2362 %
2363 % o image: the image.
2364 %
2365 */
2366 MagickExport MagickBooleanType SetImageBackgroundColor(Image *image)
2367 {
2368  CacheView
2369  *image_view;
2370 
2372  *exception;
2373 
2374  IndexPacket
2375  index;
2376 
2377  MagickBooleanType
2378  status;
2379 
2381  background;
2382 
2383  PixelPacket
2384  pixel;
2385 
2386  ssize_t
2387  y;
2388 
2389  assert(image != (Image *) NULL);
2390  assert(image->signature == MagickCoreSignature);
2391  if (IsEventLogging() != MagickFalse)
2392  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2393  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
2394  return(MagickFalse);
2395  if ((IsPixelGray(&image->background_color) == MagickFalse) &&
2396  (IsGrayColorspace(image->colorspace) != MagickFalse))
2397  (void) TransformImageColorspace(image,RGBColorspace);
2398  if ((image->background_color.opacity != OpaqueOpacity) &&
2399  (image->matte == MagickFalse))
2400  (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
2401  GetMagickPixelPacket(image,&background);
2402  SetMagickPixelPacket(image,&image->background_color,(const IndexPacket *)
2403  NULL,&background);
2404  if (image->colorspace == CMYKColorspace)
2405  ConvertRGBToCMYK(&background);
2406  index=0;
2407  pixel.opacity=OpaqueOpacity;
2408  SetPixelPacket(image,&background,&pixel,&index);
2409  /*
2410  Set image background color.
2411  */
2412  status=MagickTrue;
2413  exception=(&image->exception);
2414  image_view=AcquireAuthenticCacheView(image,exception);
2415  for (y=0; y < (ssize_t) image->rows; y++)
2416  {
2417  PixelPacket
2418  *magick_restrict q;
2419 
2420  ssize_t
2421  x;
2422 
2423  if (status == MagickFalse)
2424  continue;
2425  q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2426  if (q == (PixelPacket *) NULL)
2427  {
2428  status=MagickFalse;
2429  continue;
2430  }
2431  for (x=0; x < (ssize_t) image->columns; x++)
2432  *q++=pixel;
2433  if (image->colorspace == CMYKColorspace)
2434  {
2435  IndexPacket
2436  *magick_restrict indexes;
2437 
2438  indexes=GetCacheViewAuthenticIndexQueue(image_view);
2439  for (x=0; x < (ssize_t) image->columns; x++)
2440  SetPixelIndex(indexes+x,index);
2441  }
2442  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2443  status=MagickFalse;
2444  }
2445  image_view=DestroyCacheView(image_view);
2446  return(status);
2447 }
2448 
2449 /*
2450 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2451 % %
2452 % %
2453 % %
2454 % S e t I m a g e C h a n n e l s %
2455 % %
2456 % %
2457 % %
2458 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2459 %
2460 % SetImageChannels() sets the number of pixels channels associated with the
2461 % image.
2462 %
2463 % The format of the SetImageChannels method is:
2464 %
2465 % MagickBooleanType SetImageChannels(Image *image,const size_t channels)
2466 %
2467 % A description of each parameter follows:
2468 %
2469 % o image: the image.
2470 %
2471 % o channels: The number of pixel channels.
2472 %
2473 */
2474 MagickExport MagickBooleanType SetImageChannels(Image *image,
2475  const size_t channels)
2476 {
2477  image->channels=channels;
2478  return(MagickTrue);
2479 }
2480 
2481 /*
2482 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2483 % %
2484 % %
2485 % %
2486 % S e t I m a g e C o l o r %
2487 % %
2488 % %
2489 % %
2490 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2491 %
2492 % SetImageColor() set the entire image canvas to the specified color.
2493 %
2494 % The format of the SetImageColor method is:
2495 %
2496 % MagickBooleanType SetImageColor(Image *image,
2497 % const MagickPixelPacket *color)
2498 %
2499 % A description of each parameter follows:
2500 %
2501 % o image: the image.
2502 %
2503 % o background: the image color.
2504 %
2505 */
2506 MagickExport MagickBooleanType SetImageColor(Image *image,
2507  const MagickPixelPacket *color)
2508 {
2509  CacheView
2510  *image_view;
2511 
2513  *exception;
2514 
2515  MagickBooleanType
2516  status;
2517 
2518  ssize_t
2519  y;
2520 
2521  assert(image != (Image *) NULL);
2522  assert(image->signature == MagickCoreSignature);
2523  assert(color != (const MagickPixelPacket *) NULL);
2524  if (IsEventLogging() != MagickFalse)
2525  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2526  image->colorspace=color->colorspace;
2527  image->matte=color->matte;
2528  image->fuzz=color->fuzz;
2529  image->depth=color->depth;
2530  status=MagickTrue;
2531  exception=(&image->exception);
2532  image_view=AcquireAuthenticCacheView(image,exception);
2533 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2534  #pragma omp parallel for schedule(static) shared(status) \
2535  magick_number_threads(image,image,image->rows,1)
2536 #endif
2537  for (y=0; y < (ssize_t) image->rows; y++)
2538  {
2539  IndexPacket
2540  *magick_restrict indexes;
2541 
2542  PixelPacket
2543  *magick_restrict q;
2544 
2545  ssize_t
2546  x;
2547 
2548  if (status == MagickFalse)
2549  continue;
2550  q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2551  if (q == (PixelPacket *) NULL)
2552  {
2553  status=MagickFalse;
2554  continue;
2555  }
2556  indexes=GetCacheViewAuthenticIndexQueue(image_view);
2557  for (x=0; x < (ssize_t) image->columns; x++)
2558  {
2559  SetPixelPacket(image,color,q,
2560  indexes == (IndexPacket *) NULL ? NULL : indexes+x);
2561  q++;
2562  }
2563  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2564  status=MagickFalse;
2565  }
2566  image_view=DestroyCacheView(image_view);
2567  return(status);
2568 }
2569 
2570 /*
2571 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2572 % %
2573 % %
2574 % %
2575 % S e t I m a g e S t o r a g e C l a s s %
2576 % %
2577 % %
2578 % %
2579 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2580 %
2581 % SetImageStorageClass() sets the image class: DirectClass for true color
2582 % images or PseudoClass for colormapped images.
2583 %
2584 % The format of the SetImageStorageClass method is:
2585 %
2586 % MagickBooleanType SetImageStorageClass(Image *image,
2587 % const ClassType storage_class)
2588 %
2589 % A description of each parameter follows:
2590 %
2591 % o image: the image.
2592 %
2593 % o storage_class: The image class.
2594 %
2595 */
2596 MagickExport MagickBooleanType SetImageStorageClass(Image *image,
2597  const ClassType storage_class)
2598 {
2599  assert(image != (Image *) NULL);
2600  assert(image->signature == MagickCoreSignature);
2601  if (IsEventLogging() != MagickFalse)
2602  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2603  image->storage_class=storage_class;
2604  return(SyncImagePixelCache(image,&image->exception));
2605 }
2606 
2607 /*
2608 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2609 % %
2610 % %
2611 % %
2612 % S e t I m a g e C l i p M a s k %
2613 % %
2614 % %
2615 % %
2616 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2617 %
2618 % SetImageClipMask() associates a clip path with the image. The clip path
2619 % must be the same dimensions as the image. Set any pixel component of
2620 % the clip path to TransparentOpacity to prevent that corresponding image
2621 % pixel component from being updated when SyncAuthenticPixels() is applied.
2622 %
2623 % The format of the SetImageClipMask method is:
2624 %
2625 % MagickBooleanType SetImageClipMask(Image *image,const Image *clip_mask)
2626 %
2627 % A description of each parameter follows:
2628 %
2629 % o image: the image.
2630 %
2631 % o clip_mask: the image clip path.
2632 %
2633 */
2634 MagickExport MagickBooleanType SetImageClipMask(Image *image,
2635  const Image *clip_mask)
2636 {
2637  assert(image != (Image *) NULL);
2638  assert(image->signature == MagickCoreSignature);
2639  if (IsEventLogging() != MagickFalse)
2640  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2641  if (clip_mask != (const Image *) NULL)
2642  if ((clip_mask->columns != image->columns) ||
2643  (clip_mask->rows != image->rows))
2644  ThrowBinaryImageException(ImageError,"ImageSizeDiffers",image->filename);
2645  if (image->clip_mask != (Image *) NULL)
2646  image->clip_mask=DestroyImage(image->clip_mask);
2647  image->clip_mask=NewImageList();
2648  if (clip_mask == (Image *) NULL)
2649  return(MagickTrue);
2650  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
2651  return(MagickFalse);
2652  image->clip_mask=CloneImage(clip_mask,0,0,MagickTrue,&image->exception);
2653  if (image->clip_mask == (Image *) NULL)
2654  return(MagickFalse);
2655  return(MagickTrue);
2656 }
2657 
2658 /*
2659 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2660 % %
2661 % %
2662 % %
2663 % S e t I m a g e E x t e n t %
2664 % %
2665 % %
2666 % %
2667 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2668 %
2669 % SetImageExtent() sets the image size (i.e. columns & rows).
2670 %
2671 % The format of the SetImageExtent method is:
2672 %
2673 % MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2674 % const size_t rows)
2675 %
2676 % A description of each parameter follows:
2677 %
2678 % o image: the image.
2679 %
2680 % o columns: The image width in pixels.
2681 %
2682 % o rows: The image height in pixels.
2683 %
2684 */
2685 MagickExport MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2686  const size_t rows)
2687 {
2688  if ((columns == 0) || (rows == 0))
2689  ThrowBinaryImageException(ImageError,"NegativeOrZeroImageSize",
2690  image->filename);
2691  image->columns=columns;
2692  image->rows=rows;
2693  if (image->depth == 0)
2694  {
2695  image->depth=8;
2696  (void) ThrowMagickException(&image->exception,GetMagickModule(),
2697  ImageError,"ImageDepthNotSupported","`%s'",image->filename);
2698  }
2699  if (image->depth > (8*sizeof(MagickSizeType)))
2700  {
2701  image->depth=8*sizeof(MagickSizeType);
2702  (void) ThrowMagickException(&image->exception,GetMagickModule(),
2703  ImageError,"ImageDepthNotSupported","`%s'",image->filename);
2704  }
2705  return(SyncImagePixelCache(image,&image->exception));
2706 }
2707 
2708 /*
2709 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2710 % %
2711 % %
2712 % %
2713 + S e t I m a g e I n f o %
2714 % %
2715 % %
2716 % %
2717 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2718 %
2719 % SetImageInfo() initializes the `magick' field of the ImageInfo structure.
2720 % It is set to a type of image format based on the prefix or suffix of the
2721 % filename. For example, `ps:image' returns PS indicating a Postscript image.
2722 % JPEG is returned for this filename: `image.jpg'. The filename prefix has
2723 % precendence over the suffix. Use an optional index enclosed in brackets
2724 % after a file name to specify a desired scene of a multi-resolution image
2725 % format like Photo CD (e.g. img0001.pcd[4]). A True (non-zero) return value
2726 % indicates success.
2727 %
2728 % The format of the SetImageInfo method is:
2729 %
2730 % MagickBooleanType SetImageInfo(ImageInfo *image_info,
2731 % const unsigned int frames,ExceptionInfo *exception)
2732 %
2733 % A description of each parameter follows:
2734 %
2735 % o image_info: the image info.
2736 %
2737 % o frames: the number of images you intend to write.
2738 %
2739 % o exception: return any errors or warnings in this structure.
2740 %
2741 */
2742 MagickExport MagickBooleanType SetImageInfo(ImageInfo *image_info,
2743  const unsigned int frames,ExceptionInfo *exception)
2744 {
2745  char
2746  extension[MaxTextExtent],
2747  filename[MaxTextExtent],
2748  magic[MaxTextExtent],
2749  *q,
2750  subimage[MaxTextExtent];
2751 
2752  const MagicInfo
2753  *magic_info;
2754 
2755  const MagickInfo
2756  *magick_info;
2757 
2759  *sans_exception;
2760 
2761  Image
2762  *image;
2763 
2764  MagickBooleanType
2765  status;
2766 
2767  const char
2768  *p;
2769 
2770  ssize_t
2771  count;
2772 
2773  unsigned char
2774  magick[2*MaxTextExtent];
2775 
2776  /*
2777  Look for 'image.format' in filename.
2778  */
2779  assert(image_info != (ImageInfo *) NULL);
2780  assert(image_info->signature == MagickCoreSignature);
2781  if (IsEventLogging() != MagickFalse)
2782  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2783  image_info->filename);
2784  *subimage='\0';
2785  GetPathComponent(image_info->filename,SubimagePath,subimage);
2786  if (*subimage != '\0')
2787  {
2788  /*
2789  Look for scene specification (e.g. img0001.pcd[4]).
2790  */
2791  if (IsSceneGeometry(subimage,MagickFalse) == MagickFalse)
2792  {
2793  if (IsGeometry(subimage) != MagickFalse)
2794  (void) CloneString(&image_info->extract,subimage);
2795  }
2796  else
2797  {
2798  size_t
2799  first,
2800  last;
2801 
2802  (void) CloneString(&image_info->scenes,subimage);
2803  image_info->scene=StringToUnsignedLong(image_info->scenes);
2804  image_info->number_scenes=image_info->scene;
2805  p=image_info->scenes;
2806  for (q=(char *) image_info->scenes; *q != '\0'; p++)
2807  {
2808  while ((isspace((int) ((unsigned char) *p)) != 0) || (*p == ','))
2809  p++;
2810  first=(size_t) strtol(p,&q,10);
2811  last=first;
2812  while (isspace((int) ((unsigned char) *q)) != 0)
2813  q++;
2814  if (*q == '-')
2815  last=(size_t) strtol(q+1,&q,10);
2816  if (first > last)
2817  Swap(first,last);
2818  if (first < image_info->scene)
2819  image_info->scene=first;
2820  if (last > image_info->number_scenes)
2821  image_info->number_scenes=last;
2822  p=q;
2823  }
2824  image_info->number_scenes-=image_info->scene-1;
2825  image_info->subimage=image_info->scene;
2826  image_info->subrange=image_info->number_scenes;
2827  }
2828  }
2829  *extension='\0';
2830  if (*image_info->magick == '\0')
2831  GetPathComponent(image_info->filename,ExtensionPath,extension);
2832  if (*extension != '\0')
2833  {
2834  char
2835  path[MaxTextExtent];
2836 
2837  /*
2838  Base path sans any compression extension.
2839  */
2840  GetPathComponent(image_info->filename,BasePathSansCompressExtension,path);
2841  GetPathComponent(path,ExtensionPath,extension);
2842  }
2843  image_info->affirm=MagickFalse;
2844  sans_exception=AcquireExceptionInfo();
2845  if ((*extension != '\0') && (IsGlob(extension) == MagickFalse))
2846  {
2847  MagickFormatType
2848  format_type;
2849 
2850  ssize_t
2851  i;
2852 
2853  static const char
2854  *format_type_formats[] =
2855  {
2856  "AUTOTRACE",
2857  "BROWSE",
2858  "DCRAW",
2859  "EDIT",
2860  "LAUNCH",
2861  "MPEG:DECODE",
2862  "MPEG:ENCODE",
2863  "PRINT",
2864  "PS:ALPHA",
2865  "PS:CMYK",
2866  "PS:COLOR",
2867  "PS:GRAY",
2868  "PS:MONO",
2869  "SCAN",
2870  "SHOW",
2871  "WIN",
2872  (char *) NULL
2873  };
2874 
2875  /*
2876  User specified image format.
2877  */
2878  (void) CopyMagickString(magic,extension,MaxTextExtent);
2879  LocaleUpper(magic);
2880  /*
2881  Look for explicit image formats.
2882  */
2883  format_type=UndefinedFormatType;
2884  i=0;
2885  while ((format_type == UndefinedFormatType) &&
2886  (format_type_formats[i] != (char *) NULL))
2887  {
2888  if ((*magic == *format_type_formats[i]) &&
2889  (LocaleCompare(magic,format_type_formats[i]) == 0))
2890  format_type=ExplicitFormatType;
2891  i++;
2892  }
2893  magick_info=GetMagickInfo(magic,sans_exception);
2894  if ((magick_info != (const MagickInfo *) NULL) &&
2895  (magick_info->format_type != UndefinedFormatType))
2896  format_type=magick_info->format_type;
2897  if (format_type == UndefinedFormatType)
2898  (void) CopyMagickString(image_info->magick,magic,MaxTextExtent);
2899  else
2900  if (format_type == ExplicitFormatType)
2901  {
2902  image_info->affirm=MagickTrue;
2903  (void) CopyMagickString(image_info->magick,magic,MaxTextExtent);
2904  }
2905  if (LocaleCompare(magic,"RGB") == 0)
2906  image_info->affirm=MagickFalse; /* maybe SGI disguised as RGB */
2907  }
2908  /*
2909  Look for explicit 'format:image' in filename.
2910  */
2911  *magic='\0';
2912  GetPathComponent(image_info->filename,MagickPath,magic);
2913  if (*magic == '\0')
2914  {
2915  (void) CopyMagickString(magic,image_info->magick,MaxTextExtent);
2916  magick_info=GetMagickInfo(magic,sans_exception);
2917  if (frames == 0)
2918  GetPathComponent(image_info->filename,CanonicalPath,filename);
2919  else
2920  GetPathComponent(image_info->filename,SubcanonicalPath,filename);
2921  (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
2922  }
2923  else
2924  {
2925  const DelegateInfo
2926  *delegate_info;
2927 
2928  /*
2929  User specified image format.
2930  */
2931  LocaleUpper(magic);
2932  magick_info=GetMagickInfo(magic,sans_exception);
2933  delegate_info=GetDelegateInfo(magic,"*",sans_exception);
2934  if (delegate_info == (const DelegateInfo *) NULL)
2935  delegate_info=GetDelegateInfo("*",magic,sans_exception);
2936  if (((magick_info != (const MagickInfo *) NULL) ||
2937  (delegate_info != (const DelegateInfo *) NULL)) &&
2938  (IsMagickConflict(magic) == MagickFalse))
2939  {
2940  image_info->affirm=MagickTrue;
2941  (void) CopyMagickString(image_info->magick,magic,MaxTextExtent);
2942  GetPathComponent(image_info->filename,CanonicalPath,filename);
2943  (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
2944  }
2945  }
2946  sans_exception=DestroyExceptionInfo(sans_exception);
2947  if ((magick_info == (const MagickInfo *) NULL) ||
2948  (GetMagickEndianSupport(magick_info) == MagickFalse))
2949  image_info->endian=UndefinedEndian;
2950  if ((image_info->adjoin != MagickFalse) && (frames > 1))
2951  {
2952  /*
2953  Test for multiple image support (e.g. image%02d.png).
2954  */
2955  (void) InterpretImageFilename(image_info,(Image *) NULL,
2956  image_info->filename,(int) image_info->scene,filename);
2957  if ((LocaleCompare(filename,image_info->filename) != 0) &&
2958  (strchr(filename,'%') == (char *) NULL))
2959  image_info->adjoin=MagickFalse;
2960  }
2961  if ((image_info->adjoin != MagickFalse) && (frames > 0))
2962  {
2963  /*
2964  Some image formats do not support multiple frames per file.
2965  */
2966  magick_info=GetMagickInfo(magic,exception);
2967  if (magick_info != (const MagickInfo *) NULL)
2968  if (GetMagickAdjoin(magick_info) == MagickFalse)
2969  image_info->adjoin=MagickFalse;
2970  }
2971  if (image_info->affirm != MagickFalse)
2972  return(MagickTrue);
2973  if (frames == 0)
2974  {
2975  /*
2976  Determine the image format from the first few bytes of the file.
2977  */
2978  image=AcquireImage(image_info);
2979  (void) CopyMagickString(image->filename,image_info->filename,
2980  MaxTextExtent);
2981  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
2982  if (status == MagickFalse)
2983  {
2984  image=DestroyImage(image);
2985  return(MagickFalse);
2986  }
2987  if ((IsBlobSeekable(image) == MagickFalse) ||
2988  (IsBlobExempt(image) != MagickFalse))
2989  {
2990  /*
2991  Copy image to a seekable temporary file.
2992  */
2993  *filename='\0';
2994  status=ImageToFile(image,filename,exception);
2995  (void) CloseBlob(image);
2996  if (status == MagickFalse)
2997  {
2998  (void) RelinquishUniqueFileResource(filename);
2999  image=DestroyImage(image);
3000  return(MagickFalse);
3001  }
3002  SetImageInfoFile(image_info,(FILE *) NULL);
3003  (void) CopyMagickString(image->filename,filename,MaxTextExtent);
3004  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
3005  if (status == MagickFalse)
3006  {
3007  (void) RelinquishUniqueFileResource(filename);
3008  image=DestroyImage(image);
3009  return(MagickFalse);
3010  }
3011  (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
3012  image_info->temporary=MagickTrue;
3013  }
3014  (void) memset(magick,0,sizeof(magick));
3015  count=ReadBlob(image,2*MaxTextExtent,magick);
3016  (void) SeekBlob(image,-((MagickOffsetType) count),SEEK_CUR);
3017  (void) CloseBlob(image);
3018  image=DestroyImage(image);
3019  /*
3020  Check magic.xml configuration file.
3021  */
3022  sans_exception=AcquireExceptionInfo();
3023  magic_info=GetMagicInfo(magick,(size_t) count,sans_exception);
3024  if ((magic_info != (const MagicInfo *) NULL) &&
3025  (GetMagicName(magic_info) != (char *) NULL))
3026  {
3027  (void) CopyMagickString(image_info->magick,GetMagicName(magic_info),
3028  MaxTextExtent);
3029  magick_info=GetMagickInfo(image_info->magick,sans_exception);
3030  if ((magick_info == (const MagickInfo *) NULL) ||
3031  (GetMagickEndianSupport(magick_info) == MagickFalse))
3032  image_info->endian=UndefinedEndian;
3033  sans_exception=DestroyExceptionInfo(sans_exception);
3034  return(MagickTrue);
3035  }
3036  magick_info=GetMagickInfo(image_info->magick,sans_exception);
3037  if ((magick_info == (const MagickInfo *) NULL) ||
3038  (GetMagickEndianSupport(magick_info) == MagickFalse))
3039  image_info->endian=UndefinedEndian;
3040  sans_exception=DestroyExceptionInfo(sans_exception);
3041  }
3042  return(MagickTrue);
3043 }
3044 
3045 /*
3046 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3047 % %
3048 % %
3049 % %
3050 % S e t I m a g e I n f o B l o b %
3051 % %
3052 % %
3053 % %
3054 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3055 %
3056 % SetImageInfoBlob() sets the image info blob member.
3057 %
3058 % The format of the SetImageInfoBlob method is:
3059 %
3060 % void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3061 % const size_t length)
3062 %
3063 % A description of each parameter follows:
3064 %
3065 % o image_info: the image info.
3066 %
3067 % o blob: the blob.
3068 %
3069 % o length: the blob length.
3070 %
3071 */
3072 MagickExport void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3073  const size_t length)
3074 {
3075  assert(image_info != (ImageInfo *) NULL);
3076  assert(image_info->signature == MagickCoreSignature);
3077  if (IsEventLogging() != MagickFalse)
3078  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3079  image_info->filename);
3080  image_info->blob=(void *) blob;
3081  image_info->length=length;
3082 }
3083 
3084 /*
3085 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3086 % %
3087 % %
3088 % %
3089 % S e t I m a g e I n f o F i l e %
3090 % %
3091 % %
3092 % %
3093 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3094 %
3095 % SetImageInfoFile() sets the image info file member.
3096 %
3097 % The format of the SetImageInfoFile method is:
3098 %
3099 % void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3100 %
3101 % A description of each parameter follows:
3102 %
3103 % o image_info: the image info.
3104 %
3105 % o file: the file.
3106 %
3107 */
3108 MagickExport void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3109 {
3110  assert(image_info != (ImageInfo *) NULL);
3111  assert(image_info->signature == MagickCoreSignature);
3112  if (IsEventLogging() != MagickFalse)
3113  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3114  image_info->filename);
3115  image_info->file=file;
3116 }
3117 
3118 /*
3119 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3120 % %
3121 % %
3122 % %
3123 % S e t I m a g e M a s k %
3124 % %
3125 % %
3126 % %
3127 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3128 %
3129 % SetImageMask() associates a mask with the image. The mask must be the same
3130 % dimensions as the image.
3131 %
3132 % The format of the SetImageMask method is:
3133 %
3134 % MagickBooleanType SetImageMask(Image *image,const Image *mask)
3135 %
3136 % A description of each parameter follows:
3137 %
3138 % o image: the image.
3139 %
3140 % o mask: the image mask.
3141 %
3142 */
3143 MagickExport MagickBooleanType SetImageMask(Image *image,const Image *mask)
3144 {
3145  assert(image != (Image *) NULL);
3146  assert(image->signature == MagickCoreSignature);
3147  if (IsEventLogging() != MagickFalse)
3148  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3149  if (mask != (const Image *) NULL)
3150  if ((mask->columns != image->columns) || (mask->rows != image->rows))
3151  ThrowBinaryImageException(ImageError,"ImageSizeDiffers",image->filename);
3152  if (image->mask != (Image *) NULL)
3153  image->mask=DestroyImage(image->mask);
3154  image->mask=NewImageList();
3155  if (mask == (Image *) NULL)
3156  return(MagickTrue);
3157  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
3158  return(MagickFalse);
3159  image->mask=CloneImage(mask,0,0,MagickTrue,&image->exception);
3160  if (image->mask == (Image *) NULL)
3161  return(MagickFalse);
3162  return(MagickTrue);
3163 }
3164 
3165 /*
3166 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3167 % %
3168 % %
3169 % %
3170 % S e t I m a g e O p a c i t y %
3171 % %
3172 % %
3173 % %
3174 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3175 %
3176 % SetImageOpacity() sets the opacity levels of the image.
3177 %
3178 % The format of the SetImageOpacity method is:
3179 %
3180 % MagickBooleanType SetImageOpacity(Image *image,const Quantum opacity)
3181 %
3182 % A description of each parameter follows:
3183 %
3184 % o image: the image.
3185 %
3186 % o opacity: the level of transparency: 0 is fully opaque and QuantumRange is
3187 % fully transparent.
3188 %
3189 */
3190 MagickExport MagickBooleanType SetImageOpacity(Image *image,
3191  const Quantum opacity)
3192 {
3193  CacheView
3194  *image_view;
3195 
3197  *exception;
3198 
3199  MagickBooleanType
3200  status;
3201 
3202  ssize_t
3203  y;
3204 
3205  assert(image != (Image *) NULL);
3206  assert(image->signature == MagickCoreSignature);
3207  if (IsEventLogging() != MagickFalse)
3208  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3209  image->matte=MagickTrue;
3210  status=MagickTrue;
3211  exception=(&image->exception);
3212  image_view=AcquireAuthenticCacheView(image,exception);
3213 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3214  #pragma omp parallel for schedule(static) shared(status) \
3215  magick_number_threads(image,image,image->rows,1)
3216 #endif
3217  for (y=0; y < (ssize_t) image->rows; y++)
3218  {
3219  PixelPacket
3220  *magick_restrict q;
3221 
3222  ssize_t
3223  x;
3224 
3225  if (status == MagickFalse)
3226  continue;
3227  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3228  if (q == (PixelPacket *) NULL)
3229  {
3230  status=MagickFalse;
3231  continue;
3232  }
3233  for (x=0; x < (ssize_t) image->columns; x++)
3234  {
3235  SetPixelOpacity(q,opacity);
3236  q++;
3237  }
3238  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3239  status=MagickFalse;
3240  }
3241  image_view=DestroyCacheView(image_view);
3242  return(status);
3243 }
3244 
3245 /*
3246 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3247 % %
3248 % %
3249 % %
3250 % S e t I m a g e V i r t u a l P i x e l M e t h o d %
3251 % %
3252 % %
3253 % %
3254 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3255 %
3256 % SetImageVirtualPixelMethod() sets the "virtual pixels" method for the
3257 % image and returns the previous setting. A virtual pixel is any pixel access
3258 % that is outside the boundaries of the image cache.
3259 %
3260 % The format of the SetImageVirtualPixelMethod() method is:
3261 %
3262 % VirtualPixelMethod SetImageVirtualPixelMethod(const Image *image,
3263 % const VirtualPixelMethod virtual_pixel_method)
3264 %
3265 % A description of each parameter follows:
3266 %
3267 % o image: the image.
3268 %
3269 % o virtual_pixel_method: choose the type of virtual pixel.
3270 %
3271 */
3272 MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(const Image *image,
3273  const VirtualPixelMethod virtual_pixel_method)
3274 {
3275  assert(image != (const Image *) NULL);
3276  assert(image->signature == MagickCoreSignature);
3277  if (IsEventLogging() != MagickFalse)
3278  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3279  return(SetPixelCacheVirtualMethod(image,virtual_pixel_method));
3280 }
3281 
3282 /*
3283 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3284 % %
3285 % %
3286 % %
3287 % S m u s h I m a g e s %
3288 % %
3289 % %
3290 % %
3291 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3292 %
3293 % SmushImages() takes all images from the current image pointer to the end
3294 % of the image list and smushes them to each other top-to-bottom if the
3295 % stack parameter is true, otherwise left-to-right.
3296 %
3297 % The current gravity setting now effects how the image is justified in the
3298 % final image.
3299 %
3300 % The format of the SmushImages method is:
3301 %
3302 % Image *SmushImages(const Image *images,const MagickBooleanType stack,
3303 % ExceptionInfo *exception)
3304 %
3305 % A description of each parameter follows:
3306 %
3307 % o images: the image sequence.
3308 %
3309 % o stack: A value other than 0 stacks the images top-to-bottom.
3310 %
3311 % o offset: minimum distance in pixels between images.
3312 %
3313 % o exception: return any errors or warnings in this structure.
3314 %
3315 */
3316 
3317 static ssize_t SmushXGap(const Image *smush_image,const Image *images,
3318  const ssize_t offset,ExceptionInfo *exception)
3319 {
3320  CacheView
3321  *left_view,
3322  *right_view;
3323 
3324  const Image
3325  *left_image,
3326  *right_image;
3327 
3329  left_geometry,
3330  right_geometry;
3331 
3332  const PixelPacket
3333  *p;
3334 
3335  ssize_t
3336  i,
3337  y;
3338 
3339  size_t
3340  gap;
3341 
3342  ssize_t
3343  x;
3344 
3345  if (images->previous == (Image *) NULL)
3346  return(0);
3347  right_image=images;
3348  SetGeometry(smush_image,&right_geometry);
3349  GravityAdjustGeometry(right_image->columns,right_image->rows,
3350  right_image->gravity,&right_geometry);
3351  left_image=images->previous;
3352  SetGeometry(smush_image,&left_geometry);
3353  GravityAdjustGeometry(left_image->columns,left_image->rows,
3354  left_image->gravity,&left_geometry);
3355  gap=right_image->columns;
3356  left_view=AcquireVirtualCacheView(left_image,exception);
3357  right_view=AcquireVirtualCacheView(right_image,exception);
3358  for (y=0; y < (ssize_t) smush_image->rows; y++)
3359  {
3360  for (x=(ssize_t) left_image->columns-1; x > 0; x--)
3361  {
3362  p=GetCacheViewVirtualPixels(left_view,x,left_geometry.y+y,1,1,exception);
3363  if ((p == (const PixelPacket *) NULL) ||
3364  (GetPixelOpacity(p) != TransparentOpacity) ||
3365  ((left_image->columns-x-1) >= gap))
3366  break;
3367  }
3368  i=(ssize_t) left_image->columns-x-1;
3369  for (x=0; x < (ssize_t) right_image->columns; x++)
3370  {
3371  p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1,
3372  exception);
3373  if ((p == (const PixelPacket *) NULL) ||
3374  (GetPixelOpacity(p) != TransparentOpacity) ||
3375  ((x+i) >= (ssize_t) gap))
3376  break;
3377  }
3378  if ((x+i) < (ssize_t) gap)
3379  gap=(size_t) (x+i);
3380  }
3381  right_view=DestroyCacheView(right_view);
3382  left_view=DestroyCacheView(left_view);
3383  if (y < (ssize_t) smush_image->rows)
3384  return(offset);
3385  return((ssize_t) gap-offset);
3386 }
3387 
3388 static ssize_t SmushYGap(const Image *smush_image,const Image *images,
3389  const ssize_t offset,ExceptionInfo *exception)
3390 {
3391  CacheView
3392  *bottom_view,
3393  *top_view;
3394 
3395  const Image
3396  *bottom_image,
3397  *top_image;
3398 
3400  bottom_geometry,
3401  top_geometry;
3402 
3403  const PixelPacket
3404  *p;
3405 
3406  ssize_t
3407  i,
3408  x;
3409 
3410  size_t
3411  gap;
3412 
3413  ssize_t
3414  y;
3415 
3416  if (images->previous == (Image *) NULL)
3417  return(0);
3418  bottom_image=images;
3419  SetGeometry(smush_image,&bottom_geometry);
3420  GravityAdjustGeometry(bottom_image->columns,bottom_image->rows,
3421  bottom_image->gravity,&bottom_geometry);
3422  top_image=images->previous;
3423  SetGeometry(smush_image,&top_geometry);
3424  GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
3425  &top_geometry);
3426  gap=bottom_image->rows;
3427  top_view=AcquireVirtualCacheView(top_image,exception);
3428  bottom_view=AcquireVirtualCacheView(bottom_image,exception);
3429  for (x=0; x < (ssize_t) smush_image->columns; x++)
3430  {
3431  for (y=(ssize_t) top_image->rows-1; y > 0; y--)
3432  {
3433  p=GetCacheViewVirtualPixels(top_view,top_geometry.x+x,y,1,1,exception);
3434  if ((p == (const PixelPacket *) NULL) ||
3435  (GetPixelOpacity(p) != TransparentOpacity) ||
3436  ((top_image->rows-y-1) >= gap))
3437  break;
3438  }
3439  i=(ssize_t) top_image->rows-y-1;
3440  for (y=0; y < (ssize_t) bottom_image->rows; y++)
3441  {
3442  p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1,
3443  exception);
3444  if ((p == (const PixelPacket *) NULL) ||
3445  (GetPixelOpacity(p) != TransparentOpacity) ||
3446  ((y+i) >= (ssize_t) gap))
3447  break;
3448  }
3449  if ((y+i) < (ssize_t) gap)
3450  gap=(size_t) (y+i);
3451  }
3452  bottom_view=DestroyCacheView(bottom_view);
3453  top_view=DestroyCacheView(top_view);
3454  if (x < (ssize_t) smush_image->columns)
3455  return(offset);
3456  return((ssize_t) gap-offset);
3457 }
3458 
3459 MagickExport Image *SmushImages(const Image *images,
3460  const MagickBooleanType stack,const ssize_t offset,ExceptionInfo *exception)
3461 {
3462 #define SmushImageTag "Smush/Image"
3463 
3464  CacheView
3465  *smush_view;
3466 
3467  const Image
3468  *image;
3469 
3470  Image
3471  *smush_image;
3472 
3473  MagickBooleanType
3474  matte,
3475  proceed,
3476  status;
3477 
3478  MagickOffsetType
3479  n;
3480 
3482  geometry;
3483 
3484  const Image
3485  *next;
3486 
3487  size_t
3488  height,
3489  number_images,
3490  width;
3491 
3492  ssize_t
3493  x_offset,
3494  y_offset;
3495 
3496  /*
3497  Compute maximum area of smushed area.
3498  */
3499  assert(images != (Image *) NULL);
3500  assert(images->signature == MagickCoreSignature);
3501  assert(exception != (ExceptionInfo *) NULL);
3502  assert(exception->signature == MagickCoreSignature);
3503  if (IsEventLogging() != MagickFalse)
3504  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3505  image=images;
3506  matte=image->matte;
3507  number_images=1;
3508  width=image->columns;
3509  height=image->rows;
3510  next=GetNextImageInList(image);
3511  for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
3512  {
3513  if (next->matte != MagickFalse)
3514  matte=MagickTrue;
3515  number_images++;
3516  if (stack != MagickFalse)
3517  {
3518  if (next->columns > width)
3519  width=next->columns;
3520  height+=next->rows;
3521  if (next->previous != (Image *) NULL)
3522  height+=offset;
3523  continue;
3524  }
3525  width+=next->columns;
3526  if (next->previous != (Image *) NULL)
3527  width+=offset;
3528  if (next->rows > height)
3529  height=next->rows;
3530  }
3531  /*
3532  Smush images.
3533  */
3534  smush_image=CloneImage(image,width,height,MagickTrue,exception);
3535  if (smush_image == (Image *) NULL)
3536  return((Image *) NULL);
3537  if (SetImageStorageClass(smush_image,DirectClass) == MagickFalse)
3538  {
3539  InheritException(exception,&smush_image->exception);
3540  smush_image=DestroyImage(smush_image);
3541  return((Image *) NULL);
3542  }
3543  smush_image->matte=matte;
3544  (void) SetImageBackgroundColor(smush_image);
3545  status=MagickTrue;
3546  x_offset=0;
3547  y_offset=0;
3548  smush_view=AcquireVirtualCacheView(smush_image,exception);
3549  for (n=0; n < (MagickOffsetType) number_images; n++)
3550  {
3551  SetGeometry(smush_image,&geometry);
3552  GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry);
3553  if (stack != MagickFalse)
3554  {
3555  x_offset-=geometry.x;
3556  y_offset-=SmushYGap(smush_image,image,offset,exception);
3557  }
3558  else
3559  {
3560  x_offset-=SmushXGap(smush_image,image,offset,exception);
3561  y_offset-=geometry.y;
3562  }
3563  status=CompositeImage(smush_image,OverCompositeOp,image,x_offset,y_offset);
3564  proceed=SetImageProgress(image,SmushImageTag,n,number_images);
3565  if (proceed == MagickFalse)
3566  break;
3567  if (stack == MagickFalse)
3568  {
3569  x_offset+=(ssize_t) image->columns;
3570  y_offset=0;
3571  }
3572  else
3573  {
3574  x_offset=0;
3575  y_offset+=(ssize_t) image->rows;
3576  }
3577  image=GetNextImageInList(image);
3578  }
3579  if (stack == MagickFalse)
3580  smush_image->columns=(size_t) x_offset;
3581  else
3582  smush_image->rows=(size_t) y_offset;
3583  smush_view=DestroyCacheView(smush_view);
3584  if (status == MagickFalse)
3585  smush_image=DestroyImage(smush_image);
3586  return(smush_image);
3587 }
3588 
3589 /*
3590 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3591 % %
3592 % %
3593 % %
3594 % S t r i p I m a g e %
3595 % %
3596 % %
3597 % %
3598 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3599 %
3600 % StripImage() strips an image of all profiles and comments.
3601 %
3602 % The format of the StripImage method is:
3603 %
3604 % MagickBooleanType StripImage(Image *image)
3605 %
3606 % A description of each parameter follows:
3607 %
3608 % o image: the image.
3609 %
3610 */
3611 MagickExport MagickBooleanType StripImage(Image *image)
3612 {
3613  MagickBooleanType
3614  status;
3615 
3616  assert(image != (Image *) NULL);
3617  if (IsEventLogging() != MagickFalse)
3618  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3619  DestroyImageProfiles(image);
3620  (void) DeleteImageProperty(image,"comment");
3621  (void) DeleteImageProperty(image,"date:create");
3622  (void) DeleteImageProperty(image,"date:modify");
3623  status=SetImageArtifact(image,"png:exclude-chunk",
3624  "bKGD,caNv,cHRM,eXIf,gAMA,iCCP,iTXt,pHYs,sRGB,tEXt,zCCP,zTXt,date");
3625  return(status);
3626 }
3627 
3628 /*
3629 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3630 % %
3631 % %
3632 % %
3633 + S y n c I m a g e %
3634 % %
3635 % %
3636 % %
3637 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3638 %
3639 % SyncImage() initializes the red, green, and blue intensities of each pixel
3640 % as defined by the colormap index.
3641 %
3642 % The format of the SyncImage method is:
3643 %
3644 % MagickBooleanType SyncImage(Image *image)
3645 %
3646 % A description of each parameter follows:
3647 %
3648 % o image: the image.
3649 %
3650 */
3651 
3652 static inline IndexPacket PushColormapIndex(Image *image,
3653  const size_t index,MagickBooleanType *range_exception)
3654 {
3655  if (index < image->colors)
3656  return((IndexPacket) index);
3657  *range_exception=MagickTrue;
3658  return((IndexPacket) 0);
3659 }
3660 
3661 MagickExport MagickBooleanType SyncImage(Image *image)
3662 {
3663  CacheView
3664  *image_view;
3665 
3667  *exception;
3668 
3669  MagickBooleanType
3670  range_exception,
3671  status,
3672  taint;
3673 
3674  ssize_t
3675  y;
3676 
3677  assert(image != (Image *) NULL);
3678  assert(image->signature == MagickCoreSignature);
3679  if (IsEventLogging() != MagickFalse)
3680  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3681  if (image->ping != MagickFalse)
3682  return(MagickTrue);
3683  if (image->storage_class != PseudoClass)
3684  return(MagickFalse);
3685  assert(image->colormap != (PixelPacket *) NULL);
3686  range_exception=MagickFalse;
3687  status=MagickTrue;
3688  taint=image->taint;
3689  exception=(&image->exception);
3690  image_view=AcquireAuthenticCacheView(image,exception);
3691 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3692  #pragma omp parallel for schedule(static) shared(range_exception,status) \
3693  magick_number_threads(image,image,image->rows,1)
3694 #endif
3695  for (y=0; y < (ssize_t) image->rows; y++)
3696  {
3697  IndexPacket
3698  index;
3699 
3700  IndexPacket
3701  *magick_restrict indexes;
3702 
3703  PixelPacket
3704  *magick_restrict q;
3705 
3706  ssize_t
3707  x;
3708 
3709  if (status == MagickFalse)
3710  continue;
3711  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3712  if (q == (PixelPacket *) NULL)
3713  {
3714  status=MagickFalse;
3715  continue;
3716  }
3717  indexes=GetCacheViewAuthenticIndexQueue(image_view);
3718  for (x=0; x < (ssize_t) image->columns; x++)
3719  {
3720  index=PushColormapIndex(image,(size_t) GetPixelIndex(indexes+x),
3721  &range_exception);
3722  if (image->matte == MagickFalse)
3723  SetPixelRgb(q,image->colormap+(ssize_t) index)
3724  else
3725  SetPixelRGBO(q,image->colormap+(ssize_t) index);
3726  q++;
3727  }
3728  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3729  status=MagickFalse;
3730  }
3731  image_view=DestroyCacheView(image_view);
3732  image->taint=taint;
3733  if ((image->ping == MagickFalse) && (range_exception != MagickFalse))
3734  (void) ThrowMagickException(&image->exception,GetMagickModule(),
3735  CorruptImageWarning,"InvalidColormapIndex","`%s'",image->filename);
3736  return(status);
3737 }
3738 
3739 /*
3740 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3741 % %
3742 % %
3743 % %
3744 % S y n c I m a g e S e t t i n g s %
3745 % %
3746 % %
3747 % %
3748 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3749 %
3750 % SyncImageSettings() syncs image_info options into per-image attributes.
3751 %
3752 % The format of the SyncImageSettings method is:
3753 %
3754 % MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
3755 % Image *image)
3756 % MagickBooleanType SyncImagesSettings(const ImageInfo *image_info,
3757 % Image *image)
3758 %
3759 % A description of each parameter follows:
3760 %
3761 % o image_info: the image info.
3762 %
3763 % o image: the image.
3764 %
3765 */
3766 
3767 MagickExport MagickBooleanType SyncImagesSettings(ImageInfo *image_info,
3768  Image *images)
3769 {
3770  Image
3771  *image;
3772 
3773  assert(image_info != (const ImageInfo *) NULL);
3774  assert(image_info->signature == MagickCoreSignature);
3775  assert(images != (Image *) NULL);
3776  assert(images->signature == MagickCoreSignature);
3777  if (IsEventLogging() != MagickFalse)
3778  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3779  image=images;
3780  for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
3781  (void) SyncImageSettings(image_info,image);
3782  (void) DeleteImageOption(image_info,"page");
3783  return(MagickTrue);
3784 }
3785 
3786 MagickExport MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
3787  Image *image)
3788 {
3789  char
3790  property[MaxTextExtent];
3791 
3792  const char
3793  *option,
3794  *value;
3795 
3796  GeometryInfo
3797  geometry_info;
3798 
3799  MagickStatusType
3800  flags;
3801 
3802  ResolutionType
3803  units;
3804 
3805  /*
3806  Sync image options.
3807  */
3808  assert(image_info != (const ImageInfo *) NULL);
3809  assert(image_info->signature == MagickCoreSignature);
3810  assert(image != (Image *) NULL);
3811  assert(image->signature == MagickCoreSignature);
3812  if (IsEventLogging() != MagickFalse)
3813  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3814  option=GetImageOption(image_info,"background");
3815  if (option != (const char *) NULL)
3816  (void) QueryColorDatabase(option,&image->background_color,
3817  &image->exception);
3818  option=GetImageOption(image_info,"bias");
3819  if (option != (const char *) NULL)
3820  image->bias=StringToDoubleInterval(option,(double) QuantumRange+1.0);
3821  option=GetImageOption(image_info,"black-point-compensation");
3822  if (option != (const char *) NULL)
3823  image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
3824  MagickBooleanOptions,MagickFalse,option);
3825  option=GetImageOption(image_info,"blue-primary");
3826  if (option != (const char *) NULL)
3827  {
3828  flags=ParseGeometry(option,&geometry_info);
3829  if ((flags & RhoValue) != 0)
3830  image->chromaticity.blue_primary.x=geometry_info.rho;
3831  image->chromaticity.blue_primary.y=image->chromaticity.blue_primary.x;
3832  if ((flags & SigmaValue) != 0)
3833  image->chromaticity.blue_primary.y=geometry_info.sigma;
3834  }
3835  option=GetImageOption(image_info,"bordercolor");
3836  if (option != (const char *) NULL)
3837  (void) QueryColorDatabase(option,&image->border_color,&image->exception);
3838  option=GetImageOption(image_info,"colors");
3839  if (option != (const char *) NULL)
3840  image->colors=StringToUnsignedLong(option);
3841  option=GetImageOption(image_info,"compose");
3842  if (option != (const char *) NULL)
3843  image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
3844  MagickFalse,option);
3845  option=GetImageOption(image_info,"compress");
3846  if (option != (const char *) NULL)
3847  image->compression=(CompressionType) ParseCommandOption(
3848  MagickCompressOptions,MagickFalse,option);
3849  option=GetImageOption(image_info,"debug");
3850  if (option != (const char *) NULL)
3851  image->debug=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
3852  MagickFalse,option);
3853  option=GetImageOption(image_info,"density");
3854  if (option != (const char *) NULL)
3855  {
3856  GeometryInfo
3857  geometry_info;
3858 
3859  /*
3860  Set image density.
3861  */
3862  flags=ParseGeometry(option,&geometry_info);
3863  if ((flags & RhoValue) != 0)
3864  image->x_resolution=geometry_info.rho;
3865  image->y_resolution=image->x_resolution;
3866  if ((flags & SigmaValue) != 0)
3867  image->y_resolution=geometry_info.sigma;
3868  }
3869  option=GetImageOption(image_info,"depth");
3870  if (option != (const char *) NULL)
3871  image->depth=StringToUnsignedLong(option);
3872  option=GetImageOption(image_info,"endian");
3873  if (option != (const char *) NULL)
3874  image->endian=(EndianType) ParseCommandOption(MagickEndianOptions,
3875  MagickFalse,option);
3876  option=GetImageOption(image_info,"filter");
3877  if (option != (const char *) NULL)
3878  image->filter=(FilterTypes) ParseCommandOption(MagickFilterOptions,
3879  MagickFalse,option);
3880  option=GetImageOption(image_info,"fuzz");
3881  if (option != (const char *) NULL)
3882  image->fuzz=StringToDoubleInterval(option,(double) QuantumRange+1.0);
3883  option=GetImageOption(image_info,"gravity");
3884  if (option != (const char *) NULL)
3885  image->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
3886  MagickFalse,option);
3887  option=GetImageOption(image_info,"green-primary");
3888  if (option != (const char *) NULL)
3889  {
3890  flags=ParseGeometry(option,&geometry_info);
3891  if ((flags & RhoValue) != 0)
3892  image->chromaticity.green_primary.x=geometry_info.rho;
3893  image->chromaticity.green_primary.y=image->chromaticity.green_primary.x;
3894  if ((flags & SigmaValue) != 0)
3895  image->chromaticity.green_primary.y=geometry_info.sigma;
3896  }
3897  option=GetImageOption(image_info,"intensity");
3898  if (option != (const char *) NULL)
3899  image->intensity=(PixelIntensityMethod) ParseCommandOption(
3900  MagickPixelIntensityOptions,MagickFalse,option);
3901  option=GetImageOption(image_info,"intent");
3902  if (option != (const char *) NULL)
3903  image->rendering_intent=(RenderingIntent) ParseCommandOption(
3904  MagickIntentOptions,MagickFalse,option);
3905  option=GetImageOption(image_info,"interlace");
3906  if (option != (const char *) NULL)
3907  image->interlace=(InterlaceType) ParseCommandOption(MagickInterlaceOptions,
3908  MagickFalse,option);
3909  option=GetImageOption(image_info,"interpolate");
3910  if (option != (const char *) NULL)
3911  image->interpolate=(InterpolatePixelMethod) ParseCommandOption(
3912  MagickInterpolateOptions,MagickFalse,option);
3913  option=GetImageOption(image_info,"loop");
3914  if (option != (const char *) NULL)
3915  image->iterations=StringToUnsignedLong(option);
3916  option=GetImageOption(image_info,"mattecolor");
3917  if (option != (const char *) NULL)
3918  (void) QueryColorDatabase(option,&image->matte_color,&image->exception);
3919  option=GetImageOption(image_info,"orient");
3920  if (option != (const char *) NULL)
3921  image->orientation=(OrientationType) ParseCommandOption(
3922  MagickOrientationOptions,MagickFalse,option);
3923  option=GetImageOption(image_info,"page");
3924  if (option != (const char *) NULL)
3925  {
3926  char
3927  *geometry;
3928 
3929  geometry=GetPageGeometry(option);
3930  flags=ParseAbsoluteGeometry(geometry,&image->page);
3931  geometry=DestroyString(geometry);
3932  }
3933  option=GetImageOption(image_info,"quality");
3934  if (option != (const char *) NULL)
3935  image->quality=StringToUnsignedLong(option);
3936  option=GetImageOption(image_info,"red-primary");
3937  if (option != (const char *) NULL)
3938  {
3939  flags=ParseGeometry(option,&geometry_info);
3940  if ((flags & RhoValue) != 0)
3941  image->chromaticity.red_primary.x=geometry_info.rho;
3942  image->chromaticity.red_primary.y=image->chromaticity.red_primary.x;
3943  if ((flags & SigmaValue) != 0)
3944  image->chromaticity.red_primary.y=geometry_info.sigma;
3945  }
3946  if (image_info->quality != UndefinedCompressionQuality)
3947  image->quality=image_info->quality;
3948  option=GetImageOption(image_info,"scene");
3949  if (option != (const char *) NULL)
3950  image->scene=StringToUnsignedLong(option);
3951  option=GetImageOption(image_info,"taint");
3952  if (option != (const char *) NULL)
3953  image->taint=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
3954  MagickFalse,option);
3955  option=GetImageOption(image_info,"tile-offset");
3956  if (option != (const char *) NULL)
3957  {
3958  char
3959  *geometry;
3960 
3961  geometry=GetPageGeometry(option);
3962  flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
3963  geometry=DestroyString(geometry);
3964  }
3965  option=GetImageOption(image_info,"transparent-color");
3966  if (option != (const char *) NULL)
3967  (void) QueryColorDatabase(option,&image->transparent_color,
3968  &image->exception);
3969  option=GetImageOption(image_info,"type");
3970  if (option != (const char *) NULL)
3971  image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
3972  option);
3973  option=GetImageOption(image_info,"units");
3974  units=image_info->units;
3975  if (option != (const char *) NULL)
3976  units=(ResolutionType) ParseCommandOption(MagickResolutionOptions,
3977  MagickFalse,option);
3978  if (units != UndefinedResolution)
3979  {
3980  if (image->units != units)
3981  switch (image->units)
3982  {
3983  case PixelsPerInchResolution:
3984  {
3985  if (units == PixelsPerCentimeterResolution)
3986  {
3987  image->x_resolution/=2.54;
3988  image->y_resolution/=2.54;
3989  }
3990  break;
3991  }
3992  case PixelsPerCentimeterResolution:
3993  {
3994  if (units == PixelsPerInchResolution)
3995  {
3996  image->x_resolution=(double) ((size_t) (100.0*2.54*
3997  image->x_resolution+0.5))/100.0;
3998  image->y_resolution=(double) ((size_t) (100.0*2.54*
3999  image->y_resolution+0.5))/100.0;
4000  }
4001  break;
4002  }
4003  default:
4004  break;
4005  }
4006  image->units=units;
4007  option=GetImageOption(image_info,"density");
4008  if (option != (const char *) NULL)
4009  {
4010  flags=ParseGeometry(option,&geometry_info);
4011  if ((flags & RhoValue) != 0)
4012  image->x_resolution=geometry_info.rho;
4013  image->y_resolution=image->x_resolution;
4014  if ((flags & SigmaValue) != 0)
4015  image->y_resolution=geometry_info.sigma;
4016  }
4017  }
4018  option=GetImageOption(image_info,"white-point");
4019  if (option != (const char *) NULL)
4020  {
4021  flags=ParseGeometry(option,&geometry_info);
4022  if ((flags & RhoValue) != 0)
4023  image->chromaticity.white_point.x=geometry_info.rho;
4024  image->chromaticity.white_point.y=image->chromaticity.white_point.x;
4025  if ((flags & SigmaValue) != 0)
4026  image->chromaticity.white_point.y=geometry_info.sigma;
4027  }
4028  ResetImageOptionIterator(image_info);
4029  for (option=GetNextImageOption(image_info); option != (const char *) NULL; )
4030  {
4031  value=GetImageOption(image_info,option);
4032  if (value != (const char *) NULL)
4033  {
4034  (void) FormatLocaleString(property,MaxTextExtent,"%s",option);
4035  (void) SetImageArtifact(image,property,value);
4036  }
4037  option=GetNextImageOption(image_info);
4038  }
4039  return(MagickTrue);
4040 }
Definition: image.h:152