#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/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"
image->depth=MAGICKCORE_QUANTUM_DEPTH;
image->colorspace=sRGBColorspace;
image->rendering_intent=PerceptualIntent;
- image->gamma=0.45455;
- image->chromaticity.red_primary.x=0.6400;
- image->chromaticity.red_primary.y=0.3300;
- image->chromaticity.green_primary.x=0.3000;
- image->chromaticity.green_primary.y=0.6000;
- image->chromaticity.blue_primary.x=0.1500;
- image->chromaticity.blue_primary.y=0.0600;
- image->chromaticity.white_point.x=0.3127;
- image->chromaticity.white_point.y=0.3290;
+ 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;
- image->blur=1.0;
(void) QueryColorCompliance(BackgroundColor,AllCompliance,
&image->background_color,exception);
(void) QueryColorCompliance(BorderColor,AllCompliance,&image->border_color,
% 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 now effects how the image is justified in the
+% The current gravity setting effects how the image is justified in the
% final image.
%
% The format of the AppendImages method is:
#define AppendImageTag "Append/Image"
CacheView
- *append_view,
- *image_view;
-
- const Image
- *image;
+ *append_view;
Image
*append_image;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=images;
- matte=image->matte;
+ matte=images->matte;
number_images=1;
- width=image->columns;
- height=image->rows;
- next=GetNextImageInList(image);
+ width=images->columns;
+ height=images->rows;
+ next=GetNextImageInList(images);
for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
{
if (next->matte != MagickFalse)
/*
Append images.
*/
- append_image=CloneImage(image,width,height,MagickTrue,exception);
+ append_image=CloneImage(images,width,height,MagickTrue,exception);
if (append_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(append_image,DirectClass,exception) == MagickFalse)
status=MagickTrue;
x_offset=0;
y_offset=0;
- append_view=AcquireCacheView(append_image);
+ next=images;
+ append_view=AcquireAuthenticCacheView(append_image,exception);
for (n=0; n < (MagickOffsetType) number_images; n++)
{
+ CacheView
+ *image_view;
+
+ Image
+ *image;
+
+ 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=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(status)
+ #pragma omp parallel for schedule(static) shared(status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
MagickBooleanType
sync;
+ PixelInfo
+ pixel;
+
register const Quantum
*restrict p;
status=MagickFalse;
continue;
}
+ GetPixelInfo(image,&pixel);
for (x=0; x < (ssize_t) image->columns; x++)
{
- register ssize_t
- i;
-
if (GetPixelMask(image,p) != 0)
{
p+=GetPixelChannels(image);
q+=GetPixelChannels(append_image);
continue;
}
- for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- {
- PixelChannel
- channel;
-
- PixelTrait
- append_traits,
- traits;
-
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- append_traits=GetPixelChannelMapTraits(append_image,channel);
- if ((traits == UndefinedPixelTrait) ||
- (append_traits == UndefinedPixelTrait))
- continue;
- SetPixelChannel(append_image,channel,p[i],q);
- }
+ GetPixelInfoPixel(image,p,&pixel);
+ SetPixelInfoPixel(append_image,&pixel,q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(append_image);
}
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
- proceed=SetImageProgress(image,AppendImageTag,n,number_images);
- if (proceed == MagickFalse)
- break;
if (stack == MagickFalse)
{
x_offset+=(ssize_t) image->columns;
x_offset=0;
y_offset+=(ssize_t) image->rows;
}
- image=GetNextImageInList(image);
+ 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)
% %
% %
% %
-% C o m b i n e I m a g e s %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% CombineImages() combines one or more images into a single image. The
-% grayscale value of the pixels of each image in the sequence is assigned in
-% order to the specified channels of the combined image. The typical
-% ordering would be image 1 => Red, 2 => Green, 3 => Blue, etc.
-%
-% The format of the CombineImages method is:
-%
-% Image *CombineImages(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.
-%
-*/
-
-static inline size_t MagickMin(const size_t x,const size_t y)
-{
- if (x < y)
- return(x);
- return(y);
-}
-
-MagickExport Image *CombineImages(const Image *image,ExceptionInfo *exception)
-{
-#define CombineImageTag "Combine/Image"
-
- CacheView
- *combine_view;
-
- Image
- *combine_image;
-
- MagickBooleanType
- status;
-
- MagickOffsetType
- progress;
-
- ssize_t
- y;
-
- /*
- Ensure the image are the same size.
- */
- 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);
- combine_image=CloneImage(image,0,0,MagickTrue,exception);
- if (combine_image == (Image *) NULL)
- return((Image *) NULL);
- if (SetImageStorageClass(combine_image,DirectClass,exception) == MagickFalse)
- {
- combine_image=DestroyImage(combine_image);
- return((Image *) NULL);
- }
- if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
- combine_image->matte=MagickTrue;
- /*
- Combine images.
- */
- status=MagickTrue;
- progress=0;
- combine_view=AcquireCacheView(combine_image);
- for (y=0; y < (ssize_t) combine_image->rows; y++)
- {
- CacheView
- *image_view;
-
- const Image
- *next;
-
- Quantum
- *pixels;
-
- register const Quantum
- *restrict p;
-
- register Quantum
- *restrict q;
-
- register ssize_t
- i;
-
- if (status == MagickFalse)
- continue;
- pixels=GetCacheViewAuthenticPixels(combine_view,0,y,combine_image->columns,
- 1,exception);
- if (pixels == (Quantum *) NULL)
- {
- status=MagickFalse;
- continue;
- }
- next=image;
- for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- {
- PixelChannel
- channel;
-
- PixelTrait
- combine_traits,
- traits;
-
- register ssize_t
- x;
-
- if (next == (Image *) NULL)
- continue;
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- combine_traits=GetPixelChannelMapTraits(combine_image,channel);
- if ((traits == UndefinedPixelTrait) ||
- (combine_traits == UndefinedPixelTrait))
- continue;
- image_view=AcquireCacheView(next);
- p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);
- if (p == (const Quantum *) NULL)
- continue;
- q=pixels;
- for (x=0; x < (ssize_t) combine_image->columns; x++)
- {
- if (x < (ssize_t) image->columns)
- {
- q[i]=GetPixelGray(image,p);
- p+=GetPixelChannels(image);
- }
- q+=GetPixelChannels(combine_image);
- }
- image_view=DestroyCacheView(image_view);
- next=GetNextImageInList(next);
- if (SyncCacheViewAuthenticPixels(combine_view,exception) == MagickFalse)
- status=MagickFalse;
- if (image->progress_monitor != (MagickProgressMonitor) NULL)
- {
- MagickBooleanType
- proceed;
-
- proceed=SetImageProgress(image,CombineImageTag,progress++,
- combine_image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- }
- }
- combine_view=DestroyCacheView(combine_view);
- if (status == MagickFalse)
- combine_image=DestroyImage(combine_image);
- return(combine_image);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% D e s t r o y I m a g e %
% %
% %
*/
MagickExport void GetImageInfo(ImageInfo *image_info)
{
- const char
- *synchronize;
-
ExceptionInfo
*exception;
image_info->quality=UndefinedCompressionQuality;
image_info->antialias=MagickTrue;
image_info->dither=MagickTrue;
- synchronize=GetEnvironmentValue("MAGICK_SYNCHRONIZE");
- if (synchronize != (const char *) NULL)
- image_info->synchronize=IsMagickTrue(synchronize);
+ image_info->synchronize=IsStringTrue(GetEnvironmentValue(
+ "MAGICK_SYNCHRONIZE"));
exception=AcquireExceptionInfo();
(void) QueryColorCompliance(BackgroundColor,AllCompliance,
&image_info->background_color,exception);
if (mask_image == (Image *) NULL)
return((Image *) NULL);
status=MagickTrue;
- mask_image->colorspace=GRAYColorspace;
+ SetImageColorspace(mask_image,GRAYColorspace,exception);
mask_image->mask=MagickFalse;
- image_view=AcquireCacheView(image);
- mask_view=AcquireCacheView(mask_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ mask_view=AcquireAuthenticCacheView(mask_image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
%
% 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)
+% size_t InterpretImageFilename(const ImageInfo *image_info,Image *image,
+% const char *format,int value,char *filename,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
/*
Image option.
*/
+ /* FUTURE: Compare update with code from InterpretImageProperties()
+ Note that a 'filename:' properity should not need depth recursion.
+ */
if (strchr(p,']') == (char *) NULL)
break;
depth=1;
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 properity.
+ //
if ((image_info != (const ImageInfo *) NULL) &&
(image != (const Image *) NULL))
value=GetMagickProperty(image_info,image,pattern,exception);
else
- if (image != (Image *) NULL)
- value=GetImageProperty(image,pattern,exception);
- else
- if (image_info != (ImageInfo *) NULL)
- value=GetImageOption(image_info,pattern);
+#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--;
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
- PixelInfo
- pixel;
-
register const Quantum
*p;
image->fuzz=background->fuzz;
image->depth=background->depth;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
% %
% %
% %
-% S e p a r a t e I m a g e %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% SeparateImage() separates a channel from the image and returns it as a
-% grayscale image.
-%
-% The format of the SeparateImage method is:
-%
-% Image *SeparateImage(const Image *image,const ChannelType channel,
-% ExceptionInfo *exception)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o channel: the image channel.
-%
-% o exception: return any errors or warnings in this structure.
-%
-*/
-MagickExport Image *SeparateImage(const Image *image,
- const ChannelType channel_type,ExceptionInfo *exception)
-{
-#define GetChannelBit(mask,bit) (((size_t) (mask) >> (size_t) (bit)) & 0x01)
-#define SeparateImageTag "Separate/Image"
-
- CacheView
- *image_view,
- *separate_view;
-
- Image
- *separate_image;
-
- MagickBooleanType
- status;
-
- MagickOffsetType
- progress;
-
- ssize_t
- y;
-
- /*
- Initialize spread image attributes.
- */
- assert(image != (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);
- separate_image=CloneImage(image,image->columns,image->rows,MagickTrue,
- exception);
- if (separate_image == (Image *) NULL)
- return((Image *) NULL);
- if (SetImageStorageClass(separate_image,DirectClass,exception) == MagickFalse)
- {
- separate_image=DestroyImage(separate_image);
- return((Image *) NULL);
- }
- separate_image->colorspace=GRAYColorspace;
- /*
- Separate image.
- */
- status=MagickTrue;
- progress=0;
- image_view=AcquireCacheView(image);
- separate_view=AcquireCacheView(separate_image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static) shared(progress,status)
-#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(image_view,0,y,image->columns,1,exception);
- q=QueueCacheViewAuthenticPixels(separate_view,0,y,separate_image->columns,1,
- exception);
- if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- {
- status=MagickFalse;
- continue;
- }
- for (x=0; x < (ssize_t) image->columns; x++)
- {
- register ssize_t
- i;
-
- if (GetPixelMask(image,p) != 0)
- {
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(separate_image);
- continue;
- }
- SetPixelChannel(separate_image,GrayPixelChannel,0,q);
- for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- {
- PixelChannel
- channel;
-
- PixelTrait
- traits;
-
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- if ((traits == UndefinedPixelTrait) ||
- (GetChannelBit(channel_type,channel) == 0))
- continue;
- SetPixelChannel(separate_image,GrayPixelChannel,p[i],q);
- }
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(separate_image);
- }
- if (SyncCacheViewAuthenticPixels(separate_view,exception) == MagickFalse)
- status=MagickFalse;
- if (image->progress_monitor != (MagickProgressMonitor) NULL)
- {
- MagickBooleanType
- proceed;
-
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_SeparateImage)
-#endif
- proceed=SetImageProgress(image,SeparateImageTag,progress++,image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- }
- separate_view=DestroyCacheView(separate_view);
- image_view=DestroyCacheView(image_view);
- return(separate_image);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% S e p a r a t e I m a g e s %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% SeparateImages() returns a separate grayscale image for each channel
-% specified.
-%
-% The format of the SeparateImages method is:
-%
-% MagickBooleanType SeparateImages(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 Image *SeparateImages(const Image *image,ExceptionInfo *exception)
-{
- Image
- *images,
- *separate_image;
-
- register ssize_t
- i;
-
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- images=NewImageList();
- for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- {
- PixelChannel
- channel;
-
- PixelTrait
- traits;
-
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- if ((traits == UndefinedPixelTrait) ||
- ((traits & UpdatePixelTrait) == 0))
- continue;
- separate_image=SeparateImage(image,(ChannelType) (1 << channel),exception);
- if (separate_image != (Image *) NULL)
- AppendImageToList(&images,separate_image);
- }
- return(images);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% S e t I m a g e A l p h a C h a n n e l %
% %
% %
break;
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
break;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
/*
Copy pixel intensity to the alpha channel.
*/
- status=CompositeImage(image,IntensityCompositeOp,image,0,0,exception);
+ status=CompositeImage(image,image,IntensityCompositeOp,MagickTrue,0,0,
+ exception);
if (alpha_type == ShapeAlphaChannel)
(void) LevelImageColors(image,&image->background_color,
&image->background_color,MagickTrue,exception);
}
case ExtractAlphaChannel:
{
- status=CompositeImage(image,AlphaCompositeOp,image,0,0,exception);
+ status=CompositeImage(image,image,AlphaCompositeOp,MagickTrue,0,0,
+ exception);
image->matte=MagickFalse;
break;
}
break;
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
break;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
assert(image->signature == MagickSignature);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- if ((image->border_color.matte != MagickFalse) &&
+ if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
+ (IsPixelInfoGray(&image->background_color) == MagickFalse))
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ if ((image->background_color.matte != MagickFalse) &&
(image->matte == MagickFalse))
(void) SetImageAlpha(image,OpaqueAlpha,exception);
/*
Set image background color.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
image->fuzz=color->fuzz;
image->depth=color->depth;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetImageInfo() initializes the `magick' field of the ImageInfo structure.
+% 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
+% 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
}
status=MagickTrue;
image->mask=MagickTrue;
- image_view=AcquireCacheView(image);
- mask_view=AcquireCacheView(mask);
+ mask_view=AcquireVirtualCacheView(mask,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
assert(image->signature == MagickSignature);
image->matte=MagickTrue;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
}
case PaletteType:
{
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ if (IssRGBColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
if ((image->storage_class == DirectClass) || (image->colors > 256))
{
ChannelType
channel_mask;
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ if (IssRGBColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
if (image->matte == MagickFalse)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
}
case PaletteMatteType:
{
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ if (IssRGBColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
if (image->matte == MagickFalse)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
}
case TrueColorType:
{
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ if (IssRGBColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,exception);
}
case TrueColorMatteType:
{
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ if (IssRGBColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,exception);
{
if (image->colorspace != CMYKColorspace)
{
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ if (IssRGBColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
status=TransformImageColorspace(image,CMYKColorspace,exception);
}
{
if (image->colorspace != CMYKColorspace)
{
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ if (IssRGBColorspace(image->colorspace) == MagickFalse)
status=TransformImageColorspace(image,sRGBColorspace,exception);
status=TransformImageColorspace(image,CMYKColorspace,exception);
}
GravityAdjustGeometry(left_image->columns,left_image->rows,
left_image->gravity,&left_geometry);
gap=right_image->columns;
- left_view=AcquireCacheView(left_image);
- right_view=AcquireCacheView(right_image);
+ 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--)
GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
&top_geometry);
gap=bottom_image->rows;
- top_view=AcquireCacheView(top_image);
- bottom_view=AcquireCacheView(bottom_image);
+ 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--)
{
#define SmushImageTag "Smush/Image"
- CacheView
- *smush_view;
-
const Image
*image;
status=MagickTrue;
x_offset=0;
y_offset=0;
- smush_view=AcquireCacheView(smush_image);
for (n=0; n < (MagickOffsetType) number_images; n++)
{
SetGeometry(smush_image,&geometry);
x_offset-=SmushXGap(smush_image,image,offset,exception);
y_offset-=geometry.y;
}
- status=CompositeImage(smush_image,OverCompositeOp,image,x_offset,y_offset,
- exception);
+ status=CompositeImage(smush_image,image,OverCompositeOp,MagickTrue,x_offset,
+ y_offset,exception);
proceed=SetImageProgress(image,SmushImageTag,n,number_images);
if (proceed == MagickFalse)
break;
smush_image->columns=(size_t) x_offset;
else
smush_image->rows=(size_t) y_offset;
- smush_view=DestroyCacheView(smush_view);
if (status == MagickFalse)
smush_image=DestroyImage(smush_image);
return(smush_image);
return(MagickFalse);
range_exception=MagickFalse;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(range_exception,status)
+ #pragma omp parallel for schedule(static,4) shared(range_exception,status) \
+ dynamic_number_threads(image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=DestroyCacheView(image_view);
if (range_exception != MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
- "InvalidColormapIndex","`%s'",image->filename);
+ "InvalidColormapIndex","'%s'",image->filename);
return(status);
}
\f
if (option != (const char *) NULL)
(void) QueryColorCompliance(option,AllCompliance,&image->background_color,
exception);
- option=GetImageOption(image_info,"bias");
- if (option != (const char *) NULL)
- image->bias=StringToDoubleInterval(option,(double) QuantumRange+1.0);
option=GetImageOption(image_info,"black-point-compensation");
if (option != (const char *) NULL)
image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
if (option != (const char *) NULL)
(void) QueryColorCompliance(option,AllCompliance,&image->border_color,
exception);
+ option=GetImageOption(image_info,"channel");
+ if (option != (const char *) NULL)
+ (void) SetPixelChannelMapMask(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)
projects / imagemagick / blobdiff