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