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