| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % IIIII M M AAA GGGG EEEEE % |
| % I MM MM A A G E % |
| % I M M M AAAAA G GG EEE % |
| % I M M A A G G E % |
| % IIIII M M A A GGGG EEEEE % |
| % % |
| % % |
| % MagickCore Image Methods % |
| % % |
| % Software Design % |
| % John Cristy % |
| % July 1992 % |
| % % |
| % % |
| % Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization % |
| % dedicated to making software imaging solutions freely available. % |
| % % |
| % You may not use this file except in compliance with the License. You may % |
| % obtain a copy of the License at % |
| % % |
| % http://www.imagemagick.org/script/license.php % |
| % % |
| % Unless required by applicable law or agreed to in writing, software % |
| % distributed under the License is distributed on an "AS IS" BASIS, % |
| % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % |
| % See the License for the specific language governing permissions and % |
| % limitations under the License. % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % |
| % |
| */ |
| |
| /* |
| Include declarations. |
| */ |
| #include "MagickCore/studio.h" |
| #include "MagickCore/animate.h" |
| #include "MagickCore/artifact.h" |
| #include "MagickCore/attribute.h" |
| #include "MagickCore/blob.h" |
| #include "MagickCore/blob-private.h" |
| #include "MagickCore/cache.h" |
| #include "MagickCore/cache-private.h" |
| #include "MagickCore/cache-view.h" |
| #include "MagickCore/client.h" |
| #include "MagickCore/color.h" |
| #include "MagickCore/color-private.h" |
| #include "MagickCore/colormap.h" |
| #include "MagickCore/colorspace.h" |
| #include "MagickCore/colorspace-private.h" |
| #include "MagickCore/composite.h" |
| #include "MagickCore/composite-private.h" |
| #include "MagickCore/compress.h" |
| #include "MagickCore/constitute.h" |
| #include "MagickCore/display.h" |
| #include "MagickCore/draw.h" |
| #include "MagickCore/enhance.h" |
| #include "MagickCore/exception.h" |
| #include "MagickCore/exception-private.h" |
| #include "MagickCore/gem.h" |
| #include "MagickCore/geometry.h" |
| #include "MagickCore/histogram.h" |
| #include "MagickCore/image-private.h" |
| #include "MagickCore/list.h" |
| #include "MagickCore/magic.h" |
| #include "MagickCore/magick.h" |
| #include "MagickCore/magick-private.h" |
| #include "MagickCore/memory_.h" |
| #include "MagickCore/module.h" |
| #include "MagickCore/monitor.h" |
| #include "MagickCore/monitor-private.h" |
| #include "MagickCore/option.h" |
| #include "MagickCore/paint.h" |
| #include "MagickCore/pixel-accessor.h" |
| #include "MagickCore/profile.h" |
| #include "MagickCore/property.h" |
| #include "MagickCore/quantize.h" |
| #include "MagickCore/random_.h" |
| #include "MagickCore/resource_.h" |
| #include "MagickCore/segment.h" |
| #include "MagickCore/semaphore.h" |
| #include "MagickCore/signature-private.h" |
| #include "MagickCore/statistic.h" |
| #include "MagickCore/string_.h" |
| #include "MagickCore/string-private.h" |
| #include "MagickCore/thread-private.h" |
| #include "MagickCore/threshold.h" |
| #include "MagickCore/timer.h" |
| #include "MagickCore/token.h" |
| #include "MagickCore/utility.h" |
| #include "MagickCore/utility-private.h" |
| #include "MagickCore/version.h" |
| #include "MagickCore/xwindow-private.h" |
| |
| /* |
| Constant declaration. |
| */ |
| const char |
| BackgroundColor[] = "#ffffff", /* white */ |
| BorderColor[] = "#dfdfdf", /* gray */ |
| DefaultTileFrame[] = "15x15+3+3", |
| DefaultTileGeometry[] = "120x120+4+3>", |
| DefaultTileLabel[] = "%f\n%G\n%b", |
| ForegroundColor[] = "#000", /* black */ |
| LoadImageTag[] = "Load/Image", |
| LoadImagesTag[] = "Load/Images", |
| MatteColor[] = "#bdbdbd", /* gray */ |
| PSDensityGeometry[] = "72.0x72.0", |
| PSPageGeometry[] = "612x792", |
| SaveImageTag[] = "Save/Image", |
| SaveImagesTag[] = "Save/Images", |
| TransparentColor[] = "#00000000"; /* transparent black */ |
| |
| const double |
| DefaultResolution = 72.0; |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % A c q u i r e I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % AcquireImage() returns a pointer to an image structure initialized to |
| % default values. |
| % |
| % The format of the AcquireImage method is: |
| % |
| % Image *AcquireImage(const ImageInfo *image_info,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: Many of the image default values are set from this |
| % structure. For example, filename, compression, depth, background color, |
| % and others. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport Image *AcquireImage(const ImageInfo *image_info, |
| ExceptionInfo *exception) |
| { |
| const char |
| *option; |
| |
| Image |
| *image; |
| |
| MagickStatusType |
| flags; |
| |
| /* |
| Allocate image structure. |
| */ |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| image=(Image *) AcquireMagickMemory(sizeof(*image)); |
| if (image == (Image *) NULL) |
| ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); |
| (void) ResetMagickMemory(image,0,sizeof(*image)); |
| /* |
| Initialize Image structure. |
| */ |
| (void) CopyMagickString(image->magick,"MIFF",MaxTextExtent); |
| image->storage_class=DirectClass; |
| image->depth=MAGICKCORE_QUANTUM_DEPTH; |
| image->colorspace=sRGBColorspace; |
| image->rendering_intent=PerceptualIntent; |
| image->gamma=1.000f/2.200f; |
| image->chromaticity.red_primary.x=0.6400f; |
| image->chromaticity.red_primary.y=0.3300f; |
| image->chromaticity.red_primary.z=0.0300f; |
| image->chromaticity.green_primary.x=0.3000f; |
| image->chromaticity.green_primary.y=0.6000f; |
| image->chromaticity.green_primary.z=0.1000f; |
| image->chromaticity.blue_primary.x=0.1500f; |
| image->chromaticity.blue_primary.y=0.0600f; |
| image->chromaticity.blue_primary.z=0.7900f; |
| image->chromaticity.white_point.x=0.3127f; |
| image->chromaticity.white_point.y=0.3290f; |
| image->chromaticity.white_point.z=0.3583f; |
| image->interlace=NoInterlace; |
| image->ticks_per_second=UndefinedTicksPerSecond; |
| image->compose=OverCompositeOp; |
| (void) QueryColorCompliance(BackgroundColor,AllCompliance, |
| &image->background_color,exception); |
| (void) QueryColorCompliance(BorderColor,AllCompliance,&image->border_color, |
| exception); |
| (void) QueryColorCompliance(MatteColor,AllCompliance,&image->matte_color, |
| exception); |
| (void) QueryColorCompliance(TransparentColor,AllCompliance, |
| &image->transparent_color,exception); |
| GetTimerInfo(&image->timer); |
| image->cache=AcquirePixelCache(0); |
| image->channel_mask=DefaultChannels; |
| image->channel_map=AcquirePixelChannelMap(); |
| image->blob=CloneBlobInfo((BlobInfo *) NULL); |
| image->timestamp=time((time_t *) NULL); |
| image->debug=IsEventLogging(); |
| image->reference_count=1; |
| image->semaphore=AllocateSemaphoreInfo(); |
| image->signature=MagickSignature; |
| if (image_info == (ImageInfo *) NULL) |
| return(image); |
| /* |
| Transfer image info. |
| */ |
| SetBlobExempt(image,image_info->file != (FILE *) NULL ? MagickTrue : |
| MagickFalse); |
| (void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent); |
| (void) CopyMagickString(image->magick_filename,image_info->filename, |
| MaxTextExtent); |
| (void) CopyMagickString(image->magick,image_info->magick,MaxTextExtent); |
| if (image_info->size != (char *) NULL) |
| { |
| (void) ParseAbsoluteGeometry(image_info->size,&image->extract_info); |
| image->columns=image->extract_info.width; |
| image->rows=image->extract_info.height; |
| image->offset=image->extract_info.x; |
| image->extract_info.x=0; |
| image->extract_info.y=0; |
| } |
| if (image_info->extract != (char *) NULL) |
| { |
| RectangleInfo |
| geometry; |
| |
| flags=ParseAbsoluteGeometry(image_info->extract,&geometry); |
| if (((flags & XValue) != 0) || ((flags & YValue) != 0)) |
| { |
| image->extract_info=geometry; |
| Swap(image->columns,image->extract_info.width); |
| Swap(image->rows,image->extract_info.height); |
| } |
| } |
| image->compression=image_info->compression; |
| image->quality=image_info->quality; |
| image->endian=image_info->endian; |
| image->interlace=image_info->interlace; |
| image->units=image_info->units; |
| if (image_info->density != (char *) NULL) |
| { |
| GeometryInfo |
| geometry_info; |
| |
| flags=ParseGeometry(image_info->density,&geometry_info); |
| image->resolution.x=geometry_info.rho; |
| image->resolution.y=geometry_info.sigma; |
| if ((flags & SigmaValue) == 0) |
| image->resolution.y=image->resolution.x; |
| } |
| if (image_info->page != (char *) NULL) |
| { |
| char |
| *geometry; |
| |
| image->page=image->extract_info; |
| geometry=GetPageGeometry(image_info->page); |
| (void) ParseAbsoluteGeometry(geometry,&image->page); |
| geometry=DestroyString(geometry); |
| } |
| if (image_info->depth != 0) |
| image->depth=image_info->depth; |
| image->dither=image_info->dither; |
| image->background_color=image_info->background_color; |
| image->border_color=image_info->border_color; |
| image->matte_color=image_info->matte_color; |
| image->transparent_color=image_info->transparent_color; |
| image->ping=image_info->ping; |
| image->progress_monitor=image_info->progress_monitor; |
| image->client_data=image_info->client_data; |
| if (image_info->cache != (void *) NULL) |
| ClonePixelCacheMethods(image->cache,image_info->cache); |
| /* |
| Set all global options that map to per-image settings. |
| */ |
| (void) SyncImageSettings(image_info,image,exception); |
| /* |
| Global options that are only set for new images. |
| */ |
| image->image_info=(ImageInfo *) NULL; |
| option=GetImageOption(image_info,"delay"); |
| if (option != (const char *) NULL) |
| { |
| GeometryInfo |
| geometry_info; |
| |
| flags=ParseGeometry(option,&geometry_info); |
| if ((flags & GreaterValue) != 0) |
| { |
| if (image->delay > (size_t) floor(geometry_info.rho+0.5)) |
| image->delay=(size_t) floor(geometry_info.rho+0.5); |
| } |
| else |
| if ((flags & LessValue) != 0) |
| { |
| if (image->delay < (size_t) floor(geometry_info.rho+0.5)) |
| image->ticks_per_second=(ssize_t) floor(geometry_info.sigma+0.5); |
| } |
| else |
| image->delay=(size_t) floor(geometry_info.rho+0.5); |
| if ((flags & SigmaValue) != 0) |
| image->ticks_per_second=(ssize_t) floor(geometry_info.sigma+0.5); |
| } |
| option=GetImageOption(image_info,"dispose"); |
| if (option != (const char *) NULL) |
| image->dispose=(DisposeType) ParseCommandOption(MagickDisposeOptions, |
| MagickFalse,option); |
| return(image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % A c q u i r e I m a g e I n f o % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % AcquireImageInfo() allocates the ImageInfo structure. |
| % |
| % The format of the AcquireImageInfo method is: |
| % |
| % ImageInfo *AcquireImageInfo(void) |
| % |
| */ |
| MagickExport ImageInfo *AcquireImageInfo(void) |
| { |
| ImageInfo |
| *image_info; |
| |
| image_info=(ImageInfo *) AcquireMagickMemory(sizeof(*image_info)); |
| if (image_info == (ImageInfo *) NULL) |
| ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); |
| GetImageInfo(image_info); |
| return(image_info); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % A c q u i r e N e x t I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % AcquireNextImage() initializes the next image in a sequence to |
| % default values. The next member of image points to the newly allocated |
| % image. If there is a memory shortage, next is assigned NULL. |
| % |
| % The format of the AcquireNextImage method is: |
| % |
| % void AcquireNextImage(const ImageInfo *image_info,Image *image, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: Many of the image default values are set from this |
| % structure. For example, filename, compression, depth, background color, |
| % and others. |
| % |
| % o image: the image. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport void AcquireNextImage(const ImageInfo *image_info,Image *image, |
| ExceptionInfo *exception) |
| { |
| /* |
| Allocate image structure. |
| */ |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| image->next=AcquireImage(image_info,exception); |
| if (GetNextImageInList(image) == (Image *) NULL) |
| return; |
| (void) CopyMagickString(GetNextImageInList(image)->filename,image->filename, |
| MaxTextExtent); |
| if (image_info != (ImageInfo *) NULL) |
| (void) CopyMagickString(GetNextImageInList(image)->filename, |
| image_info->filename,MaxTextExtent); |
| DestroyBlob(GetNextImageInList(image)); |
| image->next->blob=ReferenceBlob(image->blob); |
| image->next->endian=image->endian; |
| image->next->scene=image->scene+1; |
| image->next->previous=image; |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % A p p e n d I m a g e s % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % AppendImages() takes all images from the current image pointer to the end |
| % of the image list and appends them to each other top-to-bottom if the |
| % stack parameter is true, otherwise left-to-right. |
| % |
| % The current gravity setting effects how the image is justified in the |
| % final image. |
| % |
| % The format of the AppendImages method is: |
| % |
| % Image *AppendImages(const Image *images,const MagickBooleanType stack, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o images: the image sequence. |
| % |
| % o stack: A value other than 0 stacks the images top-to-bottom. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport Image *AppendImages(const Image *images, |
| const MagickBooleanType stack,ExceptionInfo *exception) |
| { |
| #define AppendImageTag "Append/Image" |
| |
| CacheView |
| *append_view; |
| |
| Image |
| *append_image; |
| |
| MagickBooleanType |
| status; |
| |
| MagickOffsetType |
| n; |
| |
| PixelTrait |
| alpha_trait; |
| |
| RectangleInfo |
| geometry; |
| |
| register const Image |
| *next; |
| |
| size_t |
| height, |
| number_images, |
| width; |
| |
| ssize_t |
| x_offset, |
| y, |
| y_offset; |
| |
| /* |
| Compute maximum area of appended area. |
| */ |
| assert(images != (Image *) NULL); |
| assert(images->signature == MagickSignature); |
| if (images->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename); |
| assert(exception != (ExceptionInfo *) NULL); |
| assert(exception->signature == MagickSignature); |
| alpha_trait=images->alpha_trait; |
| number_images=1; |
| width=images->columns; |
| height=images->rows; |
| next=GetNextImageInList(images); |
| for ( ; next != (Image *) NULL; next=GetNextImageInList(next)) |
| { |
| if (next->alpha_trait == BlendPixelTrait) |
| alpha_trait=BlendPixelTrait; |
| number_images++; |
| if (stack != MagickFalse) |
| { |
| if (next->columns > width) |
| width=next->columns; |
| height+=next->rows; |
| continue; |
| } |
| width+=next->columns; |
| if (next->rows > height) |
| height=next->rows; |
| } |
| /* |
| Append images. |
| */ |
| append_image=CloneImage(images,width,height,MagickTrue,exception); |
| if (append_image == (Image *) NULL) |
| return((Image *) NULL); |
| if (SetImageStorageClass(append_image,DirectClass,exception) == MagickFalse) |
| { |
| append_image=DestroyImage(append_image); |
| return((Image *) NULL); |
| } |
| append_image->alpha_trait=alpha_trait; |
| (void) SetImageBackgroundColor(append_image,exception); |
| status=MagickTrue; |
| x_offset=0; |
| y_offset=0; |
| next=images; |
| append_view=AcquireAuthenticCacheView(append_image,exception); |
| for (n=0; n < (MagickOffsetType) number_images; n++) |
| { |
| CacheView |
| *image_view; |
| |
| Image |
| *image; |
| |
| MagickBooleanType |
| proceed; |
| |
| image=CloneImage(next,0,0,MagickTrue,exception); |
| if (image == (Image *) NULL) |
| break; |
| (void) TransformImageColorspace(image,append_image->colorspace,exception); |
| SetGeometry(append_image,&geometry); |
| GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry); |
| if (stack != MagickFalse) |
| x_offset-=geometry.x; |
| else |
| y_offset-=geometry.y; |
| image_view=AcquireVirtualCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| MagickBooleanType |
| sync; |
| |
| PixelInfo |
| pixel; |
| |
| register const Quantum |
| *restrict p; |
| |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception); |
| q=QueueCacheViewAuthenticPixels(append_view,x_offset,y+y_offset, |
| image->columns,1,exception); |
| if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL)) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| GetPixelInfo(image,&pixel); |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| if (GetPixelReadMask(image,p) == 0) |
| { |
| p+=GetPixelChannels(image); |
| q+=GetPixelChannels(append_image); |
| continue; |
| } |
| GetPixelInfoPixel(image,p,&pixel); |
| SetPixelInfoPixel(append_image,&pixel,q); |
| p+=GetPixelChannels(image); |
| q+=GetPixelChannels(append_image); |
| } |
| sync=SyncCacheViewAuthenticPixels(append_view,exception); |
| if (sync == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| if (stack == MagickFalse) |
| { |
| x_offset+=(ssize_t) image->columns; |
| y_offset=0; |
| } |
| else |
| { |
| x_offset=0; |
| y_offset+=(ssize_t) image->rows; |
| } |
| image=DestroyImage(image); |
| proceed=SetImageProgress(append_image,AppendImageTag,n,number_images); |
| if (proceed == MagickFalse) |
| break; |
| next=GetNextImageInList(next); |
| } |
| append_view=DestroyCacheView(append_view); |
| if (status == MagickFalse) |
| append_image=DestroyImage(append_image); |
| return(append_image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % C a t c h I m a g e E x c e p t i o n % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % CatchImageException() returns if no exceptions are found in the image |
| % sequence, otherwise it determines the most severe exception and reports |
| % it as a warning or error depending on the severity. |
| % |
| % The format of the CatchImageException method is: |
| % |
| % ExceptionType CatchImageException(Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: An image sequence. |
| % |
| */ |
| MagickExport ExceptionType CatchImageException(Image *image) |
| { |
| ExceptionInfo |
| *exception; |
| |
| ExceptionType |
| severity; |
| |
| assert(image != (const Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| exception=AcquireExceptionInfo(); |
| CatchException(exception); |
| severity=exception->severity; |
| exception=DestroyExceptionInfo(exception); |
| return(severity); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % C l i p I m a g e P a t h % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % ClipImagePath() sets the image clip mask based any clipping path information |
| % if it exists. |
| % |
| % The format of the ClipImagePath method is: |
| % |
| % MagickBooleanType ClipImagePath(Image *image,const char *pathname, |
| % const MagickBooleanType inside,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o pathname: name of clipping path resource. If name is preceded by #, use |
| % clipping path numbered by name. |
| % |
| % o inside: if non-zero, later operations take effect inside clipping path. |
| % Otherwise later operations take effect outside clipping path. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| |
| MagickExport MagickBooleanType ClipImage(Image *image,ExceptionInfo *exception) |
| { |
| return(ClipImagePath(image,"#1",MagickTrue,exception)); |
| } |
| |
| MagickExport MagickBooleanType ClipImagePath(Image *image,const char *pathname, |
| const MagickBooleanType inside,ExceptionInfo *exception) |
| { |
| #define ClipImagePathTag "ClipPath/Image" |
| |
| char |
| *property; |
| |
| const char |
| *value; |
| |
| Image |
| *clip_mask; |
| |
| ImageInfo |
| *image_info; |
| |
| assert(image != (const Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| assert(pathname != NULL); |
| property=AcquireString(pathname); |
| (void) FormatLocaleString(property,MaxTextExtent,"8BIM:1999,2998:%s", |
| pathname); |
| value=GetImageProperty(image,property,exception); |
| property=DestroyString(property); |
| if (value == (const char *) NULL) |
| { |
| ThrowFileException(exception,OptionError,"NoClipPathDefined", |
| image->filename); |
| return(MagickFalse); |
| } |
| image_info=AcquireImageInfo(); |
| (void) CopyMagickString(image_info->filename,image->filename,MaxTextExtent); |
| (void) ConcatenateMagickString(image_info->filename,pathname,MaxTextExtent); |
| clip_mask=BlobToImage(image_info,value,strlen(value),exception); |
| image_info=DestroyImageInfo(image_info); |
| if (clip_mask == (Image *) NULL) |
| return(MagickFalse); |
| if (clip_mask->storage_class == PseudoClass) |
| { |
| (void) SyncImage(clip_mask,exception); |
| if (SetImageStorageClass(clip_mask,DirectClass,exception) == MagickFalse) |
| return(MagickFalse); |
| } |
| if (inside == MagickFalse) |
| (void) NegateImage(clip_mask,MagickFalse,exception); |
| (void) FormatLocaleString(clip_mask->magick_filename,MaxTextExtent, |
| "8BIM:1999,2998:%s\nPS",pathname); |
| (void) SetImageMask(image,clip_mask,exception); |
| clip_mask=DestroyImage(clip_mask); |
| return(MagickTrue); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % C l o n e I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % CloneImage() copies an image and returns the copy as a new image object. |
| % |
| % If the specified columns and rows is 0, an exact copy of the image is |
| % returned, otherwise the pixel data is undefined and must be initialized |
| % with the QueueAuthenticPixels() and SyncAuthenticPixels() methods. On |
| % failure, a NULL image is returned and exception describes the reason for the |
| % failure. |
| % |
| % The format of the CloneImage method is: |
| % |
| % Image *CloneImage(const Image *image,const size_t columns, |
| % const size_t rows,const MagickBooleanType orphan, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o columns: the number of columns in the cloned image. |
| % |
| % o rows: the number of rows in the cloned image. |
| % |
| % o detach: With a value other than 0, the cloned image is detached from |
| % its parent I/O stream. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport Image *CloneImage(const Image *image,const size_t columns, |
| const size_t rows,const MagickBooleanType detach,ExceptionInfo *exception) |
| { |
| Image |
| *clone_image; |
| |
| double |
| scale; |
| |
| size_t |
| length; |
| |
| /* |
| Clone the image. |
| */ |
| assert(image != (const Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| assert(exception != (ExceptionInfo *) NULL); |
| assert(exception->signature == MagickSignature); |
| clone_image=(Image *) AcquireMagickMemory(sizeof(*clone_image)); |
| if (clone_image == (Image *) NULL) |
| ThrowImageException(ResourceLimitError,"MemoryAllocationFailed"); |
| (void) ResetMagickMemory(clone_image,0,sizeof(*clone_image)); |
| clone_image->signature=MagickSignature; |
| clone_image->storage_class=image->storage_class; |
| clone_image->number_channels=image->number_channels; |
| clone_image->number_meta_channels=image->number_meta_channels; |
| clone_image->metacontent_extent=image->metacontent_extent; |
| clone_image->colorspace=image->colorspace; |
| clone_image->read_mask=image->read_mask; |
| clone_image->write_mask=image->write_mask; |
| clone_image->alpha_trait=image->alpha_trait; |
| clone_image->columns=image->columns; |
| clone_image->rows=image->rows; |
| clone_image->dither=image->dither; |
| if (image->colormap != (PixelInfo *) NULL) |
| { |
| /* |
| Allocate and copy the image colormap. |
| */ |
| clone_image->colors=image->colors; |
| length=(size_t) image->colors; |
| clone_image->colormap=(PixelInfo *) AcquireQuantumMemory(length, |
| sizeof(*clone_image->colormap)); |
| if (clone_image->colormap == (PixelInfo *) NULL) |
| ThrowImageException(ResourceLimitError,"MemoryAllocationFailed"); |
| (void) CopyMagickMemory(clone_image->colormap,image->colormap,length* |
| sizeof(*clone_image->colormap)); |
| } |
| (void) CloneImageProfiles(clone_image,image); |
| (void) CloneImageProperties(clone_image,image); |
| (void) CloneImageArtifacts(clone_image,image); |
| GetTimerInfo(&clone_image->timer); |
| if (image->ascii85 != (void *) NULL) |
| Ascii85Initialize(clone_image); |
| clone_image->magick_columns=image->magick_columns; |
| clone_image->magick_rows=image->magick_rows; |
| clone_image->type=image->type; |
| clone_image->channel_mask=image->channel_mask; |
| clone_image->channel_map=ClonePixelChannelMap(image->channel_map); |
| (void) CopyMagickString(clone_image->magick_filename,image->magick_filename, |
| MaxTextExtent); |
| (void) CopyMagickString(clone_image->magick,image->magick,MaxTextExtent); |
| (void) CopyMagickString(clone_image->filename,image->filename,MaxTextExtent); |
| clone_image->progress_monitor=image->progress_monitor; |
| clone_image->client_data=image->client_data; |
| clone_image->reference_count=1; |
| clone_image->next=image->next; |
| clone_image->previous=image->previous; |
| clone_image->list=NewImageList(); |
| if (detach == MagickFalse) |
| clone_image->blob=ReferenceBlob(image->blob); |
| else |
| { |
| clone_image->next=NewImageList(); |
| clone_image->previous=NewImageList(); |
| clone_image->blob=CloneBlobInfo((BlobInfo *) NULL); |
| } |
| clone_image->ping=image->ping; |
| clone_image->debug=IsEventLogging(); |
| clone_image->semaphore=AllocateSemaphoreInfo(); |
| if ((columns == 0) && (rows == 0)) |
| { |
| if (image->montage != (char *) NULL) |
| (void) CloneString(&clone_image->montage,image->montage); |
| if (image->directory != (char *) NULL) |
| (void) CloneString(&clone_image->directory,image->directory); |
| clone_image->cache=ReferencePixelCache(image->cache); |
| return(clone_image); |
| } |
| scale=(double) columns/(double) image->columns; |
| clone_image->page.width=(size_t) floor(scale*image->page.width+0.5); |
| clone_image->page.x=(ssize_t) ceil(scale*image->page.x-0.5); |
| clone_image->tile_offset.x=(ssize_t) ceil(scale*image->tile_offset.x-0.5); |
| scale=(double) rows/(double) image->rows; |
| clone_image->page.height=(size_t) floor(scale*image->page.height+0.5); |
| clone_image->page.y=(ssize_t) ceil(scale*image->page.y-0.5); |
| clone_image->tile_offset.y=(ssize_t) ceil(scale*image->tile_offset.y-0.5); |
| clone_image->columns=columns; |
| clone_image->rows=rows; |
| clone_image->cache=ClonePixelCache(image->cache); |
| |
| return(clone_image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % C l o n e I m a g e I n f o % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % CloneImageInfo() makes a copy of the given image info structure. If |
| % NULL is specified, a new image info structure is created initialized to |
| % default values. |
| % |
| % The format of the CloneImageInfo method is: |
| % |
| % ImageInfo *CloneImageInfo(const ImageInfo *image_info) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| */ |
| MagickExport ImageInfo *CloneImageInfo(const ImageInfo *image_info) |
| { |
| ImageInfo |
| *clone_info; |
| |
| clone_info=AcquireImageInfo(); |
| if (image_info == (ImageInfo *) NULL) |
| return(clone_info); |
| clone_info->compression=image_info->compression; |
| clone_info->temporary=image_info->temporary; |
| clone_info->adjoin=image_info->adjoin; |
| clone_info->antialias=image_info->antialias; |
| clone_info->scene=image_info->scene; |
| clone_info->number_scenes=image_info->number_scenes; |
| clone_info->depth=image_info->depth; |
| (void) CloneString(&clone_info->size,image_info->size); |
| (void) CloneString(&clone_info->extract,image_info->extract); |
| (void) CloneString(&clone_info->scenes,image_info->scenes); |
| (void) CloneString(&clone_info->page,image_info->page); |
| clone_info->interlace=image_info->interlace; |
| clone_info->endian=image_info->endian; |
| clone_info->units=image_info->units; |
| clone_info->quality=image_info->quality; |
| (void) CloneString(&clone_info->sampling_factor,image_info->sampling_factor); |
| (void) CloneString(&clone_info->server_name,image_info->server_name); |
| (void) CloneString(&clone_info->font,image_info->font); |
| (void) CloneString(&clone_info->texture,image_info->texture); |
| (void) CloneString(&clone_info->density,image_info->density); |
| clone_info->pointsize=image_info->pointsize; |
| clone_info->fuzz=image_info->fuzz; |
| clone_info->background_color=image_info->background_color; |
| clone_info->border_color=image_info->border_color; |
| clone_info->matte_color=image_info->matte_color; |
| clone_info->transparent_color=image_info->transparent_color; |
| clone_info->dither=image_info->dither; |
| clone_info->monochrome=image_info->monochrome; |
| clone_info->colorspace=image_info->colorspace; |
| clone_info->type=image_info->type; |
| clone_info->orientation=image_info->orientation; |
| clone_info->preview_type=image_info->preview_type; |
| clone_info->group=image_info->group; |
| clone_info->ping=image_info->ping; |
| clone_info->verbose=image_info->verbose; |
| (void) CloneString(&clone_info->view,image_info->view); |
| clone_info->progress_monitor=image_info->progress_monitor; |
| clone_info->client_data=image_info->client_data; |
| clone_info->cache=image_info->cache; |
| if (image_info->cache != (void *) NULL) |
| clone_info->cache=ReferencePixelCache(image_info->cache); |
| if (image_info->profile != (void *) NULL) |
| clone_info->profile=(void *) CloneStringInfo((StringInfo *) |
| image_info->profile); |
| SetImageInfoFile(clone_info,image_info->file); |
| SetImageInfoBlob(clone_info,image_info->blob,image_info->length); |
| clone_info->stream=image_info->stream; |
| (void) CopyMagickString(clone_info->magick,image_info->magick,MaxTextExtent); |
| (void) CopyMagickString(clone_info->unique,image_info->unique,MaxTextExtent); |
| (void) CopyMagickString(clone_info->zero,image_info->zero,MaxTextExtent); |
| (void) CopyMagickString(clone_info->filename,image_info->filename, |
| MaxTextExtent); |
| clone_info->channel=image_info->channel; |
| (void) CloneImageOptions(clone_info,image_info); |
| clone_info->debug=IsEventLogging(); |
| clone_info->signature=image_info->signature; |
| return(clone_info); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % D e s t r o y I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % DestroyImage() dereferences an image, deallocating memory associated with |
| % the image if the reference count becomes zero. |
| % |
| % The format of the DestroyImage method is: |
| % |
| % Image *DestroyImage(Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport Image *DestroyImage(Image *image) |
| { |
| MagickBooleanType |
| destroy; |
| |
| /* |
| Dereference image. |
| */ |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| destroy=MagickFalse; |
| LockSemaphoreInfo(image->semaphore); |
| image->reference_count--; |
| if (image->reference_count == 0) |
| destroy=MagickTrue; |
| UnlockSemaphoreInfo(image->semaphore); |
| if (destroy == MagickFalse) |
| return((Image *) NULL); |
| /* |
| Destroy image. |
| */ |
| DestroyImagePixels(image); |
| image->channel_map=DestroyPixelChannelMap(image->channel_map); |
| if (image->montage != (char *) NULL) |
| image->montage=DestroyString(image->montage); |
| if (image->directory != (char *) NULL) |
| image->directory=DestroyString(image->directory); |
| if (image->colormap != (PixelInfo *) NULL) |
| image->colormap=(PixelInfo *) RelinquishMagickMemory(image->colormap); |
| if (image->geometry != (char *) NULL) |
| image->geometry=DestroyString(image->geometry); |
| DestroyImageProfiles(image); |
| DestroyImageProperties(image); |
| DestroyImageArtifacts(image); |
| if (image->ascii85 != (Ascii85Info*) NULL) |
| image->ascii85=(Ascii85Info *) RelinquishMagickMemory(image->ascii85); |
| DestroyBlob(image); |
| if (image->semaphore != (SemaphoreInfo *) NULL) |
| DestroySemaphoreInfo(&image->semaphore); |
| image->signature=(~MagickSignature); |
| image=(Image *) RelinquishMagickMemory(image); |
| return(image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % D e s t r o y I m a g e I n f o % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % DestroyImageInfo() deallocates memory associated with an ImageInfo |
| % structure. |
| % |
| % The format of the DestroyImageInfo method is: |
| % |
| % ImageInfo *DestroyImageInfo(ImageInfo *image_info) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| */ |
| MagickExport ImageInfo *DestroyImageInfo(ImageInfo *image_info) |
| { |
| assert(image_info != (ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| if (image_info->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| image_info->filename); |
| if (image_info->size != (char *) NULL) |
| image_info->size=DestroyString(image_info->size); |
| if (image_info->extract != (char *) NULL) |
| image_info->extract=DestroyString(image_info->extract); |
| if (image_info->scenes != (char *) NULL) |
| image_info->scenes=DestroyString(image_info->scenes); |
| if (image_info->page != (char *) NULL) |
| image_info->page=DestroyString(image_info->page); |
| if (image_info->sampling_factor != (char *) NULL) |
| image_info->sampling_factor=DestroyString( |
| image_info->sampling_factor); |
| if (image_info->server_name != (char *) NULL) |
| image_info->server_name=DestroyString( |
| image_info->server_name); |
| if (image_info->font != (char *) NULL) |
| image_info->font=DestroyString(image_info->font); |
| if (image_info->texture != (char *) NULL) |
| image_info->texture=DestroyString(image_info->texture); |
| if (image_info->density != (char *) NULL) |
| image_info->density=DestroyString(image_info->density); |
| if (image_info->view != (char *) NULL) |
| image_info->view=DestroyString(image_info->view); |
| if (image_info->cache != (void *) NULL) |
| image_info->cache=DestroyPixelCache(image_info->cache); |
| if (image_info->profile != (StringInfo *) NULL) |
| image_info->profile=(void *) DestroyStringInfo((StringInfo *) |
| image_info->profile); |
| DestroyImageOptions(image_info); |
| image_info->signature=(~MagickSignature); |
| image_info=(ImageInfo *) RelinquishMagickMemory(image_info); |
| return(image_info); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| + D i s a s s o c i a t e I m a g e S t r e a m % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % DisassociateImageStream() disassociates the image stream. |
| % |
| % The format of the DisassociateImageStream method is: |
| % |
| % MagickBooleanType DisassociateImageStream(const Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport void DisassociateImageStream(Image *image) |
| { |
| assert(image != (const Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| (void) DetachBlob(image->blob); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % G e t I m a g e A l p h a C h a n n e l % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % GetImageAlphaChannel() returns MagickFalse if the image alpha channel is |
| % not activated. That is, the image is RGB rather than RGBA or CMYK rather |
| % than CMYKA. |
| % |
| % The format of the GetImageAlphaChannel method is: |
| % |
| % MagickBooleanType GetImageAlphaChannel(const Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport MagickBooleanType GetImageAlphaChannel(const Image *image) |
| { |
| assert(image != (const Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| return(image->alpha_trait == BlendPixelTrait ? MagickTrue : MagickFalse); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % G e t I m a g e I n f o % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % GetImageInfo() initializes image_info to default values. |
| % |
| % The format of the GetImageInfo method is: |
| % |
| % void GetImageInfo(ImageInfo *image_info) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| */ |
| MagickExport void GetImageInfo(ImageInfo *image_info) |
| { |
| char |
| *synchronize; |
| |
| ExceptionInfo |
| *exception; |
| |
| /* |
| File and image dimension members. |
| */ |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image_info != (ImageInfo *) NULL); |
| (void) ResetMagickMemory(image_info,0,sizeof(*image_info)); |
| image_info->adjoin=MagickTrue; |
| image_info->interlace=NoInterlace; |
| image_info->channel=DefaultChannels; |
| image_info->quality=UndefinedCompressionQuality; |
| image_info->antialias=MagickTrue; |
| image_info->dither=MagickTrue; |
| synchronize=GetEnvironmentValue("MAGICK_SYNCHRONIZE"); |
| if (synchronize != (const char *) NULL) |
| { |
| image_info->synchronize=IsStringTrue(synchronize); |
| synchronize=DestroyString(synchronize); |
| } |
| exception=AcquireExceptionInfo(); |
| (void) QueryColorCompliance(BackgroundColor,AllCompliance, |
| &image_info->background_color,exception); |
| (void) QueryColorCompliance(BorderColor,AllCompliance, |
| &image_info->border_color,exception); |
| (void) QueryColorCompliance(MatteColor,AllCompliance,&image_info->matte_color, |
| exception); |
| (void) QueryColorCompliance(TransparentColor,AllCompliance, |
| &image_info->transparent_color,exception); |
| exception=DestroyExceptionInfo(exception); |
| image_info->debug=IsEventLogging(); |
| image_info->signature=MagickSignature; |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % G e t I m a g e I n f o F i l e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % GetImageInfoFile() returns the image info file member. |
| % |
| % The format of the GetImageInfoFile method is: |
| % |
| % FILE *GetImageInfoFile(const ImageInfo *image_info) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| */ |
| MagickExport FILE *GetImageInfoFile(const ImageInfo *image_info) |
| { |
| return(image_info->file); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % G e t I m a g e M a s k % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % GetImageMask() returns the mask associated with the image. |
| % |
| % The format of the GetImageMask method is: |
| % |
| % Image *GetImageMask(const Image *image,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport Image *GetImageMask(const Image *image,ExceptionInfo *exception) |
| { |
| CacheView |
| *mask_view, |
| *image_view; |
| |
| Image |
| *mask_image; |
| |
| MagickBooleanType |
| status; |
| |
| ssize_t |
| y; |
| |
| /* |
| Get image mask. |
| */ |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| mask_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception); |
| if (mask_image == (Image *) NULL) |
| return((Image *) NULL); |
| status=MagickTrue; |
| (void) SetImageColorspace(mask_image,GRAYColorspace,exception); |
| mask_image->read_mask=MagickFalse; |
| image_view=AcquireVirtualCacheView(image,exception); |
| mask_view=AcquireAuthenticCacheView(mask_image,exception); |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register const Quantum |
| *restrict p; |
| |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception); |
| q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1, |
| exception); |
| if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL)) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| SetPixelGray(mask_image,GetPixelReadMask(image,p),q); |
| p+=GetPixelChannels(image); |
| q+=GetPixelChannels(mask_image); |
| } |
| if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| mask_view=DestroyCacheView(mask_view); |
| image_view=DestroyCacheView(image_view); |
| if (status == MagickFalse) |
| mask_image=DestroyImage(mask_image); |
| return(mask_image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| + G e t I m a g e R e f e r e n c e C o u n t % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % GetImageReferenceCount() returns the image reference count. |
| % |
| % The format of the GetReferenceCount method is: |
| % |
| % ssize_t GetImageReferenceCount(Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport ssize_t GetImageReferenceCount(Image *image) |
| { |
| ssize_t |
| reference_count; |
| |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| LockSemaphoreInfo(image->semaphore); |
| reference_count=image->reference_count; |
| UnlockSemaphoreInfo(image->semaphore); |
| return(reference_count); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % 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 % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % GetImageVirtualPixelMethod() gets the "virtual pixels" method for the |
| % image. A virtual pixel is any pixel access that is outside the boundaries |
| % of the image cache. |
| % |
| % The format of the GetImageVirtualPixelMethod() method is: |
| % |
| % VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image) |
| { |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| return(GetPixelCacheVirtualMethod(image)); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % I n t e r p r e t I m a g e F i l e n a m e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % InterpretImageFilename() interprets embedded characters in an image filename. |
| % The filename length is returned. |
| % |
| % The format of the InterpretImageFilename method is: |
| % |
| % size_t InterpretImageFilename(const ImageInfo *image_info,Image *image, |
| % const char *format,int value,char *filename,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows. |
| % |
| % o image_info: the image info.. |
| % |
| % o image: the image. |
| % |
| % o format: A filename describing the format to use to write the numeric |
| % argument. Only the first numeric format identifier is replaced. |
| % |
| % o value: Numeric value to substitute into format filename. |
| % |
| % o filename: return the formatted filename in this character buffer. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport size_t InterpretImageFilename(const ImageInfo *image_info, |
| Image *image,const char *format,int value,char *filename, |
| ExceptionInfo *exception) |
| { |
| char |
| *q; |
| |
| int |
| c; |
| |
| MagickBooleanType |
| canonical; |
| |
| register const char |
| *p; |
| |
| size_t |
| length; |
| |
| canonical=MagickFalse; |
| length=0; |
| (void) CopyMagickString(filename,format,MaxTextExtent); |
| for (p=strchr(format,'%'); p != (char *) NULL; p=strchr(p+1,'%')) |
| { |
| q=(char *) p+1; |
| if (*q == '%') |
| { |
| p=q+1; |
| continue; |
| } |
| if (*q == '0') |
| { |
| ssize_t |
| value; |
| |
| value=(ssize_t) strtol(q,&q,10); |
| (void) value; |
| } |
| switch (*q) |
| { |
| case 'd': |
| case 'o': |
| case 'x': |
| { |
| q++; |
| c=(*q); |
| *q='\0'; |
| (void) FormatLocaleString(filename+(p-format),(size_t) (MaxTextExtent- |
| (p-format)),p,value); |
| *q=c; |
| (void) ConcatenateMagickString(filename,q,MaxTextExtent); |
| canonical=MagickTrue; |
| if (*(q-1) != '%') |
| break; |
| p++; |
| break; |
| } |
| case '[': |
| { |
| char |
| pattern[MaxTextExtent]; |
| |
| const char |
| *value; |
| |
| register char |
| *r; |
| |
| register ssize_t |
| i; |
| |
| ssize_t |
| depth; |
| |
| /* |
| Image option. |
| */ |
| /* FUTURE: Compare update with code from InterpretImageProperties() |
| Note that a 'filename:' property should not need depth recursion. |
| */ |
| if (strchr(p,']') == (char *) NULL) |
| break; |
| depth=1; |
| r=q+1; |
| for (i=0; (i < (MaxTextExtent-1L)) && (*r != '\0'); i++) |
| { |
| if (*r == '[') |
| depth++; |
| if (*r == ']') |
| depth--; |
| if (depth <= 0) |
| break; |
| pattern[i]=(*r++); |
| } |
| pattern[i]='\0'; |
| if (LocaleNCompare(pattern,"filename:",9) != 0) |
| break; |
| value=(const char *) NULL; |
| #if 0 |
| // FUTURE: remove this code. -- Anthony 29 Arpil 2012 |
| // Removed as GetMagickProperty() will will never match a "filename:" |
| // string as this is not a 'known' image property. |
| // |
| if ((image_info != (const ImageInfo *) NULL) && |
| (image != (const Image *) NULL)) |
| value=GetMagickProperty(image_info,image,pattern,exception); |
| else |
| #endif |
| if (image != (Image *) NULL) |
| value=GetImageProperty(image,pattern,exception); |
| if ((value == (const char *) NULL) && (image != (Image *) NULL)) |
| value=GetImageArtifact(image,pattern); |
| if ((value == (const char *) NULL) && |
| (image_info != (ImageInfo *) NULL)) |
| value=GetImageOption(image_info,pattern); |
| if (value == (const char *) NULL) |
| break; |
| q--; |
| c=(*q); |
| *q='\0'; |
| (void) CopyMagickString(filename+(p-format-length),value,(size_t) |
| (MaxTextExtent-(p-format-length))); |
| length+=strlen(pattern)-1; |
| *q=c; |
| (void) ConcatenateMagickString(filename,r+1,MaxTextExtent); |
| canonical=MagickTrue; |
| if (*(q-1) != '%') |
| break; |
| p++; |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| for (q=filename; *q != '\0'; q++) |
| if ((*q == '%') && (*(q+1) == '%')) |
| { |
| (void) CopyMagickString(q,q+1,(size_t) (MaxTextExtent-(q-filename))); |
| canonical=MagickTrue; |
| } |
| if (canonical == MagickFalse) |
| (void) CopyMagickString(filename,format,MaxTextExtent); |
| return(strlen(filename)); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % I s H i g h D y n a m i c R a n g e I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % IsHighDynamicRangeImage() returns MagickTrue if any pixel component is |
| % non-integer or exceeds the bounds of the quantum depth (e.g. for Q16 |
| % 0..65535. |
| % |
| % The format of the IsHighDynamicRangeImage method is: |
| % |
| % MagickBooleanType IsHighDynamicRangeImage(const Image *image, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType IsHighDynamicRangeImage(const Image *image, |
| ExceptionInfo *exception) |
| { |
| #if !defined(MAGICKCORE_HDRI_SUPPORT) |
| (void) image; |
| (void) exception; |
| return(MagickFalse); |
| #else |
| CacheView |
| *image_view; |
| |
| MagickBooleanType |
| status; |
| |
| ssize_t |
| y; |
| |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| status=MagickTrue; |
| image_view=AcquireVirtualCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register const Quantum |
| *p; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception); |
| if (p == (const Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| register ssize_t |
| i; |
| |
| if (GetPixelReadMask(image,p) == 0) |
| { |
| p+=GetPixelChannels(image); |
| continue; |
| } |
| for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
| { |
| double |
| pixel; |
| |
| PixelTrait |
| traits; |
| |
| traits=GetPixelChannelTraits(image,(PixelChannel) i); |
| if (traits == UndefinedPixelTrait) |
| continue; |
| pixel=(double) p[i]; |
| if ((pixel < 0.0) || (pixel > QuantumRange) || |
| (pixel != (QuantumAny) pixel)) |
| break; |
| } |
| p+=GetPixelChannels(image); |
| if (i < (ssize_t) GetPixelChannels(image)) |
| status=MagickFalse; |
| } |
| if (x < (ssize_t) image->columns) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| return(status != MagickFalse ? MagickFalse : MagickTrue); |
| #endif |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % I s I m a g e O b j e c t % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % IsImageObject() returns MagickTrue if the image sequence contains a valid |
| % set of image objects. |
| % |
| % The format of the IsImageObject method is: |
| % |
| % MagickBooleanType IsImageObject(const Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport MagickBooleanType IsImageObject(const Image *image) |
| { |
| register const Image |
| *p; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| for (p=image; p != (Image *) NULL; p=GetNextImageInList(p)) |
| if (p->signature != MagickSignature) |
| return(MagickFalse); |
| return(MagickTrue); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % I s T a i n t I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % IsTaintImage() returns MagickTrue any pixel in the image has been altered |
| % since it was first constituted. |
| % |
| % The format of the IsTaintImage method is: |
| % |
| % MagickBooleanType IsTaintImage(const Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport MagickBooleanType IsTaintImage(const Image *image) |
| { |
| char |
| magick[MaxTextExtent], |
| filename[MaxTextExtent]; |
| |
| register const Image |
| *p; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| (void) CopyMagickString(magick,image->magick,MaxTextExtent); |
| (void) CopyMagickString(filename,image->filename,MaxTextExtent); |
| for (p=image; p != (Image *) NULL; p=GetNextImageInList(p)) |
| { |
| if (p->taint != MagickFalse) |
| return(MagickTrue); |
| if (LocaleCompare(p->magick,magick) != 0) |
| return(MagickTrue); |
| if (LocaleCompare(p->filename,filename) != 0) |
| return(MagickTrue); |
| } |
| return(MagickFalse); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % M o d i f y I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % ModifyImage() ensures that there is only a single reference to the image |
| % to be modified, updating the provided image pointer to point to a clone of |
| % the original image if necessary. |
| % |
| % The format of the ModifyImage method is: |
| % |
| % MagickBooleanType ModifyImage(Image *image,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType ModifyImage(Image **image, |
| ExceptionInfo *exception) |
| { |
| Image |
| *clone_image; |
| |
| assert(image != (Image **) NULL); |
| assert(*image != (Image *) NULL); |
| assert((*image)->signature == MagickSignature); |
| if ((*image)->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename); |
| if (GetImageReferenceCount(*image) <= 1) |
| return(MagickTrue); |
| clone_image=CloneImage(*image,0,0,MagickTrue,exception); |
| LockSemaphoreInfo((*image)->semaphore); |
| (*image)->reference_count--; |
| UnlockSemaphoreInfo((*image)->semaphore); |
| *image=clone_image; |
| return(MagickTrue); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % N e w M a g i c k I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % NewMagickImage() creates a blank image canvas of the specified size and |
| % background color. |
| % |
| % The format of the NewMagickImage method is: |
| % |
| % Image *NewMagickImage(const ImageInfo *image_info, |
| % const size_t width,const size_t height,const PixelInfo *background, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o width: the image width. |
| % |
| % o height: the image height. |
| % |
| % o background: the image color. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport Image *NewMagickImage(const ImageInfo *image_info, |
| const size_t width,const size_t height,const PixelInfo *background, |
| ExceptionInfo *exception) |
| { |
| CacheView |
| *image_view; |
| |
| Image |
| *image; |
| |
| MagickBooleanType |
| status; |
| |
| ssize_t |
| y; |
| |
| assert(image_info != (const ImageInfo *) NULL); |
| if (image_info->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image_info->signature == MagickSignature); |
| assert(background != (const PixelInfo *) NULL); |
| image=AcquireImage(image_info,exception); |
| image->columns=width; |
| image->rows=height; |
| image->colorspace=background->colorspace; |
| image->alpha_trait=background->alpha_trait; |
| image->fuzz=background->fuzz; |
| image->depth=background->depth; |
| status=MagickTrue; |
| image_view=AcquireAuthenticCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception); |
| if (q == (Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| SetPixelInfoPixel(image,background,q); |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| if (status == MagickFalse) |
| image=DestroyImage(image); |
| return(image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % R e f e r e n c e I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % ReferenceImage() increments the reference count associated with an image |
| % returning a pointer to the image. |
| % |
| % The format of the ReferenceImage method is: |
| % |
| % Image *ReferenceImage(Image *image) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| */ |
| MagickExport Image *ReferenceImage(Image *image) |
| { |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| LockSemaphoreInfo(image->semaphore); |
| image->reference_count++; |
| UnlockSemaphoreInfo(image->semaphore); |
| return(image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % R e s e t I m a g e P a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % ResetImagePage() resets the image page canvas and position. |
| % |
| % The format of the ResetImagePage method is: |
| % |
| % MagickBooleanType ResetImagePage(Image *image,const char *page) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o page: the relative page specification. |
| % |
| */ |
| MagickExport MagickBooleanType ResetImagePage(Image *image,const char *page) |
| { |
| MagickStatusType |
| flags; |
| |
| RectangleInfo |
| geometry; |
| |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| flags=ParseAbsoluteGeometry(page,&geometry); |
| if ((flags & WidthValue) != 0) |
| { |
| if ((flags & HeightValue) == 0) |
| geometry.height=geometry.width; |
| image->page.width=geometry.width; |
| image->page.height=geometry.height; |
| } |
| if ((flags & AspectValue) != 0) |
| { |
| if ((flags & XValue) != 0) |
| image->page.x+=geometry.x; |
| if ((flags & YValue) != 0) |
| image->page.y+=geometry.y; |
| } |
| else |
| { |
| if ((flags & XValue) != 0) |
| { |
| image->page.x=geometry.x; |
| if ((image->page.width == 0) && (geometry.x > 0)) |
| image->page.width=image->columns+geometry.x; |
| } |
| if ((flags & YValue) != 0) |
| { |
| image->page.y=geometry.y; |
| if ((image->page.height == 0) && (geometry.y > 0)) |
| image->page.height=image->rows+geometry.y; |
| } |
| } |
| return(MagickTrue); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e A l p h a C h a n n e l % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageAlphaChannel() activates, deactivates, resets, or sets the alpha |
| % channel. |
| % |
| % The format of the SetImageAlphaChannel method is: |
| % |
| % MagickBooleanType SetImageAlphaChannel(Image *image, |
| % const AlphaChannelOption alpha_type,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o alpha_type: The alpha channel type: ActivateAlphaChannel, |
| % CopyAlphaChannel, DeactivateAlphaChannel, ExtractAlphaChannel, |
| % OpaqueAlphaChannel, SetAlphaChannel, ShapeAlphaChannel, and |
| % TransparentAlphaChannel. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| |
| static inline void FlattenPixelInfo(const Image *image,const PixelInfo *p, |
| const double alpha,const Quantum *q,const double beta, |
| Quantum *composite) |
| { |
| double |
| Da, |
| gamma, |
| Sa; |
| |
| register ssize_t |
| i; |
| |
| /* |
| Compose pixel p over pixel q with the given alpha. |
| */ |
| Sa=QuantumScale*alpha; |
| Da=QuantumScale*beta, |
| gamma=Sa*(-Da)+Sa+Da; |
| gamma=PerceptibleReciprocal(gamma); |
| for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
| { |
| PixelChannel channel=GetPixelChannelChannel(image,i); |
| PixelTrait traits=GetPixelChannelTraits(image,channel); |
| if (traits == UndefinedPixelTrait) |
| continue; |
| switch (channel) |
| { |
| case RedPixelChannel: |
| { |
| composite[i]=ClampToQuantum(gamma*MagickOver_((double) q[i],beta, |
| (double) p->red,alpha)); |
| break; |
| } |
| case GreenPixelChannel: |
| { |
| composite[i]=ClampToQuantum(gamma*MagickOver_((double) q[i],beta, |
| (double) p->green,alpha)); |
| break; |
| } |
| case BluePixelChannel: |
| { |
| composite[i]=ClampToQuantum(gamma*MagickOver_((double) q[i],beta, |
| (double) p->blue,alpha)); |
| break; |
| } |
| case BlackPixelChannel: |
| { |
| composite[i]=ClampToQuantum(gamma*MagickOver_((double) q[i],beta, |
| (double) p->black,alpha)); |
| break; |
| } |
| case AlphaPixelChannel: |
| { |
| composite[i]=ClampToQuantum(QuantumRange*(Sa*(-Da)+Sa+Da)); |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| } |
| |
| MagickExport MagickBooleanType SetImageAlphaChannel(Image *image, |
| const AlphaChannelOption alpha_type,ExceptionInfo *exception) |
| { |
| MagickBooleanType |
| status; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| status=MagickTrue; |
| switch (alpha_type) |
| { |
| case ActivateAlphaChannel: |
| { |
| image->alpha_trait=BlendPixelTrait; |
| break; |
| } |
| case BackgroundAlphaChannel: |
| { |
| CacheView |
| *image_view; |
| |
| ssize_t |
| y; |
| |
| /* |
| Set transparent pixels to background color. |
| */ |
| if (image->alpha_trait != BlendPixelTrait) |
| break; |
| if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse) |
| break; |
| image_view=AcquireAuthenticCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1, |
| exception); |
| if (q == (Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| if (GetPixelAlpha(image,q) == TransparentAlpha) |
| { |
| SetPixelInfoPixel(image,&image->background_color,q); |
| SetPixelChannel(image,AlphaPixelChannel,TransparentAlpha,q); |
| } |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| return(status); |
| } |
| case CopyAlphaChannel: |
| case ShapeAlphaChannel: |
| { |
| /* |
| Copy pixel intensity to the alpha channel. |
| */ |
| status=CompositeImage(image,image,IntensityCompositeOp,MagickTrue,0,0, |
| exception); |
| if (alpha_type == ShapeAlphaChannel) |
| (void) LevelImageColors(image,&image->background_color, |
| &image->background_color,MagickTrue,exception); |
| break; |
| } |
| case DeactivateAlphaChannel: |
| { |
| image->alpha_trait=CopyPixelTrait; |
| break; |
| } |
| case ExtractAlphaChannel: |
| { |
| status=CompositeImage(image,image,AlphaCompositeOp,MagickTrue,0,0, |
| exception); |
| image->alpha_trait=CopyPixelTrait; |
| break; |
| } |
| case OpaqueAlphaChannel: |
| { |
| status=SetImageAlpha(image,OpaqueAlpha,exception); |
| break; |
| } |
| case RemoveAlphaChannel: |
| { |
| CacheView |
| *image_view; |
| |
| ssize_t |
| y; |
| |
| /* |
| Remove transparency. |
| */ |
| if (image->alpha_trait != BlendPixelTrait) |
| break; |
| if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse) |
| break; |
| image_view=AcquireAuthenticCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1, |
| exception); |
| if (q == (Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| FlattenPixelInfo(image,&image->background_color, |
| image->background_color.alpha,q,(double) |
| GetPixelAlpha(image,q),q); |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| image->alpha_trait=image->background_color.alpha_trait; |
| return(status); |
| } |
| case SetAlphaChannel: |
| { |
| if (image->alpha_trait != BlendPixelTrait) |
| status=SetImageAlpha(image,OpaqueAlpha,exception); |
| break; |
| } |
| case TransparentAlphaChannel: |
| { |
| status=SetImageAlpha(image,TransparentAlpha,exception); |
| break; |
| } |
| case UndefinedAlphaChannel: |
| break; |
| } |
| if (status == MagickFalse) |
| return(status); |
| return(SyncImagePixelCache(image,exception)); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e B a c k g r o u n d C o l o r % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageBackgroundColor() initializes the image pixels to the image |
| % background color. The background color is defined by the background_color |
| % member of the image structure. |
| % |
| % The format of the SetImage method is: |
| % |
| % MagickBooleanType SetImageBackgroundColor(Image *image, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType SetImageBackgroundColor(Image *image, |
| ExceptionInfo *exception) |
| { |
| CacheView |
| *image_view; |
| |
| MagickBooleanType |
| status; |
| |
| ssize_t |
| y; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse) |
| return(MagickFalse); |
| if ((IsPixelInfoGray(&image->background_color) == MagickFalse) && |
| (IsGrayColorspace(image->colorspace) != MagickFalse)) |
| (void) TransformImageColorspace(image,sRGBColorspace,exception); |
| if ((image->background_color.alpha_trait == BlendPixelTrait) && |
| (image->alpha_trait != BlendPixelTrait)) |
| (void) SetImageAlpha(image,OpaqueAlpha,exception); |
| /* |
| Set image background color. |
| */ |
| status=MagickTrue; |
| image_view=AcquireAuthenticCacheView(image,exception); |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception); |
| if (q == (Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| SetPixelInfoPixel(image,&image->background_color,q); |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| return(status); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e C h a n n e l M a s k % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageChannelMask() sets the image channel mask from the specified channel |
| % mask. |
| % |
| % The format of the SetImageChannelMask method is: |
| % |
| % ChannelType SetImageChannelMask(Image *image, |
| % const ChannelType channel_mask) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o channel_mask: the channel mask. |
| % |
| */ |
| MagickExport ChannelType SetImageChannelMask(Image *image, |
| const ChannelType channel_mask) |
| { |
| ChannelType |
| mask; |
| |
| mask=image->channel_mask; |
| image->channel_mask=channel_mask; |
| SetPixelChannelMask(image,channel_mask); |
| return(mask); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e C o l o r % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageColor() set the entire image canvas to the specified color. |
| % |
| % The format of the SetImageColor method is: |
| % |
| % MagickBooleanType SetImageColor(Image *image,const PixelInfo *color, |
| % ExeptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o background: the image color. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType SetImageColor(Image *image, |
| const PixelInfo *color,ExceptionInfo *exception) |
| { |
| CacheView |
| *image_view; |
| |
| MagickBooleanType |
| status; |
| |
| ssize_t |
| y; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| assert(color != (const PixelInfo *) NULL); |
| image->colorspace=color->colorspace; |
| image->alpha_trait=color->alpha_trait; |
| image->fuzz=color->fuzz; |
| image->depth=color->depth; |
| status=MagickTrue; |
| image_view=AcquireAuthenticCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception); |
| if (q == (Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| SetPixelInfoPixel(image,color,q); |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| return(status); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e S t o r a g e C l a s s % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageStorageClass() sets the image class: DirectClass for true color |
| % images or PseudoClass for colormapped images. |
| % |
| % The format of the SetImageStorageClass method is: |
| % |
| % MagickBooleanType SetImageStorageClass(Image *image, |
| % const ClassType storage_class,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o storage_class: The image class. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType SetImageStorageClass(Image *image, |
| const ClassType storage_class,ExceptionInfo *exception) |
| { |
| image->storage_class=storage_class; |
| return(SyncImagePixelCache(image,exception)); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e E x t e n t % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageExtent() sets the image size (i.e. columns & rows). |
| % |
| % The format of the SetImageExtent method is: |
| % |
| % MagickBooleanType SetImageExtent(Image *image,const size_t columns, |
| % const size_t rows,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o columns: The image width in pixels. |
| % |
| % o rows: The image height in pixels. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType SetImageExtent(Image *image,const size_t columns, |
| const size_t rows,ExceptionInfo *exception) |
| { |
| if ((columns == 0) || (rows == 0)) |
| return(MagickFalse); |
| image->columns=columns; |
| image->rows=rows; |
| return(SyncImagePixelCache(image,exception)); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| + S e t I m a g e I n f o % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageInfo() initializes the 'magick' field of the ImageInfo structure. |
| % It is set to a type of image format based on the prefix or suffix of the |
| % filename. For example, 'ps:image' returns PS indicating a Postscript image. |
| % JPEG is returned for this filename: 'image.jpg'. The filename prefix has |
| % precendence over the suffix. Use an optional index enclosed in brackets |
| % after a file name to specify a desired scene of a multi-resolution image |
| % format like Photo CD (e.g. img0001.pcd[4]). A True (non-zero) return value |
| % indicates success. |
| % |
| % The format of the SetImageInfo method is: |
| % |
| % MagickBooleanType SetImageInfo(ImageInfo *image_info, |
| % const unsigned int frames,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| % o frames: the number of images you intend to write. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType SetImageInfo(ImageInfo *image_info, |
| const unsigned int frames,ExceptionInfo *exception) |
| { |
| char |
| extension[MaxTextExtent], |
| filename[MaxTextExtent], |
| magic[MaxTextExtent], |
| *q, |
| subimage[MaxTextExtent]; |
| |
| const MagicInfo |
| *magic_info; |
| |
| const MagickInfo |
| *magick_info; |
| |
| ExceptionInfo |
| *sans_exception; |
| |
| Image |
| *image; |
| |
| MagickBooleanType |
| status; |
| |
| register const char |
| *p; |
| |
| ssize_t |
| count; |
| |
| unsigned char |
| magick[2*MaxTextExtent]; |
| |
| /* |
| Look for 'image.format' in filename. |
| */ |
| assert(image_info != (ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| if (image_info->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| image_info->filename); |
| *subimage='\0'; |
| if (frames == 0) |
| { |
| GetPathComponent(image_info->filename,SubimagePath,subimage); |
| if (*subimage != '\0') |
| { |
| /* |
| Look for scene specification (e.g. img0001.pcd[4]). |
| */ |
| if (IsSceneGeometry(subimage,MagickFalse) == MagickFalse) |
| { |
| if (IsGeometry(subimage) != MagickFalse) |
| (void) CloneString(&image_info->extract,subimage); |
| } |
| else |
| { |
| size_t |
| first, |
| last; |
| |
| (void) CloneString(&image_info->scenes,subimage); |
| image_info->scene=StringToUnsignedLong(image_info->scenes); |
| image_info->number_scenes=image_info->scene; |
| p=image_info->scenes; |
| for (q=(char *) image_info->scenes; *q != '\0'; p++) |
| { |
| while ((isspace((int) ((unsigned char) *p)) != 0) || |
| (*p == ',')) |
| p++; |
| first=(size_t) strtol(p,&q,10); |
| last=first; |
| while (isspace((int) ((unsigned char) *q)) != 0) |
| q++; |
| if (*q == '-') |
| last=(size_t) strtol(q+1,&q,10); |
| if (first > last) |
| Swap(first,last); |
| if (first < image_info->scene) |
| image_info->scene=first; |
| if (last > image_info->number_scenes) |
| image_info->number_scenes=last; |
| p=q; |
| } |
| image_info->number_scenes-=image_info->scene-1; |
| } |
| } |
| } |
| *extension='\0'; |
| GetPathComponent(image_info->filename,ExtensionPath,extension); |
| #if defined(MAGICKCORE_ZLIB_DELEGATE) |
| if (*extension != '\0') |
| if ((LocaleCompare(extension,"gz") == 0) || |
| (LocaleCompare(extension,"Z") == 0) || |
| (LocaleCompare(extension,"svgz") == 0) || |
| (LocaleCompare(extension,"wmz") == 0)) |
| { |
| char |
| path[MaxTextExtent]; |
| |
| (void) CopyMagickString(path,image_info->filename,MaxTextExtent); |
| path[strlen(path)-strlen(extension)-1]='\0'; |
| GetPathComponent(path,ExtensionPath,extension); |
| } |
| #endif |
| #if defined(MAGICKCORE_BZLIB_DELEGATE) |
| if (*extension != '\0') |
| if (LocaleCompare(extension,"bz2") == 0) |
| { |
| char |
| path[MaxTextExtent]; |
| |
| (void) CopyMagickString(path,image_info->filename,MaxTextExtent); |
| path[strlen(path)-strlen(extension)-1]='\0'; |
| GetPathComponent(path,ExtensionPath,extension); |
| } |
| #endif |
| image_info->affirm=MagickFalse; |
| sans_exception=AcquireExceptionInfo(); |
| if (*extension != '\0') |
| { |
| MagickFormatType |
| format_type; |
| |
| register ssize_t |
| i; |
| |
| static const char |
| *format_type_formats[] = |
| { |
| "AUTOTRACE", |
| "BROWSE", |
| "DCRAW", |
| "EDIT", |
| "EPHEMERAL", |
| "LAUNCH", |
| "MPEG:DECODE", |
| "MPEG:ENCODE", |
| "PRINT", |
| "PS:ALPHA", |
| "PS:CMYK", |
| "PS:COLOR", |
| "PS:GRAY", |
| "PS:MONO", |
| "SCAN", |
| "SHOW", |
| "WIN", |
| (char *) NULL |
| }; |
| |
| /* |
| User specified image format. |
| */ |
| (void) CopyMagickString(magic,extension,MaxTextExtent); |
| LocaleUpper(magic); |
| /* |
| Look for explicit image formats. |
| */ |
| format_type=UndefinedFormatType; |
| i=0; |
| while ((format_type == UndefinedFormatType) && |
| (format_type_formats[i] != (char *) NULL)) |
| { |
| if ((*magic == *format_type_formats[i]) && |
| (LocaleCompare(magic,format_type_formats[i]) == 0)) |
| format_type=ExplicitFormatType; |
| i++; |
| } |
| magick_info=GetMagickInfo(magic,sans_exception); |
| if ((magick_info != (const MagickInfo *) NULL) && |
| (magick_info->format_type != UndefinedFormatType)) |
| format_type=magick_info->format_type; |
| if (format_type == UndefinedFormatType) |
| (void) CopyMagickString(image_info->magick,magic,MaxTextExtent); |
| else |
| if (format_type == ExplicitFormatType) |
| { |
| image_info->affirm=MagickTrue; |
| (void) CopyMagickString(image_info->magick,magic,MaxTextExtent); |
| } |
| if (LocaleCompare(magic,"RGB") == 0) |
| image_info->affirm=MagickFalse; /* maybe SGI disguised as RGB */ |
| } |
| /* |
| Look for explicit 'format:image' in filename. |
| */ |
| *magic='\0'; |
| GetPathComponent(image_info->filename,MagickPath,magic); |
| if (*magic == '\0') |
| (void) CopyMagickString(magic,image_info->magick,MaxTextExtent); |
| else |
| { |
| /* |
| User specified image format. |
| */ |
| LocaleUpper(magic); |
| if (IsMagickConflict(magic) == MagickFalse) |
| { |
| (void) CopyMagickString(image_info->magick,magic,MaxTextExtent); |
| if (LocaleCompare(magic,"EPHEMERAL") != 0) |
| image_info->affirm=MagickTrue; |
| else |
| image_info->temporary=MagickTrue; |
| } |
| } |
| magick_info=GetMagickInfo(magic,sans_exception); |
| sans_exception=DestroyExceptionInfo(sans_exception); |
| if ((magick_info == (const MagickInfo *) NULL) || |
| (GetMagickEndianSupport(magick_info) == MagickFalse)) |
| image_info->endian=UndefinedEndian; |
| GetPathComponent(image_info->filename,CanonicalPath,filename); |
| (void) CopyMagickString(image_info->filename,filename,MaxTextExtent); |
| if ((image_info->adjoin != MagickFalse) && (frames > 1)) |
| { |
| /* |
| Test for multiple image support (e.g. image%02d.png). |
| */ |
| (void) InterpretImageFilename(image_info,(Image *) NULL, |
| image_info->filename,(int) image_info->scene,filename,exception); |
| if ((LocaleCompare(filename,image_info->filename) != 0) && |
| (strchr(filename,'%') == (char *) NULL)) |
| image_info->adjoin=MagickFalse; |
| } |
| if ((image_info->adjoin != MagickFalse) && (frames > 0)) |
| { |
| /* |
| Some image formats do not support multiple frames per file. |
| */ |
| magick_info=GetMagickInfo(magic,exception); |
| if (magick_info != (const MagickInfo *) NULL) |
| if (GetMagickAdjoin(magick_info) == MagickFalse) |
| image_info->adjoin=MagickFalse; |
| } |
| if (image_info->affirm != MagickFalse) |
| return(MagickTrue); |
| if (frames == 0) |
| { |
| /* |
| Determine the image format from the first few bytes of the file. |
| */ |
| image=AcquireImage(image_info,exception); |
| (void) CopyMagickString(image->filename,image_info->filename, |
| MaxTextExtent); |
| status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); |
| if (status == MagickFalse) |
| { |
| image=DestroyImage(image); |
| return(MagickFalse); |
| } |
| if ((IsBlobSeekable(image) == MagickFalse) || |
| (IsBlobExempt(image) != MagickFalse)) |
| { |
| /* |
| Copy standard input or pipe to temporary file. |
| */ |
| *filename='\0'; |
| status=ImageToFile(image,filename,exception); |
| (void) CloseBlob(image); |
| if (status == MagickFalse) |
| { |
| image=DestroyImage(image); |
| return(MagickFalse); |
| } |
| SetImageInfoFile(image_info,(FILE *) NULL); |
| (void) CopyMagickString(image->filename,filename,MaxTextExtent); |
| status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); |
| if (status == MagickFalse) |
| { |
| image=DestroyImage(image); |
| return(MagickFalse); |
| } |
| (void) CopyMagickString(image_info->filename,filename,MaxTextExtent); |
| image_info->temporary=MagickTrue; |
| } |
| (void) ResetMagickMemory(magick,0,sizeof(magick)); |
| count=ReadBlob(image,2*MaxTextExtent,magick); |
| (void) SeekBlob(image,-((MagickOffsetType) count),SEEK_CUR); |
| (void) CloseBlob(image); |
| image=DestroyImage(image); |
| /* |
| Check magic.xml configuration file. |
| */ |
| sans_exception=AcquireExceptionInfo(); |
| magic_info=GetMagicInfo(magick,(size_t) count,sans_exception); |
| if ((magic_info != (const MagicInfo *) NULL) && |
| (GetMagicName(magic_info) != (char *) NULL)) |
| { |
| (void) CopyMagickString(image_info->magick,GetMagicName(magic_info), |
| MaxTextExtent); |
| magick_info=GetMagickInfo(image_info->magick,sans_exception); |
| if ((magick_info == (const MagickInfo *) NULL) || |
| (GetMagickEndianSupport(magick_info) == MagickFalse)) |
| image_info->endian=UndefinedEndian; |
| sans_exception=DestroyExceptionInfo(sans_exception); |
| return(MagickTrue); |
| } |
| magick_info=GetMagickInfo(image_info->magick,sans_exception); |
| if ((magick_info == (const MagickInfo *) NULL) || |
| (GetMagickEndianSupport(magick_info) == MagickFalse)) |
| image_info->endian=UndefinedEndian; |
| sans_exception=DestroyExceptionInfo(sans_exception); |
| } |
| return(MagickTrue); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e I n f o B l o b % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageInfoBlob() sets the image info blob member. |
| % |
| % The format of the SetImageInfoBlob method is: |
| % |
| % void SetImageInfoBlob(ImageInfo *image_info,const void *blob, |
| % const size_t length) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| % o blob: the blob. |
| % |
| % o length: the blob length. |
| % |
| */ |
| MagickExport void SetImageInfoBlob(ImageInfo *image_info,const void *blob, |
| const size_t length) |
| { |
| assert(image_info != (ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| if (image_info->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| image_info->filename); |
| image_info->blob=(void *) blob; |
| image_info->length=length; |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e I n f o F i l e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageInfoFile() sets the image info file member. |
| % |
| % The format of the SetImageInfoFile method is: |
| % |
| % void SetImageInfoFile(ImageInfo *image_info,FILE *file) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| % o file: the file. |
| % |
| */ |
| MagickExport void SetImageInfoFile(ImageInfo *image_info,FILE *file) |
| { |
| assert(image_info != (ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| if (image_info->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| image_info->filename); |
| image_info->file=file; |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e M a s k % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageMask() associates a mask with the image. The mask must be the same |
| % dimensions as the image. |
| % |
| % The format of the SetImageMask method is: |
| % |
| % MagickBooleanType SetImageMask(Image *image,const Image *mask, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o mask: the image mask. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType SetImageMask(Image *image,const Image *mask, |
| ExceptionInfo *exception) |
| { |
| CacheView |
| *mask_view, |
| *image_view; |
| |
| MagickBooleanType |
| status; |
| |
| ssize_t |
| y; |
| |
| /* |
| Set image mask. |
| */ |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| if (mask == (const Image *) NULL) |
| { |
| image->read_mask=MagickFalse; |
| return(SyncImagePixelCache(image,exception)); |
| } |
| image->read_mask=MagickTrue; |
| if (SyncImagePixelCache(image,exception) == MagickFalse) |
| return(MagickFalse); |
| status=MagickTrue; |
| mask_view=AcquireVirtualCacheView(mask,exception); |
| image_view=AcquireAuthenticCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(mask,image,1,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register const Quantum |
| *restrict p; |
| |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| p=GetCacheViewVirtualPixels(mask_view,0,y,mask->columns,1,exception); |
| q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception); |
| if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL)) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| SetPixelReadMask(image,ClampToQuantum(GetPixelIntensity(mask,p)),q); |
| p+=GetPixelChannels(mask); |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| mask_view=DestroyCacheView(mask_view); |
| image_view=DestroyCacheView(image_view); |
| return(status); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S e t I m a g e A l p h a % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageAlpha() sets the alpha levels of the image. |
| % |
| % The format of the SetImageAlpha method is: |
| % |
| % MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o Alpha: the level of transparency: 0 is fully opaque and QuantumRange is |
| % fully transparent. |
| % |
| */ |
| MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha, |
| ExceptionInfo *exception) |
| { |
| CacheView |
| *image_view; |
| |
| MagickBooleanType |
| status; |
| |
| ssize_t |
| y; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| image->alpha_trait=BlendPixelTrait; |
| status=MagickTrue; |
| image_view=AcquireAuthenticCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception); |
| if (q == (Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| SetPixelAlpha(image,alpha,q); |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| return(status); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % 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 % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SetImageVirtualPixelMethod() sets the "virtual pixels" method for the |
| % image and returns the previous setting. A virtual pixel is any pixel access |
| % that is outside the boundaries of the image cache. |
| % |
| % The format of the SetImageVirtualPixelMethod() method is: |
| % |
| % VirtualPixelMethod SetImageVirtualPixelMethod(Image *image, |
| % const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o virtual_pixel_method: choose the type of virtual pixel. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(Image *image, |
| const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception) |
| { |
| assert(image != (const Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| return(SetPixelCacheVirtualMethod(image,virtual_pixel_method,exception)); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S m u s h I m a g e s % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SmushImages() takes all images from the current image pointer to the end |
| % of the image list and smushes them to each other top-to-bottom if the |
| % stack parameter is true, otherwise left-to-right. |
| % |
| % The current gravity setting now effects how the image is justified in the |
| % final image. |
| % |
| % The format of the SmushImages method is: |
| % |
| % Image *SmushImages(const Image *images,const MagickBooleanType stack, |
| % ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o images: the image sequence. |
| % |
| % o stack: A value other than 0 stacks the images top-to-bottom. |
| % |
| % o offset: minimum distance in pixels between images. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| |
| static ssize_t SmushXGap(const Image *smush_image,const Image *images, |
| const ssize_t offset,ExceptionInfo *exception) |
| { |
| CacheView |
| *left_view, |
| *right_view; |
| |
| const Image |
| *left_image, |
| *right_image; |
| |
| RectangleInfo |
| left_geometry, |
| right_geometry; |
| |
| register const Quantum |
| *p; |
| |
| register ssize_t |
| i, |
| y; |
| |
| size_t |
| gap; |
| |
| ssize_t |
| x; |
| |
| if (images->previous == (Image *) NULL) |
| return(0); |
| right_image=images; |
| SetGeometry(smush_image,&right_geometry); |
| GravityAdjustGeometry(right_image->columns,right_image->rows, |
| right_image->gravity,&right_geometry); |
| left_image=images->previous; |
| SetGeometry(smush_image,&left_geometry); |
| GravityAdjustGeometry(left_image->columns,left_image->rows, |
| left_image->gravity,&left_geometry); |
| gap=right_image->columns; |
| left_view=AcquireVirtualCacheView(left_image,exception); |
| right_view=AcquireVirtualCacheView(right_image,exception); |
| for (y=0; y < (ssize_t) smush_image->rows; y++) |
| { |
| for (x=(ssize_t) left_image->columns-1; x > 0; x--) |
| { |
| p=GetCacheViewVirtualPixels(left_view,x,left_geometry.y+y,1,1,exception); |
| if ((p == (const Quantum *) NULL) || |
| (GetPixelAlpha(left_image,p) != TransparentAlpha) || |
| ((left_image->columns-x-1) >= gap)) |
| break; |
| } |
| i=(ssize_t) left_image->columns-x-1; |
| for (x=0; x < (ssize_t) right_image->columns; x++) |
| { |
| p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1, |
| exception); |
| if ((p == (const Quantum *) NULL) || |
| (GetPixelAlpha(right_image,p) != TransparentAlpha) || |
| ((x+i) >= (ssize_t) gap)) |
| break; |
| } |
| if ((x+i) < (ssize_t) gap) |
| gap=(size_t) (x+i); |
| } |
| right_view=DestroyCacheView(right_view); |
| left_view=DestroyCacheView(left_view); |
| if (y < (ssize_t) smush_image->rows) |
| return(offset); |
| return((ssize_t) gap-offset); |
| } |
| |
| static ssize_t SmushYGap(const Image *smush_image,const Image *images, |
| const ssize_t offset,ExceptionInfo *exception) |
| { |
| CacheView |
| *bottom_view, |
| *top_view; |
| |
| const Image |
| *bottom_image, |
| *top_image; |
| |
| RectangleInfo |
| bottom_geometry, |
| top_geometry; |
| |
| register const Quantum |
| *p; |
| |
| register ssize_t |
| i, |
| x; |
| |
| size_t |
| gap; |
| |
| ssize_t |
| y; |
| |
| if (images->previous == (Image *) NULL) |
| return(0); |
| bottom_image=images; |
| SetGeometry(smush_image,&bottom_geometry); |
| GravityAdjustGeometry(bottom_image->columns,bottom_image->rows, |
| bottom_image->gravity,&bottom_geometry); |
| top_image=images->previous; |
| SetGeometry(smush_image,&top_geometry); |
| GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity, |
| &top_geometry); |
| gap=bottom_image->rows; |
| top_view=AcquireVirtualCacheView(top_image,exception); |
| bottom_view=AcquireVirtualCacheView(bottom_image,exception); |
| for (x=0; x < (ssize_t) smush_image->columns; x++) |
| { |
| for (y=(ssize_t) top_image->rows-1; y > 0; y--) |
| { |
| p=GetCacheViewVirtualPixels(top_view,top_geometry.x+x,y,1,1,exception); |
| if ((p == (const Quantum *) NULL) || |
| (GetPixelAlpha(top_image,p) != TransparentAlpha) || |
| ((top_image->rows-y-1) >= gap)) |
| break; |
| } |
| i=(ssize_t) top_image->rows-y-1; |
| for (y=0; y < (ssize_t) bottom_image->rows; y++) |
| { |
| p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1, |
| exception); |
| if ((p == (const Quantum *) NULL) || |
| (GetPixelAlpha(bottom_image,p) != TransparentAlpha) || |
| ((y+i) >= (ssize_t) gap)) |
| break; |
| } |
| if ((y+i) < (ssize_t) gap) |
| gap=(size_t) (y+i); |
| } |
| bottom_view=DestroyCacheView(bottom_view); |
| top_view=DestroyCacheView(top_view); |
| if (x < (ssize_t) smush_image->columns) |
| return(offset); |
| return((ssize_t) gap-offset); |
| } |
| |
| MagickExport Image *SmushImages(const Image *images, |
| const MagickBooleanType stack,const ssize_t offset,ExceptionInfo *exception) |
| { |
| #define SmushImageTag "Smush/Image" |
| |
| const Image |
| *image; |
| |
| Image |
| *smush_image; |
| |
| MagickBooleanType |
| proceed, |
| status; |
| |
| MagickOffsetType |
| n; |
| |
| PixelTrait |
| alpha_trait; |
| |
| RectangleInfo |
| geometry; |
| |
| register const Image |
| *next; |
| |
| size_t |
| height, |
| number_images, |
| width; |
| |
| ssize_t |
| x_offset, |
| y_offset; |
| |
| /* |
| Compute maximum area of smushed area. |
| */ |
| assert(images != (Image *) NULL); |
| assert(images->signature == MagickSignature); |
| if (images->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename); |
| assert(exception != (ExceptionInfo *) NULL); |
| assert(exception->signature == MagickSignature); |
| image=images; |
| alpha_trait=image->alpha_trait; |
| number_images=1; |
| width=image->columns; |
| height=image->rows; |
| next=GetNextImageInList(image); |
| for ( ; next != (Image *) NULL; next=GetNextImageInList(next)) |
| { |
| if (next->alpha_trait == BlendPixelTrait) |
| alpha_trait=BlendPixelTrait; |
| number_images++; |
| if (stack != MagickFalse) |
| { |
| if (next->columns > width) |
| width=next->columns; |
| height+=next->rows; |
| if (next->previous != (Image *) NULL) |
| height+=offset; |
| continue; |
| } |
| width+=next->columns; |
| if (next->previous != (Image *) NULL) |
| width+=offset; |
| if (next->rows > height) |
| height=next->rows; |
| } |
| /* |
| Smush images. |
| */ |
| smush_image=CloneImage(image,width,height,MagickTrue,exception); |
| if (smush_image == (Image *) NULL) |
| return((Image *) NULL); |
| if (SetImageStorageClass(smush_image,DirectClass,exception) == MagickFalse) |
| { |
| smush_image=DestroyImage(smush_image); |
| return((Image *) NULL); |
| } |
| smush_image->alpha_trait=alpha_trait; |
| (void) SetImageBackgroundColor(smush_image,exception); |
| status=MagickTrue; |
| x_offset=0; |
| y_offset=0; |
| for (n=0; n < (MagickOffsetType) number_images; n++) |
| { |
| SetGeometry(smush_image,&geometry); |
| GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry); |
| if (stack != MagickFalse) |
| { |
| x_offset-=geometry.x; |
| y_offset-=SmushYGap(smush_image,image,offset,exception); |
| } |
| else |
| { |
| x_offset-=SmushXGap(smush_image,image,offset,exception); |
| y_offset-=geometry.y; |
| } |
| status=CompositeImage(smush_image,image,OverCompositeOp,MagickTrue,x_offset, |
| y_offset,exception); |
| proceed=SetImageProgress(image,SmushImageTag,n,number_images); |
| if (proceed == MagickFalse) |
| break; |
| if (stack == MagickFalse) |
| { |
| x_offset+=(ssize_t) image->columns; |
| y_offset=0; |
| } |
| else |
| { |
| x_offset=0; |
| y_offset+=(ssize_t) image->rows; |
| } |
| image=GetNextImageInList(image); |
| } |
| if (stack == MagickFalse) |
| smush_image->columns=(size_t) x_offset; |
| else |
| smush_image->rows=(size_t) y_offset; |
| if (status == MagickFalse) |
| smush_image=DestroyImage(smush_image); |
| return(smush_image); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S t r i p I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % StripImage() strips an image of all profiles and comments. |
| % |
| % The format of the StripImage method is: |
| % |
| % MagickBooleanType StripImage(Image *image,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| MagickExport MagickBooleanType StripImage(Image *image,ExceptionInfo *exception) |
| { |
| MagickBooleanType |
| status; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| (void) exception; |
| DestroyImageProfiles(image); |
| (void) DeleteImageProperty(image,"comment"); |
| (void) DeleteImageProperty(image,"date:create"); |
| (void) DeleteImageProperty(image,"date:modify"); |
| status=SetImageArtifact(image,"png:include-chunk","none,trns,gama"); |
| return(status); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| + S y n c I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SyncImage() initializes the red, green, and blue intensities of each pixel |
| % as defined by the colormap index. |
| % |
| % The format of the SyncImage method is: |
| % |
| % MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image: the image. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| |
| static inline Quantum PushColormapIndex(Image *image,const Quantum index, |
| MagickBooleanType *range_exception) |
| { |
| if ((size_t) index < image->colors) |
| return(index); |
| *range_exception=MagickTrue; |
| return((Quantum) 0); |
| } |
| |
| MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception) |
| { |
| CacheView |
| *image_view; |
| |
| MagickBooleanType |
| range_exception, |
| status; |
| |
| ssize_t |
| y; |
| |
| assert(image != (Image *) NULL); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); |
| assert(image->signature == MagickSignature); |
| if (image->storage_class == DirectClass) |
| return(MagickFalse); |
| range_exception=MagickFalse; |
| status=MagickTrue; |
| image_view=AcquireAuthenticCacheView(image,exception); |
| #if defined(MAGICKCORE_OPENMP_SUPPORT) |
| #pragma omp parallel for schedule(static,4) shared(range_exception,status) \ |
| magick_threads(image,image,image->rows,1) |
| #endif |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| Quantum |
| index; |
| |
| register Quantum |
| *restrict q; |
| |
| register ssize_t |
| x; |
| |
| if (status == MagickFalse) |
| continue; |
| q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception); |
| if (q == (Quantum *) NULL) |
| { |
| status=MagickFalse; |
| continue; |
| } |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| index=PushColormapIndex(image,GetPixelIndex(image,q),&range_exception); |
| SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q); |
| q+=GetPixelChannels(image); |
| } |
| if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse) |
| status=MagickFalse; |
| } |
| image_view=DestroyCacheView(image_view); |
| if ((image->ping == MagickFalse) && (range_exception != MagickFalse)) |
| (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError, |
| "InvalidColormapIndex","`%s'",image->filename); |
| return(status); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % S y n c I m a g e S e t t i n g s % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % SyncImageSettings() syncs any image_info global options into per-image |
| % attributes. |
| % |
| % Note: in IMv6 free form 'options' were always mapped into 'artifacts', so |
| % that operations and coders can find such settings. In IMv7 if a desired |
| % per-image artifact is not set, then it will directly look for a global |
| % option as a fallback, as such this copy is no longer needed, only the |
| % link set up. |
| % |
| % The format of the SyncImageSettings method is: |
| % |
| % MagickBooleanType SyncImageSettings(const ImageInfo *image_info, |
| % Image *image,ExceptionInfo *exception) |
| % MagickBooleanType SyncImagesSettings(const ImageInfo *image_info, |
| % Image *image,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| % o image: the image. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| |
| MagickExport MagickBooleanType SyncImagesSettings(ImageInfo *image_info, |
| Image *images,ExceptionInfo *exception) |
| { |
| Image |
| *image; |
| |
| assert(image_info != (const ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| assert(images != (Image *) NULL); |
| assert(images->signature == MagickSignature); |
| if (images->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename); |
| image=images; |
| for ( ; image != (Image *) NULL; image=GetNextImageInList(image)) |
| (void) SyncImageSettings(image_info,image,exception); |
| (void) DeleteImageOption(image_info,"page"); |
| return(MagickTrue); |
| } |
| |
| MagickExport MagickBooleanType SyncImageSettings(const ImageInfo *image_info, |
| Image *image,ExceptionInfo *exception) |
| { |
| const char |
| *option; |
| |
| GeometryInfo |
| geometry_info; |
| |
| MagickStatusType |
| flags; |
| |
| ResolutionType |
| units; |
| |
| /* |
| Sync image options. |
| */ |
| assert(image_info != (const ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| option=GetImageOption(image_info,"background"); |
| if (option != (const char *) NULL) |
| (void) QueryColorCompliance(option,AllCompliance,&image->background_color, |
| exception); |
| option=GetImageOption(image_info,"black-point-compensation"); |
| if (option != (const char *) NULL) |
| image->black_point_compensation=(MagickBooleanType) ParseCommandOption( |
| MagickBooleanOptions,MagickFalse,option); |
| option=GetImageOption(image_info,"blue-primary"); |
| if (option != (const char *) NULL) |
| { |
| flags=ParseGeometry(option,&geometry_info); |
| image->chromaticity.blue_primary.x=geometry_info.rho; |
| image->chromaticity.blue_primary.y=geometry_info.sigma; |
| if ((flags & SigmaValue) == 0) |
| image->chromaticity.blue_primary.y=image->chromaticity.blue_primary.x; |
| } |
| option=GetImageOption(image_info,"bordercolor"); |
| if (option != (const char *) NULL) |
| (void) QueryColorCompliance(option,AllCompliance,&image->border_color, |
| exception); |
| option=GetImageOption(image_info,"channel"); |
| if (option != (const char *) NULL) |
| (void) SetPixelChannelMask(image,(ChannelType) |
| ParseChannelOption(option)); |
| /* FUTURE: do not sync compose to per-image compose setting here */ |
| option=GetImageOption(image_info,"compose"); |
| if (option != (const char *) NULL) |
| image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions, |
| MagickFalse,option); |
| /* -- */ |
| option=GetImageOption(image_info,"compress"); |
| if (option != (const char *) NULL) |
| image->compression=(CompressionType) ParseCommandOption( |
| MagickCompressOptions,MagickFalse,option); |
| option=GetImageOption(image_info,"debug"); |
| if (option != (const char *) NULL) |
| image->debug=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions, |
| MagickFalse,option); |
| option=GetImageOption(image_info,"density"); |
| if (option != (const char *) NULL) |
| { |
| GeometryInfo |
| geometry_info; |
| |
| flags=ParseGeometry(option,&geometry_info); |
| image->resolution.x=geometry_info.rho; |
| image->resolution.y=geometry_info.sigma; |
| if ((flags & SigmaValue) == 0) |
| image->resolution.y=image->resolution.x; |
| } |
| option=GetImageOption(image_info,"depth"); |
| if (option != (const char *) NULL) |
| image->depth=StringToUnsignedLong(option); |
| option=GetImageOption(image_info,"endian"); |
| if (option != (const char *) NULL) |
| image->endian=(EndianType) ParseCommandOption(MagickEndianOptions, |
| MagickFalse,option); |
| option=GetImageOption(image_info,"filter"); |
| if (option != (const char *) NULL) |
| image->filter=(FilterTypes) ParseCommandOption(MagickFilterOptions, |
| MagickFalse,option); |
| option=GetImageOption(image_info,"fuzz"); |
| if (option != (const char *) NULL) |
| image->fuzz=StringToDoubleInterval(option,(double) QuantumRange+1.0); |
| option=GetImageOption(image_info,"gravity"); |
| if (option != (const char *) NULL) |
| image->gravity=(GravityType) ParseCommandOption(MagickGravityOptions, |
| MagickFalse,option); |
| option=GetImageOption(image_info,"green-primary"); |
| if (option != (const char *) NULL) |
| { |
| flags=ParseGeometry(option,&geometry_info); |
| image->chromaticity.green_primary.x=geometry_info.rho; |
| image->chromaticity.green_primary.y=geometry_info.sigma; |
| if ((flags & SigmaValue) == 0) |
| image->chromaticity.green_primary.y=image->chromaticity.green_primary.x; |
| } |
| option=GetImageOption(image_info,"intent"); |
| if (option != (const char *) NULL) |
| image->rendering_intent=(RenderingIntent) ParseCommandOption( |
| MagickIntentOptions,MagickFalse,option); |
| option=GetImageOption(image_info,"intensity"); |
| if (option != (const char *) NULL) |
| image->intensity=(PixelIntensityMethod) ParseCommandOption( |
| MagickPixelIntensityOptions,MagickFalse,option); |
| option=GetImageOption(image_info,"interlace"); |
| if (option != (const char *) NULL) |
| image->interlace=(InterlaceType) ParseCommandOption(MagickInterlaceOptions, |
| MagickFalse,option); |
| option=GetImageOption(image_info,"interpolate"); |
| if (option != (const char *) NULL) |
| image->interpolate=(PixelInterpolateMethod) ParseCommandOption( |
| MagickInterpolateOptions,MagickFalse,option); |
| option=GetImageOption(image_info,"loop"); |
| if (option != (const char *) NULL) |
| image->iterations=StringToUnsignedLong(option); |
| option=GetImageOption(image_info,"mattecolor"); |
| if (option != (const char *) NULL) |
| (void) QueryColorCompliance(option,AllCompliance,&image->matte_color, |
| exception); |
| option=GetImageOption(image_info,"orient"); |
| if (option != (const char *) NULL) |
| image->orientation=(OrientationType) ParseCommandOption( |
| MagickOrientationOptions,MagickFalse,option); |
| option=GetImageOption(image_info,"quality"); |
| if (option != (const char *) NULL) |
| image->quality=StringToUnsignedLong(option); |
| option=GetImageOption(image_info,"red-primary"); |
| if (option != (const char *) NULL) |
| { |
| flags=ParseGeometry(option,&geometry_info); |
| image->chromaticity.red_primary.x=geometry_info.rho; |
| image->chromaticity.red_primary.y=geometry_info.sigma; |
| if ((flags & SigmaValue) == 0) |
| image->chromaticity.red_primary.y=image->chromaticity.red_primary.x; |
| } |
| if (image_info->quality != UndefinedCompressionQuality) |
| image->quality=image_info->quality; |
| option=GetImageOption(image_info,"scene"); |
| if (option != (const char *) NULL) |
| image->scene=StringToUnsignedLong(option); |
| option=GetImageOption(image_info,"taint"); |
| if (option != (const char *) NULL) |
| image->taint=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions, |
| MagickFalse,option); |
| option=GetImageOption(image_info,"tile-offset"); |
| if (option != (const char *) NULL) |
| { |
| char |
| *geometry; |
| |
| geometry=GetPageGeometry(option); |
| flags=ParseAbsoluteGeometry(geometry,&image->tile_offset); |
| geometry=DestroyString(geometry); |
| } |
| option=GetImageOption(image_info,"transparent-color"); |
| if (option != (const char *) NULL) |
| (void) QueryColorCompliance(option,AllCompliance,&image->transparent_color, |
| exception); |
| option=GetImageOption(image_info,"type"); |
| if (option != (const char *) NULL) |
| image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse, |
| option); |
| option=GetImageOption(image_info,"units"); |
| units=image_info->units; |
| if (option != (const char *) NULL) |
| units=(ResolutionType) ParseCommandOption(MagickResolutionOptions, |
| MagickFalse,option); |
| if (units != UndefinedResolution) |
| { |
| if (image->units != units) |
| switch (image->units) |
| { |
| case PixelsPerInchResolution: |
| { |
| if (units == PixelsPerCentimeterResolution) |
| { |
| image->resolution.x/=2.54; |
| image->resolution.y/=2.54; |
| } |
| break; |
| } |
| case PixelsPerCentimeterResolution: |
| { |
| if (units == PixelsPerInchResolution) |
| { |
| image->resolution.x=(double) ((size_t) (100.0*2.54* |
| image->resolution.x+0.5))/100.0; |
| image->resolution.y=(double) ((size_t) (100.0*2.54* |
| image->resolution.y+0.5))/100.0; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| image->units=units; |
| } |
| option=GetImageOption(image_info,"virtual-pixel"); |
| if (option != (const char *) NULL) |
| (void) SetImageVirtualPixelMethod(image,(VirtualPixelMethod) |
| ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,option), |
| exception); |
| option=GetImageOption(image_info,"white-point"); |
| if (option != (const char *) NULL) |
| { |
| flags=ParseGeometry(option,&geometry_info); |
| image->chromaticity.white_point.x=geometry_info.rho; |
| image->chromaticity.white_point.y=geometry_info.sigma; |
| if ((flags & SigmaValue) == 0) |
| image->chromaticity.white_point.y=image->chromaticity.white_point.x; |
| } |
| ResetImageOptionIterator(image_info); |
| #if 0 |
| { |
| /* IMv6: Copy freeform global options into per-image artifacts, so |
| * various operations and coders can access them. |
| * |
| * This has a problem, as per-image artefacts may have been set in |
| * parenthesis, but may not be unset when parenthesis ends. |
| */ |
| char |
| property[MaxTextExtent]; |
| |
| const char |
| *value; |
| |
| for (option=GetNextImageOption(image_info); option != (const char *) NULL; ) |
| { |
| value=GetImageOption(image_info,option); |
| if (value != (const char *) NULL) |
| { |
| (void) FormatLocaleString(property,MaxTextExtent,"%s",option); |
| (void) SetImageArtifact(image,property,value); |
| } |
| option=GetNextImageOption(image_info); |
| } |
| } |
| #else |
| /* IMv7: pointer to allow the lookup of pre-image artefact will fallback to |
| a global option setting/define. This saves a lot of duplication of |
| global options into per-image artifacts, while ensuring only specifically |
| set per-image artifacts are preverved when parenthesis ends. |
| |
| This pointer is never explictally freed, as it is only used as a back |
| reference, not as the main pointer to the image_info structure. Images |
| being removed from a image_info image list (or yet to be added to such), |
| should have this pointer reset to NULL. |
| */ |
| image->image_info=image_info; |
| #endif |
| return(MagickTrue); |
| } |