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