MagickCore  6.9.13-21
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  sans_exception=AcquireExceptionInfo();
2995  status=OpenBlob(image_info,image,ReadBinaryBlobMode,sans_exception);
2996  sans_exception=DestroyExceptionInfo(sans_exception);
2997  if (status == MagickFalse)
2998  {
2999  image=DestroyImage(image);
3000  return(MagickFalse);
3001  }
3002  if ((IsBlobSeekable(image) == MagickFalse) ||
3003  (IsBlobExempt(image) != MagickFalse))
3004  {
3005  /*
3006  Copy image to a seekable temporary file.
3007  */
3008  *filename='\0';
3009  status=ImageToFile(image,filename,exception);
3010  if (CloseBlob(image) == MagickFalse)
3011  status=MagickFalse;
3012  if (status == MagickFalse)
3013  {
3014  (void) RelinquishUniqueFileResource(filename);
3015  image=DestroyImage(image);
3016  return(MagickFalse);
3017  }
3018  SetImageInfoFile(image_info,(FILE *) NULL);
3019  (void) CopyMagickString(image->filename,filename,MaxTextExtent);
3020  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
3021  if (status == MagickFalse)
3022  {
3023  (void) RelinquishUniqueFileResource(filename);
3024  image=DestroyImage(image);
3025  return(MagickFalse);
3026  }
3027  (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
3028  image_info->temporary=MagickTrue;
3029  }
3030  (void) memset(magick,0,sizeof(magick));
3031  count=ReadBlob(image,2*MaxTextExtent,magick);
3032  (void) SeekBlob(image,-((MagickOffsetType) count),SEEK_CUR);
3033  (void) CloseBlob(image);
3034  image=DestroyImage(image);
3035  /*
3036  Check magic.xml configuration file.
3037  */
3038  sans_exception=AcquireExceptionInfo();
3039  magic_info=GetMagicInfo(magick,(size_t) count,sans_exception);
3040  if ((magic_info != (const MagicInfo *) NULL) &&
3041  (GetMagicName(magic_info) != (char *) NULL))
3042  {
3043  (void) CopyMagickString(image_info->magick,GetMagicName(magic_info),
3044  MaxTextExtent);
3045  magick_info=GetMagickInfo(image_info->magick,sans_exception);
3046  if ((magick_info == (const MagickInfo *) NULL) ||
3047  (GetMagickEndianSupport(magick_info) == MagickFalse))
3048  image_info->endian=UndefinedEndian;
3049  sans_exception=DestroyExceptionInfo(sans_exception);
3050  return(MagickTrue);
3051  }
3052  magick_info=GetMagickInfo(image_info->magick,sans_exception);
3053  if ((magick_info == (const MagickInfo *) NULL) ||
3054  (GetMagickEndianSupport(magick_info) == MagickFalse))
3055  image_info->endian=UndefinedEndian;
3056  sans_exception=DestroyExceptionInfo(sans_exception);
3057  }
3058  return(MagickTrue);
3059 }
3060 
3061 /*
3062 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3063 % %
3064 % %
3065 % %
3066 % S e t I m a g e I n f o B l o b %
3067 % %
3068 % %
3069 % %
3070 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3071 %
3072 % SetImageInfoBlob() sets the image info blob member.
3073 %
3074 % The format of the SetImageInfoBlob method is:
3075 %
3076 % void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3077 % const size_t length)
3078 %
3079 % A description of each parameter follows:
3080 %
3081 % o image_info: the image info.
3082 %
3083 % o blob: the blob.
3084 %
3085 % o length: the blob length.
3086 %
3087 */
3088 MagickExport void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3089  const size_t length)
3090 {
3091  assert(image_info != (ImageInfo *) NULL);
3092  assert(image_info->signature == MagickCoreSignature);
3093  if (IsEventLogging() != MagickFalse)
3094  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3095  image_info->filename);
3096  image_info->blob=(void *) blob;
3097  image_info->length=length;
3098 }
3099 
3100 /*
3101 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3102 % %
3103 % %
3104 % %
3105 % S e t I m a g e I n f o F i l e %
3106 % %
3107 % %
3108 % %
3109 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3110 %
3111 % SetImageInfoFile() sets the image info file member.
3112 %
3113 % The format of the SetImageInfoFile method is:
3114 %
3115 % void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3116 %
3117 % A description of each parameter follows:
3118 %
3119 % o image_info: the image info.
3120 %
3121 % o file: the file.
3122 %
3123 */
3124 MagickExport void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3125 {
3126  assert(image_info != (ImageInfo *) NULL);
3127  assert(image_info->signature == MagickCoreSignature);
3128  if (IsEventLogging() != MagickFalse)
3129  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3130  image_info->filename);
3131  image_info->file=file;
3132 }
3133 
3134 /*
3135 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3136 % %
3137 % %
3138 % %
3139 % S e t I m a g e M a s k %
3140 % %
3141 % %
3142 % %
3143 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3144 %
3145 % SetImageMask() associates a mask with the image. The mask must be the same
3146 % dimensions as the image.
3147 %
3148 % The format of the SetImageMask method is:
3149 %
3150 % MagickBooleanType SetImageMask(Image *image,const Image *mask)
3151 %
3152 % A description of each parameter follows:
3153 %
3154 % o image: the image.
3155 %
3156 % o mask: the image mask.
3157 %
3158 */
3159 MagickExport MagickBooleanType SetImageMask(Image *image,const Image *mask)
3160 {
3161  assert(image != (Image *) NULL);
3162  assert(image->signature == MagickCoreSignature);
3163  if (IsEventLogging() != MagickFalse)
3164  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3165  if (mask != (const Image *) NULL)
3166  if ((mask->columns != image->columns) || (mask->rows != image->rows))
3167  ThrowBinaryImageException(ImageError,"ImageSizeDiffers",image->filename);
3168  if (image->mask != (Image *) NULL)
3169  image->mask=DestroyImage(image->mask);
3170  image->mask=NewImageList();
3171  if (mask == (Image *) NULL)
3172  return(MagickTrue);
3173  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
3174  return(MagickFalse);
3175  image->mask=CloneImage(mask,0,0,MagickTrue,&image->exception);
3176  if (image->mask == (Image *) NULL)
3177  return(MagickFalse);
3178  return(MagickTrue);
3179 }
3180 
3181 /*
3182 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3183 % %
3184 % %
3185 % %
3186 % S e t I m a g e O p a c i t y %
3187 % %
3188 % %
3189 % %
3190 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3191 %
3192 % SetImageOpacity() sets the opacity levels of the image.
3193 %
3194 % The format of the SetImageOpacity method is:
3195 %
3196 % MagickBooleanType SetImageOpacity(Image *image,const Quantum opacity)
3197 %
3198 % A description of each parameter follows:
3199 %
3200 % o image: the image.
3201 %
3202 % o opacity: the level of transparency: 0 is fully opaque and QuantumRange is
3203 % fully transparent.
3204 %
3205 */
3206 MagickExport MagickBooleanType SetImageOpacity(Image *image,
3207  const Quantum opacity)
3208 {
3209  CacheView
3210  *image_view;
3211 
3213  *exception;
3214 
3215  MagickBooleanType
3216  status;
3217 
3218  ssize_t
3219  y;
3220 
3221  assert(image != (Image *) NULL);
3222  assert(image->signature == MagickCoreSignature);
3223  if (IsEventLogging() != MagickFalse)
3224  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3225  image->matte=MagickTrue;
3226  status=MagickTrue;
3227  exception=(&image->exception);
3228  image_view=AcquireAuthenticCacheView(image,exception);
3229 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3230  #pragma omp parallel for schedule(static) shared(status) \
3231  magick_number_threads(image,image,image->rows,2)
3232 #endif
3233  for (y=0; y < (ssize_t) image->rows; y++)
3234  {
3235  PixelPacket
3236  *magick_restrict q;
3237 
3238  ssize_t
3239  x;
3240 
3241  if (status == MagickFalse)
3242  continue;
3243  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3244  if (q == (PixelPacket *) NULL)
3245  {
3246  status=MagickFalse;
3247  continue;
3248  }
3249  for (x=0; x < (ssize_t) image->columns; x++)
3250  {
3251  SetPixelOpacity(q,opacity);
3252  q++;
3253  }
3254  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3255  status=MagickFalse;
3256  }
3257  image_view=DestroyCacheView(image_view);
3258  return(status);
3259 }
3260 
3261 /*
3262 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3263 % %
3264 % %
3265 % %
3266 % 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 %
3267 % %
3268 % %
3269 % %
3270 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3271 %
3272 % SetImageVirtualPixelMethod() sets the "virtual pixels" method for the
3273 % image and returns the previous setting. A virtual pixel is any pixel access
3274 % that is outside the boundaries of the image cache.
3275 %
3276 % The format of the SetImageVirtualPixelMethod() method is:
3277 %
3278 % VirtualPixelMethod SetImageVirtualPixelMethod(const Image *image,
3279 % const VirtualPixelMethod virtual_pixel_method)
3280 %
3281 % A description of each parameter follows:
3282 %
3283 % o image: the image.
3284 %
3285 % o virtual_pixel_method: choose the type of virtual pixel.
3286 %
3287 */
3288 MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(const Image *image,
3289  const VirtualPixelMethod virtual_pixel_method)
3290 {
3291  assert(image != (const Image *) NULL);
3292  assert(image->signature == MagickCoreSignature);
3293  if (IsEventLogging() != MagickFalse)
3294  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3295  return(SetPixelCacheVirtualMethod(image,virtual_pixel_method));
3296 }
3297 
3298 /*
3299 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3300 % %
3301 % %
3302 % %
3303 % S m u s h I m a g e s %
3304 % %
3305 % %
3306 % %
3307 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3308 %
3309 % SmushImages() takes all images from the current image pointer to the end
3310 % of the image list and smushes them to each other top-to-bottom if the
3311 % stack parameter is true, otherwise left-to-right.
3312 %
3313 % The current gravity setting now effects how the image is justified in the
3314 % final image.
3315 %
3316 % The format of the SmushImages method is:
3317 %
3318 % Image *SmushImages(const Image *images,const MagickBooleanType stack,
3319 % ExceptionInfo *exception)
3320 %
3321 % A description of each parameter follows:
3322 %
3323 % o images: the image sequence.
3324 %
3325 % o stack: A value other than 0 stacks the images top-to-bottom.
3326 %
3327 % o offset: minimum distance in pixels between images.
3328 %
3329 % o exception: return any errors or warnings in this structure.
3330 %
3331 */
3332 
3333 static ssize_t SmushXGap(const Image *smush_image,const Image *images,
3334  const ssize_t offset,ExceptionInfo *exception)
3335 {
3336  CacheView
3337  *left_view,
3338  *right_view;
3339 
3340  const Image
3341  *left_image,
3342  *right_image;
3343 
3345  left_geometry,
3346  right_geometry;
3347 
3348  const PixelPacket
3349  *p;
3350 
3351  ssize_t
3352  i,
3353  y;
3354 
3355  size_t
3356  gap;
3357 
3358  ssize_t
3359  x;
3360 
3361  if (images->previous == (Image *) NULL)
3362  return(0);
3363  right_image=images;
3364  SetGeometry(smush_image,&right_geometry);
3365  GravityAdjustGeometry(right_image->columns,right_image->rows,
3366  right_image->gravity,&right_geometry);
3367  left_image=images->previous;
3368  SetGeometry(smush_image,&left_geometry);
3369  GravityAdjustGeometry(left_image->columns,left_image->rows,
3370  left_image->gravity,&left_geometry);
3371  gap=right_image->columns;
3372  left_view=AcquireVirtualCacheView(left_image,exception);
3373  right_view=AcquireVirtualCacheView(right_image,exception);
3374  for (y=0; y < (ssize_t) smush_image->rows; y++)
3375  {
3376  for (x=(ssize_t) left_image->columns-1; x > 0; x--)
3377  {
3378  p=GetCacheViewVirtualPixels(left_view,x,left_geometry.y+y,1,1,exception);
3379  if ((p == (const PixelPacket *) NULL) ||
3380  (GetPixelOpacity(p) != TransparentOpacity) ||
3381  (((ssize_t) left_image->columns-x-1) >= (ssize_t) gap))
3382  break;
3383  }
3384  i=(ssize_t) left_image->columns-x-1;
3385  for (x=0; x < (ssize_t) right_image->columns; x++)
3386  {
3387  p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1,
3388  exception);
3389  if ((p == (const PixelPacket *) NULL) ||
3390  (GetPixelOpacity(p) != TransparentOpacity) ||
3391  ((x+i) >= (ssize_t) gap))
3392  break;
3393  }
3394  if ((x+i) < (ssize_t) gap)
3395  gap=(size_t) (x+i);
3396  }
3397  right_view=DestroyCacheView(right_view);
3398  left_view=DestroyCacheView(left_view);
3399  if (y < (ssize_t) smush_image->rows)
3400  return(offset);
3401  return((ssize_t) gap-offset);
3402 }
3403 
3404 static ssize_t SmushYGap(const Image *smush_image,const Image *images,
3405  const ssize_t offset,ExceptionInfo *exception)
3406 {
3407  CacheView
3408  *bottom_view,
3409  *top_view;
3410 
3411  const Image
3412  *bottom_image,
3413  *top_image;
3414 
3416  bottom_geometry,
3417  top_geometry;
3418 
3419  const PixelPacket
3420  *p;
3421 
3422  ssize_t
3423  i,
3424  x;
3425 
3426  size_t
3427  gap;
3428 
3429  ssize_t
3430  y;
3431 
3432  if (images->previous == (Image *) NULL)
3433  return(0);
3434  bottom_image=images;
3435  SetGeometry(smush_image,&bottom_geometry);
3436  GravityAdjustGeometry(bottom_image->columns,bottom_image->rows,
3437  bottom_image->gravity,&bottom_geometry);
3438  top_image=images->previous;
3439  SetGeometry(smush_image,&top_geometry);
3440  GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
3441  &top_geometry);
3442  gap=bottom_image->rows;
3443  top_view=AcquireVirtualCacheView(top_image,exception);
3444  bottom_view=AcquireVirtualCacheView(bottom_image,exception);
3445  for (x=0; x < (ssize_t) smush_image->columns; x++)
3446  {
3447  for (y=(ssize_t) top_image->rows-1; y > 0; y--)
3448  {
3449  p=GetCacheViewVirtualPixels(top_view,top_geometry.x+x,y,1,1,exception);
3450  if ((p == (const PixelPacket *) NULL) ||
3451  (GetPixelOpacity(p) != TransparentOpacity) ||
3452  (((ssize_t) top_image->rows-y-1) >= (ssize_t) gap))
3453  break;
3454  }
3455  i=(ssize_t) top_image->rows-y-1;
3456  for (y=0; y < (ssize_t) bottom_image->rows; y++)
3457  {
3458  p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1,
3459  exception);
3460  if ((p == (const PixelPacket *) NULL) ||
3461  (GetPixelOpacity(p) != TransparentOpacity) ||
3462  ((y+i) >= (ssize_t) gap))
3463  break;
3464  }
3465  if ((y+i) < (ssize_t) gap)
3466  gap=(size_t) (y+i);
3467  }
3468  bottom_view=DestroyCacheView(bottom_view);
3469  top_view=DestroyCacheView(top_view);
3470  if (x < (ssize_t) smush_image->columns)
3471  return(offset);
3472  return((ssize_t) gap-offset);
3473 }
3474 
3475 MagickExport Image *SmushImages(const Image *images,
3476  const MagickBooleanType stack,const ssize_t offset,ExceptionInfo *exception)
3477 {
3478 #define SmushImageTag "Smush/Image"
3479 
3480  CacheView
3481  *smush_view;
3482 
3483  const Image
3484  *image;
3485 
3486  Image
3487  *smush_image;
3488 
3489  MagickBooleanType
3490  matte,
3491  proceed,
3492  status;
3493 
3494  MagickOffsetType
3495  n;
3496 
3498  geometry;
3499 
3500  const Image
3501  *next;
3502 
3503  size_t
3504  height,
3505  number_images,
3506  width;
3507 
3508  ssize_t
3509  x_offset,
3510  y_offset;
3511 
3512  /*
3513  Compute maximum area of smushed area.
3514  */
3515  assert(images != (Image *) NULL);
3516  assert(images->signature == MagickCoreSignature);
3517  assert(exception != (ExceptionInfo *) NULL);
3518  assert(exception->signature == MagickCoreSignature);
3519  if (IsEventLogging() != MagickFalse)
3520  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3521  image=images;
3522  matte=image->matte;
3523  number_images=1;
3524  width=image->columns;
3525  height=image->rows;
3526  next=GetNextImageInList(image);
3527  for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
3528  {
3529  if (next->matte != MagickFalse)
3530  matte=MagickTrue;
3531  number_images++;
3532  if (stack != MagickFalse)
3533  {
3534  if (next->columns > width)
3535  width=next->columns;
3536  height+=next->rows;
3537  if (next->previous != (Image *) NULL)
3538  height=(size_t) MagickMax((ssize_t) height+offset,0U);
3539  continue;
3540  }
3541  width+=next->columns;
3542  if (next->previous != (Image *) NULL)
3543  width=(size_t) MagickMax((ssize_t) width+offset,0U);
3544  if (next->rows > height)
3545  height=next->rows;
3546  }
3547  /*
3548  Smush images.
3549  */
3550  smush_image=CloneImage(image,width,height,MagickTrue,exception);
3551  if (smush_image == (Image *) NULL)
3552  return((Image *) NULL);
3553  if (SetImageStorageClass(smush_image,DirectClass) == MagickFalse)
3554  {
3555  InheritException(exception,&smush_image->exception);
3556  smush_image=DestroyImage(smush_image);
3557  return((Image *) NULL);
3558  }
3559  smush_image->matte=matte;
3560  (void) SetImageBackgroundColor(smush_image);
3561  status=MagickTrue;
3562  x_offset=0;
3563  y_offset=0;
3564  smush_view=AcquireVirtualCacheView(smush_image,exception);
3565  for (n=0; n < (MagickOffsetType) number_images; n++)
3566  {
3567  SetGeometry(smush_image,&geometry);
3568  GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry);
3569  if (stack != MagickFalse)
3570  {
3571  x_offset-=geometry.x;
3572  y_offset-=SmushYGap(smush_image,image,offset,exception);
3573  }
3574  else
3575  {
3576  x_offset-=SmushXGap(smush_image,image,offset,exception);
3577  y_offset-=geometry.y;
3578  }
3579  status=CompositeImage(smush_image,OverCompositeOp,image,x_offset,y_offset);
3580  proceed=SetImageProgress(image,SmushImageTag,n,number_images);
3581  if (proceed == MagickFalse)
3582  break;
3583  if (stack == MagickFalse)
3584  {
3585  x_offset+=(ssize_t) image->columns;
3586  y_offset=0;
3587  }
3588  else
3589  {
3590  x_offset=0;
3591  y_offset+=(ssize_t) image->rows;
3592  }
3593  image=GetNextImageInList(image);
3594  }
3595  if (stack == MagickFalse)
3596  smush_image->columns=(size_t) x_offset;
3597  else
3598  smush_image->rows=(size_t) y_offset;
3599  smush_view=DestroyCacheView(smush_view);
3600  if (status == MagickFalse)
3601  smush_image=DestroyImage(smush_image);
3602  return(smush_image);
3603 }
3604 
3605 /*
3606 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3607 % %
3608 % %
3609 % %
3610 % S t r i p I m a g e %
3611 % %
3612 % %
3613 % %
3614 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3615 %
3616 % StripImage() strips an image of all profiles and comments.
3617 %
3618 % The format of the StripImage method is:
3619 %
3620 % MagickBooleanType StripImage(Image *image)
3621 %
3622 % A description of each parameter follows:
3623 %
3624 % o image: the image.
3625 %
3626 */
3627 MagickExport MagickBooleanType StripImage(Image *image)
3628 {
3629  MagickBooleanType
3630  status;
3631 
3632  assert(image != (Image *) NULL);
3633  if (IsEventLogging() != MagickFalse)
3634  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3635  DestroyImageProfiles(image);
3636  (void) DeleteImageProperty(image,"comment");
3637  (void) DeleteImageProperty(image,"date:create");
3638  (void) DeleteImageProperty(image,"date:modify");
3639  status=SetImageArtifact(image,"png:exclude-chunk",
3640  "bKGD,caNv,cHRM,eXIf,gAMA,iCCP,iTXt,pHYs,sRGB,tEXt,zCCP,zTXt,date");
3641  return(status);
3642 }
3643 
3644 /*
3645 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3646 % %
3647 % %
3648 % %
3649 + S y n c I m a g e %
3650 % %
3651 % %
3652 % %
3653 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3654 %
3655 % SyncImage() initializes the red, green, and blue intensities of each pixel
3656 % as defined by the colormap index.
3657 %
3658 % The format of the SyncImage method is:
3659 %
3660 % MagickBooleanType SyncImage(Image *image)
3661 %
3662 % A description of each parameter follows:
3663 %
3664 % o image: the image.
3665 %
3666 */
3667 
3668 static inline IndexPacket PushColormapIndex(Image *image,
3669  const size_t index,MagickBooleanType *range_exception)
3670 {
3671  if (index < image->colors)
3672  return((IndexPacket) index);
3673  *range_exception=MagickTrue;
3674  return((IndexPacket) 0);
3675 }
3676 
3677 MagickExport MagickBooleanType SyncImage(Image *image)
3678 {
3679  CacheView
3680  *image_view;
3681 
3683  *exception;
3684 
3685  MagickBooleanType
3686  range_exception,
3687  status,
3688  taint;
3689 
3690  ssize_t
3691  y;
3692 
3693  assert(image != (Image *) NULL);
3694  assert(image->signature == MagickCoreSignature);
3695  if (IsEventLogging() != MagickFalse)
3696  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3697  if (image->ping != MagickFalse)
3698  return(MagickTrue);
3699  if (image->storage_class != PseudoClass)
3700  return(MagickFalse);
3701  assert(image->colormap != (PixelPacket *) NULL);
3702  range_exception=MagickFalse;
3703  status=MagickTrue;
3704  taint=image->taint;
3705  exception=(&image->exception);
3706  image_view=AcquireAuthenticCacheView(image,exception);
3707 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3708  #pragma omp parallel for schedule(static) shared(range_exception,status) \
3709  magick_number_threads(image,image,image->rows,2)
3710 #endif
3711  for (y=0; y < (ssize_t) image->rows; y++)
3712  {
3713  IndexPacket
3714  index;
3715 
3716  IndexPacket
3717  *magick_restrict indexes;
3718 
3719  PixelPacket
3720  *magick_restrict q;
3721 
3722  ssize_t
3723  x;
3724 
3725  if (status == MagickFalse)
3726  continue;
3727  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3728  if (q == (PixelPacket *) NULL)
3729  {
3730  status=MagickFalse;
3731  continue;
3732  }
3733  indexes=GetCacheViewAuthenticIndexQueue(image_view);
3734  for (x=0; x < (ssize_t) image->columns; x++)
3735  {
3736  index=PushColormapIndex(image,(size_t) GetPixelIndex(indexes+x),
3737  &range_exception);
3738  if (image->matte == MagickFalse)
3739  SetPixelRgb(q,image->colormap+(ssize_t) index)
3740  else
3741  SetPixelRGBO(q,image->colormap+(ssize_t) index);
3742  q++;
3743  }
3744  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3745  status=MagickFalse;
3746  }
3747  image_view=DestroyCacheView(image_view);
3748  image->taint=taint;
3749  if ((image->ping == MagickFalse) && (range_exception != MagickFalse))
3750  (void) ThrowMagickException(&image->exception,GetMagickModule(),
3751  CorruptImageWarning,"InvalidColormapIndex","`%s'",image->filename);
3752  return(status);
3753 }
3754 
3755 /*
3756 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3757 % %
3758 % %
3759 % %
3760 % S y n c I m a g e S e t t i n g s %
3761 % %
3762 % %
3763 % %
3764 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3765 %
3766 % SyncImageSettings() syncs image_info options into per-image attributes.
3767 %
3768 % The format of the SyncImageSettings method is:
3769 %
3770 % MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
3771 % Image *image)
3772 % MagickBooleanType SyncImagesSettings(const ImageInfo *image_info,
3773 % Image *image)
3774 %
3775 % A description of each parameter follows:
3776 %
3777 % o image_info: the image info.
3778 %
3779 % o image: the image.
3780 %
3781 */
3782 
3783 MagickExport MagickBooleanType SyncImagesSettings(ImageInfo *image_info,
3784  Image *images)
3785 {
3786  Image
3787  *image;
3788 
3789  assert(image_info != (const ImageInfo *) NULL);
3790  assert(image_info->signature == MagickCoreSignature);
3791  assert(images != (Image *) NULL);
3792  assert(images->signature == MagickCoreSignature);
3793  if (IsEventLogging() != MagickFalse)
3794  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3795  image=images;
3796  for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
3797  (void) SyncImageSettings(image_info,image);
3798  (void) DeleteImageOption(image_info,"page");
3799  return(MagickTrue);
3800 }
3801 
3802 MagickExport MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
3803  Image *image)
3804 {
3805  char
3806  property[MaxTextExtent];
3807 
3808  const char
3809  *option,
3810  *value;
3811 
3812  GeometryInfo
3813  geometry_info;
3814 
3815  MagickStatusType
3816  flags;
3817 
3818  ResolutionType
3819  units;
3820 
3821  /*
3822  Sync image options.
3823  */
3824  assert(image_info != (const ImageInfo *) NULL);
3825  assert(image_info->signature == MagickCoreSignature);
3826  assert(image != (Image *) NULL);
3827  assert(image->signature == MagickCoreSignature);
3828  if (IsEventLogging() != MagickFalse)
3829  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3830  option=GetImageOption(image_info,"background");
3831  if (option != (const char *) NULL)
3832  (void) QueryColorDatabase(option,&image->background_color,
3833  &image->exception);
3834  option=GetImageOption(image_info,"bias");
3835  if (option != (const char *) NULL)
3836  image->bias=StringToDoubleInterval(option,(double) QuantumRange+1.0);
3837  option=GetImageOption(image_info,"black-point-compensation");
3838  if (option != (const char *) NULL)
3839  image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
3840  MagickBooleanOptions,MagickFalse,option);
3841  option=GetImageOption(image_info,"blue-primary");
3842  if (option != (const char *) NULL)
3843  {
3844  flags=ParseGeometry(option,&geometry_info);
3845  if ((flags & RhoValue) != 0)
3846  image->chromaticity.blue_primary.x=geometry_info.rho;
3847  image->chromaticity.blue_primary.y=image->chromaticity.blue_primary.x;
3848  if ((flags & SigmaValue) != 0)
3849  image->chromaticity.blue_primary.y=geometry_info.sigma;
3850  }
3851  option=GetImageOption(image_info,"bordercolor");
3852  if (option != (const char *) NULL)
3853  (void) QueryColorDatabase(option,&image->border_color,&image->exception);
3854  option=GetImageOption(image_info,"colors");
3855  if (option != (const char *) NULL)
3856  image->colors=StringToUnsignedLong(option);
3857  option=GetImageOption(image_info,"compose");
3858  if (option != (const char *) NULL)
3859  image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
3860  MagickFalse,option);
3861  option=GetImageOption(image_info,"compress");
3862  if (option != (const char *) NULL)
3863  image->compression=(CompressionType) ParseCommandOption(
3864  MagickCompressOptions,MagickFalse,option);
3865  option=GetImageOption(image_info,"debug");
3866  if (option != (const char *) NULL)
3867  image->debug=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
3868  MagickFalse,option);
3869  option=GetImageOption(image_info,"density");
3870  if (option != (const char *) NULL)
3871  {
3872  GeometryInfo
3873  geometry_info;
3874 
3875  /*
3876  Set image density.
3877  */
3878  flags=ParseGeometry(option,&geometry_info);
3879  if ((flags & RhoValue) != 0)
3880  image->x_resolution=geometry_info.rho;
3881  image->y_resolution=image->x_resolution;
3882  if ((flags & SigmaValue) != 0)
3883  image->y_resolution=geometry_info.sigma;
3884  }
3885  option=GetImageOption(image_info,"depth");
3886  if (option != (const char *) NULL)
3887  image->depth=StringToUnsignedLong(option);
3888  option=GetImageOption(image_info,"endian");
3889  if (option != (const char *) NULL)
3890  image->endian=(EndianType) ParseCommandOption(MagickEndianOptions,
3891  MagickFalse,option);
3892  option=GetImageOption(image_info,"filter");
3893  if (option != (const char *) NULL)
3894  image->filter=(FilterTypes) ParseCommandOption(MagickFilterOptions,
3895  MagickFalse,option);
3896  option=GetImageOption(image_info,"fuzz");
3897  if (option != (const char *) NULL)
3898  image->fuzz=StringToDoubleInterval(option,(double) QuantumRange+1.0);
3899  option=GetImageOption(image_info,"gravity");
3900  if (option != (const char *) NULL)
3901  image->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
3902  MagickFalse,option);
3903  option=GetImageOption(image_info,"green-primary");
3904  if (option != (const char *) NULL)
3905  {
3906  flags=ParseGeometry(option,&geometry_info);
3907  if ((flags & RhoValue) != 0)
3908  image->chromaticity.green_primary.x=geometry_info.rho;
3909  image->chromaticity.green_primary.y=image->chromaticity.green_primary.x;
3910  if ((flags & SigmaValue) != 0)
3911  image->chromaticity.green_primary.y=geometry_info.sigma;
3912  }
3913  option=GetImageOption(image_info,"intensity");
3914  if (option != (const char *) NULL)
3915  image->intensity=(PixelIntensityMethod) ParseCommandOption(
3916  MagickPixelIntensityOptions,MagickFalse,option);
3917  option=GetImageOption(image_info,"intent");
3918  if (option != (const char *) NULL)
3919  image->rendering_intent=(RenderingIntent) ParseCommandOption(
3920  MagickIntentOptions,MagickFalse,option);
3921  option=GetImageOption(image_info,"interlace");
3922  if (option != (const char *) NULL)
3923  image->interlace=(InterlaceType) ParseCommandOption(MagickInterlaceOptions,
3924  MagickFalse,option);
3925  option=GetImageOption(image_info,"interpolate");
3926  if (option != (const char *) NULL)
3927  image->interpolate=(InterpolatePixelMethod) ParseCommandOption(
3928  MagickInterpolateOptions,MagickFalse,option);
3929  option=GetImageOption(image_info,"loop");
3930  if (option != (const char *) NULL)
3931  image->iterations=StringToUnsignedLong(option);
3932  option=GetImageOption(image_info,"mattecolor");
3933  if (option != (const char *) NULL)
3934  (void) QueryColorDatabase(option,&image->matte_color,&image->exception);
3935  option=GetImageOption(image_info,"orient");
3936  if (option != (const char *) NULL)
3937  image->orientation=(OrientationType) ParseCommandOption(
3938  MagickOrientationOptions,MagickFalse,option);
3939  option=GetImageOption(image_info,"page");
3940  if (option != (const char *) NULL)
3941  {
3942  char
3943  *geometry;
3944 
3945  geometry=GetPageGeometry(option);
3946  flags=ParseAbsoluteGeometry(geometry,&image->page);
3947  geometry=DestroyString(geometry);
3948  }
3949  option=GetImageOption(image_info,"quality");
3950  if (option != (const char *) NULL)
3951  image->quality=StringToUnsignedLong(option);
3952  option=GetImageOption(image_info,"red-primary");
3953  if (option != (const char *) NULL)
3954  {
3955  flags=ParseGeometry(option,&geometry_info);
3956  if ((flags & RhoValue) != 0)
3957  image->chromaticity.red_primary.x=geometry_info.rho;
3958  image->chromaticity.red_primary.y=image->chromaticity.red_primary.x;
3959  if ((flags & SigmaValue) != 0)
3960  image->chromaticity.red_primary.y=geometry_info.sigma;
3961  }
3962  if (image_info->quality != UndefinedCompressionQuality)
3963  image->quality=image_info->quality;
3964  option=GetImageOption(image_info,"scene");
3965  if (option != (const char *) NULL)
3966  image->scene=StringToUnsignedLong(option);
3967  option=GetImageOption(image_info,"taint");
3968  if (option != (const char *) NULL)
3969  image->taint=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
3970  MagickFalse,option);
3971  option=GetImageOption(image_info,"tile-offset");
3972  if (option != (const char *) NULL)
3973  {
3974  char
3975  *geometry;
3976 
3977  geometry=GetPageGeometry(option);
3978  flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
3979  geometry=DestroyString(geometry);
3980  }
3981  option=GetImageOption(image_info,"transparent-color");
3982  if (option != (const char *) NULL)
3983  (void) QueryColorDatabase(option,&image->transparent_color,
3984  &image->exception);
3985  option=GetImageOption(image_info,"type");
3986  if (option != (const char *) NULL)
3987  image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
3988  option);
3989  option=GetImageOption(image_info,"units");
3990  units=image_info->units;
3991  if (option != (const char *) NULL)
3992  units=(ResolutionType) ParseCommandOption(MagickResolutionOptions,
3993  MagickFalse,option);
3994  if (units != UndefinedResolution)
3995  {
3996  if (image->units != units)
3997  switch (image->units)
3998  {
3999  case PixelsPerInchResolution:
4000  {
4001  if (units == PixelsPerCentimeterResolution)
4002  {
4003  image->x_resolution/=2.54;
4004  image->y_resolution/=2.54;
4005  }
4006  break;
4007  }
4008  case PixelsPerCentimeterResolution:
4009  {
4010  if (units == PixelsPerInchResolution)
4011  {
4012  image->x_resolution=(double) ((size_t) (100.0*2.54*
4013  image->x_resolution+0.5))/100.0;
4014  image->y_resolution=(double) ((size_t) (100.0*2.54*
4015  image->y_resolution+0.5))/100.0;
4016  }
4017  break;
4018  }
4019  default:
4020  break;
4021  }
4022  image->units=units;
4023  option=GetImageOption(image_info,"density");
4024  if (option != (const char *) NULL)
4025  {
4026  flags=ParseGeometry(option,&geometry_info);
4027  if ((flags & RhoValue) != 0)
4028  image->x_resolution=geometry_info.rho;
4029  image->y_resolution=image->x_resolution;
4030  if ((flags & SigmaValue) != 0)
4031  image->y_resolution=geometry_info.sigma;
4032  }
4033  }
4034  option=GetImageOption(image_info,"white-point");
4035  if (option != (const char *) NULL)
4036  {
4037  flags=ParseGeometry(option,&geometry_info);
4038  if ((flags & RhoValue) != 0)
4039  image->chromaticity.white_point.x=geometry_info.rho;
4040  image->chromaticity.white_point.y=image->chromaticity.white_point.x;
4041  if ((flags & SigmaValue) != 0)
4042  image->chromaticity.white_point.y=geometry_info.sigma;
4043  }
4044  ResetImageOptionIterator(image_info);
4045  for (option=GetNextImageOption(image_info); option != (const char *) NULL; )
4046  {
4047  value=GetImageOption(image_info,option);
4048  if (value != (const char *) NULL)
4049  {
4050  (void) FormatLocaleString(property,MaxTextExtent,"%s",option);
4051  (void) SetImageArtifact(image,property,value);
4052  }
4053  option=GetNextImageOption(image_info);
4054  }
4055  return(MagickTrue);
4056 }
Definition: image.h:133