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"
152 if (IsEventLogging() != MagickFalse)
153 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
154 image=(
Image *) AcquireCriticalMemory(
sizeof(*image));
155 (void) memset(image,0,
sizeof(*image));
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);
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;
203 SetBlobExempt(image,image_info->file != (FILE *) NULL ? MagickTrue :
205 (void) CopyMagickString(image->filename,image_info->filename,
207 (void) CopyMagickString(image->magick_filename,image_info->filename,
209 (void) CopyMagickString(image->magick,image_info->magick,MagickPathExtent);
210 if (image_info->size != (
char *) NULL)
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;
219 if (image_info->extract != (
char *) NULL)
224 (void) memset(&geometry,0,
sizeof(geometry));
225 flags=ParseAbsoluteGeometry(image_info->extract,&geometry);
226 if (((flags & XValue) != 0) || ((flags & YValue) != 0))
228 image->extract_info=geometry;
229 Swap(image->columns,image->extract_info.width);
230 Swap(image->rows,image->extract_info.height);
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)
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;
250 if (image_info->page != (
char *) NULL)
255 image->page=image->extract_info;
256 geometry=GetPageGeometry(image_info->page);
257 (void) ParseAbsoluteGeometry(geometry,&image->page);
258 geometry=DestroyString(geometry);
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);
275 (void) SyncImageSettings(image_info,image,exception);
279 option=GetImageOption(image_info,
"delay");
280 if (option != (
const char *) NULL)
285 flags=ParseGeometry(option,&geometry_info);
286 if ((flags & GreaterValue) != 0)
288 if ((
double) image->delay > floor(geometry_info.rho+0.5))
289 image->delay=(size_t) CastDoubleToLong(floor(
290 geometry_info.rho+0.5));
293 if ((flags & LessValue) != 0)
295 if ((
double) image->delay < floor(geometry_info.rho+0.5))
296 image->ticks_per_second=CastDoubleToLong(floor(
297 geometry_info.sigma+0.5));
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));
305 option=GetImageOption(image_info,
"dispose");
306 if (option != (
const char *) NULL)
307 image->dispose=(DisposeType) ParseCommandOption(MagickDisposeOptions,
330MagickExport
ImageInfo *AcquireImageInfo(
void)
335 image_info=(
ImageInfo *) AcquireCriticalMemory(
sizeof(*image_info));
336 GetImageInfo(image_info);
371MagickExport
void AcquireNextImage(
const ImageInfo *image_info,
Image *image,
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)
384 (void) CopyMagickString(GetNextImageInList(image)->filename,image->filename,
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;
428MagickExport
Image *AppendImages(
const Image *images,
431#define AppendImageTag "Append/Image"
443 homogeneous_colorspace,
472 assert(images != (
Image *) NULL);
473 assert(images->signature == MagickCoreSignature);
475 assert(exception->signature == MagickCoreSignature);
476 if (IsEventLogging() != MagickFalse)
477 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",images->filename);
478 alpha_trait=images->alpha_trait;
480 width=images->columns;
483 image_type=images->type;
484 homogeneous_colorspace=MagickTrue;
485 next=GetNextImageInList(images);
486 for ( ; next != (
Image *) NULL; next=GetNextImageInList(next))
488 if (next->depth > 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;
497 if (stack != MagickFalse)
499 if (next->columns > width)
504 width+=next->columns;
505 if (next->rows > height)
511 append_image=CloneImage(images,width,height,MagickTrue,exception);
512 if (append_image == (
Image *) NULL)
513 return((
Image *) NULL);
514 if (image_type != BilevelType)
516 if (SetImageStorageClass(append_image,DirectClass,exception) == MagickFalse)
518 append_image=DestroyImage(append_image);
519 return((
Image *) NULL);
521 if (homogeneous_colorspace == MagickFalse)
522 (void) SetImageColorspace(append_image,sRGBColorspace,exception);
524 append_image->depth=depth;
525 append_image->alpha_trait=alpha_trait;
526 append_image->page=images->page;
527 (void) SetImageBackgroundColor(append_image,exception);
532 append_view=AcquireAuthenticCacheView(append_image,exception);
533 for (n=0; n < (MagickOffsetType) number_images; n++)
541 SetGeometry(append_image,&geometry);
542 GravityAdjustGeometry(next->columns,next->rows,next->gravity,&geometry);
543 if (stack != MagickFalse)
544 x_offset-=geometry.x;
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)
552 for (y=0; y < (ssize_t) next->rows; y++)
569 if (status == MagickFalse)
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))
579 GetPixelInfo(next,&pixel);
580 for (x=0; x < (ssize_t) next->columns; x++)
582 GetPixelInfoPixel(next,p,&pixel);
583 SetPixelViaPixelInfo(append_image,&pixel,q);
584 p+=(ptrdiff_t) GetPixelChannels(next);
585 q+=(ptrdiff_t) GetPixelChannels(append_image);
587 sync=SyncCacheViewAuthenticPixels(append_view,exception);
588 if (sync == MagickFalse)
591 image_view=DestroyCacheView(image_view);
592 if (stack == MagickFalse)
594 x_offset+=(ssize_t) next->columns;
600 y_offset+=(ssize_t) next->rows;
602 proceed=SetImageProgress(append_image,AppendImageTag,n,number_images);
603 if (proceed == MagickFalse)
605 next=GetNextImageInList(next);
607 append_view=DestroyCacheView(append_view);
608 if (status == MagickFalse)
609 append_image=DestroyImage(append_image);
610 return(append_image);
637MagickExport ExceptionType CatchImageException(
Image *image)
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);
691 return(ClipImagePath(image,
"#1",MagickTrue,exception));
694MagickExport MagickBooleanType ClipImagePath(
Image *image,
const char *pathname,
697#define ClipImagePathTag "ClipPath/Image"
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",
719 value=GetImageProperty(image,property,exception);
720 property=DestroyString(property);
721 if (value == (
const char *) NULL)
723 ThrowFileException(exception,OptionError,
"NoClipPathDefined",
727 image_info=AcquireImageInfo();
728 (void) CopyMagickString(image_info->filename,image->filename,
730 (void) ConcatenateMagickString(image_info->filename,pathname,
732 clip_mask=BlobToImage(image_info,value,strlen(value),exception);
733 image_info=DestroyImageInfo(image_info);
734 if (clip_mask == (
Image *) NULL)
736 if (clip_mask->storage_class == PseudoClass)
738 (void) SyncImage(clip_mask,exception);
739 if (SetImageStorageClass(clip_mask,DirectClass,exception) == MagickFalse)
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);
791MagickExport
Image *CloneImage(
const Image *image,
const size_t columns,
792 const size_t rows,
const MagickBooleanType detach,
ExceptionInfo *exception)
807 assert(image != (
const Image *) NULL);
808 assert(image->signature == MagickCoreSignature);
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))
815 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
816 "NegativeOrZeroImageSize",
"`%s'",image->filename);
817 return((
Image *) NULL);
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,
848 (void) CopyMagickString(clone_image->magick,image->magick,MagickPathExtent);
849 (void) CopyMagickString(clone_image->filename,image->filename,
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);
861 clone_image->next=NewImageList();
862 clone_image->previous=NewImageList();
863 clone_image->blob=CloneBlobInfo((
BlobInfo *) NULL);
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)
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)
881 clone_image=DestroyImage(clone_image);
882 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
884 (void) memcpy(clone_image->colormap,image->colormap,length*
885 sizeof(*clone_image->colormap));
887 if ((columns == 0) || (rows == 0))
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);
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);
949 clone_info=AcquireImageInfo();
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,
1009 (void) CopyMagickString(clone_info->unique,image_info->unique,
1011 (void) CopyMagickString(clone_info->filename,image_info->filename,
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;
1053MagickExport MagickBooleanType CopyImagePixels(
Image *image,
1057#define CopyImageTag "Copy/Image"
1072 assert(image != (
Image *) NULL);
1073 assert(source_image != (
Image *) 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",
1083 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1084 return(MagickFalse);
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)
1096 for (y=0; y < (ssize_t) geometry->height; y++)
1110 if (status == MagickFalse)
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))
1121 for (x=0; x < (ssize_t) geometry->width; x++)
1126 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
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))
1135 SetPixelChannel(image,channel,p[i],q);
1137 p+=(ptrdiff_t) GetPixelChannels(source_image);
1138 q+=(ptrdiff_t) GetPixelChannels(image);
1140 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1141 if (sync == MagickFalse)
1143 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1148#if defined(MAGICKCORE_OPENMP_SUPPORT)
1152 proceed=SetImageProgress(image,CopyImageTag,progress,image->rows);
1153 if (proceed == MagickFalse)
1157 source_view=DestroyCacheView(source_view);
1158 image_view=DestroyCacheView(image_view);
1185MagickExport
Image *DestroyImage(
Image *image)
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)
1202 UnlockSemaphoreInfo(image->semaphore);
1203 if (destroy == MagickFalse)
1204 return((
Image *) NULL);
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);
1222 image->ascii85=(
Ascii85Info *) RelinquishMagickMemory(image->ascii85);
1223 if (image->image_info != (
ImageInfo *) NULL)
1224 image->image_info=DestroyImageInfo(image->image_info);
1227 RelinquishSemaphoreInfo(&image->semaphore);
1228 image->signature=(~MagickCoreSignature);
1229 image=(
Image *) RelinquishMagickMemory(image);
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);
1318MagickExport
void DisassociateImageStream(
Image *image)
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);
1349MagickExport
void GetImageInfo(
ImageInfo *image_info)
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)
1371 image_info->synchronize=IsStringTrue(synchronize);
1372 synchronize=DestroyString(synchronize);
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 :
1380 image_info->signature=MagickCoreSignature;
1405MagickExport FILE *GetImageInfoFile(
const ImageInfo *image_info)
1407 return(image_info->file);
1435MagickExport
Image *GetImageMask(
const Image *image,
const PixelMask type,
1454 assert(image != (
Image *) NULL);
1455 assert(image->signature == MagickCoreSignature);
1456 if (IsEventLogging() != MagickFalse)
1457 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
1462 if ((image->channels & ReadMaskChannel) == 0)
1463 return((
Image *) NULL);
1466 case WritePixelMask:
1468 if ((image->channels & WriteMaskChannel) == 0)
1469 return((
Image *) NULL);
1474 if ((image->channels & CompositeMaskChannel) == 0)
1475 return((
Image *) NULL);
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));
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)
1492 for (y=0; y < (ssize_t) image->rows; y++)
1503 if (status == MagickFalse)
1505 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1506 q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1,
1508 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1513 for (x=0; x < (ssize_t) image->columns; x++)
1519 SetPixelGray(mask_image,GetPixelReadMask(image,p),q);
1522 case WritePixelMask:
1524 SetPixelGray(mask_image,GetPixelWriteMask(image,p),q);
1529 SetPixelGray(mask_image,GetPixelCompositeMask(image,p),q);
1533 p+=(ptrdiff_t) GetPixelChannels(image);
1534 q+=(ptrdiff_t) GetPixelChannels(mask_image);
1536 if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse)
1539 mask_view=DestroyCacheView(mask_view);
1540 image_view=DestroyCacheView(image_view);
1541 if (status == MagickFalse)
1542 mask_image=DestroyImage(mask_image);
1568MagickExport ssize_t GetImageReferenceCount(
Image *image)
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);
1607MagickExport VirtualPixelMethod GetImageVirtualPixelMethod(
const Image *image)
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));
1651MagickExport
size_t InterpretImageFilename(
const ImageInfo *image_info,
1652 Image *image,
const char *format,
int value,
char *filename,
1670 canonical=MagickFalse;
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,
'%'))
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))))
1699 offset+=(ssize_t) ((q-p)-count);
1701 (void) ConcatenateMagickString(filename,q,MagickPathExtent);
1702 canonical=MagickTrue;
1711 pattern[MagickPathExtent];
1728 if (strchr(p,
']') == (
char *) NULL)
1732 for (i=0; (i < (MagickPathExtent-1L)) && (*r !=
'\0'); i++)
1743 if (LocaleNCompare(pattern,
"filename:",9) != 0)
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) &&
1752 option=GetImageOption(image_info,pattern);
1753 if (option == (
const char *) NULL)
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;
1762 (void) ConcatenateMagickString(filename,r+1,MagickPathExtent);
1763 canonical=MagickTrue;
1773 if (canonical == MagickFalse)
1774 (void) CopyMagickString(filename,format,MagickPathExtent);
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));
1809MagickExport MagickBooleanType IsHighDynamicRangeImage(
const Image *image,
1812#if !defined(MAGICKCORE_HDRI_SUPPORT)
1815 return(MagickFalse);
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)
1835 for (y=0; y < (ssize_t) image->rows; y++)
1843 if (hdri != MagickFalse)
1845 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1846 if (p == (
const Quantum *) NULL)
1848 for (x=0; x < (ssize_t) image->columns; x++)
1853 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1861 traits=GetPixelChannelTraits(image,(PixelChannel) i);
1862 if (traits == UndefinedPixelTrait)
1864 pixel=(double) p[i];
1865 if ((pixel < 0.0) || (pixel > (double) QuantumRange) ||
1866 (pixel != (double) ((QuantumAny) pixel)))
1872 if (hdri != MagickFalse)
1874 p+=(ptrdiff_t) GetPixelChannels(image);
1877 image_view=DestroyCacheView(image_view);
1905MagickExport MagickBooleanType IsImageObject(
const Image *image)
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);
1942MagickExport MagickBooleanType IsTaintImage(
const Image *image)
1945 magick[MagickPathExtent],
1946 filename[MagickPathExtent];
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))
1959 if (p->taint != MagickFalse)
1961 if (LocaleCompare(p->magick,magick) != 0)
1963 if (LocaleCompare(p->filename,filename) != 0)
1966 return(MagickFalse);
1995MagickExport MagickBooleanType ModifyImage(
Image **image,
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)
2008 clone_image=CloneImage(*image,0,0,MagickTrue,exception);
2009 LockSemaphoreInfo((*image)->semaphore);
2010 (*image)->reference_count--;
2011 UnlockSemaphoreInfo((*image)->semaphore);
2050 const size_t width,
const size_t height,
const PixelInfo *background,
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;
2073 image->colorspace=background->colorspace;
2074 image->alpha_trait=background->alpha_trait;
2075 image->fuzz=background->fuzz;
2076 image->depth=background->depth;
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)
2083 for (y=0; y < (ssize_t) image->rows; y++)
2091 if (status == MagickFalse)
2093 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2094 if (q == (Quantum *) NULL)
2099 for (x=0; x < (ssize_t) image->columns; x++)
2101 SetPixelViaPixelInfo(image,background,q);
2102 q+=(ptrdiff_t) GetPixelChannels(image);
2104 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2107 image_view=DestroyCacheView(image_view);
2108 if (status == MagickFalse)
2109 image=DestroyImage(image);
2136MagickExport
Image *ReferenceImage(
Image *image)
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);
2172MagickExport MagickBooleanType ResetImagePage(
Image *image,
const char *page)
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)
2187 if ((flags & HeightValue) == 0)
2188 geometry.height=geometry.width;
2189 image->page.width=geometry.width;
2190 image->page.height=geometry.height;
2192 if ((flags & AspectValue) != 0)
2194 if ((flags & XValue) != 0)
2195 image->page.x+=geometry.x;
2196 if ((flags & YValue) != 0)
2197 image->page.y+=geometry.y;
2201 if ((flags & XValue) != 0)
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);
2207 if ((flags & YValue) != 0)
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);
2243MagickExport MagickBooleanType ResetImagePixels(
Image *image,
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)
2271 (void) memset(pixels,0,length);
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)
2283 for (y=0; y < (ssize_t) image->rows; y++)
2291 if (status == MagickFalse)
2293 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2294 if (q == (Quantum *) NULL)
2299 for (x=0; x < (ssize_t) image->columns; x++)
2301 (void) memset(q,0,GetPixelChannels(image)*
sizeof(Quantum));
2302 q+=(ptrdiff_t) GetPixelChannels(image);
2304 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2307 image_view=DestroyCacheView(image_view);
2339MagickExport MagickBooleanType SetImageAlpha(
Image *image,
const Quantum alpha,
2351 assert(image != (
Image *) NULL);
2352 assert(image->signature == MagickCoreSignature);
2353 if (IsEventLogging() != MagickFalse)
2354 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
2355 image->alpha_trait=BlendPixelTrait;
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)
2362 for (y=0; y < (ssize_t) image->rows; y++)
2370 if (status == MagickFalse)
2372 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2373 if (q == (Quantum *) NULL)
2378 for (x=0; x < (ssize_t) image->columns; x++)
2380 if (GetPixelWriteMask(image,q) > (QuantumRange/2))
2381 SetPixelAlpha(image,alpha,q);
2382 q+=(ptrdiff_t) GetPixelChannels(image);
2384 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2387 image_view=DestroyCacheView(image_view);
2418MagickExport MagickBooleanType SetImageBackgroundColor(
Image *image,
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);
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)
2452 for (y=0; y < (ssize_t) image->rows; y++)
2460 if (status == MagickFalse)
2462 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2463 if (q == (Quantum *) NULL)
2468 for (x=0; x < (ssize_t) image->columns; x++)
2470 SetPixelViaPixelInfo(image,&background,q);
2471 q+=(ptrdiff_t) GetPixelChannels(image);
2473 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2476 image_view=DestroyCacheView(image_view);
2506MagickExport ChannelType SetImageChannelMask(
Image *image,
2507 const ChannelType channel_mask)
2509 return(SetPixelChannelMask(image,channel_mask));
2539MagickExport MagickBooleanType SetImageColor(
Image *image,
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;
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)
2566 for (y=0; y < (ssize_t) image->rows; y++)
2574 if (status == MagickFalse)
2576 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2577 if (q == (Quantum *) NULL)
2582 for (x=0; x < (ssize_t) image->columns; x++)
2584 SetPixelViaPixelInfo(image,color,q);
2585 q+=(ptrdiff_t) GetPixelChannels(image);
2587 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2590 image_view=DestroyCacheView(image_view);
2622MagickExport MagickBooleanType SetImageStorageClass(
Image *image,
2625 assert(image != (
Image *) NULL);
2626 assert(image->signature == MagickCoreSignature);
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));
2664MagickExport MagickBooleanType SetImageExtent(
Image *image,
const size_t columns,
2667 if ((columns == 0) || (rows == 0))
2668 ThrowBinaryException(ImageError,
"NegativeOrZeroImageSize",image->filename);
2669 image->columns=columns;
2671 if (image->depth == 0)
2674 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2675 "ImageDepthNotSupported",
"`%s'",image->filename);
2677 if (image->depth > (8*
sizeof(MagickSizeType)))
2679 image->depth=8*
sizeof(MagickSizeType);
2680 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2681 "ImageDepthNotSupported",
"`%s'",image->filename);
2683 return(SyncImagePixelCache(image,exception));
2734 *format_type_formats[] =
2758 (void) CopyMagickString(magic,component,MagickPathExtent);
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;
2769 while ((format_type == UndefinedFormatType) &&
2770 (format_type_formats[i] != (
char *) NULL))
2772 if ((*magic == *format_type_formats[i]) &&
2773 (LocaleCompare(magic,format_type_formats[i]) == 0))
2774 format_type=ExplicitFormatType;
2777 if (format_type == UndefinedFormatType)
2778 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2780 if (format_type == ExplicitFormatType)
2782 image_info->affirm=MagickTrue;
2783 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2785 if (LocaleCompare(magic,
"RGB") == 0)
2786 image_info->affirm=MagickFalse;
2787 return(magick_info);
2790MagickExport MagickBooleanType SetImageInfo(
ImageInfo *image_info,
2794 component[MagickPathExtent],
2795 magic[MagickPathExtent],
2796 path[MagickPathExtent],
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);
2829 GetPathComponent(image_info->filename,SubimagePath,component);
2830 if (*component !=
'\0')
2835 if (IsSceneGeometry(component,MagickFalse) == MagickFalse)
2837 if (IsGeometry(component) != MagickFalse)
2838 (void) CloneString(&image_info->extract,component);
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++)
2852 while ((isspace((
int) ((
unsigned char) *p)) != 0) || (*p ==
','))
2854 first=(size_t) strtol(p,&q,10);
2856 while (isspace((
int) ((
unsigned char) *q)) != 0)
2859 last=(size_t) strtol(q+1,&q,10);
2862 if (first < image_info->scene)
2863 image_info->scene=first;
2864 if (last > image_info->number_scenes)
2865 image_info->number_scenes=last;
2868 image_info->number_scenes-=image_info->scene-1;
2872 if (*image_info->magick ==
'\0')
2873 GetPathComponent(image_info->filename,ExtensionPath,component);
2874 if (*component !=
'\0')
2879 GetPathComponent(image_info->filename,BasePathSansCompressExtension,path);
2880 GetPathComponent(path,ExtensionPath,component);
2882 image_info->affirm=MagickFalse;
2883 sans_exception=AcquireExceptionInfo();
2884 if ((*component !=
'\0') && (IsGlob(component) == MagickFalse))
2885 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2891 GetPathComponent(image_info->filename,MagickPath,magic);
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;
2900 GetPathComponent(image_info->filename,CanonicalPath,component);
2902 GetPathComponent(image_info->filename,SubcanonicalPath,component);
2903 (void) CopyMagickString(image_info->filename,component,MagickPathExtent);
2914 magick_info=GetMagickInfo(magic,sans_exception);
2916 if (magick_info == (
const MagickInfo *) NULL)
2918 delegate_info=GetDelegateInfo(magic,
"*",sans_exception);
2920 delegate_info=GetDelegateInfo(
"*",magic,sans_exception);
2922 ((*component !=
'\0') && (IsGlob(component) == MagickFalse)))
2927 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2931 if (((magick_info != (
const MagickInfo *) NULL) ||
2933 (IsMagickConflict(magic) == MagickFalse))
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,
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))
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;
2957 if ((image_info->adjoin != MagickFalse) && (frames > 0))
2962 magick_info=GetMagickInfo(magic,exception);
2963 if (magick_info != (
const MagickInfo *) NULL)
2964 if (GetMagickAdjoin(magick_info) == MagickFalse)
2965 image_info->adjoin=MagickFalse;
2967 if (image_info->affirm != MagickFalse)
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,
2986 sans_exception=AcquireExceptionInfo();
2987 status=OpenBlob(image_info,image,ReadBinaryBlobMode,sans_exception);
2988 sans_exception=DestroyExceptionInfo(sans_exception);
2989 if (status == MagickFalse)
2991 image=DestroyImage(image);
2992 return(MagickFalse);
2994 if ((IsBlobSeekable(image) == MagickFalse) ||
2995 (IsBlobExempt(image) != MagickFalse))
3001 status=ImageToFile(image,component,exception);
3002 if (CloseBlob(image) == MagickFalse)
3004 if (status == MagickFalse)
3006 (void) RelinquishUniqueFileResource(component);
3007 image=DestroyImage(image);
3008 return(MagickFalse);
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)
3015 (void) RelinquishUniqueFileResource(component);
3016 image=DestroyImage(image);
3017 return(MagickFalse);
3019 (void) CopyMagickString(image_info->filename,component,
3021 image_info->temporary=MagickTrue;
3023 magick=(
unsigned char *) AcquireQuantumMemory(1,magick_size);
3024 if (magick == (
unsigned char *) NULL)
3026 (void) CloseBlob(image);
3027 image=DestroyImage(image);
3028 return(MagickFalse);
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);
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))
3047 if ((magick_info != (
const MagickInfo *) NULL) &&
3048 (GetMagickUseExtension(magick_info) != MagickFalse) &&
3049 (LocaleCompare(magick_info->magick_module,GetMagicName(
3051 (
void) CopyMagickString(image_info->magick,magick_info->name,
3055 (void) CopyMagickString(image_info->magick,GetMagicName(
3056 magic_info),MagickPathExtent);
3057 magick_info=GetMagickInfo(image_info->magick,sans_exception);
3059 if ((magick_info == (
const MagickInfo *) NULL) ||
3060 (GetMagickEndianSupport(magick_info) == MagickFalse))
3061 image_info->endian=UndefinedEndian;
3062 sans_exception=DestroyExceptionInfo(sans_exception);
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);
3101MagickExport
void SetImageInfoBlob(
ImageInfo *image_info,
const void *blob,
3102 const size_t length)
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;
3138MagickExport
void SetImageInfoCustomStream(
ImageInfo *image_info,
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);
3173MagickExport
void SetImageInfoFile(
ImageInfo *image_info,FILE *file)
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;
3213MagickExport MagickBooleanType SetImageMask(
Image *image,
const PixelMask type,
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)
3239 image->channels=(ChannelType) ((
unsigned int) image->channels &
3240 (
unsigned int) ~ReadMaskChannel);
3243 case WritePixelMask:
3245 image->channels=(ChannelType) ((
unsigned int) image->channels &
3246 (
unsigned int) ~WriteMaskChannel);
3251 image->channels=(ChannelType) ((
unsigned int) image->channels &
3252 (
unsigned int) ~CompositeMaskChannel);
3256 return(SyncImagePixelCache(image,exception));
3262 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3265 case WritePixelMask:
3267 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3272 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3276 if (SyncImagePixelCache(image,exception) == MagickFalse)
3277 return(MagickFalse);
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)
3286 for (y=0; y < (ssize_t) image->rows; y++)
3297 if (status == MagickFalse)
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))
3306 for (x=0; x < (ssize_t) image->columns; x++)
3312 if ((x < (ssize_t) mask->columns) && (y < (ssize_t) mask->rows))
3313 intensity=GetPixelIntensity(mask,p);
3318 SetPixelReadMask(image,ClampToQuantum(intensity),q);
3321 case WritePixelMask:
3323 SetPixelWriteMask(image,ClampToQuantum(intensity),q);
3328 SetPixelCompositeMask(image,ClampToQuantum(intensity),q);
3332 p+=(ptrdiff_t) GetPixelChannels(mask);
3333 q+=(ptrdiff_t) GetPixelChannels(image);
3335 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3338 image->mask_trait=UndefinedPixelTrait;
3339 mask_view=DestroyCacheView(mask_view);
3340 image_view=DestroyCacheView(image_view);
3374MagickExport MagickBooleanType SetImageRegionMask(
Image *image,
3389 assert(image != (
Image *) NULL);
3390 assert(image->signature == MagickCoreSignature);
3391 if (IsEventLogging() != MagickFalse)
3392 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
3399 image->channels=(ChannelType) ((
unsigned int) image->channels &
3400 (
unsigned int) ~ReadMaskChannel);
3403 case WritePixelMask:
3405 image->channels=(ChannelType) ((
unsigned int) image->channels &
3406 (
unsigned int) ~WriteMaskChannel);
3411 image->channels=(ChannelType) ((
unsigned int) image->channels &
3412 (
unsigned int) ~CompositeMaskChannel);
3416 return(SyncImagePixelCache(image,exception));
3422 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3425 case WritePixelMask:
3427 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3432 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3436 if (SyncImagePixelCache(image,exception) == MagickFalse)
3437 return(MagickFalse);
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)
3445 for (y=0; y < (ssize_t) image->rows; y++)
3453 if (status == MagickFalse)
3455 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3456 if (q == (Quantum *) NULL)
3461 for (x=0; x < (ssize_t) image->columns; x++)
3467 if (((x >= region->x) && (x < (region->x+(ssize_t) region->width))) &&
3468 ((y >= region->y) && (y < (region->y+(ssize_t) region->height))))
3474 SetPixelReadMask(image,pixel,q);
3477 case WritePixelMask:
3479 SetPixelWriteMask(image,pixel,q);
3484 SetPixelCompositeMask(image,pixel,q);
3488 q+=(ptrdiff_t) GetPixelChannels(image);
3490 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3493 image->mask_trait=UndefinedPixelTrait;
3494 image_view=DestroyCacheView(image_view);
3527MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(
Image *image,
3528 const VirtualPixelMethod virtual_pixel_method,
ExceptionInfo *exception)
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));
3572static ssize_t SmushXGap(
const Image *smush_image,
const Image *images,
3600 if (images->previous == (
Image *) NULL)
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++)
3615 for (x=(ssize_t) left_image->columns-1; x > 0; x--)
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))
3623 i=(ssize_t) left_image->columns-x-1;
3624 for (x=0; x < (ssize_t) right_image->columns; x++)
3626 p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1,
3628 if ((p == (
const Quantum *) NULL) ||
3629 (GetPixelAlpha(right_image,p) != TransparentAlpha) ||
3630 ((x+i) >= (ssize_t) gap))
3633 if ((x+i) < (ssize_t) gap)
3636 right_view=DestroyCacheView(right_view);
3637 left_view=DestroyCacheView(left_view);
3638 if (y < (ssize_t) smush_image->rows)
3640 return((ssize_t) gap-offset);
3643static ssize_t SmushYGap(
const Image *smush_image,
const Image *images,
3671 if (images->previous == (
Image *) NULL)
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,
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++)
3686 for (y=(ssize_t) top_image->rows-1; y > 0; y--)
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))
3694 i=(ssize_t) top_image->rows-y-1;
3695 for (y=0; y < (ssize_t) bottom_image->rows; y++)
3697 p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1,
3699 if ((p == (
const Quantum *) NULL) ||
3700 (GetPixelAlpha(bottom_image,p) != TransparentAlpha) ||
3701 ((y+i) >= (ssize_t) gap))
3704 if ((y+i) < (ssize_t) gap)
3707 bottom_view=DestroyCacheView(bottom_view);
3708 top_view=DestroyCacheView(top_view);
3709 if (x < (ssize_t) smush_image->columns)
3711 return((ssize_t) gap-offset);
3714MagickExport
Image *SmushImages(
const Image *images,
3715 const MagickBooleanType stack,
const ssize_t offset,
ExceptionInfo *exception)
3717#define SmushImageTag "Smush/Image"
3753 assert(images != (
Image *) NULL);
3754 assert(images->signature == MagickCoreSignature);
3756 assert(exception->signature == MagickCoreSignature);
3757 if (IsEventLogging() != MagickFalse)
3758 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",images->filename);
3760 alpha_trait=image->alpha_trait;
3762 width=image->columns;
3764 next=GetNextImageInList(image);
3765 for ( ; next != (
Image *) NULL; next=GetNextImageInList(next))
3767 if (next->alpha_trait != UndefinedPixelTrait)
3768 alpha_trait=BlendPixelTrait;
3770 if (stack != MagickFalse)
3772 if (next->columns > width)
3773 width=next->columns;
3775 if (next->previous != (
Image *) NULL)
3776 height=(
size_t) MagickMax((ssize_t) height+offset,0U);
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)
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)
3793 smush_image=DestroyImage(smush_image);
3794 return((
Image *) NULL);
3796 smush_image->alpha_trait=alpha_trait;
3797 (void) SetImageBackgroundColor(smush_image,exception);
3801 for (n=0; n < (MagickOffsetType) number_images; n++)
3803 SetGeometry(smush_image,&geometry);
3804 GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry);
3805 if (stack != MagickFalse)
3807 x_offset-=geometry.x;
3808 y_offset-=SmushYGap(smush_image,image,offset,exception);
3812 x_offset-=SmushXGap(smush_image,image,offset,exception);
3813 y_offset-=geometry.y;
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)
3820 if (stack == MagickFalse)
3822 x_offset+=(ssize_t) image->columns;
3828 y_offset+=(ssize_t) image->rows;
3830 image=GetNextImageInList(image);
3832 if (stack == MagickFalse)
3833 smush_image->columns=(size_t) x_offset;
3835 smush_image->rows=(size_t) y_offset;
3836 if (status == MagickFalse)
3837 smush_image=DestroyImage(smush_image);
3838 return(smush_image);
3865MagickExport MagickBooleanType StripImage(
Image *image,
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");
3911static inline Quantum PushColormapIndex(
Image *image,
const Quantum index,
3912 MagickBooleanType *range_exception)
3914 if ((
size_t) index < image->colors)
3916 *range_exception=MagickTrue;
3917 return((Quantum) 0);
3933 assert(image != (
Image *) NULL);
3934 assert(image->signature == MagickCoreSignature);
3935 if (IsEventLogging() != MagickFalse)
3936 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
3937 if (image->ping != MagickFalse)
3939 if (image->storage_class != PseudoClass)
3940 return(MagickFalse);
3941 assert(image->colormap != (
PixelInfo *) NULL);
3942 range_exception=MagickFalse;
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)
3950 for (y=0; y < (ssize_t) image->rows; y++)
3961 if (status == MagickFalse)
3963 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3964 if (q == (Quantum *) NULL)
3969 for (x=0; x < (ssize_t) image->columns; x++)
3971 index=PushColormapIndex(image,GetPixelIndex(image,q),&range_exception);
3972 SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
3973 q+=(ptrdiff_t) GetPixelChannels(image);
3975 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3978 image_view=DestroyCacheView(image_view);
3980 if ((image->ping == MagickFalse) && (range_exception != MagickFalse))
3981 (void) ThrowMagickException(exception,GetMagickModule(),
3982 CorruptImageWarning,
"InvalidColormapIndex",
"`%s'",image->filename);
4023MagickExport MagickBooleanType SyncImagesSettings(
ImageInfo *image_info,
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);
4036 for ( ; image != (
Image *) NULL; image=GetNextImageInList(image))
4037 (
void) SyncImageSettings(image_info,image,exception);
4038 (void) DeleteImageOption(image_info,
"page");
4042MagickExport MagickBooleanType SyncImageSettings(
const ImageInfo *image_info,
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,
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)
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;
4084 option=GetImageOption(image_info,
"bordercolor");
4085 if (option != (
const char *) NULL)
4086 (void) QueryColorCompliance(option,AllCompliance,&image->border_color,
4089 option=GetImageOption(image_info,
"compose");
4090 if (option != (
const char *) NULL)
4091 image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
4092 MagickFalse,option);
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)
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;
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)
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;
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,
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)
4173 geometry=GetPageGeometry(option);
4174 flags=ParseAbsoluteGeometry(geometry,&image->page);
4175 geometry=DestroyString(geometry);
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)
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;
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)
4205 geometry=GetPageGeometry(option);
4206 flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
4207 geometry=DestroyString(geometry);
4209 option=GetImageOption(image_info,
"transparent-color");
4210 if (option != (
const char *) NULL)
4211 (void) QueryColorCompliance(option,AllCompliance,&image->transparent_color,
4213 option=GetImageOption(image_info,
"type");
4214 if (option != (
const char *) NULL)
4215 image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
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)
4224 if (image->units != units)
4225 switch (image->units)
4227 case PixelsPerInchResolution:
4229 if (units == PixelsPerCentimeterResolution)
4231 image->resolution.x/=2.54;
4232 image->resolution.y/=2.54;
4236 case PixelsPerCentimeterResolution:
4238 if (units == PixelsPerInchResolution)
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;
4251 option=GetImageOption(image_info,
"density");
4252 if (option != (
const char *) NULL)
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;
4262 option=GetImageOption(image_info,
"virtual-pixel");
4263 if (option != (
const char *) NULL)
4264 (void) SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
4265 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,option),
4267 option=GetImageOption(image_info,
"white-point");
4268 if (option != (
const char *) NULL)
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;
4283 if (image->image_info != (
ImageInfo *) NULL)
4284 image->image_info=DestroyImageInfo(image->image_info);
4285 image->image_info=CloneImageInfo(image_info);