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