MagickCore 7.1.1
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 {
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 {
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 {
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{
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
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
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 {
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
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+=GetPixelChannels(next);
585 q+=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{
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
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{
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+=GetPixelChannels(source_image);
1138 q+=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+=GetPixelChannels(image);
1534 q+=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*/
1651MagickExport size_t InterpretImageFilename(const ImageInfo *image_info,
1652 Image *image,const char *format,int value,char *filename,
1653 ExceptionInfo *exception)
1654{
1655 char
1656 *q;
1657
1658 const char
1659 *p;
1660
1661 int
1662 c;
1663
1664 MagickBooleanType
1665 canonical;
1666
1667 ssize_t
1668 field_width,
1669 offset;
1670
1671 canonical=MagickFalse;
1672 offset=0;
1673 (void) CopyMagickString(filename,format,MagickPathExtent);
1674 if (IsStringTrue(GetImageOption(image_info,"filename:literal")) != MagickFalse)
1675 return(strlen(filename));
1676 for (p=strchr(format,'%'); p != (char *) NULL; p=strchr(p+1,'%'))
1677 {
1678 q=(char *) p+1;
1679 if (*q == '%')
1680 {
1681 p=q+1;
1682 continue;
1683 }
1684 field_width=0;
1685 if (*q == '0')
1686 field_width=(ssize_t) strtol(q,&q,10);
1687 switch (*q)
1688 {
1689 case 'd':
1690 case 'o':
1691 case 'x':
1692 {
1693 q++;
1694 c=(*q);
1695 *q='\0';
1696 (void) FormatLocaleString(filename+(p-format-offset),(size_t)
1697 (MagickPathExtent-(p-format-offset)),p,value);
1698 offset+=(4-field_width);
1699 *q=c;
1700 (void) ConcatenateMagickString(filename,q,MagickPathExtent);
1701 canonical=MagickTrue;
1702 if (*(q-1) != '%')
1703 break;
1704 p++;
1705 break;
1706 }
1707 case '[':
1708 {
1709 char
1710 pattern[MagickPathExtent];
1711
1712 const char
1713 *option;
1714
1715 char
1716 *r;
1717
1718 ssize_t
1719 i;
1720
1721 ssize_t
1722 depth;
1723
1724 /*
1725 Image option.
1726 */
1727 if (strchr(p,']') == (char *) NULL)
1728 break;
1729 depth=1;
1730 r=q+1;
1731 for (i=0; (i < (MagickPathExtent-1L)) && (*r != '\0'); i++)
1732 {
1733 if (*r == '[')
1734 depth++;
1735 if (*r == ']')
1736 depth--;
1737 if (depth <= 0)
1738 break;
1739 pattern[i]=(*r++);
1740 }
1741 pattern[i]='\0';
1742 if (LocaleNCompare(pattern,"filename:",9) != 0)
1743 break;
1744 option=(const char *) NULL;
1745 if (image != (Image *) NULL)
1746 option=GetImageProperty(image,pattern,exception);
1747 if ((option == (const char *) NULL) && (image != (Image *) NULL))
1748 option=GetImageArtifact(image,pattern);
1749 if ((option == (const char *) NULL) &&
1750 (image_info != (ImageInfo *) NULL))
1751 option=GetImageOption(image_info,pattern);
1752 if (option == (const char *) NULL)
1753 break;
1754 q--;
1755 c=(*q);
1756 *q='\0';
1757 (void) CopyMagickString(filename+(p-format-offset),option,(size_t)
1758 (MagickPathExtent-(p-format-offset)));
1759 offset+=(ssize_t) strlen(pattern)-(ssize_t) strlen(option)+3;
1760 *q=c;
1761 (void) ConcatenateMagickString(filename,r+1,MagickPathExtent);
1762 canonical=MagickTrue;
1763 if (*(q-1) != '%')
1764 break;
1765 p++;
1766 break;
1767 }
1768 default:
1769 break;
1770 }
1771 }
1772 if (canonical == MagickFalse)
1773 (void) CopyMagickString(filename,format,MagickPathExtent);
1774 else
1775 for (q=filename; *q != '\0'; q++)
1776 if ((*q == '%') && (*(q+1) == '%'))
1777 (void) CopyMagickString(q,q+1,(size_t) (MagickPathExtent-(q-filename)));
1778 return(strlen(filename));
1779}
1780
1781/*
1782%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1783% %
1784% %
1785% %
1786% I s H i g h D y n a m i c R a n g e I m a g e %
1787% %
1788% %
1789% %
1790%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1791%
1792% IsHighDynamicRangeImage() returns MagickTrue if any pixel component is
1793% non-integer or exceeds the bounds of the quantum depth (e.g. for Q16
1794% 0..65535.
1795%
1796% The format of the IsHighDynamicRangeImage method is:
1797%
1798% MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1799% ExceptionInfo *exception)
1800%
1801% A description of each parameter follows:
1802%
1803% o image: the image.
1804%
1805% o exception: return any errors or warnings in this structure.
1806%
1807*/
1808MagickExport MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1809 ExceptionInfo *exception)
1810{
1811#if !defined(MAGICKCORE_HDRI_SUPPORT)
1812 (void) image;
1813 (void) exception;
1814 return(MagickFalse);
1815#else
1816 CacheView
1817 *image_view;
1818
1819 MagickBooleanType
1820 hdri = MagickFalse;
1821
1822 ssize_t
1823 y;
1824
1825 assert(image != (Image *) NULL);
1826 assert(image->signature == MagickCoreSignature);
1827 if (IsEventLogging() != MagickFalse)
1828 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1829 image_view=AcquireVirtualCacheView(image,exception);
1830#if defined(MAGICKCORE_OPENMP_SUPPORT)
1831 #pragma omp parallel for schedule(static) shared(hdri) \
1832 magick_number_threads(image,image,image->rows,2)
1833#endif
1834 for (y=0; y < (ssize_t) image->rows; y++)
1835 {
1836 const Quantum
1837 *p;
1838
1839 ssize_t
1840 x;
1841
1842 if (hdri != MagickFalse)
1843 continue;
1844 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1845 if (p == (const Quantum *) NULL)
1846 continue;
1847 for (x=0; x < (ssize_t) image->columns; x++)
1848 {
1849 ssize_t
1850 i;
1851
1852 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1853 {
1854 double
1855 pixel;
1856
1857 PixelTrait
1858 traits;
1859
1860 traits=GetPixelChannelTraits(image,(PixelChannel) i);
1861 if (traits == UndefinedPixelTrait)
1862 continue;
1863 pixel=(double) p[i];
1864 if ((pixel < 0.0) || (pixel > (double) QuantumRange) ||
1865 (pixel != (double) ((QuantumAny) pixel)))
1866 {
1867 hdri=MagickTrue;
1868 break;
1869 }
1870 }
1871 if (hdri != MagickFalse)
1872 break;
1873 p+=GetPixelChannels(image);
1874 }
1875 }
1876 image_view=DestroyCacheView(image_view);
1877 return(hdri);
1878#endif
1879}
1880
1881/*
1882%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1883% %
1884% %
1885% %
1886% I s I m a g e O b j e c t %
1887% %
1888% %
1889% %
1890%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1891%
1892% IsImageObject() returns MagickTrue if the image sequence contains a valid
1893% set of image objects.
1894%
1895% The format of the IsImageObject method is:
1896%
1897% MagickBooleanType IsImageObject(const Image *image)
1898%
1899% A description of each parameter follows:
1900%
1901% o image: the image.
1902%
1903*/
1904MagickExport MagickBooleanType IsImageObject(const Image *image)
1905{
1906 const Image
1907 *p;
1908
1909 assert(image != (Image *) NULL);
1910 if (IsEventLogging() != MagickFalse)
1911 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1912 for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
1913 if (p->signature != MagickCoreSignature)
1914 return(MagickFalse);
1915 return(MagickTrue);
1916}
1917
1918/*
1919%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1920% %
1921% %
1922% %
1923% I s T a i n t I m a g e %
1924% %
1925% %
1926% %
1927%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1928%
1929% IsTaintImage() returns MagickTrue any pixel in the image has been altered
1930% since it was first constituted.
1931%
1932% The format of the IsTaintImage method is:
1933%
1934% MagickBooleanType IsTaintImage(const Image *image)
1935%
1936% A description of each parameter follows:
1937%
1938% o image: the image.
1939%
1940*/
1941MagickExport MagickBooleanType IsTaintImage(const Image *image)
1942{
1943 char
1944 magick[MagickPathExtent],
1945 filename[MagickPathExtent];
1946
1947 const Image
1948 *p;
1949
1950 assert(image != (Image *) NULL);
1951 assert(image->signature == MagickCoreSignature);
1952 if (IsEventLogging() != MagickFalse)
1953 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1954 (void) CopyMagickString(magick,image->magick,MagickPathExtent);
1955 (void) CopyMagickString(filename,image->filename,MagickPathExtent);
1956 for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
1957 {
1958 if (p->taint != MagickFalse)
1959 return(MagickTrue);
1960 if (LocaleCompare(p->magick,magick) != 0)
1961 return(MagickTrue);
1962 if (LocaleCompare(p->filename,filename) != 0)
1963 return(MagickTrue);
1964 }
1965 return(MagickFalse);
1966}
1967
1968/*
1969%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1970% %
1971% %
1972% %
1973% M o d i f y I m a g e %
1974% %
1975% %
1976% %
1977%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1978%
1979% ModifyImage() ensures that there is only a single reference to the image
1980% to be modified, updating the provided image pointer to point to a clone of
1981% the original image if necessary.
1982%
1983% The format of the ModifyImage method is:
1984%
1985% MagickBooleanType ModifyImage(Image *image,ExceptionInfo *exception)
1986%
1987% A description of each parameter follows:
1988%
1989% o image: the image.
1990%
1991% o exception: return any errors or warnings in this structure.
1992%
1993*/
1994MagickExport MagickBooleanType ModifyImage(Image **image,
1995 ExceptionInfo *exception)
1996{
1997 Image
1998 *clone_image;
1999
2000 assert(image != (Image **) NULL);
2001 assert(*image != (Image *) NULL);
2002 assert((*image)->signature == MagickCoreSignature);
2003 if (IsEventLogging() != MagickFalse)
2004 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
2005 if (GetImageReferenceCount(*image) <= 1)
2006 return(MagickTrue);
2007 clone_image=CloneImage(*image,0,0,MagickTrue,exception);
2008 LockSemaphoreInfo((*image)->semaphore);
2009 (*image)->reference_count--;
2010 UnlockSemaphoreInfo((*image)->semaphore);
2011 *image=clone_image;
2012 return(MagickTrue);
2013}
2014
2015/*
2016%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2017% %
2018% %
2019% %
2020% N e w M a g i c k I m a g e %
2021% %
2022% %
2023% %
2024%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2025%
2026% NewMagickImage() creates a blank image canvas of the specified size and
2027% background color.
2028%
2029% The format of the NewMagickImage method is:
2030%
2031% Image *NewMagickImage(const ImageInfo *image_info,const size_t width,
2032% const size_t height,const PixelInfo *background,
2033% ExceptionInfo *exception)
2034%
2035% A description of each parameter follows:
2036%
2037% o image: the image.
2038%
2039% o width: the image width.
2040%
2041% o height: the image height.
2042%
2043% o background: the image color.
2044%
2045% o exception: return any errors or warnings in this structure.
2046%
2047*/
2048MagickExport Image *NewMagickImage(const ImageInfo *image_info,
2049 const size_t width,const size_t height,const PixelInfo *background,
2050 ExceptionInfo *exception)
2051{
2052 CacheView
2053 *image_view;
2054
2055 Image
2056 *image;
2057
2058 MagickBooleanType
2059 status;
2060
2061 ssize_t
2062 y;
2063
2064 assert(image_info != (const ImageInfo *) NULL);
2065 assert(image_info->signature == MagickCoreSignature);
2066 assert(background != (const PixelInfo *) NULL);
2067 if (IsEventLogging() != MagickFalse)
2068 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2069 image=AcquireImage(image_info,exception);
2070 image->columns=width;
2071 image->rows=height;
2072 image->colorspace=background->colorspace;
2073 image->alpha_trait=background->alpha_trait;
2074 image->fuzz=background->fuzz;
2075 image->depth=background->depth;
2076 status=MagickTrue;
2077 image_view=AcquireAuthenticCacheView(image,exception);
2078#if defined(MAGICKCORE_OPENMP_SUPPORT)
2079 #pragma omp parallel for schedule(static) shared(status) \
2080 magick_number_threads(image,image,image->rows,2)
2081#endif
2082 for (y=0; y < (ssize_t) image->rows; y++)
2083 {
2084 Quantum
2085 *magick_restrict q;
2086
2087 ssize_t
2088 x;
2089
2090 if (status == MagickFalse)
2091 continue;
2092 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2093 if (q == (Quantum *) NULL)
2094 {
2095 status=MagickFalse;
2096 continue;
2097 }
2098 for (x=0; x < (ssize_t) image->columns; x++)
2099 {
2100 SetPixelViaPixelInfo(image,background,q);
2101 q+=GetPixelChannels(image);
2102 }
2103 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2104 status=MagickFalse;
2105 }
2106 image_view=DestroyCacheView(image_view);
2107 if (status == MagickFalse)
2108 image=DestroyImage(image);
2109 return(image);
2110}
2111
2112/*
2113%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2114% %
2115% %
2116% %
2117% R e f e r e n c e I m a g e %
2118% %
2119% %
2120% %
2121%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2122%
2123% ReferenceImage() increments the reference count associated with an image
2124% returning a pointer to the image.
2125%
2126% The format of the ReferenceImage method is:
2127%
2128% Image *ReferenceImage(Image *image)
2129%
2130% A description of each parameter follows:
2131%
2132% o image: the image.
2133%
2134*/
2135MagickExport Image *ReferenceImage(Image *image)
2136{
2137 assert(image != (Image *) NULL);
2138 assert(image->signature == MagickCoreSignature);
2139 if (IsEventLogging() != MagickFalse)
2140 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2141 LockSemaphoreInfo(image->semaphore);
2142 image->reference_count++;
2143 UnlockSemaphoreInfo(image->semaphore);
2144 return(image);
2145}
2146
2147/*
2148%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2149% %
2150% %
2151% %
2152% R e s e t I m a g e P a g e %
2153% %
2154% %
2155% %
2156%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2157%
2158% ResetImagePage() resets the image page canvas and position.
2159%
2160% The format of the ResetImagePage method is:
2161%
2162% MagickBooleanType ResetImagePage(Image *image,const char *page)
2163%
2164% A description of each parameter follows:
2165%
2166% o image: the image.
2167%
2168% o page: the relative page specification.
2169%
2170*/
2171MagickExport MagickBooleanType ResetImagePage(Image *image,const char *page)
2172{
2173 MagickStatusType
2174 flags;
2175
2177 geometry;
2178
2179 assert(image != (Image *) NULL);
2180 assert(image->signature == MagickCoreSignature);
2181 if (IsEventLogging() != MagickFalse)
2182 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2183 flags=ParseAbsoluteGeometry(page,&geometry);
2184 if ((flags & WidthValue) != 0)
2185 {
2186 if ((flags & HeightValue) == 0)
2187 geometry.height=geometry.width;
2188 image->page.width=geometry.width;
2189 image->page.height=geometry.height;
2190 }
2191 if ((flags & AspectValue) != 0)
2192 {
2193 if ((flags & XValue) != 0)
2194 image->page.x+=geometry.x;
2195 if ((flags & YValue) != 0)
2196 image->page.y+=geometry.y;
2197 }
2198 else
2199 {
2200 if ((flags & XValue) != 0)
2201 {
2202 image->page.x=geometry.x;
2203 if ((image->page.width == 0) && (geometry.x > 0))
2204 image->page.width=(size_t) ((ssize_t) image->columns+geometry.x);
2205 }
2206 if ((flags & YValue) != 0)
2207 {
2208 image->page.y=geometry.y;
2209 if ((image->page.height == 0) && (geometry.y > 0))
2210 image->page.height=(size_t) ((ssize_t) image->rows+geometry.y);
2211 }
2212 }
2213 return(MagickTrue);
2214}
2215
2216/*
2217%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2218% %
2219% %
2220% %
2221% R e s e t I m a g e P i x e l s %
2222% %
2223% %
2224% %
2225%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2226%
2227% ResetImagePixels() reset the image pixels, that is, all the pixel components
2228% are zeroed.
2229%
2230% The format of the SetImage method is:
2231%
2232% MagickBooleanType ResetImagePixels(Image *image,
2233% ExceptionInfo *exception)
2234%
2235% A description of each parameter follows:
2236%
2237% o image: the image.
2238%
2239% o exception: return any errors or warnings in this structure.
2240%
2241*/
2242MagickExport MagickBooleanType ResetImagePixels(Image *image,
2243 ExceptionInfo *exception)
2244{
2245 CacheView
2246 *image_view;
2247
2248 MagickBooleanType
2249 status;
2250
2251 size_t
2252 length;
2253
2254 ssize_t
2255 y;
2256
2257 void
2258 *pixels;
2259
2260 assert(image != (Image *) NULL);
2261 assert(image->signature == MagickCoreSignature);
2262 if (IsEventLogging() != MagickFalse)
2263 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2264 pixels=AcquirePixelCachePixels(image,&length,exception);
2265 if (pixels != (void *) NULL)
2266 {
2267 /*
2268 Reset in-core image pixels.
2269 */
2270 (void) memset(pixels,0,length);
2271 return(MagickTrue);
2272 }
2273 /*
2274 Reset image pixels.
2275 */
2276 status=MagickTrue;
2277 image_view=AcquireAuthenticCacheView(image,exception);
2278#if defined(MAGICKCORE_OPENMP_SUPPORT)
2279 #pragma omp parallel for schedule(static) shared(status) \
2280 magick_number_threads(image,image,image->rows,2)
2281#endif
2282 for (y=0; y < (ssize_t) image->rows; y++)
2283 {
2284 Quantum
2285 *magick_restrict q;
2286
2287 ssize_t
2288 x;
2289
2290 if (status == MagickFalse)
2291 continue;
2292 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2293 if (q == (Quantum *) NULL)
2294 {
2295 status=MagickFalse;
2296 continue;
2297 }
2298 for (x=0; x < (ssize_t) image->columns; x++)
2299 {
2300 (void) memset(q,0,GetPixelChannels(image)*sizeof(Quantum));
2301 q+=GetPixelChannels(image);
2302 }
2303 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2304 status=MagickFalse;
2305 }
2306 image_view=DestroyCacheView(image_view);
2307 return(status);
2308}
2309
2310/*
2311%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2312% %
2313% %
2314% %
2315% S e t I m a g e A l p h a %
2316% %
2317% %
2318% %
2319%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2320%
2321% SetImageAlpha() sets the alpha levels of the image.
2322%
2323% The format of the SetImageAlpha method is:
2324%
2325% MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
2326% ExceptionInfo *exception)
2327%
2328% A description of each parameter follows:
2329%
2330% o image: the image.
2331%
2332% o alpha: the level of transparency: 0 is fully transparent and QuantumRange
2333% is fully opaque.
2334%
2335% o exception: return any errors or warnings in this structure.
2336%
2337*/
2338MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
2339 ExceptionInfo *exception)
2340{
2341 CacheView
2342 *image_view;
2343
2344 MagickBooleanType
2345 status;
2346
2347 ssize_t
2348 y;
2349
2350 assert(image != (Image *) NULL);
2351 assert(image->signature == MagickCoreSignature);
2352 if (IsEventLogging() != MagickFalse)
2353 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2354 image->alpha_trait=BlendPixelTrait;
2355 status=MagickTrue;
2356 image_view=AcquireAuthenticCacheView(image,exception);
2357#if defined(MAGICKCORE_OPENMP_SUPPORT)
2358 #pragma omp parallel for schedule(static) shared(status) \
2359 magick_number_threads(image,image,image->rows,2)
2360#endif
2361 for (y=0; y < (ssize_t) image->rows; y++)
2362 {
2363 Quantum
2364 *magick_restrict q;
2365
2366 ssize_t
2367 x;
2368
2369 if (status == MagickFalse)
2370 continue;
2371 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2372 if (q == (Quantum *) NULL)
2373 {
2374 status=MagickFalse;
2375 continue;
2376 }
2377 for (x=0; x < (ssize_t) image->columns; x++)
2378 {
2379 if (GetPixelWriteMask(image,q) > (QuantumRange/2))
2380 SetPixelAlpha(image,alpha,q);
2381 q+=GetPixelChannels(image);
2382 }
2383 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2384 status=MagickFalse;
2385 }
2386 image_view=DestroyCacheView(image_view);
2387 return(status);
2388}
2389
2390/*
2391%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2392% %
2393% %
2394% %
2395% S e t I m a g e B a c k g r o u n d C o l o r %
2396% %
2397% %
2398% %
2399%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2400%
2401% SetImageBackgroundColor() initializes the image pixels to the image
2402% background color. The background color is defined by the background_color
2403% member of the image structure.
2404%
2405% The format of the SetImage method is:
2406%
2407% MagickBooleanType SetImageBackgroundColor(Image *image,
2408% ExceptionInfo *exception)
2409%
2410% A description of each parameter follows:
2411%
2412% o image: the image.
2413%
2414% o exception: return any errors or warnings in this structure.
2415%
2416*/
2417MagickExport MagickBooleanType SetImageBackgroundColor(Image *image,
2418 ExceptionInfo *exception)
2419{
2420 CacheView
2421 *image_view;
2422
2423 MagickBooleanType
2424 status;
2425
2426 PixelInfo
2427 background;
2428
2429 ssize_t
2430 y;
2431
2432 assert(image != (Image *) NULL);
2433 assert(image->signature == MagickCoreSignature);
2434 if (IsEventLogging() != MagickFalse)
2435 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2436 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2437 return(MagickFalse);
2438 if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
2439 ((image->alpha_trait & BlendPixelTrait) == 0))
2440 (void) SetImageAlphaChannel(image,OnAlphaChannel,exception);
2441 ConformPixelInfo(image,&image->background_color,&background,exception);
2442 /*
2443 Set image background color.
2444 */
2445 status=MagickTrue;
2446 image_view=AcquireAuthenticCacheView(image,exception);
2447#if defined(MAGICKCORE_OPENMP_SUPPORT)
2448 #pragma omp parallel for schedule(static) shared(status) \
2449 magick_number_threads(image,image,image->rows,2)
2450#endif
2451 for (y=0; y < (ssize_t) image->rows; y++)
2452 {
2453 Quantum
2454 *magick_restrict q;
2455
2456 ssize_t
2457 x;
2458
2459 if (status == MagickFalse)
2460 continue;
2461 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2462 if (q == (Quantum *) NULL)
2463 {
2464 status=MagickFalse;
2465 continue;
2466 }
2467 for (x=0; x < (ssize_t) image->columns; x++)
2468 {
2469 SetPixelViaPixelInfo(image,&background,q);
2470 q+=GetPixelChannels(image);
2471 }
2472 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2473 status=MagickFalse;
2474 }
2475 image_view=DestroyCacheView(image_view);
2476 return(status);
2477}
2478
2479/*
2480%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2481% %
2482% %
2483% %
2484% S e t I m a g e C h a n n e l M a s k %
2485% %
2486% %
2487% %
2488%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2489%
2490% SetImageChannelMask() sets the image channel mask from the specified channel
2491% mask.
2492%
2493% The format of the SetImageChannelMask method is:
2494%
2495% ChannelType SetImageChannelMask(Image *image,
2496% const ChannelType channel_mask)
2497%
2498% A description of each parameter follows:
2499%
2500% o image: the image.
2501%
2502% o channel_mask: the channel mask.
2503%
2504*/
2505MagickExport ChannelType SetImageChannelMask(Image *image,
2506 const ChannelType channel_mask)
2507{
2508 return(SetPixelChannelMask(image,channel_mask));
2509}
2510
2511/*
2512%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2513% %
2514% %
2515% %
2516% S e t I m a g e C o l o r %
2517% %
2518% %
2519% %
2520%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2521%
2522% SetImageColor() set the entire image canvas to the specified color.
2523%
2524% The format of the SetImageColor method is:
2525%
2526% MagickBooleanType SetImageColor(Image *image,const PixelInfo *color,
2527% ExceptionInfo *exception)
2528%
2529% A description of each parameter follows:
2530%
2531% o image: the image.
2532%
2533% o background: the image color.
2534%
2535% o exception: return any errors or warnings in this structure.
2536%
2537*/
2538MagickExport MagickBooleanType SetImageColor(Image *image,
2539 const PixelInfo *color,ExceptionInfo *exception)
2540{
2541 CacheView
2542 *image_view;
2543
2544 MagickBooleanType
2545 status;
2546
2547 ssize_t
2548 y;
2549
2550 assert(image != (Image *) NULL);
2551 assert(image->signature == MagickCoreSignature);
2552 assert(color != (const PixelInfo *) NULL);
2553 if (IsEventLogging() != MagickFalse)
2554 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2555 image->colorspace=color->colorspace;
2556 image->alpha_trait=color->alpha_trait;
2557 image->fuzz=color->fuzz;
2558 image->depth=color->depth;
2559 status=MagickTrue;
2560 image_view=AcquireAuthenticCacheView(image,exception);
2561#if defined(MAGICKCORE_OPENMP_SUPPORT)
2562 #pragma omp parallel for schedule(static) shared(status) \
2563 magick_number_threads(image,image,image->rows,2)
2564#endif
2565 for (y=0; y < (ssize_t) image->rows; y++)
2566 {
2567 Quantum
2568 *magick_restrict q;
2569
2570 ssize_t
2571 x;
2572
2573 if (status == MagickFalse)
2574 continue;
2575 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2576 if (q == (Quantum *) NULL)
2577 {
2578 status=MagickFalse;
2579 continue;
2580 }
2581 for (x=0; x < (ssize_t) image->columns; x++)
2582 {
2583 SetPixelViaPixelInfo(image,color,q);
2584 q+=GetPixelChannels(image);
2585 }
2586 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2587 status=MagickFalse;
2588 }
2589 image_view=DestroyCacheView(image_view);
2590 return(status);
2591}
2592
2593/*
2594%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2595% %
2596% %
2597% %
2598% S e t I m a g e S t o r a g e C l a s s %
2599% %
2600% %
2601% %
2602%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2603%
2604% SetImageStorageClass() sets the image class: DirectClass for true color
2605% images or PseudoClass for colormapped images.
2606%
2607% The format of the SetImageStorageClass method is:
2608%
2609% MagickBooleanType SetImageStorageClass(Image *image,
2610% const ClassType storage_class,ExceptionInfo *exception)
2611%
2612% A description of each parameter follows:
2613%
2614% o image: the image.
2615%
2616% o storage_class: The image class.
2617%
2618% o exception: return any errors or warnings in this structure.
2619%
2620*/
2621MagickExport MagickBooleanType SetImageStorageClass(Image *image,
2622 const ClassType storage_class,ExceptionInfo *exception)
2623{
2624 assert(image != (Image *) NULL);
2625 assert(image->signature == MagickCoreSignature);
2626 assert(exception != (ExceptionInfo *) NULL);
2627 assert(exception->signature == MagickCoreSignature);
2628 if (IsEventLogging() != MagickFalse)
2629 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2630 image->storage_class=storage_class;
2631 return(SyncImagePixelCache(image,exception));
2632}
2633
2634/*
2635%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2636% %
2637% %
2638% %
2639% S e t I m a g e E x t e n t %
2640% %
2641% %
2642% %
2643%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2644%
2645% SetImageExtent() sets the image size (i.e. columns & rows).
2646%
2647% The format of the SetImageExtent method is:
2648%
2649% MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2650% const size_t rows,ExceptionInfo *exception)
2651%
2652% A description of each parameter follows:
2653%
2654% o image: the image.
2655%
2656% o columns: The image width in pixels.
2657%
2658% o rows: The image height in pixels.
2659%
2660% o exception: return any errors or warnings in this structure.
2661%
2662*/
2663MagickExport MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2664 const size_t rows,ExceptionInfo *exception)
2665{
2666 if ((columns == 0) || (rows == 0))
2667 ThrowBinaryException(ImageError,"NegativeOrZeroImageSize",image->filename);
2668 image->columns=columns;
2669 image->rows=rows;
2670 if (image->depth == 0)
2671 {
2672 image->depth=8;
2673 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2674 "ImageDepthNotSupported","`%s'",image->filename);
2675 }
2676 if (image->depth > (8*sizeof(MagickSizeType)))
2677 {
2678 image->depth=8*sizeof(MagickSizeType);
2679 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2680 "ImageDepthNotSupported","`%s'",image->filename);
2681 }
2682 return(SyncImagePixelCache(image,exception));
2683}
2684
2685/*
2686%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2687% %
2688% %
2689% %
2690+ S e t I m a g e I n f o %
2691% %
2692% %
2693% %
2694%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2695%
2696% SetImageInfo() initializes the 'magick' field of the ImageInfo structure.
2697% It is set to a type of image format based on the prefix or suffix of the
2698% filename. For example, 'ps:image' returns PS indicating a Postscript image.
2699% JPEG is returned for this filename: 'image.jpg'. The filename prefix has
2700% precedence over the suffix. Use an optional index enclosed in brackets
2701% after a file name to specify a desired scene of a multi-resolution image
2702% format like Photo CD (e.g. img0001.pcd[4]). A True (non-zero) return value
2703% indicates success.
2704%
2705% The format of the SetImageInfo method is:
2706%
2707% MagickBooleanType SetImageInfo(ImageInfo *image_info,
2708% const unsigned int frames,ExceptionInfo *exception)
2709%
2710% A description of each parameter follows:
2711%
2712% o image_info: the image info.
2713%
2714% o frames: the number of images you intend to write.
2715%
2716% o exception: return any errors or warnings in this structure.
2717%
2718*/
2719
2720static const MagickInfo *SetImageInfoFromExtension(ImageInfo *image_info,
2721 const char *component,char *magic,ExceptionInfo *exception)
2722{
2723 const MagickInfo
2724 *magick_info;
2725
2726 MagickFormatType
2727 format_type;
2728
2729 ssize_t
2730 i;
2731
2732 static const char
2733 *format_type_formats[] =
2734 {
2735 "AUTOTRACE",
2736 "BROWSE",
2737 "DCRAW",
2738 "EDIT",
2739 "LAUNCH",
2740 "MPEG:DECODE",
2741 "MPEG:ENCODE",
2742 "PRINT",
2743 "PS:ALPHA",
2744 "PS:CMYK",
2745 "PS:COLOR",
2746 "PS:GRAY",
2747 "PS:MONO",
2748 "SCAN",
2749 "SHOW",
2750 "WIN",
2751 (char *) NULL
2752 };
2753
2754 /*
2755 User specified image format.
2756 */
2757 (void) CopyMagickString(magic,component,MagickPathExtent);
2758 LocaleUpper(magic);
2759 /*
2760 Look for explicit image formats.
2761 */
2762 format_type=UndefinedFormatType;
2763 magick_info=GetMagickInfo(magic,exception);
2764 if ((magick_info != (const MagickInfo *) NULL) &&
2765 (magick_info->format_type != UndefinedFormatType))
2766 format_type=magick_info->format_type;
2767 i=0;
2768 while ((format_type == UndefinedFormatType) &&
2769 (format_type_formats[i] != (char *) NULL))
2770 {
2771 if ((*magic == *format_type_formats[i]) &&
2772 (LocaleCompare(magic,format_type_formats[i]) == 0))
2773 format_type=ExplicitFormatType;
2774 i++;
2775 }
2776 if (format_type == UndefinedFormatType)
2777 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2778 else
2779 if (format_type == ExplicitFormatType)
2780 {
2781 image_info->affirm=MagickTrue;
2782 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2783 }
2784 if (LocaleCompare(magic,"RGB") == 0)
2785 image_info->affirm=MagickFalse; /* maybe SGI disguised as RGB */
2786 return(magick_info);
2787}
2788
2789MagickExport MagickBooleanType SetImageInfo(ImageInfo *image_info,
2790 const unsigned int frames,ExceptionInfo *exception)
2791{
2792 char
2793 component[MagickPathExtent],
2794 magic[MagickPathExtent],
2795 path[MagickPathExtent],
2796 *q;
2797
2798 const MagicInfo
2799 *magic_info;
2800
2801 const MagickInfo
2802 *magick_info;
2803
2805 *sans_exception;
2806
2807 Image
2808 *image;
2809
2810 MagickBooleanType
2811 status;
2812
2813 const char
2814 *p;
2815
2816 ssize_t
2817 count;
2818
2819 /*
2820 Look for 'image.format' in filename.
2821 */
2822 assert(image_info != (ImageInfo *) NULL);
2823 assert(image_info->signature == MagickCoreSignature);
2824 if (IsEventLogging() != MagickFalse)
2825 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2826 image_info->filename);
2827 *component='\0';
2828 GetPathComponent(image_info->filename,SubimagePath,component);
2829 if (*component != '\0')
2830 {
2831 /*
2832 Look for scene specification (e.g. img0001.pcd[4]).
2833 */
2834 if (IsSceneGeometry(component,MagickFalse) == MagickFalse)
2835 {
2836 if (IsGeometry(component) != MagickFalse)
2837 (void) CloneString(&image_info->extract,component);
2838 }
2839 else
2840 {
2841 size_t
2842 first,
2843 last;
2844
2845 (void) CloneString(&image_info->scenes,component);
2846 image_info->scene=StringToUnsignedLong(image_info->scenes);
2847 image_info->number_scenes=image_info->scene;
2848 p=image_info->scenes;
2849 for (q=(char *) image_info->scenes; *q != '\0'; p++)
2850 {
2851 while ((isspace((int) ((unsigned char) *p)) != 0) || (*p == ','))
2852 p++;
2853 first=(size_t) strtol(p,&q,10);
2854 last=first;
2855 while (isspace((int) ((unsigned char) *q)) != 0)
2856 q++;
2857 if (*q == '-')
2858 last=(size_t) strtol(q+1,&q,10);
2859 if (first > last)
2860 Swap(first,last);
2861 if (first < image_info->scene)
2862 image_info->scene=first;
2863 if (last > image_info->number_scenes)
2864 image_info->number_scenes=last;
2865 p=q;
2866 }
2867 image_info->number_scenes-=image_info->scene-1;
2868 }
2869 }
2870 *component='\0';
2871 if (*image_info->magick == '\0')
2872 GetPathComponent(image_info->filename,ExtensionPath,component);
2873 if (*component != '\0')
2874 {
2875 /*
2876 Base path sans any compression extension.
2877 */
2878 GetPathComponent(image_info->filename,BasePathSansCompressExtension,path);
2879 GetPathComponent(path,ExtensionPath,component);
2880 }
2881 image_info->affirm=MagickFalse;
2882 sans_exception=AcquireExceptionInfo();
2883 if ((*component != '\0') && (IsGlob(component) == MagickFalse))
2884 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2885 sans_exception);
2886 /*
2887 Look for explicit 'format:image' in filename.
2888 */
2889 *magic='\0';
2890 GetPathComponent(image_info->filename,MagickPath,magic);
2891 if (*magic == '\0')
2892 {
2893 (void) CopyMagickString(magic,image_info->magick,MagickPathExtent);
2894 magick_info=GetMagickInfo(magic,sans_exception);
2895 if ((magick_info != (const MagickInfo *) NULL) &&
2896 (magick_info->format_type == ExplicitFormatType))
2897 image_info->affirm=MagickTrue;
2898 if (frames == 0)
2899 GetPathComponent(image_info->filename,CanonicalPath,component);
2900 else
2901 GetPathComponent(image_info->filename,SubcanonicalPath,component);
2902 (void) CopyMagickString(image_info->filename,component,MagickPathExtent);
2903 }
2904 else
2905 {
2906 const DelegateInfo
2907 *delegate_info;
2908
2909 /*
2910 User specified image format.
2911 */
2912 LocaleUpper(magic);
2913 magick_info=GetMagickInfo(magic,sans_exception);
2914 delegate_info=(const DelegateInfo *) NULL;
2915 if (magick_info == (const MagickInfo *) NULL)
2916 {
2917 delegate_info=GetDelegateInfo(magic,"*",sans_exception);
2918 if (delegate_info == (const DelegateInfo *) NULL)
2919 delegate_info=GetDelegateInfo("*",magic,sans_exception);
2920 if ((delegate_info == (const DelegateInfo *) NULL) &&
2921 ((*component != '\0') && (IsGlob(component) == MagickFalse)))
2922 {
2923 /*
2924 Retry in case GetMagickInfo loaded a custom module.
2925 */
2926 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2927 sans_exception);
2928 }
2929 }
2930 if (((magick_info != (const MagickInfo *) NULL) ||
2931 (delegate_info != (const DelegateInfo *) NULL)) &&
2932 (IsMagickConflict(magic) == MagickFalse))
2933 {
2934 image_info->affirm=MagickTrue;
2935 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2936 GetPathComponent(image_info->filename,CanonicalPath,component);
2937 (void) CopyMagickString(image_info->filename,component,
2938 MagickPathExtent);
2939 }
2940 }
2941 sans_exception=DestroyExceptionInfo(sans_exception);
2942 if ((magick_info == (const MagickInfo *) NULL) ||
2943 (GetMagickEndianSupport(magick_info) == MagickFalse))
2944 image_info->endian=UndefinedEndian;
2945 if ((image_info->adjoin != MagickFalse) && (frames > 1))
2946 {
2947 /*
2948 Test for multiple image support (e.g. image%02d.png).
2949 */
2950 (void) InterpretImageFilename(image_info,(Image *) NULL,
2951 image_info->filename,(int) image_info->scene,component,exception);
2952 if ((LocaleCompare(component,image_info->filename) != 0) &&
2953 (strchr(component,'%') == (char *) NULL))
2954 image_info->adjoin=MagickFalse;
2955 }
2956 if ((image_info->adjoin != MagickFalse) && (frames > 0))
2957 {
2958 /*
2959 Some image formats do not support multiple frames per file.
2960 */
2961 magick_info=GetMagickInfo(magic,exception);
2962 if (magick_info != (const MagickInfo *) NULL)
2963 if (GetMagickAdjoin(magick_info) == MagickFalse)
2964 image_info->adjoin=MagickFalse;
2965 }
2966 if (image_info->affirm != MagickFalse)
2967 return(MagickTrue);
2968 if (frames == 0)
2969 {
2970 unsigned char
2971 *magick;
2972
2973 size_t
2974 magick_size;
2975
2976 /*
2977 Determine the image format from the first few bytes of the file.
2978 */
2979 magick_size=GetMagicPatternExtent(exception);
2980 if (magick_size == 0)
2981 return(MagickFalse);
2982 image=AcquireImage(image_info,exception);
2983 (void) CopyMagickString(image->filename,image_info->filename,
2984 MagickPathExtent);
2985 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
2986 if (status == MagickFalse)
2987 {
2988 image=DestroyImage(image);
2989 return(MagickFalse);
2990 }
2991 if ((IsBlobSeekable(image) == MagickFalse) ||
2992 (IsBlobExempt(image) != MagickFalse))
2993 {
2994 /*
2995 Copy image to seekable temporary file.
2996 */
2997 *component='\0';
2998 status=ImageToFile(image,component,exception);
2999 if (CloseBlob(image) == MagickFalse)
3000 status=MagickFalse;
3001 if (status == MagickFalse)
3002 {
3003 (void) RelinquishUniqueFileResource(component);
3004 image=DestroyImage(image);
3005 return(MagickFalse);
3006 }
3007 SetImageInfoFile(image_info,(FILE *) NULL);
3008 (void) CopyMagickString(image->filename,component,MagickPathExtent);
3009 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
3010 if (status == MagickFalse)
3011 {
3012 (void) RelinquishUniqueFileResource(component);
3013 image=DestroyImage(image);
3014 return(MagickFalse);
3015 }
3016 (void) CopyMagickString(image_info->filename,component,
3017 MagickPathExtent);
3018 image_info->temporary=MagickTrue;
3019 }
3020 magick=(unsigned char *) AcquireQuantumMemory(1,magick_size);
3021 if (magick == (unsigned char *) NULL)
3022 {
3023 (void) CloseBlob(image);
3024 image=DestroyImage(image);
3025 return(MagickFalse);
3026 }
3027 (void) memset(magick,0,magick_size);
3028 count=ReadBlob(image,magick_size,magick);
3029 (void) SeekBlob(image,-((MagickOffsetType) count),SEEK_CUR);
3030 (void) CloseBlob(image);
3031 image=DestroyImage(image);
3032 /*
3033 Check magic cache.
3034 */
3035 sans_exception=AcquireExceptionInfo();
3036 magic_info=GetMagicInfo(magick,(size_t) count,sans_exception);
3037 magick=(unsigned char *) RelinquishMagickMemory(magick);
3038 if ((magic_info != (const MagicInfo *) NULL) &&
3039 (GetMagicName(magic_info) != (char *) NULL))
3040 {
3041 /*
3042 Try to use magick_info that was determined earlier by the extension
3043 */
3044 if ((magick_info != (const MagickInfo *) NULL) &&
3045 (GetMagickUseExtension(magick_info) != MagickFalse) &&
3046 (LocaleCompare(magick_info->magick_module,GetMagicName(
3047 magic_info)) == 0))
3048 (void) CopyMagickString(image_info->magick,magick_info->name,
3049 MagickPathExtent);
3050 else
3051 {
3052 (void) CopyMagickString(image_info->magick,GetMagicName(
3053 magic_info),MagickPathExtent);
3054 magick_info=GetMagickInfo(image_info->magick,sans_exception);
3055 }
3056 if ((magick_info == (const MagickInfo *) NULL) ||
3057 (GetMagickEndianSupport(magick_info) == MagickFalse))
3058 image_info->endian=UndefinedEndian;
3059 sans_exception=DestroyExceptionInfo(sans_exception);
3060 return(MagickTrue);
3061 }
3062 magick_info=GetMagickInfo(image_info->magick,sans_exception);
3063 if ((magick_info == (const MagickInfo *) NULL) ||
3064 (GetMagickEndianSupport(magick_info) == MagickFalse))
3065 image_info->endian=UndefinedEndian;
3066 sans_exception=DestroyExceptionInfo(sans_exception);
3067 }
3068 return(MagickTrue);
3069}
3070
3071/*
3072%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3073% %
3074% %
3075% %
3076% S e t I m a g e I n f o B l o b %
3077% %
3078% %
3079% %
3080%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3081%
3082% SetImageInfoBlob() sets the image info blob member.
3083%
3084% The format of the SetImageInfoBlob method is:
3085%
3086% void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3087% const size_t length)
3088%
3089% A description of each parameter follows:
3090%
3091% o image_info: the image info.
3092%
3093% o blob: the blob.
3094%
3095% o length: the blob length.
3096%
3097*/
3098MagickExport void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3099 const size_t length)
3100{
3101 assert(image_info != (ImageInfo *) NULL);
3102 assert(image_info->signature == MagickCoreSignature);
3103 if (IsEventLogging() != MagickFalse)
3104 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3105 image_info->filename);
3106 image_info->blob=(void *) blob;
3107 image_info->length=length;
3108}
3109
3110/*
3111%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3112% %
3113% %
3114% %
3115% S e t I m a g e I n f o C u s t o m S t r e a m %
3116% %
3117% %
3118% %
3119%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3120%
3121% SetImageInfoCustomStream() sets the image info custom stream handlers.
3122%
3123% The format of the SetImageInfoCustomStream method is:
3124%
3125% void SetImageInfoCustomStream(ImageInfo *image_info,
3126% CustomStreamInfo *custom_stream)
3127%
3128% A description of each parameter follows:
3129%
3130% o image_info: the image info.
3131%
3132% o custom_stream: your custom stream methods.
3133%
3134*/
3135MagickExport void SetImageInfoCustomStream(ImageInfo *image_info,
3136 CustomStreamInfo *custom_stream)
3137{
3138 assert(image_info != (ImageInfo *) NULL);
3139 assert(image_info->signature == MagickCoreSignature);
3140 if (IsEventLogging() != MagickFalse)
3141 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3142 image_info->filename);
3143 image_info->custom_stream=(CustomStreamInfo *) custom_stream;
3144}
3145
3146/*
3147%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3148% %
3149% %
3150% %
3151% S e t I m a g e I n f o F i l e %
3152% %
3153% %
3154% %
3155%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3156%
3157% SetImageInfoFile() sets the image info file member.
3158%
3159% The format of the SetImageInfoFile method is:
3160%
3161% void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3162%
3163% A description of each parameter follows:
3164%
3165% o image_info: the image info.
3166%
3167% o file: the file.
3168%
3169*/
3170MagickExport void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3171{
3172 assert(image_info != (ImageInfo *) NULL);
3173 assert(image_info->signature == MagickCoreSignature);
3174 if (IsEventLogging() != MagickFalse)
3175 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3176 image_info->filename);
3177 image_info->file=file;
3178}
3179
3180/*
3181%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3182% %
3183% %
3184% %
3185% S e t I m a g e M a s k %
3186% %
3187% %
3188% %
3189%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3190%
3191% SetImageMask() associates a mask with the image. The mask must be the same
3192% dimensions as the image.
3193%
3194% The format of the SetImageMask method is:
3195%
3196% MagickBooleanType SetImageMask(Image *image,const PixelMask type,
3197% const Image *mask,ExceptionInfo *exception)
3198%
3199% A description of each parameter follows:
3200%
3201% o image: the image.
3202%
3203% o type: the mask type, ReadPixelMask or WritePixelMask.
3204%
3205% o mask: the image mask.
3206%
3207% o exception: return any errors or warnings in this structure.
3208%
3209*/
3210MagickExport MagickBooleanType SetImageMask(Image *image,const PixelMask type,
3211 const Image *mask,ExceptionInfo *exception)
3212{
3213 CacheView
3214 *mask_view,
3215 *image_view;
3216
3217 MagickBooleanType
3218 status;
3219
3220 ssize_t
3221 y;
3222
3223 /*
3224 Set image mask.
3225 */
3226 assert(image != (Image *) NULL);
3227 if (IsEventLogging() != MagickFalse)
3228 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3229 assert(image->signature == MagickCoreSignature);
3230 if (mask == (const Image *) NULL)
3231 {
3232 switch (type)
3233 {
3234 case ReadPixelMask:
3235 {
3236 image->channels=(ChannelType) ((unsigned int) image->channels &
3237 (unsigned int) ~ReadMaskChannel);
3238 break;
3239 }
3240 case WritePixelMask:
3241 {
3242 image->channels=(ChannelType) ((unsigned int) image->channels &
3243 (unsigned int) ~WriteMaskChannel);
3244 magick_fallthrough;
3245 }
3246 default:
3247 {
3248 image->channels=(ChannelType) ((unsigned int) image->channels &
3249 (unsigned int) ~CompositeMaskChannel);
3250 break;
3251 }
3252 }
3253 return(SyncImagePixelCache(image,exception));
3254 }
3255 switch (type)
3256 {
3257 case ReadPixelMask:
3258 {
3259 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3260 break;
3261 }
3262 case WritePixelMask:
3263 {
3264 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3265 break;
3266 }
3267 default:
3268 {
3269 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3270 break;
3271 }
3272 }
3273 if (SyncImagePixelCache(image,exception) == MagickFalse)
3274 return(MagickFalse);
3275 status=MagickTrue;
3276 image->mask_trait=UpdatePixelTrait;
3277 mask_view=AcquireVirtualCacheView(mask,exception);
3278 image_view=AcquireAuthenticCacheView(image,exception);
3279#if defined(MAGICKCORE_OPENMP_SUPPORT)
3280 #pragma omp parallel for schedule(static) shared(status) \
3281 magick_number_threads(mask,image,image->rows,2)
3282#endif
3283 for (y=0; y < (ssize_t) image->rows; y++)
3284 {
3285 const Quantum
3286 *magick_restrict p;
3287
3288 Quantum
3289 *magick_restrict q;
3290
3291 ssize_t
3292 x;
3293
3294 if (status == MagickFalse)
3295 continue;
3296 p=GetCacheViewVirtualPixels(mask_view,0,y,mask->columns,1,exception);
3297 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3298 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3299 {
3300 status=MagickFalse;
3301 continue;
3302 }
3303 for (x=0; x < (ssize_t) image->columns; x++)
3304 {
3305 MagickRealType
3306 intensity;
3307
3308 intensity=0.0;
3309 if ((x < (ssize_t) mask->columns) && (y < (ssize_t) mask->rows))
3310 intensity=GetPixelIntensity(mask,p);
3311 switch (type)
3312 {
3313 case ReadPixelMask:
3314 {
3315 SetPixelReadMask(image,ClampToQuantum(intensity),q);
3316 break;
3317 }
3318 case WritePixelMask:
3319 {
3320 SetPixelWriteMask(image,ClampToQuantum(intensity),q);
3321 break;
3322 }
3323 default:
3324 {
3325 SetPixelCompositeMask(image,ClampToQuantum(intensity),q);
3326 break;
3327 }
3328 }
3329 p+=GetPixelChannels(mask);
3330 q+=GetPixelChannels(image);
3331 }
3332 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3333 status=MagickFalse;
3334 }
3335 image->mask_trait=UndefinedPixelTrait;
3336 mask_view=DestroyCacheView(mask_view);
3337 image_view=DestroyCacheView(image_view);
3338 return(status);
3339}
3340
3341/*
3342%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3343% %
3344% %
3345% %
3346% S e t I m a g e R e g i o n M a s k %
3347% %
3348% %
3349% %
3350%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3351%
3352% SetImageRegionMask() associates a mask with the image as defined by the
3353% specified region.
3354%
3355% The format of the SetImageRegionMask method is:
3356%
3357% MagickBooleanType SetImageRegionMask(Image *image,const PixelMask type,
3358% const RectangleInfo *region,ExceptionInfo *exception)
3359%
3360% A description of each parameter follows:
3361%
3362% o image: the image.
3363%
3364% o type: the mask type, ReadPixelMask or WritePixelMask.
3365%
3366% o geometry: the mask region.
3367%
3368% o exception: return any errors or warnings in this structure.
3369%
3370*/
3371MagickExport MagickBooleanType SetImageRegionMask(Image *image,
3372 const PixelMask type,const RectangleInfo *region,ExceptionInfo *exception)
3373{
3374 CacheView
3375 *image_view;
3376
3377 MagickBooleanType
3378 status;
3379
3380 ssize_t
3381 y;
3382
3383 /*
3384 Set image mask as defined by the region.
3385 */
3386 assert(image != (Image *) NULL);
3387 assert(image->signature == MagickCoreSignature);
3388 if (IsEventLogging() != MagickFalse)
3389 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3390 if (region == (const RectangleInfo *) NULL)
3391 {
3392 switch (type)
3393 {
3394 case ReadPixelMask:
3395 {
3396 image->channels=(ChannelType) ((unsigned int) image->channels &
3397 (unsigned int) ~ReadMaskChannel);
3398 break;
3399 }
3400 case WritePixelMask:
3401 {
3402 image->channels=(ChannelType) ((unsigned int) image->channels &
3403 (unsigned int) ~WriteMaskChannel);
3404 break;
3405 }
3406 default:
3407 {
3408 image->channels=(ChannelType) ((unsigned int) image->channels &
3409 (unsigned int) ~CompositeMaskChannel);
3410 break;
3411 }
3412 }
3413 return(SyncImagePixelCache(image,exception));
3414 }
3415 switch (type)
3416 {
3417 case ReadPixelMask:
3418 {
3419 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3420 break;
3421 }
3422 case WritePixelMask:
3423 {
3424 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3425 break;
3426 }
3427 default:
3428 {
3429 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3430 break;
3431 }
3432 }
3433 if (SyncImagePixelCache(image,exception) == MagickFalse)
3434 return(MagickFalse);
3435 status=MagickTrue;
3436 image->mask_trait=UpdatePixelTrait;
3437 image_view=AcquireAuthenticCacheView(image,exception);
3438#if defined(MAGICKCORE_OPENMP_SUPPORT)
3439 #pragma omp parallel for schedule(static) shared(status) \
3440 magick_number_threads(image,image,image->rows,2)
3441#endif
3442 for (y=0; y < (ssize_t) image->rows; y++)
3443 {
3444 Quantum
3445 *magick_restrict q;
3446
3447 ssize_t
3448 x;
3449
3450 if (status == MagickFalse)
3451 continue;
3452 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3453 if (q == (Quantum *) NULL)
3454 {
3455 status=MagickFalse;
3456 continue;
3457 }
3458 for (x=0; x < (ssize_t) image->columns; x++)
3459 {
3460 Quantum
3461 pixel;
3462
3463 pixel=QuantumRange;
3464 if (((x >= region->x) && (x < (region->x+(ssize_t) region->width))) &&
3465 ((y >= region->y) && (y < (region->y+(ssize_t) region->height))))
3466 pixel=(Quantum) 0;
3467 switch (type)
3468 {
3469 case ReadPixelMask:
3470 {
3471 SetPixelReadMask(image,pixel,q);
3472 break;
3473 }
3474 case WritePixelMask:
3475 {
3476 SetPixelWriteMask(image,pixel,q);
3477 break;
3478 }
3479 default:
3480 {
3481 SetPixelCompositeMask(image,pixel,q);
3482 break;
3483 }
3484 }
3485 q+=GetPixelChannels(image);
3486 }
3487 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3488 status=MagickFalse;
3489 }
3490 image->mask_trait=UndefinedPixelTrait;
3491 image_view=DestroyCacheView(image_view);
3492 return(status);
3493}
3494
3495/*
3496%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3497% %
3498% %
3499% %
3500% 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 %
3501% %
3502% %
3503% %
3504%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3505%
3506% SetImageVirtualPixelMethod() sets the "virtual pixels" method for the
3507% image and returns the previous setting. A virtual pixel is any pixel access
3508% that is outside the boundaries of the image cache.
3509%
3510% The format of the SetImageVirtualPixelMethod() method is:
3511%
3512% VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3513% const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3514%
3515% A description of each parameter follows:
3516%
3517% o image: the image.
3518%
3519% o virtual_pixel_method: choose the type of virtual pixel.
3520%
3521% o exception: return any errors or warnings in this structure.
3522%
3523*/
3524MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3525 const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3526{
3527 assert(image != (const Image *) NULL);
3528 assert(image->signature == MagickCoreSignature);
3529 if (IsEventLogging() != MagickFalse)
3530 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3531 return(SetPixelCacheVirtualMethod(image,virtual_pixel_method,exception));
3532}
3533
3534/*
3535%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3536% %
3537% %
3538% %
3539% S m u s h I m a g e s %
3540% %
3541% %
3542% %
3543%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3544%
3545% SmushImages() takes all images from the current image pointer to the end
3546% of the image list and smushes them to each other top-to-bottom if the
3547% stack parameter is true, otherwise left-to-right.
3548%
3549% The current gravity setting now effects how the image is justified in the
3550% final image.
3551%
3552% The format of the SmushImages method is:
3553%
3554% Image *SmushImages(const Image *images,const MagickBooleanType stack,
3555% ExceptionInfo *exception)
3556%
3557% A description of each parameter follows:
3558%
3559% o images: the image sequence.
3560%
3561% o stack: A value other than 0 stacks the images top-to-bottom.
3562%
3563% o offset: minimum distance in pixels between images.
3564%
3565% o exception: return any errors or warnings in this structure.
3566%
3567*/
3568
3569static ssize_t SmushXGap(const Image *smush_image,const Image *images,
3570 const ssize_t offset,ExceptionInfo *exception)
3571{
3572 CacheView
3573 *left_view,
3574 *right_view;
3575
3576 const Image
3577 *left_image,
3578 *right_image;
3579
3581 left_geometry,
3582 right_geometry;
3583
3584 const Quantum
3585 *p;
3586
3587 ssize_t
3588 i,
3589 y;
3590
3591 size_t
3592 gap;
3593
3594 ssize_t
3595 x;
3596
3597 if (images->previous == (Image *) NULL)
3598 return(0);
3599 right_image=images;
3600 SetGeometry(smush_image,&right_geometry);
3601 GravityAdjustGeometry(right_image->columns,right_image->rows,
3602 right_image->gravity,&right_geometry);
3603 left_image=images->previous;
3604 SetGeometry(smush_image,&left_geometry);
3605 GravityAdjustGeometry(left_image->columns,left_image->rows,
3606 left_image->gravity,&left_geometry);
3607 gap=right_image->columns;
3608 left_view=AcquireVirtualCacheView(left_image,exception);
3609 right_view=AcquireVirtualCacheView(right_image,exception);
3610 for (y=0; y < (ssize_t) smush_image->rows; y++)
3611 {
3612 for (x=(ssize_t) left_image->columns-1; x > 0; x--)
3613 {
3614 p=GetCacheViewVirtualPixels(left_view,x,left_geometry.y+y,1,1,exception);
3615 if ((p == (const Quantum *) NULL) ||
3616 (GetPixelAlpha(left_image,p) != TransparentAlpha) ||
3617 (((ssize_t) left_image->columns-x-1) >= (ssize_t) gap))
3618 break;
3619 }
3620 i=(ssize_t) left_image->columns-x-1;
3621 for (x=0; x < (ssize_t) right_image->columns; x++)
3622 {
3623 p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1,
3624 exception);
3625 if ((p == (const Quantum *) NULL) ||
3626 (GetPixelAlpha(right_image,p) != TransparentAlpha) ||
3627 ((x+i) >= (ssize_t) gap))
3628 break;
3629 }
3630 if ((x+i) < (ssize_t) gap)
3631 gap=(size_t) (x+i);
3632 }
3633 right_view=DestroyCacheView(right_view);
3634 left_view=DestroyCacheView(left_view);
3635 if (y < (ssize_t) smush_image->rows)
3636 return(offset);
3637 return((ssize_t) gap-offset);
3638}
3639
3640static ssize_t SmushYGap(const Image *smush_image,const Image *images,
3641 const ssize_t offset,ExceptionInfo *exception)
3642{
3643 CacheView
3644 *bottom_view,
3645 *top_view;
3646
3647 const Image
3648 *bottom_image,
3649 *top_image;
3650
3652 bottom_geometry,
3653 top_geometry;
3654
3655 const Quantum
3656 *p;
3657
3658 ssize_t
3659 i,
3660 x;
3661
3662 size_t
3663 gap;
3664
3665 ssize_t
3666 y;
3667
3668 if (images->previous == (Image *) NULL)
3669 return(0);
3670 bottom_image=images;
3671 SetGeometry(smush_image,&bottom_geometry);
3672 GravityAdjustGeometry(bottom_image->columns,bottom_image->rows,
3673 bottom_image->gravity,&bottom_geometry);
3674 top_image=images->previous;
3675 SetGeometry(smush_image,&top_geometry);
3676 GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
3677 &top_geometry);
3678 gap=bottom_image->rows;
3679 top_view=AcquireVirtualCacheView(top_image,exception);
3680 bottom_view=AcquireVirtualCacheView(bottom_image,exception);
3681 for (x=0; x < (ssize_t) smush_image->columns; x++)
3682 {
3683 for (y=(ssize_t) top_image->rows-1; y > 0; y--)
3684 {
3685 p=GetCacheViewVirtualPixels(top_view,top_geometry.x+x,y,1,1,exception);
3686 if ((p == (const Quantum *) NULL) ||
3687 (GetPixelAlpha(top_image,p) != TransparentAlpha) ||
3688 (((ssize_t) top_image->rows-y-1) >= (ssize_t) gap))
3689 break;
3690 }
3691 i=(ssize_t) top_image->rows-y-1;
3692 for (y=0; y < (ssize_t) bottom_image->rows; y++)
3693 {
3694 p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1,
3695 exception);
3696 if ((p == (const Quantum *) NULL) ||
3697 (GetPixelAlpha(bottom_image,p) != TransparentAlpha) ||
3698 ((y+i) >= (ssize_t) gap))
3699 break;
3700 }
3701 if ((y+i) < (ssize_t) gap)
3702 gap=(size_t) (y+i);
3703 }
3704 bottom_view=DestroyCacheView(bottom_view);
3705 top_view=DestroyCacheView(top_view);
3706 if (x < (ssize_t) smush_image->columns)
3707 return(offset);
3708 return((ssize_t) gap-offset);
3709}
3710
3711MagickExport Image *SmushImages(const Image *images,
3712 const MagickBooleanType stack,const ssize_t offset,ExceptionInfo *exception)
3713{
3714#define SmushImageTag "Smush/Image"
3715
3716 const Image
3717 *image;
3718
3719 Image
3720 *smush_image;
3721
3722 MagickBooleanType
3723 proceed,
3724 status;
3725
3726 MagickOffsetType
3727 n;
3728
3729 PixelTrait
3730 alpha_trait;
3731
3733 geometry;
3734
3735 const Image
3736 *next;
3737
3738 size_t
3739 height,
3740 number_images,
3741 width;
3742
3743 ssize_t
3744 x_offset,
3745 y_offset;
3746
3747 /*
3748 Compute maximum area of smushed area.
3749 */
3750 assert(images != (Image *) NULL);
3751 assert(images->signature == MagickCoreSignature);
3752 assert(exception != (ExceptionInfo *) NULL);
3753 assert(exception->signature == MagickCoreSignature);
3754 if (IsEventLogging() != MagickFalse)
3755 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3756 image=images;
3757 alpha_trait=image->alpha_trait;
3758 number_images=1;
3759 width=image->columns;
3760 height=image->rows;
3761 next=GetNextImageInList(image);
3762 for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
3763 {
3764 if (next->alpha_trait != UndefinedPixelTrait)
3765 alpha_trait=BlendPixelTrait;
3766 number_images++;
3767 if (stack != MagickFalse)
3768 {
3769 if (next->columns > width)
3770 width=next->columns;
3771 height+=next->rows;
3772 if (next->previous != (Image *) NULL)
3773 height=(size_t) MagickMax((ssize_t) height+offset,0U);
3774 continue;
3775 }
3776 width+=next->columns;
3777 if (next->previous != (Image *) NULL)
3778 width=(size_t) MagickMax((ssize_t) width+offset,0U);
3779 if (next->rows > height)
3780 height=next->rows;
3781 }
3782 /*
3783 Smush images.
3784 */
3785 smush_image=CloneImage(image,width,height,MagickTrue,exception);
3786 if (smush_image == (Image *) NULL)
3787 return((Image *) NULL);
3788 if (SetImageStorageClass(smush_image,DirectClass,exception) == MagickFalse)
3789 {
3790 smush_image=DestroyImage(smush_image);
3791 return((Image *) NULL);
3792 }
3793 smush_image->alpha_trait=alpha_trait;
3794 (void) SetImageBackgroundColor(smush_image,exception);
3795 status=MagickTrue;
3796 x_offset=0;
3797 y_offset=0;
3798 for (n=0; n < (MagickOffsetType) number_images; n++)
3799 {
3800 SetGeometry(smush_image,&geometry);
3801 GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry);
3802 if (stack != MagickFalse)
3803 {
3804 x_offset-=geometry.x;
3805 y_offset-=SmushYGap(smush_image,image,offset,exception);
3806 }
3807 else
3808 {
3809 x_offset-=SmushXGap(smush_image,image,offset,exception);
3810 y_offset-=geometry.y;
3811 }
3812 status=CompositeImage(smush_image,image,OverCompositeOp,MagickTrue,x_offset,
3813 y_offset,exception);
3814 proceed=SetImageProgress(image,SmushImageTag,n,number_images);
3815 if (proceed == MagickFalse)
3816 break;
3817 if (stack == MagickFalse)
3818 {
3819 x_offset+=(ssize_t) image->columns;
3820 y_offset=0;
3821 }
3822 else
3823 {
3824 x_offset=0;
3825 y_offset+=(ssize_t) image->rows;
3826 }
3827 image=GetNextImageInList(image);
3828 }
3829 if (stack == MagickFalse)
3830 smush_image->columns=(size_t) x_offset;
3831 else
3832 smush_image->rows=(size_t) y_offset;
3833 if (status == MagickFalse)
3834 smush_image=DestroyImage(smush_image);
3835 return(smush_image);
3836}
3837
3838/*
3839%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3840% %
3841% %
3842% %
3843% S t r i p I m a g e %
3844% %
3845% %
3846% %
3847%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3848%
3849% StripImage() strips an image of all profiles and comments.
3850%
3851% The format of the StripImage method is:
3852%
3853% MagickBooleanType StripImage(Image *image,ExceptionInfo *exception)
3854%
3855% A description of each parameter follows:
3856%
3857% o image: the image.
3858%
3859% o exception: return any errors or warnings in this structure.
3860%
3861*/
3862MagickExport MagickBooleanType StripImage(Image *image,
3863 ExceptionInfo *magick_unused(exception))
3864{
3865 MagickBooleanType
3866 status;
3867
3868 magick_unreferenced(exception);
3869 assert(image != (Image *) NULL);
3870 if (IsEventLogging() != MagickFalse)
3871 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3872 DestroyImageProfiles(image);
3873 (void) DeleteImageProperty(image,"comment");
3874 (void) DeleteImageProperty(image,"date:create");
3875 (void) DeleteImageProperty(image,"date:modify");
3876 (void) DeleteImageProperty(image,"date:timestamp");
3877 status=SetImageArtifact(image,"png:exclude-chunk",
3878 "bKGD,caNv,cHRM,eXIf,gAMA,iCCP,iTXt,pHYs,sRGB,tEXt,zCCP,zTXt,date");
3879 return(status);
3880}
3881
3882/*
3883%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3884% %
3885% %
3886% %
3887+ S y n c I m a g e %
3888% %
3889% %
3890% %
3891%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3892%
3893% SyncImage() initializes the red, green, and blue intensities of each pixel
3894% as defined by the colormap index.
3895%
3896% The format of the SyncImage method is:
3897%
3898% MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3899%
3900% A description of each parameter follows:
3901%
3902% o image: the image.
3903%
3904% o exception: return any errors or warnings in this structure.
3905%
3906*/
3907
3908static inline Quantum PushColormapIndex(Image *image,const Quantum index,
3909 MagickBooleanType *range_exception)
3910{
3911 if ((size_t) index < image->colors)
3912 return(index);
3913 *range_exception=MagickTrue;
3914 return((Quantum) 0);
3915}
3916
3917MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3918{
3919 CacheView
3920 *image_view;
3921
3922 MagickBooleanType
3923 range_exception,
3924 status,
3925 taint;
3926
3927 ssize_t
3928 y;
3929
3930 assert(image != (Image *) NULL);
3931 assert(image->signature == MagickCoreSignature);
3932 if (IsEventLogging() != MagickFalse)
3933 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3934 if (image->ping != MagickFalse)
3935 return(MagickTrue);
3936 if (image->storage_class != PseudoClass)
3937 return(MagickFalse);
3938 assert(image->colormap != (PixelInfo *) NULL);
3939 range_exception=MagickFalse;
3940 status=MagickTrue;
3941 taint=image->taint;
3942 image_view=AcquireAuthenticCacheView(image,exception);
3943#if defined(MAGICKCORE_OPENMP_SUPPORT)
3944 #pragma omp parallel for schedule(static) shared(range_exception,status) \
3945 magick_number_threads(image,image,image->rows,2)
3946#endif
3947 for (y=0; y < (ssize_t) image->rows; y++)
3948 {
3949 Quantum
3950 index;
3951
3952 Quantum
3953 *magick_restrict q;
3954
3955 ssize_t
3956 x;
3957
3958 if (status == MagickFalse)
3959 continue;
3960 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3961 if (q == (Quantum *) NULL)
3962 {
3963 status=MagickFalse;
3964 continue;
3965 }
3966 for (x=0; x < (ssize_t) image->columns; x++)
3967 {
3968 index=PushColormapIndex(image,GetPixelIndex(image,q),&range_exception);
3969 SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
3970 q+=GetPixelChannels(image);
3971 }
3972 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3973 status=MagickFalse;
3974 }
3975 image_view=DestroyCacheView(image_view);
3976 image->taint=taint;
3977 if ((image->ping == MagickFalse) && (range_exception != MagickFalse))
3978 (void) ThrowMagickException(exception,GetMagickModule(),
3979 CorruptImageWarning,"InvalidColormapIndex","`%s'",image->filename);
3980 return(status);
3981}
3982
3983/*
3984%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3985% %
3986% %
3987% %
3988% S y n c I m a g e S e t t i n g s %
3989% %
3990% %
3991% %
3992%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3993%
3994% SyncImageSettings() syncs any image_info global options into per-image
3995% attributes.
3996%
3997% Note: in IMv6 free form 'options' were always mapped into 'artifacts', so
3998% that operations and coders can find such settings. In IMv7 if a desired
3999% per-image artifact is not set, then it will directly look for a global
4000% option as a fallback, as such this copy is no longer needed, only the
4001% link set up.
4002%
4003% The format of the SyncImageSettings method is:
4004%
4005% MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4006% Image *image,ExceptionInfo *exception)
4007% MagickBooleanType SyncImagesSettings(const ImageInfo *image_info,
4008% Image *image,ExceptionInfo *exception)
4009%
4010% A description of each parameter follows:
4011%
4012% o image_info: the image info.
4013%
4014% o image: the image.
4015%
4016% o exception: return any errors or warnings in this structure.
4017%
4018*/
4019
4020MagickExport MagickBooleanType SyncImagesSettings(ImageInfo *image_info,
4021 Image *images,ExceptionInfo *exception)
4022{
4023 Image
4024 *image;
4025
4026 assert(image_info != (const ImageInfo *) NULL);
4027 assert(image_info->signature == MagickCoreSignature);
4028 assert(images != (Image *) NULL);
4029 assert(images->signature == MagickCoreSignature);
4030 if (IsEventLogging() != MagickFalse)
4031 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
4032 image=images;
4033 for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
4034 (void) SyncImageSettings(image_info,image,exception);
4035 (void) DeleteImageOption(image_info,"page");
4036 return(MagickTrue);
4037}
4038
4039MagickExport MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4040 Image *image,ExceptionInfo *exception)
4041{
4042 const char
4043 *option;
4044
4046 geometry_info;
4047
4048 MagickStatusType
4049 flags;
4050
4051 ResolutionType
4052 units;
4053
4054 /*
4055 Sync image options.
4056 */
4057 assert(image_info != (const ImageInfo *) NULL);
4058 assert(image_info->signature == MagickCoreSignature);
4059 assert(image != (Image *) NULL);
4060 assert(image->signature == MagickCoreSignature);
4061 if (IsEventLogging() != MagickFalse)
4062 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4063 option=GetImageOption(image_info,"background");
4064 if (option != (const char *) NULL)
4065 (void) QueryColorCompliance(option,AllCompliance,&image->background_color,
4066 exception);
4067 option=GetImageOption(image_info,"black-point-compensation");
4068 if (option != (const char *) NULL)
4069 image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
4070 MagickBooleanOptions,MagickFalse,option);
4071 option=GetImageOption(image_info,"blue-primary");
4072 if (option != (const char *) NULL)
4073 {
4074 flags=ParseGeometry(option,&geometry_info);
4075 if ((flags & RhoValue) != 0)
4076 image->chromaticity.blue_primary.x=geometry_info.rho;
4077 image->chromaticity.blue_primary.y=image->chromaticity.blue_primary.x;
4078 if ((flags & SigmaValue) != 0)
4079 image->chromaticity.blue_primary.y=geometry_info.sigma;
4080 }
4081 option=GetImageOption(image_info,"bordercolor");
4082 if (option != (const char *) NULL)
4083 (void) QueryColorCompliance(option,AllCompliance,&image->border_color,
4084 exception);
4085 /* FUTURE: do not sync compose to per-image compose setting here */
4086 option=GetImageOption(image_info,"compose");
4087 if (option != (const char *) NULL)
4088 image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
4089 MagickFalse,option);
4090 /* -- */
4091 option=GetImageOption(image_info,"compress");
4092 if (option != (const char *) NULL)
4093 image->compression=(CompressionType) ParseCommandOption(
4094 MagickCompressOptions,MagickFalse,option);
4095 option=GetImageOption(image_info,"debug");
4096 if (option != (const char *) NULL)
4097 image->debug=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4098 MagickFalse,option);
4099 option=GetImageOption(image_info,"density");
4100 if (option != (const char *) NULL)
4101 {
4102 flags=ParseGeometry(option,&geometry_info);
4103 if ((flags & RhoValue) != 0)
4104 image->resolution.x=geometry_info.rho;
4105 image->resolution.y=image->resolution.x;
4106 if ((flags & SigmaValue) != 0)
4107 image->resolution.y=geometry_info.sigma;
4108 }
4109 option=GetImageOption(image_info,"depth");
4110 if (option != (const char *) NULL)
4111 image->depth=StringToUnsignedLong(option);
4112 option=GetImageOption(image_info,"endian");
4113 if (option != (const char *) NULL)
4114 image->endian=(EndianType) ParseCommandOption(MagickEndianOptions,
4115 MagickFalse,option);
4116 option=GetImageOption(image_info,"filter");
4117 if (option != (const char *) NULL)
4118 image->filter=(FilterType) ParseCommandOption(MagickFilterOptions,
4119 MagickFalse,option);
4120 option=GetImageOption(image_info,"fuzz");
4121 if (option != (const char *) NULL)
4122 image->fuzz=StringToDoubleInterval(option,(double) QuantumRange+1.0);
4123 option=GetImageOption(image_info,"gravity");
4124 if (option != (const char *) NULL)
4125 image->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
4126 MagickFalse,option);
4127 option=GetImageOption(image_info,"green-primary");
4128 if (option != (const char *) NULL)
4129 {
4130 flags=ParseGeometry(option,&geometry_info);
4131 if ((flags & RhoValue) != 0)
4132 image->chromaticity.green_primary.x=geometry_info.rho;
4133 image->chromaticity.green_primary.y=image->chromaticity.green_primary.x;
4134 if ((flags & SigmaValue) != 0)
4135 image->chromaticity.green_primary.y=geometry_info.sigma;
4136 }
4137 option=GetImageOption(image_info,"intent");
4138 if (option != (const char *) NULL)
4139 image->rendering_intent=(RenderingIntent) ParseCommandOption(
4140 MagickIntentOptions,MagickFalse,option);
4141 option=GetImageOption(image_info,"intensity");
4142 if (option != (const char *) NULL)
4143 image->intensity=(PixelIntensityMethod) ParseCommandOption(
4144 MagickPixelIntensityOptions,MagickFalse,option);
4145 option=GetImageOption(image_info,"interlace");
4146 if (option != (const char *) NULL)
4147 image->interlace=(InterlaceType) ParseCommandOption(MagickInterlaceOptions,
4148 MagickFalse,option);
4149 option=GetImageOption(image_info,"interpolate");
4150 if (option != (const char *) NULL)
4151 image->interpolate=(PixelInterpolateMethod) ParseCommandOption(
4152 MagickInterpolateOptions,MagickFalse,option);
4153 option=GetImageOption(image_info,"loop");
4154 if (option != (const char *) NULL)
4155 image->iterations=StringToUnsignedLong(option);
4156 option=GetImageOption(image_info,"mattecolor");
4157 if (option != (const char *) NULL)
4158 (void) QueryColorCompliance(option,AllCompliance,&image->matte_color,
4159 exception);
4160 option=GetImageOption(image_info,"orient");
4161 if (option != (const char *) NULL)
4162 image->orientation=(OrientationType) ParseCommandOption(
4163 MagickOrientationOptions,MagickFalse,option);
4164 option=GetImageOption(image_info,"page");
4165 if (option != (const char *) NULL)
4166 {
4167 char
4168 *geometry;
4169
4170 geometry=GetPageGeometry(option);
4171 flags=ParseAbsoluteGeometry(geometry,&image->page);
4172 geometry=DestroyString(geometry);
4173 }
4174 option=GetImageOption(image_info,"quality");
4175 if (option != (const char *) NULL)
4176 image->quality=StringToUnsignedLong(option);
4177 option=GetImageOption(image_info,"red-primary");
4178 if (option != (const char *) NULL)
4179 {
4180 flags=ParseGeometry(option,&geometry_info);
4181 if ((flags & RhoValue) != 0)
4182 image->chromaticity.red_primary.x=geometry_info.rho;
4183 image->chromaticity.red_primary.y=image->chromaticity.red_primary.x;
4184 if ((flags & SigmaValue) != 0)
4185 image->chromaticity.red_primary.y=geometry_info.sigma;
4186 }
4187 if (image_info->quality != UndefinedCompressionQuality)
4188 image->quality=image_info->quality;
4189 option=GetImageOption(image_info,"scene");
4190 if (option != (const char *) NULL)
4191 image->scene=StringToUnsignedLong(option);
4192 option=GetImageOption(image_info,"taint");
4193 if (option != (const char *) NULL)
4194 image->taint=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4195 MagickFalse,option);
4196 option=GetImageOption(image_info,"tile-offset");
4197 if (option != (const char *) NULL)
4198 {
4199 char
4200 *geometry;
4201
4202 geometry=GetPageGeometry(option);
4203 flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
4204 geometry=DestroyString(geometry);
4205 }
4206 option=GetImageOption(image_info,"transparent-color");
4207 if (option != (const char *) NULL)
4208 (void) QueryColorCompliance(option,AllCompliance,&image->transparent_color,
4209 exception);
4210 option=GetImageOption(image_info,"type");
4211 if (option != (const char *) NULL)
4212 image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
4213 option);
4214 option=GetImageOption(image_info,"units");
4215 units=image_info->units;
4216 if (option != (const char *) NULL)
4217 units=(ResolutionType) ParseCommandOption(MagickResolutionOptions,
4218 MagickFalse,option);
4219 if (units != UndefinedResolution)
4220 {
4221 if (image->units != units)
4222 switch (image->units)
4223 {
4224 case PixelsPerInchResolution:
4225 {
4226 if (units == PixelsPerCentimeterResolution)
4227 {
4228 image->resolution.x/=2.54;
4229 image->resolution.y/=2.54;
4230 }
4231 break;
4232 }
4233 case PixelsPerCentimeterResolution:
4234 {
4235 if (units == PixelsPerInchResolution)
4236 {
4237 image->resolution.x=(double) ((size_t) (100.0*2.54*
4238 image->resolution.x+0.5))/100.0;
4239 image->resolution.y=(double) ((size_t) (100.0*2.54*
4240 image->resolution.y+0.5))/100.0;
4241 }
4242 break;
4243 }
4244 default:
4245 break;
4246 }
4247 image->units=units;
4248 option=GetImageOption(image_info,"density");
4249 if (option != (const char *) NULL)
4250 {
4251 flags=ParseGeometry(option,&geometry_info);
4252 if ((flags & RhoValue) != 0)
4253 image->resolution.x=geometry_info.rho;
4254 image->resolution.y=image->resolution.x;
4255 if ((flags & SigmaValue) != 0)
4256 image->resolution.y=geometry_info.sigma;
4257 }
4258 }
4259 option=GetImageOption(image_info,"virtual-pixel");
4260 if (option != (const char *) NULL)
4261 (void) SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
4262 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,option),
4263 exception);
4264 option=GetImageOption(image_info,"white-point");
4265 if (option != (const char *) NULL)
4266 {
4267 flags=ParseGeometry(option,&geometry_info);
4268 if ((flags & RhoValue) != 0)
4269 image->chromaticity.white_point.x=geometry_info.rho;
4270 image->chromaticity.white_point.y=image->chromaticity.white_point.x;
4271 if ((flags & SigmaValue) != 0)
4272 image->chromaticity.white_point.y=geometry_info.sigma;
4273 }
4274 /*
4275 Pointer to allow the lookup of pre-image artifact will fallback to a global
4276 option setting/define. This saves a lot of duplication of global options
4277 into per-image artifacts, while ensuring only specifically set per-image
4278 artifacts are preserved when parenthesis ends.
4279 */
4280 if (image->image_info != (ImageInfo *) NULL)
4281 image->image_info=DestroyImageInfo(image->image_info);
4282 image->image_info=CloneImageInfo(image_info);
4283 return(MagickTrue);
4284}