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