MagickCore 7.1.1-43
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
image.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% IIIII M M AAA GGGG EEEEE %
7% I MM MM A A G E %
8% I M M M AAAAA G GG EEE %
9% I M M A A G G E %
10% IIIII M M A A GGGG EEEEE %
11% %
12% %
13% MagickCore Image Methods %
14% %
15% Software Design %
16% Cristy %
17% July 1992 %
18% %
19% %
20% Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
21% dedicated to making software imaging solutions freely available. %
22% %
23% You may not use this file except in compliance with the License. You may %
24% obtain a copy of the License at %
25% %
26% https://imagemagick.org/script/license.php %
27% %
28% Unless required by applicable law or agreed to in writing, software %
29% distributed under the License is distributed on an "AS IS" BASIS, %
30% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31% See the License for the specific language governing permissions and %
32% limitations under the License. %
33% %
34%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35%
36%
37%
38*/
39
40/*
41 Include declarations.
42*/
43#include "MagickCore/studio.h"
44#include "MagickCore/animate.h"
45#include "MagickCore/artifact.h"
46#include "MagickCore/attribute.h"
47#include "MagickCore/blob.h"
48#include "MagickCore/blob-private.h"
49#include "MagickCore/cache.h"
50#include "MagickCore/cache-private.h"
51#include "MagickCore/cache-view.h"
52#include "MagickCore/channel.h"
53#include "MagickCore/client.h"
54#include "MagickCore/color.h"
55#include "MagickCore/color-private.h"
56#include "MagickCore/colormap.h"
57#include "MagickCore/colorspace.h"
58#include "MagickCore/colorspace-private.h"
59#include "MagickCore/composite.h"
60#include "MagickCore/composite-private.h"
61#include "MagickCore/compress.h"
62#include "MagickCore/constitute.h"
63#include "MagickCore/delegate.h"
64#include "MagickCore/display.h"
65#include "MagickCore/draw.h"
66#include "MagickCore/enhance.h"
67#include "MagickCore/exception.h"
68#include "MagickCore/exception-private.h"
69#include "MagickCore/gem.h"
70#include "MagickCore/geometry.h"
71#include "MagickCore/histogram.h"
72#include "MagickCore/image-private.h"
73#include "MagickCore/list.h"
74#include "MagickCore/magic.h"
75#include "MagickCore/magick.h"
76#include "MagickCore/magick-private.h"
77#include "MagickCore/memory_.h"
78#include "MagickCore/memory-private.h"
79#include "MagickCore/module.h"
80#include "MagickCore/monitor.h"
81#include "MagickCore/monitor-private.h"
82#include "MagickCore/option.h"
83#include "MagickCore/paint.h"
84#include "MagickCore/pixel-accessor.h"
85#include "MagickCore/profile.h"
86#include "MagickCore/property.h"
87#include "MagickCore/quantize.h"
88#include "MagickCore/random_.h"
89#include "MagickCore/resource_.h"
90#include "MagickCore/segment.h"
91#include "MagickCore/semaphore.h"
92#include "MagickCore/signature-private.h"
93#include "MagickCore/statistic.h"
94#include "MagickCore/string_.h"
95#include "MagickCore/string-private.h"
96#include "MagickCore/thread-private.h"
97#include "MagickCore/threshold.h"
98#include "MagickCore/timer.h"
99#include "MagickCore/timer-private.h"
100#include "MagickCore/token.h"
101#include "MagickCore/token-private.h"
102#include "MagickCore/utility.h"
103#include "MagickCore/utility-private.h"
104#include "MagickCore/version.h"
105#include "MagickCore/xwindow-private.h"
106
107/*
108%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
109% %
110% %
111% %
112% A c q u i r e I m a g e %
113% %
114% %
115% %
116%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
117%
118% AcquireImage() returns a pointer to an image structure initialized to
119% default values.
120%
121% The format of the AcquireImage method is:
122%
123% Image *AcquireImage(const ImageInfo *image_info,ExceptionInfo *exception)
124%
125% A description of each parameter follows:
126%
127% o image_info: Many of the image default values are set from this
128% structure. For example, filename, compression, depth, background color,
129% and others.
130%
131% o exception: return any errors or warnings in this structure.
132%
133*/
134MagickExport Image *AcquireImage(const ImageInfo *image_info,
135 ExceptionInfo *exception)
136{
137 const char
138 *option;
139
140 Image
141 *image;
142
143 int
144 time_limit;
145
146 MagickStatusType
147 flags;
148
149 /*
150 Allocate image structure.
151 */
152 if (IsEventLogging() != MagickFalse)
153 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
154 image=(Image *) AcquireCriticalMemory(sizeof(*image));
155 (void) memset(image,0,sizeof(*image));
156 /*
157 Initialize Image structure.
158 */
159 (void) CopyMagickString(image->magick,"MIFF",MagickPathExtent);
160 image->storage_class=DirectClass;
161 image->depth=MAGICKCORE_QUANTUM_DEPTH;
162 image->colorspace=sRGBColorspace;
163 image->rendering_intent=PerceptualIntent;
164 image->gamma=1.000/2.200;
165 image->chromaticity.red_primary.x=0.6400;
166 image->chromaticity.red_primary.y=0.3300;
167 image->chromaticity.red_primary.z=0.0300;
168 image->chromaticity.green_primary.x=0.3000;
169 image->chromaticity.green_primary.y=0.6000;
170 image->chromaticity.green_primary.z=0.1000;
171 image->chromaticity.blue_primary.x=0.1500;
172 image->chromaticity.blue_primary.y=0.0600;
173 image->chromaticity.blue_primary.z=0.7900;
174 image->chromaticity.white_point.x=0.3127;
175 image->chromaticity.white_point.y=0.3290;
176 image->chromaticity.white_point.z=0.3583;
177 image->interlace=NoInterlace;
178 image->ticks_per_second=UndefinedTicksPerSecond;
179 image->compose=OverCompositeOp;
180 GetPixelInfoRGBA(BackgroundColorRGBA,&image->background_color);
181 GetPixelInfoRGBA(BorderColorRGBA,&image->border_color);
182 GetPixelInfoRGBA(MatteColorRGBA,&image->matte_color);
183 GetPixelInfoRGBA(TransparentColorRGBA,&image->transparent_color);
184 GetTimerInfo(&image->timer);
185 image->cache=AcquirePixelCache(0);
186 image->channel_mask=AllChannels;
187 image->channel_map=AcquirePixelChannelMap();
188 image->blob=CloneBlobInfo((BlobInfo *) NULL);
189 image->timestamp=GetMagickTime();
190 time_limit=(int) GetMagickResourceLimit(TimeResource);
191 if (time_limit > 0)
192 image->ttl=image->timestamp+time_limit;
193 image->debug=(GetLogEventMask() & (ImageEvent | TransformEvent | CoderEvent))
194 != 0 ? MagickTrue : MagickFalse;
195 image->reference_count=1;
196 image->semaphore=AcquireSemaphoreInfo();
197 image->signature=MagickCoreSignature;
198 if (image_info == (ImageInfo *) NULL)
199 return(image);
200 /*
201 Transfer image info.
202 */
203 SetBlobExempt(image,image_info->file != (FILE *) NULL ? MagickTrue :
204 MagickFalse);
205 (void) CopyMagickString(image->filename,image_info->filename,
206 MagickPathExtent);
207 (void) CopyMagickString(image->magick_filename,image_info->filename,
208 MagickPathExtent);
209 (void) CopyMagickString(image->magick,image_info->magick,MagickPathExtent);
210 if (image_info->size != (char *) NULL)
211 {
212 (void) ParseAbsoluteGeometry(image_info->size,&image->extract_info);
213 image->columns=image->extract_info.width;
214 image->rows=image->extract_info.height;
215 image->offset=image->extract_info.x;
216 image->extract_info.x=0;
217 image->extract_info.y=0;
218 }
219 if (image_info->extract != (char *) NULL)
220 {
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+=(ptrdiff_t) GetPixelChannels(next);
585 q+=(ptrdiff_t) GetPixelChannels(append_image);
586 }
587 sync=SyncCacheViewAuthenticPixels(append_view,exception);
588 if (sync == MagickFalse)
589 status=MagickFalse;
590 }
591 image_view=DestroyCacheView(image_view);
592 if (stack == MagickFalse)
593 {
594 x_offset+=(ssize_t) next->columns;
595 y_offset=0;
596 }
597 else
598 {
599 x_offset=0;
600 y_offset+=(ssize_t) next->rows;
601 }
602 proceed=SetImageProgress(append_image,AppendImageTag,n,number_images);
603 if (proceed == MagickFalse)
604 break;
605 next=GetNextImageInList(next);
606 }
607 append_view=DestroyCacheView(append_view);
608 if (status == MagickFalse)
609 append_image=DestroyImage(append_image);
610 return(append_image);
611}
612
613/*
614%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
615% %
616% %
617% %
618% C a t c h I m a g e E x c e p t i o n %
619% %
620% %
621% %
622%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
623%
624% CatchImageException() returns if no exceptions are found in the image
625% sequence, otherwise it determines the most severe exception and reports
626% it as a warning or error depending on the severity.
627%
628% The format of the CatchImageException method is:
629%
630% ExceptionType CatchImageException(Image *image)
631%
632% A description of each parameter follows:
633%
634% o image: An image sequence.
635%
636*/
637MagickExport ExceptionType CatchImageException(Image *image)
638{
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+=(ptrdiff_t) GetPixelChannels(source_image);
1138 q+=(ptrdiff_t) GetPixelChannels(image);
1139 }
1140 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1141 if (sync == MagickFalse)
1142 status=MagickFalse;
1143 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1144 {
1145 MagickBooleanType
1146 proceed;
1147
1148#if defined(MAGICKCORE_OPENMP_SUPPORT)
1149 #pragma omp atomic
1150#endif
1151 progress++;
1152 proceed=SetImageProgress(image,CopyImageTag,progress,image->rows);
1153 if (proceed == MagickFalse)
1154 status=MagickFalse;
1155 }
1156 }
1157 source_view=DestroyCacheView(source_view);
1158 image_view=DestroyCacheView(image_view);
1159 return(status);
1160}
1161
1162/*
1163%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1164% %
1165% %
1166% %
1167% D e s t r o y I m a g e %
1168% %
1169% %
1170% %
1171%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1172%
1173% DestroyImage() dereferences an image, deallocating memory associated with
1174% the image if the reference count becomes zero.
1175%
1176% The format of the DestroyImage method is:
1177%
1178% Image *DestroyImage(Image *image)
1179%
1180% A description of each parameter follows:
1181%
1182% o image: the image.
1183%
1184*/
1185MagickExport Image *DestroyImage(Image *image)
1186{
1187 MagickBooleanType
1188 destroy;
1189
1190 /*
1191 Dereference image.
1192 */
1193 assert(image != (Image *) NULL);
1194 assert(image->signature == MagickCoreSignature);
1195 if (IsEventLogging() != MagickFalse)
1196 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1197 destroy=MagickFalse;
1198 LockSemaphoreInfo(image->semaphore);
1199 image->reference_count--;
1200 if (image->reference_count == 0)
1201 destroy=MagickTrue;
1202 UnlockSemaphoreInfo(image->semaphore);
1203 if (destroy == MagickFalse)
1204 return((Image *) NULL);
1205 /*
1206 Destroy image.
1207 */
1208 DestroyImagePixels(image);
1209 image->channel_map=DestroyPixelChannelMap(image->channel_map);
1210 if (image->montage != (char *) NULL)
1211 image->montage=DestroyString(image->montage);
1212 if (image->directory != (char *) NULL)
1213 image->directory=DestroyString(image->directory);
1214 if (image->colormap != (PixelInfo *) NULL)
1215 image->colormap=(PixelInfo *) RelinquishMagickMemory(image->colormap);
1216 if (image->geometry != (char *) NULL)
1217 image->geometry=DestroyString(image->geometry);
1218 DestroyImageProfiles(image);
1219 DestroyImageProperties(image);
1220 DestroyImageArtifacts(image);
1221 if (image->ascii85 != (Ascii85Info *) NULL)
1222 image->ascii85=(Ascii85Info *) RelinquishMagickMemory(image->ascii85);
1223 if (image->image_info != (ImageInfo *) NULL)
1224 image->image_info=DestroyImageInfo(image->image_info);
1225 DestroyBlob(image);
1226 if (image->semaphore != (SemaphoreInfo *) NULL)
1227 RelinquishSemaphoreInfo(&image->semaphore);
1228 image->signature=(~MagickCoreSignature);
1229 image=(Image *) RelinquishMagickMemory(image);
1230 return(image);
1231}
1232
1233/*
1234%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1235% %
1236% %
1237% %
1238% D e s t r o y I m a g e I n f o %
1239% %
1240% %
1241% %
1242%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1243%
1244% DestroyImageInfo() deallocates memory associated with an ImageInfo
1245% structure.
1246%
1247% The format of the DestroyImageInfo method is:
1248%
1249% ImageInfo *DestroyImageInfo(ImageInfo *image_info)
1250%
1251% A description of each parameter follows:
1252%
1253% o image_info: the image info.
1254%
1255*/
1256MagickExport ImageInfo *DestroyImageInfo(ImageInfo *image_info)
1257{
1258 assert(image_info != (ImageInfo *) NULL);
1259 assert(image_info->signature == MagickCoreSignature);
1260 if (IsEventLogging() != MagickFalse)
1261 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1262 image_info->filename);
1263 if (image_info->size != (char *) NULL)
1264 image_info->size=DestroyString(image_info->size);
1265 if (image_info->extract != (char *) NULL)
1266 image_info->extract=DestroyString(image_info->extract);
1267 if (image_info->scenes != (char *) NULL)
1268 image_info->scenes=DestroyString(image_info->scenes);
1269 if (image_info->page != (char *) NULL)
1270 image_info->page=DestroyString(image_info->page);
1271 if (image_info->sampling_factor != (char *) NULL)
1272 image_info->sampling_factor=DestroyString(
1273 image_info->sampling_factor);
1274 if (image_info->server_name != (char *) NULL)
1275 image_info->server_name=DestroyString(
1276 image_info->server_name);
1277 if (image_info->font != (char *) NULL)
1278 image_info->font=DestroyString(image_info->font);
1279 if (image_info->texture != (char *) NULL)
1280 image_info->texture=DestroyString(image_info->texture);
1281 if (image_info->density != (char *) NULL)
1282 image_info->density=DestroyString(image_info->density);
1283 if (image_info->cache != (void *) NULL)
1284 image_info->cache=DestroyPixelCache(image_info->cache);
1285 if (image_info->profile != (StringInfo *) NULL)
1286 image_info->profile=(void *) DestroyStringInfo((StringInfo *)
1287 image_info->profile);
1288 DestroyImageOptions(image_info);
1289 image_info->signature=(~MagickCoreSignature);
1290 image_info=(ImageInfo *) RelinquishMagickMemory(image_info);
1291 return(image_info);
1292}
1293
1294/*
1295%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1296% %
1297% %
1298% %
1299+ D i s a s s o c i a t e I m a g e S t r e a m %
1300% %
1301% %
1302% %
1303%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1304%
1305% DisassociateImageStream() disassociates the image stream. It checks if the
1306% blob of the specified image is referenced by other images. If the reference
1307% count is higher then 1 a new blob is assigned to the specified image.
1308%
1309% The format of the DisassociateImageStream method is:
1310%
1311% void DisassociateImageStream(const Image *image)
1312%
1313% A description of each parameter follows:
1314%
1315% o image: the image.
1316%
1317*/
1318MagickExport void DisassociateImageStream(Image *image)
1319{
1320 assert(image != (Image *) NULL);
1321 assert(image->signature == MagickCoreSignature);
1322 if (IsEventLogging() != MagickFalse)
1323 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1324 DisassociateBlob(image);
1325}
1326
1327/*
1328%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1329% %
1330% %
1331% %
1332% G e t I m a g e I n f o %
1333% %
1334% %
1335% %
1336%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1337%
1338% GetImageInfo() initializes image_info to default values.
1339%
1340% The format of the GetImageInfo method is:
1341%
1342% void GetImageInfo(ImageInfo *image_info)
1343%
1344% A description of each parameter follows:
1345%
1346% o image_info: the image info.
1347%
1348*/
1349MagickExport void GetImageInfo(ImageInfo *image_info)
1350{
1351 char
1352 *synchronize;
1353
1354 /*
1355 File and image dimension members.
1356 */
1357 assert(image_info != (ImageInfo *) NULL);
1358 if (IsEventLogging() != MagickFalse)
1359 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1360 (void) memset(image_info,0,sizeof(*image_info));
1361 image_info->adjoin=MagickTrue;
1362 image_info->interlace=NoInterlace;
1363 image_info->channel=AllChannels;
1364 image_info->quality=UndefinedCompressionQuality;
1365 image_info->antialias=MagickTrue;
1366 image_info->dither=MagickTrue;
1367 image_info->depth=0;
1368 synchronize=GetEnvironmentValue("MAGICK_SYNCHRONIZE");
1369 if (synchronize != (const char *) NULL)
1370 {
1371 image_info->synchronize=IsStringTrue(synchronize);
1372 synchronize=DestroyString(synchronize);
1373 }
1374 GetPixelInfoRGBA(BackgroundColorRGBA,&image_info->background_color);
1375 GetPixelInfoRGBA(BorderColorRGBA,&image_info->border_color);
1376 GetPixelInfoRGBA(MatteColorRGBA,&image_info->matte_color);
1377 GetPixelInfoRGBA(TransparentColorRGBA,&image_info->transparent_color);
1378 image_info->debug=(GetLogEventMask() & ImageEvent) != 0 ? MagickTrue :
1379 MagickFalse;
1380 image_info->signature=MagickCoreSignature;
1381}
1382
1383/*
1384%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1385% %
1386% %
1387% %
1388% G e t I m a g e I n f o F i l e %
1389% %
1390% %
1391% %
1392%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1393%
1394% GetImageInfoFile() returns the image info file member.
1395%
1396% The format of the GetImageInfoFile method is:
1397%
1398% FILE *GetImageInfoFile(const ImageInfo *image_info)
1399%
1400% A description of each parameter follows:
1401%
1402% o image_info: the image info.
1403%
1404*/
1405MagickExport FILE *GetImageInfoFile(const ImageInfo *image_info)
1406{
1407 return(image_info->file);
1408}
1409
1410/*
1411%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1412% %
1413% %
1414% %
1415% G e t I m a g e M a s k %
1416% %
1417% %
1418% %
1419%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1420%
1421% GetImageMask() returns the mask associated with the image.
1422%
1423% The format of the GetImageMask method is:
1424%
1425% Image *GetImageMask(const Image *image,const PixelMask type,
1426% ExceptionInfo *exception)
1427%
1428% A description of each parameter follows:
1429%
1430% o image: the image.
1431%
1432% o type: the mask type, ReadPixelMask or WritePixelMask.
1433%
1434*/
1435MagickExport Image *GetImageMask(const Image *image,const PixelMask type,
1436 ExceptionInfo *exception)
1437{
1438 CacheView
1439 *mask_view,
1440 *image_view;
1441
1442 Image
1443 *mask_image;
1444
1445 MagickBooleanType
1446 status;
1447
1448 ssize_t
1449 y;
1450
1451 /*
1452 Get image mask.
1453 */
1454 assert(image != (Image *) NULL);
1455 assert(image->signature == MagickCoreSignature);
1456 if (IsEventLogging() != MagickFalse)
1457 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1458 switch (type)
1459 {
1460 case ReadPixelMask:
1461 {
1462 if ((image->channels & ReadMaskChannel) == 0)
1463 return((Image *) NULL);
1464 break;
1465 }
1466 case WritePixelMask:
1467 {
1468 if ((image->channels & WriteMaskChannel) == 0)
1469 return((Image *) NULL);
1470 break;
1471 }
1472 default:
1473 {
1474 if ((image->channels & CompositeMaskChannel) == 0)
1475 return((Image *) NULL);
1476 break;
1477 }
1478 }
1479 mask_image=AcquireImage((ImageInfo *) NULL,exception);
1480 status=SetImageExtent(mask_image,image->columns,image->rows,exception);
1481 if (status == MagickFalse)
1482 return(DestroyImage(mask_image));
1483 status=MagickTrue;
1484 mask_image->alpha_trait=UndefinedPixelTrait;
1485 (void) SetImageColorspace(mask_image,GRAYColorspace,exception);
1486 image_view=AcquireVirtualCacheView(image,exception);
1487 mask_view=AcquireAuthenticCacheView(mask_image,exception);
1488#if defined(MAGICKCORE_OPENMP_SUPPORT)
1489 #pragma omp parallel for schedule(static) shared(status) \
1490 magick_number_threads(image,image,image->rows,2)
1491#endif
1492 for (y=0; y < (ssize_t) image->rows; y++)
1493 {
1494 const Quantum
1495 *magick_restrict p;
1496
1497 Quantum
1498 *magick_restrict q;
1499
1500 ssize_t
1501 x;
1502
1503 if (status == MagickFalse)
1504 continue;
1505 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1506 q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1,
1507 exception);
1508 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1509 {
1510 status=MagickFalse;
1511 continue;
1512 }
1513 for (x=0; x < (ssize_t) image->columns; x++)
1514 {
1515 switch (type)
1516 {
1517 case ReadPixelMask:
1518 {
1519 SetPixelGray(mask_image,GetPixelReadMask(image,p),q);
1520 break;
1521 }
1522 case WritePixelMask:
1523 {
1524 SetPixelGray(mask_image,GetPixelWriteMask(image,p),q);
1525 break;
1526 }
1527 default:
1528 {
1529 SetPixelGray(mask_image,GetPixelCompositeMask(image,p),q);
1530 break;
1531 }
1532 }
1533 p+=(ptrdiff_t) GetPixelChannels(image);
1534 q+=(ptrdiff_t) GetPixelChannels(mask_image);
1535 }
1536 if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse)
1537 status=MagickFalse;
1538 }
1539 mask_view=DestroyCacheView(mask_view);
1540 image_view=DestroyCacheView(image_view);
1541 if (status == MagickFalse)
1542 mask_image=DestroyImage(mask_image);
1543 return(mask_image);
1544}
1545
1546/*
1547%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1548% %
1549% %
1550% %
1551+ G e t I m a g e R e f e r e n c e C o u n t %
1552% %
1553% %
1554% %
1555%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1556%
1557% GetImageReferenceCount() returns the image reference count.
1558%
1559% The format of the GetReferenceCount method is:
1560%
1561% ssize_t GetImageReferenceCount(Image *image)
1562%
1563% A description of each parameter follows:
1564%
1565% o image: the image.
1566%
1567*/
1568MagickExport ssize_t GetImageReferenceCount(Image *image)
1569{
1570 ssize_t
1571 reference_count;
1572
1573 assert(image != (Image *) NULL);
1574 assert(image->signature == MagickCoreSignature);
1575 if (IsEventLogging() != MagickFalse)
1576 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1577 LockSemaphoreInfo(image->semaphore);
1578 reference_count=image->reference_count;
1579 UnlockSemaphoreInfo(image->semaphore);
1580 return(reference_count);
1581}
1582
1583/*
1584%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1585% %
1586% %
1587% %
1588% G e t I m a g e V i r t u a l P i x e l M e t h o d %
1589% %
1590% %
1591% %
1592%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1593%
1594% GetImageVirtualPixelMethod() gets the "virtual pixels" method for the
1595% image. A virtual pixel is any pixel access that is outside the boundaries
1596% of the image cache.
1597%
1598% The format of the GetImageVirtualPixelMethod() method is:
1599%
1600% VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image)
1601%
1602% A description of each parameter follows:
1603%
1604% o image: the image.
1605%
1606*/
1607MagickExport VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image)
1608{
1609 assert(image != (Image *) NULL);
1610 assert(image->signature == MagickCoreSignature);
1611 if (IsEventLogging() != MagickFalse)
1612 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1613 return(GetPixelCacheVirtualMethod(image));
1614}
1615
1616/*
1617%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1618% %
1619% %
1620% %
1621% I n t e r p r e t I m a g e F i l e n a m e %
1622% %
1623% %
1624% %
1625%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1626%
1627% InterpretImageFilename() interprets embedded characters in an image filename.
1628% The filename length is returned.
1629%
1630% The format of the InterpretImageFilename method is:
1631%
1632% size_t InterpretImageFilename(const ImageInfo *image_info,Image *image,
1633% const char *format,int value,char *filename,ExceptionInfo *exception)
1634%
1635% A description of each parameter follows.
1636%
1637% o image_info: the image info..
1638%
1639% o image: the image.
1640%
1641% o format: A filename describing the format to use to write the numeric
1642% argument. Only the first numeric format identifier is replaced.
1643%
1644% o value: Numeric value to substitute into format filename.
1645%
1646% o filename: return the formatted filename in this character buffer.
1647%
1648% o exception: return any errors or warnings in this structure.
1649%
1650*/
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 offset;
1669
1670 canonical=MagickFalse;
1671 offset=0;
1672 (void) CopyMagickString(filename,format,MagickPathExtent);
1673 if (IsStringTrue(GetImageOption(image_info,"filename:literal")) != MagickFalse)
1674 return(strlen(filename));
1675 for (p=strchr(format,'%'); p != (char *) NULL; p=strchr(p+1,'%'))
1676 {
1677 q=(char *) p+1;
1678 if (*q == '%')
1679 {
1680 p++;
1681 continue;
1682 }
1683 switch (*q)
1684 {
1685 case 'd':
1686 case 'o':
1687 case 'x':
1688 {
1689 ssize_t
1690 count;
1691
1692 q++;
1693 c=(*q);
1694 *q='\0';
1695 count=FormatLocaleString(filename+(p-format-offset),(size_t)
1696 (MagickPathExtent-(p-format-offset)),p,value);
1697 if ((count <= 0) || (count > (MagickPathExtent-(p-format-offset))))
1698 return(0);
1699 offset+=(ssize_t) ((q-p)-count);
1700 *q=(char) c;
1701 (void) ConcatenateMagickString(filename,q,MagickPathExtent);
1702 canonical=MagickTrue;
1703 if (*(q-1) != '%')
1704 break;
1705 p++;
1706 break;
1707 }
1708 case '[':
1709 {
1710 char
1711 pattern[MagickPathExtent];
1712
1713 const char
1714 *option;
1715
1716 char
1717 *r;
1718
1719 ssize_t
1720 i;
1721
1722 ssize_t
1723 depth;
1724
1725 /*
1726 Image option.
1727 */
1728 if (strchr(p,']') == (char *) NULL)
1729 break;
1730 depth=1;
1731 r=q+1;
1732 for (i=0; (i < (MagickPathExtent-1L)) && (*r != '\0'); i++)
1733 {
1734 if (*r == '[')
1735 depth++;
1736 if (*r == ']')
1737 depth--;
1738 if (depth <= 0)
1739 break;
1740 pattern[i]=(*r++);
1741 }
1742 pattern[i]='\0';
1743 if (LocaleNCompare(pattern,"filename:",9) != 0)
1744 break;
1745 option=(const char *) NULL;
1746 if (image != (Image *) NULL)
1747 option=GetImageProperty(image,pattern,exception);
1748 if ((option == (const char *) NULL) && (image != (Image *) NULL))
1749 option=GetImageArtifact(image,pattern);
1750 if ((option == (const char *) NULL) &&
1751 (image_info != (ImageInfo *) NULL))
1752 option=GetImageOption(image_info,pattern);
1753 if (option == (const char *) NULL)
1754 break;
1755 q--;
1756 c=(*q);
1757 *q='\0';
1758 (void) CopyMagickString(filename+(p-format-offset),option,(size_t)
1759 (MagickPathExtent-(p-format-offset)));
1760 offset+=(ssize_t) strlen(pattern)-(ssize_t) strlen(option)+3;
1761 *q=c;
1762 (void) ConcatenateMagickString(filename,r+1,MagickPathExtent);
1763 canonical=MagickTrue;
1764 if (*(q-1) != '%')
1765 break;
1766 p++;
1767 break;
1768 }
1769 default:
1770 break;
1771 }
1772 }
1773 if (canonical == MagickFalse)
1774 (void) CopyMagickString(filename,format,MagickPathExtent);
1775 else
1776 for (q=filename; *q != '\0'; q++)
1777 if ((*q == '%') && (*(q+1) == '%'))
1778 (void) CopyMagickString(q,q+1,(size_t) (MagickPathExtent-(q-filename)));
1779 return(strlen(filename));
1780}
1781
1782/*
1783%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1784% %
1785% %
1786% %
1787% I s H i g h D y n a m i c R a n g e I m a g e %
1788% %
1789% %
1790% %
1791%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1792%
1793% IsHighDynamicRangeImage() returns MagickTrue if any pixel component is
1794% non-integer or exceeds the bounds of the quantum depth (e.g. for Q16
1795% 0..65535.
1796%
1797% The format of the IsHighDynamicRangeImage method is:
1798%
1799% MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1800% ExceptionInfo *exception)
1801%
1802% A description of each parameter follows:
1803%
1804% o image: the image.
1805%
1806% o exception: return any errors or warnings in this structure.
1807%
1808*/
1809MagickExport MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1810 ExceptionInfo *exception)
1811{
1812#if !defined(MAGICKCORE_HDRI_SUPPORT)
1813 (void) image;
1814 (void) exception;
1815 return(MagickFalse);
1816#else
1817 CacheView
1818 *image_view;
1819
1820 MagickBooleanType
1821 hdri = MagickFalse;
1822
1823 ssize_t
1824 y;
1825
1826 assert(image != (Image *) NULL);
1827 assert(image->signature == MagickCoreSignature);
1828 if (IsEventLogging() != MagickFalse)
1829 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1830 image_view=AcquireVirtualCacheView(image,exception);
1831#if defined(MAGICKCORE_OPENMP_SUPPORT)
1832 #pragma omp parallel for schedule(static) shared(hdri) \
1833 magick_number_threads(image,image,image->rows,2)
1834#endif
1835 for (y=0; y < (ssize_t) image->rows; y++)
1836 {
1837 const Quantum
1838 *p;
1839
1840 ssize_t
1841 x;
1842
1843 if (hdri != MagickFalse)
1844 continue;
1845 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1846 if (p == (const Quantum *) NULL)
1847 continue;
1848 for (x=0; x < (ssize_t) image->columns; x++)
1849 {
1850 ssize_t
1851 i;
1852
1853 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1854 {
1855 double
1856 pixel;
1857
1858 PixelTrait
1859 traits;
1860
1861 traits=GetPixelChannelTraits(image,(PixelChannel) i);
1862 if (traits == UndefinedPixelTrait)
1863 continue;
1864 pixel=(double) p[i];
1865 if ((pixel < 0.0) || (pixel > (double) QuantumRange) ||
1866 (pixel != (double) ((QuantumAny) pixel)))
1867 {
1868 hdri=MagickTrue;
1869 break;
1870 }
1871 }
1872 if (hdri != MagickFalse)
1873 break;
1874 p+=(ptrdiff_t) GetPixelChannels(image);
1875 }
1876 }
1877 image_view=DestroyCacheView(image_view);
1878 return(hdri);
1879#endif
1880}
1881
1882/*
1883%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1884% %
1885% %
1886% %
1887% I s I m a g e O b j e c t %
1888% %
1889% %
1890% %
1891%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1892%
1893% IsImageObject() returns MagickTrue if the image sequence contains a valid
1894% set of image objects.
1895%
1896% The format of the IsImageObject method is:
1897%
1898% MagickBooleanType IsImageObject(const Image *image)
1899%
1900% A description of each parameter follows:
1901%
1902% o image: the image.
1903%
1904*/
1905MagickExport MagickBooleanType IsImageObject(const Image *image)
1906{
1907 const Image
1908 *p;
1909
1910 assert(image != (Image *) NULL);
1911 if (IsEventLogging() != MagickFalse)
1912 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1913 for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
1914 if (p->signature != MagickCoreSignature)
1915 return(MagickFalse);
1916 return(MagickTrue);
1917}
1918
1919/*
1920%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1921% %
1922% %
1923% %
1924% I s T a i n t I m a g e %
1925% %
1926% %
1927% %
1928%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1929%
1930% IsTaintImage() returns MagickTrue any pixel in the image has been altered
1931% since it was first constituted.
1932%
1933% The format of the IsTaintImage method is:
1934%
1935% MagickBooleanType IsTaintImage(const Image *image)
1936%
1937% A description of each parameter follows:
1938%
1939% o image: the image.
1940%
1941*/
1942MagickExport MagickBooleanType IsTaintImage(const Image *image)
1943{
1944 char
1945 magick[MagickPathExtent],
1946 filename[MagickPathExtent];
1947
1948 const Image
1949 *p;
1950
1951 assert(image != (Image *) NULL);
1952 assert(image->signature == MagickCoreSignature);
1953 if (IsEventLogging() != MagickFalse)
1954 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1955 (void) CopyMagickString(magick,image->magick,MagickPathExtent);
1956 (void) CopyMagickString(filename,image->filename,MagickPathExtent);
1957 for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
1958 {
1959 if (p->taint != MagickFalse)
1960 return(MagickTrue);
1961 if (LocaleCompare(p->magick,magick) != 0)
1962 return(MagickTrue);
1963 if (LocaleCompare(p->filename,filename) != 0)
1964 return(MagickTrue);
1965 }
1966 return(MagickFalse);
1967}
1968
1969/*
1970%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1971% %
1972% %
1973% %
1974% M o d i f y I m a g e %
1975% %
1976% %
1977% %
1978%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1979%
1980% ModifyImage() ensures that there is only a single reference to the image
1981% to be modified, updating the provided image pointer to point to a clone of
1982% the original image if necessary.
1983%
1984% The format of the ModifyImage method is:
1985%
1986% MagickBooleanType ModifyImage(Image *image,ExceptionInfo *exception)
1987%
1988% A description of each parameter follows:
1989%
1990% o image: the image.
1991%
1992% o exception: return any errors or warnings in this structure.
1993%
1994*/
1995MagickExport MagickBooleanType ModifyImage(Image **image,
1996 ExceptionInfo *exception)
1997{
1998 Image
1999 *clone_image;
2000
2001 assert(image != (Image **) NULL);
2002 assert(*image != (Image *) NULL);
2003 assert((*image)->signature == MagickCoreSignature);
2004 if (IsEventLogging() != MagickFalse)
2005 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
2006 if (GetImageReferenceCount(*image) <= 1)
2007 return(MagickTrue);
2008 clone_image=CloneImage(*image,0,0,MagickTrue,exception);
2009 LockSemaphoreInfo((*image)->semaphore);
2010 (*image)->reference_count--;
2011 UnlockSemaphoreInfo((*image)->semaphore);
2012 *image=clone_image;
2013 return(MagickTrue);
2014}
2015
2016/*
2017%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2018% %
2019% %
2020% %
2021% N e w M a g i c k I m a g e %
2022% %
2023% %
2024% %
2025%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2026%
2027% NewMagickImage() creates a blank image canvas of the specified size and
2028% background color.
2029%
2030% The format of the NewMagickImage method is:
2031%
2032% Image *NewMagickImage(const ImageInfo *image_info,const size_t width,
2033% const size_t height,const PixelInfo *background,
2034% ExceptionInfo *exception)
2035%
2036% A description of each parameter follows:
2037%
2038% o image: the image.
2039%
2040% o width: the image width.
2041%
2042% o height: the image height.
2043%
2044% o background: the image color.
2045%
2046% o exception: return any errors or warnings in this structure.
2047%
2048*/
2049MagickExport Image *NewMagickImage(const ImageInfo *image_info,
2050 const size_t width,const size_t height,const PixelInfo *background,
2051 ExceptionInfo *exception)
2052{
2053 CacheView
2054 *image_view;
2055
2056 Image
2057 *image;
2058
2059 MagickBooleanType
2060 status;
2061
2062 ssize_t
2063 y;
2064
2065 assert(image_info != (const ImageInfo *) NULL);
2066 assert(image_info->signature == MagickCoreSignature);
2067 assert(background != (const PixelInfo *) NULL);
2068 if (IsEventLogging() != MagickFalse)
2069 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2070 image=AcquireImage(image_info,exception);
2071 image->columns=width;
2072 image->rows=height;
2073 image->colorspace=background->colorspace;
2074 image->alpha_trait=background->alpha_trait;
2075 image->fuzz=background->fuzz;
2076 image->depth=background->depth;
2077 status=MagickTrue;
2078 image_view=AcquireAuthenticCacheView(image,exception);
2079#if defined(MAGICKCORE_OPENMP_SUPPORT)
2080 #pragma omp parallel for schedule(static) shared(status) \
2081 magick_number_threads(image,image,image->rows,2)
2082#endif
2083 for (y=0; y < (ssize_t) image->rows; y++)
2084 {
2085 Quantum
2086 *magick_restrict q;
2087
2088 ssize_t
2089 x;
2090
2091 if (status == MagickFalse)
2092 continue;
2093 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2094 if (q == (Quantum *) NULL)
2095 {
2096 status=MagickFalse;
2097 continue;
2098 }
2099 for (x=0; x < (ssize_t) image->columns; x++)
2100 {
2101 SetPixelViaPixelInfo(image,background,q);
2102 q+=(ptrdiff_t) GetPixelChannels(image);
2103 }
2104 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2105 status=MagickFalse;
2106 }
2107 image_view=DestroyCacheView(image_view);
2108 if (status == MagickFalse)
2109 image=DestroyImage(image);
2110 return(image);
2111}
2112
2113/*
2114%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2115% %
2116% %
2117% %
2118% R e f e r e n c e I m a g e %
2119% %
2120% %
2121% %
2122%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2123%
2124% ReferenceImage() increments the reference count associated with an image
2125% returning a pointer to the image.
2126%
2127% The format of the ReferenceImage method is:
2128%
2129% Image *ReferenceImage(Image *image)
2130%
2131% A description of each parameter follows:
2132%
2133% o image: the image.
2134%
2135*/
2136MagickExport Image *ReferenceImage(Image *image)
2137{
2138 assert(image != (Image *) NULL);
2139 assert(image->signature == MagickCoreSignature);
2140 if (IsEventLogging() != MagickFalse)
2141 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2142 LockSemaphoreInfo(image->semaphore);
2143 image->reference_count++;
2144 UnlockSemaphoreInfo(image->semaphore);
2145 return(image);
2146}
2147
2148/*
2149%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2150% %
2151% %
2152% %
2153% R e s e t I m a g e P a g e %
2154% %
2155% %
2156% %
2157%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2158%
2159% ResetImagePage() resets the image page canvas and position.
2160%
2161% The format of the ResetImagePage method is:
2162%
2163% MagickBooleanType ResetImagePage(Image *image,const char *page)
2164%
2165% A description of each parameter follows:
2166%
2167% o image: the image.
2168%
2169% o page: the relative page specification.
2170%
2171*/
2172MagickExport MagickBooleanType ResetImagePage(Image *image,const char *page)
2173{
2174 MagickStatusType
2175 flags;
2176
2178 geometry;
2179
2180 assert(image != (Image *) NULL);
2181 assert(image->signature == MagickCoreSignature);
2182 if (IsEventLogging() != MagickFalse)
2183 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2184 flags=ParseAbsoluteGeometry(page,&geometry);
2185 if ((flags & WidthValue) != 0)
2186 {
2187 if ((flags & HeightValue) == 0)
2188 geometry.height=geometry.width;
2189 image->page.width=geometry.width;
2190 image->page.height=geometry.height;
2191 }
2192 if ((flags & AspectValue) != 0)
2193 {
2194 if ((flags & XValue) != 0)
2195 image->page.x+=geometry.x;
2196 if ((flags & YValue) != 0)
2197 image->page.y+=geometry.y;
2198 }
2199 else
2200 {
2201 if ((flags & XValue) != 0)
2202 {
2203 image->page.x=geometry.x;
2204 if ((image->page.width == 0) && (geometry.x > 0))
2205 image->page.width=(size_t) ((ssize_t) image->columns+geometry.x);
2206 }
2207 if ((flags & YValue) != 0)
2208 {
2209 image->page.y=geometry.y;
2210 if ((image->page.height == 0) && (geometry.y > 0))
2211 image->page.height=(size_t) ((ssize_t) image->rows+geometry.y);
2212 }
2213 }
2214 return(MagickTrue);
2215}
2216
2217/*
2218%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2219% %
2220% %
2221% %
2222% R e s e t I m a g e P i x e l s %
2223% %
2224% %
2225% %
2226%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2227%
2228% ResetImagePixels() reset the image pixels, that is, all the pixel components
2229% are zeroed.
2230%
2231% The format of the SetImage method is:
2232%
2233% MagickBooleanType ResetImagePixels(Image *image,
2234% ExceptionInfo *exception)
2235%
2236% A description of each parameter follows:
2237%
2238% o image: the image.
2239%
2240% o exception: return any errors or warnings in this structure.
2241%
2242*/
2243MagickExport MagickBooleanType ResetImagePixels(Image *image,
2244 ExceptionInfo *exception)
2245{
2246 CacheView
2247 *image_view;
2248
2249 MagickBooleanType
2250 status;
2251
2252 size_t
2253 length;
2254
2255 ssize_t
2256 y;
2257
2258 void
2259 *pixels;
2260
2261 assert(image != (Image *) NULL);
2262 assert(image->signature == MagickCoreSignature);
2263 if (IsEventLogging() != MagickFalse)
2264 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2265 pixels=AcquirePixelCachePixels(image,&length,exception);
2266 if (pixels != (void *) NULL)
2267 {
2268 /*
2269 Reset in-core image pixels.
2270 */
2271 (void) memset(pixels,0,length);
2272 return(MagickTrue);
2273 }
2274 /*
2275 Reset image pixels.
2276 */
2277 status=MagickTrue;
2278 image_view=AcquireAuthenticCacheView(image,exception);
2279#if defined(MAGICKCORE_OPENMP_SUPPORT)
2280 #pragma omp parallel for schedule(static) shared(status) \
2281 magick_number_threads(image,image,image->rows,2)
2282#endif
2283 for (y=0; y < (ssize_t) image->rows; y++)
2284 {
2285 Quantum
2286 *magick_restrict q;
2287
2288 ssize_t
2289 x;
2290
2291 if (status == MagickFalse)
2292 continue;
2293 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2294 if (q == (Quantum *) NULL)
2295 {
2296 status=MagickFalse;
2297 continue;
2298 }
2299 for (x=0; x < (ssize_t) image->columns; x++)
2300 {
2301 (void) memset(q,0,GetPixelChannels(image)*sizeof(Quantum));
2302 q+=(ptrdiff_t) GetPixelChannels(image);
2303 }
2304 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2305 status=MagickFalse;
2306 }
2307 image_view=DestroyCacheView(image_view);
2308 return(status);
2309}
2310
2311/*
2312%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2313% %
2314% %
2315% %
2316% S e t I m a g e A l p h a %
2317% %
2318% %
2319% %
2320%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2321%
2322% SetImageAlpha() sets the alpha levels of the image.
2323%
2324% The format of the SetImageAlpha method is:
2325%
2326% MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
2327% ExceptionInfo *exception)
2328%
2329% A description of each parameter follows:
2330%
2331% o image: the image.
2332%
2333% o alpha: the level of transparency: 0 is fully transparent and QuantumRange
2334% is fully opaque.
2335%
2336% o exception: return any errors or warnings in this structure.
2337%
2338*/
2339MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
2340 ExceptionInfo *exception)
2341{
2342 CacheView
2343 *image_view;
2344
2345 MagickBooleanType
2346 status;
2347
2348 ssize_t
2349 y;
2350
2351 assert(image != (Image *) NULL);
2352 assert(image->signature == MagickCoreSignature);
2353 if (IsEventLogging() != MagickFalse)
2354 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2355 image->alpha_trait=BlendPixelTrait;
2356 status=MagickTrue;
2357 image_view=AcquireAuthenticCacheView(image,exception);
2358#if defined(MAGICKCORE_OPENMP_SUPPORT)
2359 #pragma omp parallel for schedule(static) shared(status) \
2360 magick_number_threads(image,image,image->rows,2)
2361#endif
2362 for (y=0; y < (ssize_t) image->rows; y++)
2363 {
2364 Quantum
2365 *magick_restrict q;
2366
2367 ssize_t
2368 x;
2369
2370 if (status == MagickFalse)
2371 continue;
2372 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2373 if (q == (Quantum *) NULL)
2374 {
2375 status=MagickFalse;
2376 continue;
2377 }
2378 for (x=0; x < (ssize_t) image->columns; x++)
2379 {
2380 if (GetPixelWriteMask(image,q) > (QuantumRange/2))
2381 SetPixelAlpha(image,alpha,q);
2382 q+=(ptrdiff_t) GetPixelChannels(image);
2383 }
2384 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2385 status=MagickFalse;
2386 }
2387 image_view=DestroyCacheView(image_view);
2388 return(status);
2389}
2390
2391/*
2392%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2393% %
2394% %
2395% %
2396% S e t I m a g e B a c k g r o u n d C o l o r %
2397% %
2398% %
2399% %
2400%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2401%
2402% SetImageBackgroundColor() initializes the image pixels to the image
2403% background color. The background color is defined by the background_color
2404% member of the image structure.
2405%
2406% The format of the SetImage method is:
2407%
2408% MagickBooleanType SetImageBackgroundColor(Image *image,
2409% ExceptionInfo *exception)
2410%
2411% A description of each parameter follows:
2412%
2413% o image: the image.
2414%
2415% o exception: return any errors or warnings in this structure.
2416%
2417*/
2418MagickExport MagickBooleanType SetImageBackgroundColor(Image *image,
2419 ExceptionInfo *exception)
2420{
2421 CacheView
2422 *image_view;
2423
2424 MagickBooleanType
2425 status;
2426
2427 PixelInfo
2428 background;
2429
2430 ssize_t
2431 y;
2432
2433 assert(image != (Image *) NULL);
2434 assert(image->signature == MagickCoreSignature);
2435 if (IsEventLogging() != MagickFalse)
2436 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2437 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2438 return(MagickFalse);
2439 if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
2440 ((image->alpha_trait & BlendPixelTrait) == 0))
2441 (void) SetImageAlphaChannel(image,ActivateAlphaChannel,exception);
2442 ConformPixelInfo(image,&image->background_color,&background,exception);
2443 /*
2444 Set image background color.
2445 */
2446 status=MagickTrue;
2447 image_view=AcquireAuthenticCacheView(image,exception);
2448#if defined(MAGICKCORE_OPENMP_SUPPORT)
2449 #pragma omp parallel for schedule(static) shared(status) \
2450 magick_number_threads(image,image,image->rows,2)
2451#endif
2452 for (y=0; y < (ssize_t) image->rows; y++)
2453 {
2454 Quantum
2455 *magick_restrict q;
2456
2457 ssize_t
2458 x;
2459
2460 if (status == MagickFalse)
2461 continue;
2462 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2463 if (q == (Quantum *) NULL)
2464 {
2465 status=MagickFalse;
2466 continue;
2467 }
2468 for (x=0; x < (ssize_t) image->columns; x++)
2469 {
2470 SetPixelViaPixelInfo(image,&background,q);
2471 q+=(ptrdiff_t) GetPixelChannels(image);
2472 }
2473 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2474 status=MagickFalse;
2475 }
2476 image_view=DestroyCacheView(image_view);
2477 return(status);
2478}
2479
2480/*
2481%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2482% %
2483% %
2484% %
2485% S e t I m a g e C h a n n e l M a s k %
2486% %
2487% %
2488% %
2489%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2490%
2491% SetImageChannelMask() sets the image channel mask from the specified channel
2492% mask.
2493%
2494% The format of the SetImageChannelMask method is:
2495%
2496% ChannelType SetImageChannelMask(Image *image,
2497% const ChannelType channel_mask)
2498%
2499% A description of each parameter follows:
2500%
2501% o image: the image.
2502%
2503% o channel_mask: the channel mask.
2504%
2505*/
2506MagickExport ChannelType SetImageChannelMask(Image *image,
2507 const ChannelType channel_mask)
2508{
2509 return(SetPixelChannelMask(image,channel_mask));
2510}
2511
2512/*
2513%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2514% %
2515% %
2516% %
2517% S e t I m a g e C o l o r %
2518% %
2519% %
2520% %
2521%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2522%
2523% SetImageColor() set the entire image canvas to the specified color.
2524%
2525% The format of the SetImageColor method is:
2526%
2527% MagickBooleanType SetImageColor(Image *image,const PixelInfo *color,
2528% ExceptionInfo *exception)
2529%
2530% A description of each parameter follows:
2531%
2532% o image: the image.
2533%
2534% o background: the image color.
2535%
2536% o exception: return any errors or warnings in this structure.
2537%
2538*/
2539MagickExport MagickBooleanType SetImageColor(Image *image,
2540 const PixelInfo *color,ExceptionInfo *exception)
2541{
2542 CacheView
2543 *image_view;
2544
2545 MagickBooleanType
2546 status;
2547
2548 ssize_t
2549 y;
2550
2551 assert(image != (Image *) NULL);
2552 assert(image->signature == MagickCoreSignature);
2553 assert(color != (const PixelInfo *) NULL);
2554 if (IsEventLogging() != MagickFalse)
2555 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2556 image->colorspace=color->colorspace;
2557 image->alpha_trait=color->alpha_trait;
2558 image->fuzz=color->fuzz;
2559 image->depth=color->depth;
2560 status=MagickTrue;
2561 image_view=AcquireAuthenticCacheView(image,exception);
2562#if defined(MAGICKCORE_OPENMP_SUPPORT)
2563 #pragma omp parallel for schedule(static) shared(status) \
2564 magick_number_threads(image,image,image->rows,2)
2565#endif
2566 for (y=0; y < (ssize_t) image->rows; y++)
2567 {
2568 Quantum
2569 *magick_restrict q;
2570
2571 ssize_t
2572 x;
2573
2574 if (status == MagickFalse)
2575 continue;
2576 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2577 if (q == (Quantum *) NULL)
2578 {
2579 status=MagickFalse;
2580 continue;
2581 }
2582 for (x=0; x < (ssize_t) image->columns; x++)
2583 {
2584 SetPixelViaPixelInfo(image,color,q);
2585 q+=(ptrdiff_t) GetPixelChannels(image);
2586 }
2587 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2588 status=MagickFalse;
2589 }
2590 image_view=DestroyCacheView(image_view);
2591 return(status);
2592}
2593
2594/*
2595%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2596% %
2597% %
2598% %
2599% S e t I m a g e S t o r a g e C l a s s %
2600% %
2601% %
2602% %
2603%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2604%
2605% SetImageStorageClass() sets the image class: DirectClass for true color
2606% images or PseudoClass for colormapped images.
2607%
2608% The format of the SetImageStorageClass method is:
2609%
2610% MagickBooleanType SetImageStorageClass(Image *image,
2611% const ClassType storage_class,ExceptionInfo *exception)
2612%
2613% A description of each parameter follows:
2614%
2615% o image: the image.
2616%
2617% o storage_class: The image class.
2618%
2619% o exception: return any errors or warnings in this structure.
2620%
2621*/
2622MagickExport MagickBooleanType SetImageStorageClass(Image *image,
2623 const ClassType storage_class,ExceptionInfo *exception)
2624{
2625 assert(image != (Image *) NULL);
2626 assert(image->signature == MagickCoreSignature);
2627 assert(exception != (ExceptionInfo *) NULL);
2628 assert(exception->signature == MagickCoreSignature);
2629 if (IsEventLogging() != MagickFalse)
2630 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2631 image->storage_class=storage_class;
2632 return(SyncImagePixelCache(image,exception));
2633}
2634
2635/*
2636%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2637% %
2638% %
2639% %
2640% S e t I m a g e E x t e n t %
2641% %
2642% %
2643% %
2644%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2645%
2646% SetImageExtent() sets the image size (i.e. columns & rows).
2647%
2648% The format of the SetImageExtent method is:
2649%
2650% MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2651% const size_t rows,ExceptionInfo *exception)
2652%
2653% A description of each parameter follows:
2654%
2655% o image: the image.
2656%
2657% o columns: The image width in pixels.
2658%
2659% o rows: The image height in pixels.
2660%
2661% o exception: return any errors or warnings in this structure.
2662%
2663*/
2664MagickExport MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2665 const size_t rows,ExceptionInfo *exception)
2666{
2667 if ((columns == 0) || (rows == 0))
2668 ThrowBinaryException(ImageError,"NegativeOrZeroImageSize",image->filename);
2669 image->columns=columns;
2670 image->rows=rows;
2671 if (image->depth == 0)
2672 {
2673 image->depth=8;
2674 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2675 "ImageDepthNotSupported","`%s'",image->filename);
2676 }
2677 if (image->depth > (8*sizeof(MagickSizeType)))
2678 {
2679 image->depth=8*sizeof(MagickSizeType);
2680 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2681 "ImageDepthNotSupported","`%s'",image->filename);
2682 }
2683 return(SyncImagePixelCache(image,exception));
2684}
2685
2686/*
2687%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2688% %
2689% %
2690% %
2691+ S e t I m a g e I n f o %
2692% %
2693% %
2694% %
2695%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2696%
2697% SetImageInfo() initializes the 'magick' field of the ImageInfo structure.
2698% It is set to a type of image format based on the prefix or suffix of the
2699% filename. For example, 'ps:image' returns PS indicating a Postscript image.
2700% JPEG is returned for this filename: 'image.jpg'. The filename prefix has
2701% precedence over the suffix. Use an optional index enclosed in brackets
2702% after a file name to specify a desired scene of a multi-resolution image
2703% format like Photo CD (e.g. img0001.pcd[4]). A True (non-zero) return value
2704% indicates success.
2705%
2706% The format of the SetImageInfo method is:
2707%
2708% MagickBooleanType SetImageInfo(ImageInfo *image_info,
2709% const unsigned int frames,ExceptionInfo *exception)
2710%
2711% A description of each parameter follows:
2712%
2713% o image_info: the image info.
2714%
2715% o frames: the number of images you intend to write.
2716%
2717% o exception: return any errors or warnings in this structure.
2718%
2719*/
2720
2721static const MagickInfo *SetImageInfoFromExtension(ImageInfo *image_info,
2722 const char *component,char *magic,ExceptionInfo *exception)
2723{
2724 const MagickInfo
2725 *magick_info;
2726
2727 MagickFormatType
2728 format_type;
2729
2730 ssize_t
2731 i;
2732
2733 static const char
2734 *format_type_formats[] =
2735 {
2736 "AUTOTRACE",
2737 "BROWSE",
2738 "DCRAW",
2739 "EDIT",
2740 "LAUNCH",
2741 "MPEG:DECODE",
2742 "MPEG:ENCODE",
2743 "PRINT",
2744 "PS:ALPHA",
2745 "PS:CMYK",
2746 "PS:COLOR",
2747 "PS:GRAY",
2748 "PS:MONO",
2749 "SCAN",
2750 "SHOW",
2751 "WIN",
2752 (char *) NULL
2753 };
2754
2755 /*
2756 User specified image format.
2757 */
2758 (void) CopyMagickString(magic,component,MagickPathExtent);
2759 LocaleUpper(magic);
2760 /*
2761 Look for explicit image formats.
2762 */
2763 format_type=UndefinedFormatType;
2764 magick_info=GetMagickInfo(magic,exception);
2765 if ((magick_info != (const MagickInfo *) NULL) &&
2766 (magick_info->format_type != UndefinedFormatType))
2767 format_type=magick_info->format_type;
2768 i=0;
2769 while ((format_type == UndefinedFormatType) &&
2770 (format_type_formats[i] != (char *) NULL))
2771 {
2772 if ((*magic == *format_type_formats[i]) &&
2773 (LocaleCompare(magic,format_type_formats[i]) == 0))
2774 format_type=ExplicitFormatType;
2775 i++;
2776 }
2777 if (format_type == UndefinedFormatType)
2778 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2779 else
2780 if (format_type == ExplicitFormatType)
2781 {
2782 image_info->affirm=MagickTrue;
2783 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2784 }
2785 if (LocaleCompare(magic,"RGB") == 0)
2786 image_info->affirm=MagickFalse; /* maybe SGI disguised as RGB */
2787 return(magick_info);
2788}
2789
2790MagickExport MagickBooleanType SetImageInfo(ImageInfo *image_info,
2791 const unsigned int frames,ExceptionInfo *exception)
2792{
2793 char
2794 component[MagickPathExtent],
2795 magic[MagickPathExtent],
2796 path[MagickPathExtent],
2797 *q;
2798
2799 const MagicInfo
2800 *magic_info;
2801
2802 const MagickInfo
2803 *magick_info;
2804
2806 *sans_exception;
2807
2808 Image
2809 *image;
2810
2811 MagickBooleanType
2812 status;
2813
2814 const char
2815 *p;
2816
2817 ssize_t
2818 count;
2819
2820 /*
2821 Look for 'image.format' in filename.
2822 */
2823 assert(image_info != (ImageInfo *) NULL);
2824 assert(image_info->signature == MagickCoreSignature);
2825 if (IsEventLogging() != MagickFalse)
2826 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2827 image_info->filename);
2828 *component='\0';
2829 GetPathComponent(image_info->filename,SubimagePath,component);
2830 if (*component != '\0')
2831 {
2832 /*
2833 Look for scene specification (e.g. img0001.pcd[4]).
2834 */
2835 if (IsSceneGeometry(component,MagickFalse) == MagickFalse)
2836 {
2837 if (IsGeometry(component) != MagickFalse)
2838 (void) CloneString(&image_info->extract,component);
2839 }
2840 else
2841 {
2842 size_t
2843 first,
2844 last;
2845
2846 (void) CloneString(&image_info->scenes,component);
2847 image_info->scene=StringToUnsignedLong(image_info->scenes);
2848 image_info->number_scenes=image_info->scene;
2849 p=image_info->scenes;
2850 for (q=(char *) image_info->scenes; *q != '\0'; p++)
2851 {
2852 while ((isspace((int) ((unsigned char) *p)) != 0) || (*p == ','))
2853 p++;
2854 first=(size_t) strtol(p,&q,10);
2855 last=first;
2856 while (isspace((int) ((unsigned char) *q)) != 0)
2857 q++;
2858 if (*q == '-')
2859 last=(size_t) strtol(q+1,&q,10);
2860 if (first > last)
2861 Swap(first,last);
2862 if (first < image_info->scene)
2863 image_info->scene=first;
2864 if (last > image_info->number_scenes)
2865 image_info->number_scenes=last;
2866 p=q;
2867 }
2868 image_info->number_scenes-=image_info->scene-1;
2869 }
2870 }
2871 *component='\0';
2872 if (*image_info->magick == '\0')
2873 GetPathComponent(image_info->filename,ExtensionPath,component);
2874 if (*component != '\0')
2875 {
2876 /*
2877 Base path sans any compression extension.
2878 */
2879 GetPathComponent(image_info->filename,BasePathSansCompressExtension,path);
2880 GetPathComponent(path,ExtensionPath,component);
2881 }
2882 image_info->affirm=MagickFalse;
2883 sans_exception=AcquireExceptionInfo();
2884 if ((*component != '\0') && (IsGlob(component) == MagickFalse))
2885 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2886 sans_exception);
2887 /*
2888 Look for explicit 'format:image' in filename.
2889 */
2890 *magic='\0';
2891 GetPathComponent(image_info->filename,MagickPath,magic);
2892 if (*magic == '\0')
2893 {
2894 (void) CopyMagickString(magic,image_info->magick,MagickPathExtent);
2895 magick_info=GetMagickInfo(magic,sans_exception);
2896 if ((magick_info != (const MagickInfo *) NULL) &&
2897 (magick_info->format_type == ExplicitFormatType))
2898 image_info->affirm=MagickTrue;
2899 if (frames == 0)
2900 GetPathComponent(image_info->filename,CanonicalPath,component);
2901 else
2902 GetPathComponent(image_info->filename,SubcanonicalPath,component);
2903 (void) CopyMagickString(image_info->filename,component,MagickPathExtent);
2904 }
2905 else
2906 {
2907 const DelegateInfo
2908 *delegate_info;
2909
2910 /*
2911 User specified image format.
2912 */
2913 LocaleUpper(magic);
2914 magick_info=GetMagickInfo(magic,sans_exception);
2915 delegate_info=(const DelegateInfo *) NULL;
2916 if (magick_info == (const MagickInfo *) NULL)
2917 {
2918 delegate_info=GetDelegateInfo(magic,"*",sans_exception);
2919 if (delegate_info == (const DelegateInfo *) NULL)
2920 delegate_info=GetDelegateInfo("*",magic,sans_exception);
2921 if ((delegate_info == (const DelegateInfo *) NULL) &&
2922 ((*component != '\0') && (IsGlob(component) == MagickFalse)))
2923 {
2924 /*
2925 Retry in case GetMagickInfo loaded a custom module.
2926 */
2927 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2928 sans_exception);
2929 }
2930 }
2931 if (((magick_info != (const MagickInfo *) NULL) ||
2932 (delegate_info != (const DelegateInfo *) NULL)) &&
2933 (IsMagickConflict(magic) == MagickFalse))
2934 {
2935 image_info->affirm=MagickTrue;
2936 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2937 GetPathComponent(image_info->filename,CanonicalPath,component);
2938 (void) CopyMagickString(image_info->filename,component,
2939 MagickPathExtent);
2940 }
2941 }
2942 sans_exception=DestroyExceptionInfo(sans_exception);
2943 if ((magick_info == (const MagickInfo *) NULL) ||
2944 (GetMagickEndianSupport(magick_info) == MagickFalse))
2945 image_info->endian=UndefinedEndian;
2946 if ((image_info->adjoin != MagickFalse) && (frames > 1))
2947 {
2948 /*
2949 Test for multiple image support (e.g. image%02d.png).
2950 */
2951 (void) InterpretImageFilename(image_info,(Image *) NULL,
2952 image_info->filename,(int) image_info->scene,component,exception);
2953 if ((LocaleCompare(component,image_info->filename) != 0) &&
2954 (strchr(component,'%') == (char *) NULL))
2955 image_info->adjoin=MagickFalse;
2956 }
2957 if ((image_info->adjoin != MagickFalse) && (frames > 0))
2958 {
2959 /*
2960 Some image formats do not support multiple frames per file.
2961 */
2962 magick_info=GetMagickInfo(magic,exception);
2963 if (magick_info != (const MagickInfo *) NULL)
2964 if (GetMagickAdjoin(magick_info) == MagickFalse)
2965 image_info->adjoin=MagickFalse;
2966 }
2967 if (image_info->affirm != MagickFalse)
2968 return(MagickTrue);
2969 if (frames == 0)
2970 {
2971 unsigned char
2972 *magick;
2973
2974 size_t
2975 magick_size;
2976
2977 /*
2978 Determine the image format from the first few bytes of the file.
2979 */
2980 magick_size=GetMagicPatternExtent(exception);
2981 if (magick_size == 0)
2982 return(MagickFalse);
2983 image=AcquireImage(image_info,exception);
2984 (void) CopyMagickString(image->filename,image_info->filename,
2985 MagickPathExtent);
2986 sans_exception=AcquireExceptionInfo();
2987 status=OpenBlob(image_info,image,ReadBinaryBlobMode,sans_exception);
2988 sans_exception=DestroyExceptionInfo(sans_exception);
2989 if (status == MagickFalse)
2990 {
2991 image=DestroyImage(image);
2992 return(MagickFalse);
2993 }
2994 if ((IsBlobSeekable(image) == MagickFalse) ||
2995 (IsBlobExempt(image) != MagickFalse))
2996 {
2997 /*
2998 Copy image to seekable temporary file.
2999 */
3000 *component='\0';
3001 status=ImageToFile(image,component,exception);
3002 if (CloseBlob(image) == MagickFalse)
3003 status=MagickFalse;
3004 if (status == MagickFalse)
3005 {
3006 (void) RelinquishUniqueFileResource(component);
3007 image=DestroyImage(image);
3008 return(MagickFalse);
3009 }
3010 SetImageInfoFile(image_info,(FILE *) NULL);
3011 (void) CopyMagickString(image->filename,component,MagickPathExtent);
3012 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
3013 if (status == MagickFalse)
3014 {
3015 (void) RelinquishUniqueFileResource(component);
3016 image=DestroyImage(image);
3017 return(MagickFalse);
3018 }
3019 (void) CopyMagickString(image_info->filename,component,
3020 MagickPathExtent);
3021 image_info->temporary=MagickTrue;
3022 }
3023 magick=(unsigned char *) AcquireQuantumMemory(1,magick_size);
3024 if (magick == (unsigned char *) NULL)
3025 {
3026 (void) CloseBlob(image);
3027 image=DestroyImage(image);
3028 return(MagickFalse);
3029 }
3030 (void) memset(magick,0,magick_size);
3031 count=ReadBlob(image,magick_size,magick);
3032 (void) SeekBlob(image,-((MagickOffsetType) count),SEEK_CUR);
3033 (void) CloseBlob(image);
3034 image=DestroyImage(image);
3035 /*
3036 Check magic cache.
3037 */
3038 sans_exception=AcquireExceptionInfo();
3039 magic_info=GetMagicInfo(magick,(size_t) count,sans_exception);
3040 magick=(unsigned char *) RelinquishMagickMemory(magick);
3041 if ((magic_info != (const MagicInfo *) NULL) &&
3042 (GetMagicName(magic_info) != (char *) NULL))
3043 {
3044 /*
3045 Try to use magick_info that was determined earlier by the extension
3046 */
3047 if ((magick_info != (const MagickInfo *) NULL) &&
3048 (GetMagickUseExtension(magick_info) != MagickFalse) &&
3049 (LocaleCompare(magick_info->magick_module,GetMagicName(
3050 magic_info)) == 0))
3051 (void) CopyMagickString(image_info->magick,magick_info->name,
3052 MagickPathExtent);
3053 else
3054 {
3055 (void) CopyMagickString(image_info->magick,GetMagicName(
3056 magic_info),MagickPathExtent);
3057 magick_info=GetMagickInfo(image_info->magick,sans_exception);
3058 }
3059 if ((magick_info == (const MagickInfo *) NULL) ||
3060 (GetMagickEndianSupport(magick_info) == MagickFalse))
3061 image_info->endian=UndefinedEndian;
3062 sans_exception=DestroyExceptionInfo(sans_exception);
3063 return(MagickTrue);
3064 }
3065 magick_info=GetMagickInfo(image_info->magick,sans_exception);
3066 if ((magick_info == (const MagickInfo *) NULL) ||
3067 (GetMagickEndianSupport(magick_info) == MagickFalse))
3068 image_info->endian=UndefinedEndian;
3069 sans_exception=DestroyExceptionInfo(sans_exception);
3070 }
3071 return(MagickTrue);
3072}
3073
3074/*
3075%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3076% %
3077% %
3078% %
3079% S e t I m a g e I n f o B l o b %
3080% %
3081% %
3082% %
3083%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3084%
3085% SetImageInfoBlob() sets the image info blob member.
3086%
3087% The format of the SetImageInfoBlob method is:
3088%
3089% void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3090% const size_t length)
3091%
3092% A description of each parameter follows:
3093%
3094% o image_info: the image info.
3095%
3096% o blob: the blob.
3097%
3098% o length: the blob length.
3099%
3100*/
3101MagickExport void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3102 const size_t length)
3103{
3104 assert(image_info != (ImageInfo *) NULL);
3105 assert(image_info->signature == MagickCoreSignature);
3106 if (IsEventLogging() != MagickFalse)
3107 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3108 image_info->filename);
3109 image_info->blob=(void *) blob;
3110 image_info->length=length;
3111}
3112
3113/*
3114%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3115% %
3116% %
3117% %
3118% S e t I m a g e I n f o C u s t o m S t r e a m %
3119% %
3120% %
3121% %
3122%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3123%
3124% SetImageInfoCustomStream() sets the image info custom stream handlers.
3125%
3126% The format of the SetImageInfoCustomStream method is:
3127%
3128% void SetImageInfoCustomStream(ImageInfo *image_info,
3129% CustomStreamInfo *custom_stream)
3130%
3131% A description of each parameter follows:
3132%
3133% o image_info: the image info.
3134%
3135% o custom_stream: your custom stream methods.
3136%
3137*/
3138MagickExport void SetImageInfoCustomStream(ImageInfo *image_info,
3139 CustomStreamInfo *custom_stream)
3140{
3141 assert(image_info != (ImageInfo *) NULL);
3142 assert(image_info->signature == MagickCoreSignature);
3143 if (IsEventLogging() != MagickFalse)
3144 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3145 image_info->filename);
3146 image_info->custom_stream=(CustomStreamInfo *) custom_stream;
3147}
3148
3149/*
3150%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3151% %
3152% %
3153% %
3154% S e t I m a g e I n f o F i l e %
3155% %
3156% %
3157% %
3158%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3159%
3160% SetImageInfoFile() sets the image info file member.
3161%
3162% The format of the SetImageInfoFile method is:
3163%
3164% void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3165%
3166% A description of each parameter follows:
3167%
3168% o image_info: the image info.
3169%
3170% o file: the file.
3171%
3172*/
3173MagickExport void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3174{
3175 assert(image_info != (ImageInfo *) NULL);
3176 assert(image_info->signature == MagickCoreSignature);
3177 if (IsEventLogging() != MagickFalse)
3178 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3179 image_info->filename);
3180 image_info->file=file;
3181}
3182
3183/*
3184%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3185% %
3186% %
3187% %
3188% S e t I m a g e M a s k %
3189% %
3190% %
3191% %
3192%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3193%
3194% SetImageMask() associates a mask with the image. The mask must be the same
3195% dimensions as the image.
3196%
3197% The format of the SetImageMask method is:
3198%
3199% MagickBooleanType SetImageMask(Image *image,const PixelMask type,
3200% const Image *mask,ExceptionInfo *exception)
3201%
3202% A description of each parameter follows:
3203%
3204% o image: the image.
3205%
3206% o type: the mask type, ReadPixelMask or WritePixelMask.
3207%
3208% o mask: the image mask.
3209%
3210% o exception: return any errors or warnings in this structure.
3211%
3212*/
3213MagickExport MagickBooleanType SetImageMask(Image *image,const PixelMask type,
3214 const Image *mask,ExceptionInfo *exception)
3215{
3216 CacheView
3217 *mask_view,
3218 *image_view;
3219
3220 MagickBooleanType
3221 status;
3222
3223 ssize_t
3224 y;
3225
3226 /*
3227 Set image mask.
3228 */
3229 assert(image != (Image *) NULL);
3230 if (IsEventLogging() != MagickFalse)
3231 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3232 assert(image->signature == MagickCoreSignature);
3233 if (mask == (const Image *) NULL)
3234 {
3235 switch (type)
3236 {
3237 case ReadPixelMask:
3238 {
3239 image->channels=(ChannelType) ((unsigned int) image->channels &
3240 (unsigned int) ~ReadMaskChannel);
3241 break;
3242 }
3243 case WritePixelMask:
3244 {
3245 image->channels=(ChannelType) ((unsigned int) image->channels &
3246 (unsigned int) ~WriteMaskChannel);
3247 magick_fallthrough;
3248 }
3249 default:
3250 {
3251 image->channels=(ChannelType) ((unsigned int) image->channels &
3252 (unsigned int) ~CompositeMaskChannel);
3253 break;
3254 }
3255 }
3256 return(SyncImagePixelCache(image,exception));
3257 }
3258 switch (type)
3259 {
3260 case ReadPixelMask:
3261 {
3262 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3263 break;
3264 }
3265 case WritePixelMask:
3266 {
3267 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3268 break;
3269 }
3270 default:
3271 {
3272 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3273 break;
3274 }
3275 }
3276 if (SyncImagePixelCache(image,exception) == MagickFalse)
3277 return(MagickFalse);
3278 status=MagickTrue;
3279 image->mask_trait=UpdatePixelTrait;
3280 mask_view=AcquireVirtualCacheView(mask,exception);
3281 image_view=AcquireAuthenticCacheView(image,exception);
3282#if defined(MAGICKCORE_OPENMP_SUPPORT)
3283 #pragma omp parallel for schedule(static) shared(status) \
3284 magick_number_threads(mask,image,image->rows,2)
3285#endif
3286 for (y=0; y < (ssize_t) image->rows; y++)
3287 {
3288 const Quantum
3289 *magick_restrict p;
3290
3291 Quantum
3292 *magick_restrict q;
3293
3294 ssize_t
3295 x;
3296
3297 if (status == MagickFalse)
3298 continue;
3299 p=GetCacheViewVirtualPixels(mask_view,0,y,mask->columns,1,exception);
3300 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3301 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3302 {
3303 status=MagickFalse;
3304 continue;
3305 }
3306 for (x=0; x < (ssize_t) image->columns; x++)
3307 {
3308 MagickRealType
3309 intensity;
3310
3311 intensity=0.0;
3312 if ((x < (ssize_t) mask->columns) && (y < (ssize_t) mask->rows))
3313 intensity=GetPixelIntensity(mask,p);
3314 switch (type)
3315 {
3316 case ReadPixelMask:
3317 {
3318 SetPixelReadMask(image,ClampToQuantum(intensity),q);
3319 break;
3320 }
3321 case WritePixelMask:
3322 {
3323 SetPixelWriteMask(image,ClampToQuantum(intensity),q);
3324 break;
3325 }
3326 default:
3327 {
3328 SetPixelCompositeMask(image,ClampToQuantum(intensity),q);
3329 break;
3330 }
3331 }
3332 p+=(ptrdiff_t) GetPixelChannels(mask);
3333 q+=(ptrdiff_t) GetPixelChannels(image);
3334 }
3335 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3336 status=MagickFalse;
3337 }
3338 image->mask_trait=UndefinedPixelTrait;
3339 mask_view=DestroyCacheView(mask_view);
3340 image_view=DestroyCacheView(image_view);
3341 return(status);
3342}
3343
3344/*
3345%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3346% %
3347% %
3348% %
3349% S e t I m a g e R e g i o n M a s k %
3350% %
3351% %
3352% %
3353%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3354%
3355% SetImageRegionMask() associates a mask with the image as defined by the
3356% specified region.
3357%
3358% The format of the SetImageRegionMask method is:
3359%
3360% MagickBooleanType SetImageRegionMask(Image *image,const PixelMask type,
3361% const RectangleInfo *region,ExceptionInfo *exception)
3362%
3363% A description of each parameter follows:
3364%
3365% o image: the image.
3366%
3367% o type: the mask type, ReadPixelMask or WritePixelMask.
3368%
3369% o geometry: the mask region.
3370%
3371% o exception: return any errors or warnings in this structure.
3372%
3373*/
3374MagickExport MagickBooleanType SetImageRegionMask(Image *image,
3375 const PixelMask type,const RectangleInfo *region,ExceptionInfo *exception)
3376{
3377 CacheView
3378 *image_view;
3379
3380 MagickBooleanType
3381 status;
3382
3383 ssize_t
3384 y;
3385
3386 /*
3387 Set image mask as defined by the region.
3388 */
3389 assert(image != (Image *) NULL);
3390 assert(image->signature == MagickCoreSignature);
3391 if (IsEventLogging() != MagickFalse)
3392 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3393 if (region == (const RectangleInfo *) NULL)
3394 {
3395 switch (type)
3396 {
3397 case ReadPixelMask:
3398 {
3399 image->channels=(ChannelType) ((unsigned int) image->channels &
3400 (unsigned int) ~ReadMaskChannel);
3401 break;
3402 }
3403 case WritePixelMask:
3404 {
3405 image->channels=(ChannelType) ((unsigned int) image->channels &
3406 (unsigned int) ~WriteMaskChannel);
3407 break;
3408 }
3409 default:
3410 {
3411 image->channels=(ChannelType) ((unsigned int) image->channels &
3412 (unsigned int) ~CompositeMaskChannel);
3413 break;
3414 }
3415 }
3416 return(SyncImagePixelCache(image,exception));
3417 }
3418 switch (type)
3419 {
3420 case ReadPixelMask:
3421 {
3422 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3423 break;
3424 }
3425 case WritePixelMask:
3426 {
3427 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3428 break;
3429 }
3430 default:
3431 {
3432 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3433 break;
3434 }
3435 }
3436 if (SyncImagePixelCache(image,exception) == MagickFalse)
3437 return(MagickFalse);
3438 status=MagickTrue;
3439 image->mask_trait=UpdatePixelTrait;
3440 image_view=AcquireAuthenticCacheView(image,exception);
3441#if defined(MAGICKCORE_OPENMP_SUPPORT)
3442 #pragma omp parallel for schedule(static) shared(status) \
3443 magick_number_threads(image,image,image->rows,2)
3444#endif
3445 for (y=0; y < (ssize_t) image->rows; y++)
3446 {
3447 Quantum
3448 *magick_restrict q;
3449
3450 ssize_t
3451 x;
3452
3453 if (status == MagickFalse)
3454 continue;
3455 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3456 if (q == (Quantum *) NULL)
3457 {
3458 status=MagickFalse;
3459 continue;
3460 }
3461 for (x=0; x < (ssize_t) image->columns; x++)
3462 {
3463 Quantum
3464 pixel;
3465
3466 pixel=QuantumRange;
3467 if (((x >= region->x) && (x < (region->x+(ssize_t) region->width))) &&
3468 ((y >= region->y) && (y < (region->y+(ssize_t) region->height))))
3469 pixel=(Quantum) 0;
3470 switch (type)
3471 {
3472 case ReadPixelMask:
3473 {
3474 SetPixelReadMask(image,pixel,q);
3475 break;
3476 }
3477 case WritePixelMask:
3478 {
3479 SetPixelWriteMask(image,pixel,q);
3480 break;
3481 }
3482 default:
3483 {
3484 SetPixelCompositeMask(image,pixel,q);
3485 break;
3486 }
3487 }
3488 q+=(ptrdiff_t) GetPixelChannels(image);
3489 }
3490 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3491 status=MagickFalse;
3492 }
3493 image->mask_trait=UndefinedPixelTrait;
3494 image_view=DestroyCacheView(image_view);
3495 return(status);
3496}
3497
3498/*
3499%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3500% %
3501% %
3502% %
3503% 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 %
3504% %
3505% %
3506% %
3507%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3508%
3509% SetImageVirtualPixelMethod() sets the "virtual pixels" method for the
3510% image and returns the previous setting. A virtual pixel is any pixel access
3511% that is outside the boundaries of the image cache.
3512%
3513% The format of the SetImageVirtualPixelMethod() method is:
3514%
3515% VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3516% const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3517%
3518% A description of each parameter follows:
3519%
3520% o image: the image.
3521%
3522% o virtual_pixel_method: choose the type of virtual pixel.
3523%
3524% o exception: return any errors or warnings in this structure.
3525%
3526*/
3527MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3528 const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3529{
3530 assert(image != (const Image *) NULL);
3531 assert(image->signature == MagickCoreSignature);
3532 if (IsEventLogging() != MagickFalse)
3533 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3534 return(SetPixelCacheVirtualMethod(image,virtual_pixel_method,exception));
3535}
3536
3537/*
3538%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3539% %
3540% %
3541% %
3542% S m u s h I m a g e s %
3543% %
3544% %
3545% %
3546%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3547%
3548% SmushImages() takes all images from the current image pointer to the end
3549% of the image list and smushes them to each other top-to-bottom if the
3550% stack parameter is true, otherwise left-to-right.
3551%
3552% The current gravity setting now effects how the image is justified in the
3553% final image.
3554%
3555% The format of the SmushImages method is:
3556%
3557% Image *SmushImages(const Image *images,const MagickBooleanType stack,
3558% ExceptionInfo *exception)
3559%
3560% A description of each parameter follows:
3561%
3562% o images: the image sequence.
3563%
3564% o stack: A value other than 0 stacks the images top-to-bottom.
3565%
3566% o offset: minimum distance in pixels between images.
3567%
3568% o exception: return any errors or warnings in this structure.
3569%
3570*/
3571
3572static ssize_t SmushXGap(const Image *smush_image,const Image *images,
3573 const ssize_t offset,ExceptionInfo *exception)
3574{
3575 CacheView
3576 *left_view,
3577 *right_view;
3578
3579 const Image
3580 *left_image,
3581 *right_image;
3582
3584 left_geometry,
3585 right_geometry;
3586
3587 const Quantum
3588 *p;
3589
3590 ssize_t
3591 i,
3592 y;
3593
3594 size_t
3595 gap;
3596
3597 ssize_t
3598 x;
3599
3600 if (images->previous == (Image *) NULL)
3601 return(0);
3602 right_image=images;
3603 SetGeometry(smush_image,&right_geometry);
3604 GravityAdjustGeometry(right_image->columns,right_image->rows,
3605 right_image->gravity,&right_geometry);
3606 left_image=images->previous;
3607 SetGeometry(smush_image,&left_geometry);
3608 GravityAdjustGeometry(left_image->columns,left_image->rows,
3609 left_image->gravity,&left_geometry);
3610 gap=right_image->columns;
3611 left_view=AcquireVirtualCacheView(left_image,exception);
3612 right_view=AcquireVirtualCacheView(right_image,exception);
3613 for (y=0; y < (ssize_t) smush_image->rows; y++)
3614 {
3615 for (x=(ssize_t) left_image->columns-1; x > 0; x--)
3616 {
3617 p=GetCacheViewVirtualPixels(left_view,x,left_geometry.y+y,1,1,exception);
3618 if ((p == (const Quantum *) NULL) ||
3619 (GetPixelAlpha(left_image,p) != TransparentAlpha) ||
3620 (((ssize_t) left_image->columns-x-1) >= (ssize_t) gap))
3621 break;
3622 }
3623 i=(ssize_t) left_image->columns-x-1;
3624 for (x=0; x < (ssize_t) right_image->columns; x++)
3625 {
3626 p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1,
3627 exception);
3628 if ((p == (const Quantum *) NULL) ||
3629 (GetPixelAlpha(right_image,p) != TransparentAlpha) ||
3630 ((x+i) >= (ssize_t) gap))
3631 break;
3632 }
3633 if ((x+i) < (ssize_t) gap)
3634 gap=(size_t) (x+i);
3635 }
3636 right_view=DestroyCacheView(right_view);
3637 left_view=DestroyCacheView(left_view);
3638 if (y < (ssize_t) smush_image->rows)
3639 return(offset);
3640 return((ssize_t) gap-offset);
3641}
3642
3643static ssize_t SmushYGap(const Image *smush_image,const Image *images,
3644 const ssize_t offset,ExceptionInfo *exception)
3645{
3646 CacheView
3647 *bottom_view,
3648 *top_view;
3649
3650 const Image
3651 *bottom_image,
3652 *top_image;
3653
3655 bottom_geometry,
3656 top_geometry;
3657
3658 const Quantum
3659 *p;
3660
3661 ssize_t
3662 i,
3663 x;
3664
3665 size_t
3666 gap;
3667
3668 ssize_t
3669 y;
3670
3671 if (images->previous == (Image *) NULL)
3672 return(0);
3673 bottom_image=images;
3674 SetGeometry(smush_image,&bottom_geometry);
3675 GravityAdjustGeometry(bottom_image->columns,bottom_image->rows,
3676 bottom_image->gravity,&bottom_geometry);
3677 top_image=images->previous;
3678 SetGeometry(smush_image,&top_geometry);
3679 GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
3680 &top_geometry);
3681 gap=bottom_image->rows;
3682 top_view=AcquireVirtualCacheView(top_image,exception);
3683 bottom_view=AcquireVirtualCacheView(bottom_image,exception);
3684 for (x=0; x < (ssize_t) smush_image->columns; x++)
3685 {
3686 for (y=(ssize_t) top_image->rows-1; y > 0; y--)
3687 {
3688 p=GetCacheViewVirtualPixels(top_view,top_geometry.x+x,y,1,1,exception);
3689 if ((p == (const Quantum *) NULL) ||
3690 (GetPixelAlpha(top_image,p) != TransparentAlpha) ||
3691 (((ssize_t) top_image->rows-y-1) >= (ssize_t) gap))
3692 break;
3693 }
3694 i=(ssize_t) top_image->rows-y-1;
3695 for (y=0; y < (ssize_t) bottom_image->rows; y++)
3696 {
3697 p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1,
3698 exception);
3699 if ((p == (const Quantum *) NULL) ||
3700 (GetPixelAlpha(bottom_image,p) != TransparentAlpha) ||
3701 ((y+i) >= (ssize_t) gap))
3702 break;
3703 }
3704 if ((y+i) < (ssize_t) gap)
3705 gap=(size_t) (y+i);
3706 }
3707 bottom_view=DestroyCacheView(bottom_view);
3708 top_view=DestroyCacheView(top_view);
3709 if (x < (ssize_t) smush_image->columns)
3710 return(offset);
3711 return((ssize_t) gap-offset);
3712}
3713
3714MagickExport Image *SmushImages(const Image *images,
3715 const MagickBooleanType stack,const ssize_t offset,ExceptionInfo *exception)
3716{
3717#define SmushImageTag "Smush/Image"
3718
3719 const Image
3720 *image;
3721
3722 Image
3723 *smush_image;
3724
3725 MagickBooleanType
3726 proceed,
3727 status;
3728
3729 MagickOffsetType
3730 n;
3731
3732 PixelTrait
3733 alpha_trait;
3734
3736 geometry;
3737
3738 const Image
3739 *next;
3740
3741 size_t
3742 height,
3743 number_images,
3744 width;
3745
3746 ssize_t
3747 x_offset,
3748 y_offset;
3749
3750 /*
3751 Compute maximum area of smushed area.
3752 */
3753 assert(images != (Image *) NULL);
3754 assert(images->signature == MagickCoreSignature);
3755 assert(exception != (ExceptionInfo *) NULL);
3756 assert(exception->signature == MagickCoreSignature);
3757 if (IsEventLogging() != MagickFalse)
3758 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3759 image=images;
3760 alpha_trait=image->alpha_trait;
3761 number_images=1;
3762 width=image->columns;
3763 height=image->rows;
3764 next=GetNextImageInList(image);
3765 for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
3766 {
3767 if (next->alpha_trait != UndefinedPixelTrait)
3768 alpha_trait=BlendPixelTrait;
3769 number_images++;
3770 if (stack != MagickFalse)
3771 {
3772 if (next->columns > width)
3773 width=next->columns;
3774 height+=next->rows;
3775 if (next->previous != (Image *) NULL)
3776 height=(size_t) MagickMax((ssize_t) height+offset,0U);
3777 continue;
3778 }
3779 width+=next->columns;
3780 if (next->previous != (Image *) NULL)
3781 width=(size_t) MagickMax((ssize_t) width+offset,0U);
3782 if (next->rows > height)
3783 height=next->rows;
3784 }
3785 /*
3786 Smush images.
3787 */
3788 smush_image=CloneImage(image,width,height,MagickTrue,exception);
3789 if (smush_image == (Image *) NULL)
3790 return((Image *) NULL);
3791 if (SetImageStorageClass(smush_image,DirectClass,exception) == MagickFalse)
3792 {
3793 smush_image=DestroyImage(smush_image);
3794 return((Image *) NULL);
3795 }
3796 smush_image->alpha_trait=alpha_trait;
3797 (void) SetImageBackgroundColor(smush_image,exception);
3798 status=MagickTrue;
3799 x_offset=0;
3800 y_offset=0;
3801 for (n=0; n < (MagickOffsetType) number_images; n++)
3802 {
3803 SetGeometry(smush_image,&geometry);
3804 GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry);
3805 if (stack != MagickFalse)
3806 {
3807 x_offset-=geometry.x;
3808 y_offset-=SmushYGap(smush_image,image,offset,exception);
3809 }
3810 else
3811 {
3812 x_offset-=SmushXGap(smush_image,image,offset,exception);
3813 y_offset-=geometry.y;
3814 }
3815 status=CompositeImage(smush_image,image,OverCompositeOp,MagickTrue,x_offset,
3816 y_offset,exception);
3817 proceed=SetImageProgress(image,SmushImageTag,n,number_images);
3818 if (proceed == MagickFalse)
3819 break;
3820 if (stack == MagickFalse)
3821 {
3822 x_offset+=(ssize_t) image->columns;
3823 y_offset=0;
3824 }
3825 else
3826 {
3827 x_offset=0;
3828 y_offset+=(ssize_t) image->rows;
3829 }
3830 image=GetNextImageInList(image);
3831 }
3832 if (stack == MagickFalse)
3833 smush_image->columns=(size_t) x_offset;
3834 else
3835 smush_image->rows=(size_t) y_offset;
3836 if (status == MagickFalse)
3837 smush_image=DestroyImage(smush_image);
3838 return(smush_image);
3839}
3840
3841/*
3842%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3843% %
3844% %
3845% %
3846% S t r i p I m a g e %
3847% %
3848% %
3849% %
3850%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3851%
3852% StripImage() strips an image of all profiles and comments.
3853%
3854% The format of the StripImage method is:
3855%
3856% MagickBooleanType StripImage(Image *image,ExceptionInfo *exception)
3857%
3858% A description of each parameter follows:
3859%
3860% o image: the image.
3861%
3862% o exception: return any errors or warnings in this structure.
3863%
3864*/
3865MagickExport MagickBooleanType StripImage(Image *image,
3866 ExceptionInfo *magick_unused(exception))
3867{
3868 MagickBooleanType
3869 status;
3870
3871 magick_unreferenced(exception);
3872 assert(image != (Image *) NULL);
3873 if (IsEventLogging() != MagickFalse)
3874 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3875 DestroyImageProfiles(image);
3876 (void) DeleteImageProperty(image,"comment");
3877 (void) DeleteImageProperty(image,"date:create");
3878 (void) DeleteImageProperty(image,"date:modify");
3879 (void) DeleteImageProperty(image,"date:timestamp");
3880 status=SetImageArtifact(image,"png:exclude-chunk",
3881 "bKGD,caNv,cHRM,eXIf,gAMA,iCCP,iTXt,pHYs,sRGB,tEXt,zCCP,zTXt,date");
3882 return(status);
3883}
3884
3885/*
3886%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3887% %
3888% %
3889% %
3890+ S y n c I m a g e %
3891% %
3892% %
3893% %
3894%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3895%
3896% SyncImage() initializes the red, green, and blue intensities of each pixel
3897% as defined by the colormap index.
3898%
3899% The format of the SyncImage method is:
3900%
3901% MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3902%
3903% A description of each parameter follows:
3904%
3905% o image: the image.
3906%
3907% o exception: return any errors or warnings in this structure.
3908%
3909*/
3910
3911static inline Quantum PushColormapIndex(Image *image,const Quantum index,
3912 MagickBooleanType *range_exception)
3913{
3914 if ((size_t) index < image->colors)
3915 return(index);
3916 *range_exception=MagickTrue;
3917 return((Quantum) 0);
3918}
3919
3920MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3921{
3922 CacheView
3923 *image_view;
3924
3925 MagickBooleanType
3926 range_exception,
3927 status,
3928 taint;
3929
3930 ssize_t
3931 y;
3932
3933 assert(image != (Image *) NULL);
3934 assert(image->signature == MagickCoreSignature);
3935 if (IsEventLogging() != MagickFalse)
3936 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3937 if (image->ping != MagickFalse)
3938 return(MagickTrue);
3939 if (image->storage_class != PseudoClass)
3940 return(MagickFalse);
3941 assert(image->colormap != (PixelInfo *) NULL);
3942 range_exception=MagickFalse;
3943 status=MagickTrue;
3944 taint=image->taint;
3945 image_view=AcquireAuthenticCacheView(image,exception);
3946#if defined(MAGICKCORE_OPENMP_SUPPORT)
3947 #pragma omp parallel for schedule(static) shared(range_exception,status) \
3948 magick_number_threads(image,image,image->rows,2)
3949#endif
3950 for (y=0; y < (ssize_t) image->rows; y++)
3951 {
3952 Quantum
3953 index;
3954
3955 Quantum
3956 *magick_restrict q;
3957
3958 ssize_t
3959 x;
3960
3961 if (status == MagickFalse)
3962 continue;
3963 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3964 if (q == (Quantum *) NULL)
3965 {
3966 status=MagickFalse;
3967 continue;
3968 }
3969 for (x=0; x < (ssize_t) image->columns; x++)
3970 {
3971 index=PushColormapIndex(image,GetPixelIndex(image,q),&range_exception);
3972 SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
3973 q+=(ptrdiff_t) GetPixelChannels(image);
3974 }
3975 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3976 status=MagickFalse;
3977 }
3978 image_view=DestroyCacheView(image_view);
3979 image->taint=taint;
3980 if ((image->ping == MagickFalse) && (range_exception != MagickFalse))
3981 (void) ThrowMagickException(exception,GetMagickModule(),
3982 CorruptImageWarning,"InvalidColormapIndex","`%s'",image->filename);
3983 return(status);
3984}
3985
3986/*
3987%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3988% %
3989% %
3990% %
3991% S y n c I m a g e S e t t i n g s %
3992% %
3993% %
3994% %
3995%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3996%
3997% SyncImageSettings() syncs any image_info global options into per-image
3998% attributes.
3999%
4000% Note: in IMv6 free form 'options' were always mapped into 'artifacts', so
4001% that operations and coders can find such settings. In IMv7 if a desired
4002% per-image artifact is not set, then it will directly look for a global
4003% option as a fallback, as such this copy is no longer needed, only the
4004% link set up.
4005%
4006% The format of the SyncImageSettings method is:
4007%
4008% MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4009% Image *image,ExceptionInfo *exception)
4010% MagickBooleanType SyncImagesSettings(const ImageInfo *image_info,
4011% Image *image,ExceptionInfo *exception)
4012%
4013% A description of each parameter follows:
4014%
4015% o image_info: the image info.
4016%
4017% o image: the image.
4018%
4019% o exception: return any errors or warnings in this structure.
4020%
4021*/
4022
4023MagickExport MagickBooleanType SyncImagesSettings(ImageInfo *image_info,
4024 Image *images,ExceptionInfo *exception)
4025{
4026 Image
4027 *image;
4028
4029 assert(image_info != (const ImageInfo *) NULL);
4030 assert(image_info->signature == MagickCoreSignature);
4031 assert(images != (Image *) NULL);
4032 assert(images->signature == MagickCoreSignature);
4033 if (IsEventLogging() != MagickFalse)
4034 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
4035 image=images;
4036 for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
4037 (void) SyncImageSettings(image_info,image,exception);
4038 (void) DeleteImageOption(image_info,"page");
4039 return(MagickTrue);
4040}
4041
4042MagickExport MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4043 Image *image,ExceptionInfo *exception)
4044{
4045 const char
4046 *option;
4047
4049 geometry_info;
4050
4051 MagickStatusType
4052 flags;
4053
4054 ResolutionType
4055 units;
4056
4057 /*
4058 Sync image options.
4059 */
4060 assert(image_info != (const ImageInfo *) NULL);
4061 assert(image_info->signature == MagickCoreSignature);
4062 assert(image != (Image *) NULL);
4063 assert(image->signature == MagickCoreSignature);
4064 if (IsEventLogging() != MagickFalse)
4065 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4066 option=GetImageOption(image_info,"background");
4067 if (option != (const char *) NULL)
4068 (void) QueryColorCompliance(option,AllCompliance,&image->background_color,
4069 exception);
4070 option=GetImageOption(image_info,"black-point-compensation");
4071 if (option != (const char *) NULL)
4072 image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
4073 MagickBooleanOptions,MagickFalse,option);
4074 option=GetImageOption(image_info,"blue-primary");
4075 if (option != (const char *) NULL)
4076 {
4077 flags=ParseGeometry(option,&geometry_info);
4078 if ((flags & RhoValue) != 0)
4079 image->chromaticity.blue_primary.x=geometry_info.rho;
4080 image->chromaticity.blue_primary.y=image->chromaticity.blue_primary.x;
4081 if ((flags & SigmaValue) != 0)
4082 image->chromaticity.blue_primary.y=geometry_info.sigma;
4083 }
4084 option=GetImageOption(image_info,"bordercolor");
4085 if (option != (const char *) NULL)
4086 (void) QueryColorCompliance(option,AllCompliance,&image->border_color,
4087 exception);
4088 /* FUTURE: do not sync compose to per-image compose setting here */
4089 option=GetImageOption(image_info,"compose");
4090 if (option != (const char *) NULL)
4091 image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
4092 MagickFalse,option);
4093 /* -- */
4094 option=GetImageOption(image_info,"compress");
4095 if (option != (const char *) NULL)
4096 image->compression=(CompressionType) ParseCommandOption(
4097 MagickCompressOptions,MagickFalse,option);
4098 option=GetImageOption(image_info,"debug");
4099 if (option != (const char *) NULL)
4100 image->debug=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4101 MagickFalse,option);
4102 option=GetImageOption(image_info,"density");
4103 if (option != (const char *) NULL)
4104 {
4105 flags=ParseGeometry(option,&geometry_info);
4106 if ((flags & RhoValue) != 0)
4107 image->resolution.x=geometry_info.rho;
4108 image->resolution.y=image->resolution.x;
4109 if ((flags & SigmaValue) != 0)
4110 image->resolution.y=geometry_info.sigma;
4111 }
4112 option=GetImageOption(image_info,"depth");
4113 if (option != (const char *) NULL)
4114 image->depth=StringToUnsignedLong(option);
4115 option=GetImageOption(image_info,"endian");
4116 if (option != (const char *) NULL)
4117 image->endian=(EndianType) ParseCommandOption(MagickEndianOptions,
4118 MagickFalse,option);
4119 option=GetImageOption(image_info,"filter");
4120 if (option != (const char *) NULL)
4121 image->filter=(FilterType) ParseCommandOption(MagickFilterOptions,
4122 MagickFalse,option);
4123 option=GetImageOption(image_info,"fuzz");
4124 if (option != (const char *) NULL)
4125 image->fuzz=StringToDoubleInterval(option,(double) QuantumRange+1.0);
4126 option=GetImageOption(image_info,"gravity");
4127 if (option != (const char *) NULL)
4128 image->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
4129 MagickFalse,option);
4130 option=GetImageOption(image_info,"green-primary");
4131 if (option != (const char *) NULL)
4132 {
4133 flags=ParseGeometry(option,&geometry_info);
4134 if ((flags & RhoValue) != 0)
4135 image->chromaticity.green_primary.x=geometry_info.rho;
4136 image->chromaticity.green_primary.y=image->chromaticity.green_primary.x;
4137 if ((flags & SigmaValue) != 0)
4138 image->chromaticity.green_primary.y=geometry_info.sigma;
4139 }
4140 option=GetImageOption(image_info,"intent");
4141 if (option != (const char *) NULL)
4142 image->rendering_intent=(RenderingIntent) ParseCommandOption(
4143 MagickIntentOptions,MagickFalse,option);
4144 option=GetImageOption(image_info,"intensity");
4145 if (option != (const char *) NULL)
4146 image->intensity=(PixelIntensityMethod) ParseCommandOption(
4147 MagickPixelIntensityOptions,MagickFalse,option);
4148 option=GetImageOption(image_info,"interlace");
4149 if (option != (const char *) NULL)
4150 image->interlace=(InterlaceType) ParseCommandOption(MagickInterlaceOptions,
4151 MagickFalse,option);
4152 option=GetImageOption(image_info,"interpolate");
4153 if (option != (const char *) NULL)
4154 image->interpolate=(PixelInterpolateMethod) ParseCommandOption(
4155 MagickInterpolateOptions,MagickFalse,option);
4156 option=GetImageOption(image_info,"loop");
4157 if (option != (const char *) NULL)
4158 image->iterations=StringToUnsignedLong(option);
4159 option=GetImageOption(image_info,"mattecolor");
4160 if (option != (const char *) NULL)
4161 (void) QueryColorCompliance(option,AllCompliance,&image->matte_color,
4162 exception);
4163 option=GetImageOption(image_info,"orient");
4164 if (option != (const char *) NULL)
4165 image->orientation=(OrientationType) ParseCommandOption(
4166 MagickOrientationOptions,MagickFalse,option);
4167 option=GetImageOption(image_info,"page");
4168 if (option != (const char *) NULL)
4169 {
4170 char
4171 *geometry;
4172
4173 geometry=GetPageGeometry(option);
4174 flags=ParseAbsoluteGeometry(geometry,&image->page);
4175 geometry=DestroyString(geometry);
4176 }
4177 option=GetImageOption(image_info,"quality");
4178 if (option != (const char *) NULL)
4179 image->quality=StringToUnsignedLong(option);
4180 option=GetImageOption(image_info,"red-primary");
4181 if (option != (const char *) NULL)
4182 {
4183 flags=ParseGeometry(option,&geometry_info);
4184 if ((flags & RhoValue) != 0)
4185 image->chromaticity.red_primary.x=geometry_info.rho;
4186 image->chromaticity.red_primary.y=image->chromaticity.red_primary.x;
4187 if ((flags & SigmaValue) != 0)
4188 image->chromaticity.red_primary.y=geometry_info.sigma;
4189 }
4190 if (image_info->quality != UndefinedCompressionQuality)
4191 image->quality=image_info->quality;
4192 option=GetImageOption(image_info,"scene");
4193 if (option != (const char *) NULL)
4194 image->scene=StringToUnsignedLong(option);
4195 option=GetImageOption(image_info,"taint");
4196 if (option != (const char *) NULL)
4197 image->taint=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4198 MagickFalse,option);
4199 option=GetImageOption(image_info,"tile-offset");
4200 if (option != (const char *) NULL)
4201 {
4202 char
4203 *geometry;
4204
4205 geometry=GetPageGeometry(option);
4206 flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
4207 geometry=DestroyString(geometry);
4208 }
4209 option=GetImageOption(image_info,"transparent-color");
4210 if (option != (const char *) NULL)
4211 (void) QueryColorCompliance(option,AllCompliance,&image->transparent_color,
4212 exception);
4213 option=GetImageOption(image_info,"type");
4214 if (option != (const char *) NULL)
4215 image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
4216 option);
4217 option=GetImageOption(image_info,"units");
4218 units=image_info->units;
4219 if (option != (const char *) NULL)
4220 units=(ResolutionType) ParseCommandOption(MagickResolutionOptions,
4221 MagickFalse,option);
4222 if (units != UndefinedResolution)
4223 {
4224 if (image->units != units)
4225 switch (image->units)
4226 {
4227 case PixelsPerInchResolution:
4228 {
4229 if (units == PixelsPerCentimeterResolution)
4230 {
4231 image->resolution.x/=2.54;
4232 image->resolution.y/=2.54;
4233 }
4234 break;
4235 }
4236 case PixelsPerCentimeterResolution:
4237 {
4238 if (units == PixelsPerInchResolution)
4239 {
4240 image->resolution.x=(double) ((size_t) (100.0*2.54*
4241 image->resolution.x+0.5))/100.0;
4242 image->resolution.y=(double) ((size_t) (100.0*2.54*
4243 image->resolution.y+0.5))/100.0;
4244 }
4245 break;
4246 }
4247 default:
4248 break;
4249 }
4250 image->units=units;
4251 option=GetImageOption(image_info,"density");
4252 if (option != (const char *) NULL)
4253 {
4254 flags=ParseGeometry(option,&geometry_info);
4255 if ((flags & RhoValue) != 0)
4256 image->resolution.x=geometry_info.rho;
4257 image->resolution.y=image->resolution.x;
4258 if ((flags & SigmaValue) != 0)
4259 image->resolution.y=geometry_info.sigma;
4260 }
4261 }
4262 option=GetImageOption(image_info,"virtual-pixel");
4263 if (option != (const char *) NULL)
4264 (void) SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
4265 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,option),
4266 exception);
4267 option=GetImageOption(image_info,"white-point");
4268 if (option != (const char *) NULL)
4269 {
4270 flags=ParseGeometry(option,&geometry_info);
4271 if ((flags & RhoValue) != 0)
4272 image->chromaticity.white_point.x=geometry_info.rho;
4273 image->chromaticity.white_point.y=image->chromaticity.white_point.x;
4274 if ((flags & SigmaValue) != 0)
4275 image->chromaticity.white_point.y=geometry_info.sigma;
4276 }
4277 /*
4278 Pointer to allow the lookup of pre-image artifact will fallback to a global
4279 option setting/define. This saves a lot of duplication of global options
4280 into per-image artifacts, while ensuring only specifically set per-image
4281 artifacts are preserved when parenthesis ends.
4282 */
4283 if (image->image_info != (ImageInfo *) NULL)
4284 image->image_info=DestroyImageInfo(image->image_info);
4285 image->image_info=CloneImageInfo(image_info);
4286 return(MagickTrue);
4287}