% MagickCore Image Resize Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1992 %
% %
% %
-% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 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 %
#include "MagickCore/blob.h"
#include "MagickCore/cache.h"
#include "MagickCore/cache-view.h"
+#include "MagickCore/channel.h"
#include "MagickCore/color.h"
#include "MagickCore/color-private.h"
#include "MagickCore/draw.h"
#include "MagickCore/property.h"
#include "MagickCore/monitor.h"
#include "MagickCore/monitor-private.h"
+#include "MagickCore/nt-base-private.h"
#include "MagickCore/option.h"
#include "MagickCore/pixel.h"
#include "MagickCore/pixel-private.h"
blur, /* x-scale (blur-sharpen) */
coefficient[7]; /* cubic coefficents for BC-cubic filters */
+ ResizeWeightingFunctionType
+ filterWeightingType,
+ windowWeightingType;
+
size_t
signature;
};
%
% The individual filter functions have this format...
%
-% static MagickRealtype *FilterName(const double x,
-% const double support)
+% static MagickRealtype *FilterName(const double x,const double support)
%
% A description of each parameter follows:
%
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(UndefinedFilter < filter && filter < SentinelFilter);
assert(exception != (ExceptionInfo *) NULL);
window_type=mapping[filter].window;
resize_filter->blur=1.0;
/* Promote 1D Windowed Sinc Filters to a 2D Windowed Jinc filters */
- if( IfMagickTrue(cylindrical) && (filter_type == SincFastFilter) &&
+ if ( IfMagickTrue(cylindrical) && (filter_type == SincFastFilter) &&
(filter != SincFastFilter))
filter_type=JincFilter; /* 1D Windowed Sinc => 2D Windowed Jinc filters */
value=StringToDouble(artifact,(char **) NULL)*MagickPI;
/* Define coefficents for Kaiser Windowing Function */
resize_filter->coefficient[0]=value; /* alpha */
- resize_filter->coefficient[1]=PerceptibleReciprocal(I0(value)); /* normalization */
+ resize_filter->coefficient[1]=PerceptibleReciprocal(I0(value));
+ /* normalization */
}
/* Support Overrides */
lobes=1;
resize_filter->support=(double) lobes;
}
- /* Convert a Jinc function lobes value to a real support value */
if (resize_filter->filter == Jinc)
{
+ /*
+ Convert a Jinc function lobes value to a real support value.
+ */
if (resize_filter->support > 16)
resize_filter->support=jinc_zeros[15]; /* largest entry in table */
else
- resize_filter->support=jinc_zeros[((long)resize_filter->support)-1];
-
- /* blur this filter so support is a integer value (lobes dependant) */
+ resize_filter->support=jinc_zeros[((long) resize_filter->support)-1];
+ /*
+ Blur this filter so support is a integer value (lobes dependant).
+ */
if (filter_type == LanczosRadiusFilter)
- {
- resize_filter->blur *= floor(resize_filter->support)/
- resize_filter->support;
- }
+ resize_filter->blur*=floor(resize_filter->support)/
+ resize_filter->support;
}
- /* Expert Blur Override */
+ /*
+ Expert blur override.
+ */
artifact=GetImageArtifact(image,"filter:blur");
if (artifact != (const char *) NULL)
resize_filter->blur*=StringToDouble(artifact,(char **) NULL);
if (resize_filter->blur < MagickEpsilon)
resize_filter->blur=(double) MagickEpsilon;
-
- /* Expert override of the support setting */
+ /*
+ Expert override of the support setting.
+ */
artifact=GetImageArtifact(image,"filter:support");
if (artifact != (const char *) NULL)
resize_filter->support=fabs(StringToDouble(artifact,(char **) NULL));
/*
- Scale windowing function separately to the support 'clipping'
- window that calling operator is planning to actually use. (Expert
- override)
+ Scale windowing function separately to the support 'clipping' window
+ that calling operator is planning to actually use. (Expert override)
*/
resize_filter->window_support=resize_filter->support; /* default */
artifact=GetImageArtifact(image,"filter:win-support");
if (artifact != (const char *) NULL)
resize_filter->window_support=fabs(StringToDouble(artifact,(char **) NULL));
/*
- Adjust window function scaling to match windowing support for
- weighting function. This avoids a division on every filter call.
+ Adjust window function scaling to match windowing support for weighting
+ function. This avoids a division on every filter call.
*/
resize_filter->scale/=resize_filter->window_support;
-
/*
* Set Cubic Spline B,C values, calculate Cubic coefficients.
*/
B=1.0-2.0*C; /* Calculate B to get a Keys cubic filter. */
}
}
- /* Convert B,C values into Cubic Coefficents. See CubicBC(). */
{
- const double twoB = B+B;
+ const double
+ twoB = B+B;
+
+ /*
+ Convert B,C values into Cubic Coefficents. See CubicBC().
+ */
resize_filter->coefficient[0]=1.0-(1.0/3.0)*B;
resize_filter->coefficient[1]=-3.0+twoB+C;
resize_filter->coefficient[2]=2.0-1.5*B-C;
x;
/*
- Set the weighting function properly when the weighting
- function may not exactly match the filter of the same name.
- EG: a Point filter is really uses a Box weighting function
- with a different support than is typically used.
+ Set the weighting function properly when the weighting function
+ may not exactly match the filter of the same name. EG: a Point
+ filter is really uses a Box weighting function with a different
+ support than is typically used.
*/
if (resize_filter->filter == Box) filter_type=BoxFilter;
if (resize_filter->filter == Sinc) filter_type=SincFilter;
Report Filter Details.
*/
support=GetResizeFilterSupport(resize_filter); /* practical_support */
- (void) FormatLocaleFile(stdout,"# Resampling Filter (for graphing)\n#\n");
+ (void) FormatLocaleFile(stdout,
+ "# Resampling Filter (for graphing)\n#\n");
(void) FormatLocaleFile(stdout,"# filter = %s\n",
- CommandOptionToMnemonic(MagickFilterOptions,filter_type));
+ CommandOptionToMnemonic(MagickFilterOptions,filter_type));
(void) FormatLocaleFile(stdout,"# window = %s\n",
- CommandOptionToMnemonic(MagickFilterOptions,window_type));
+ CommandOptionToMnemonic(MagickFilterOptions,window_type));
(void) FormatLocaleFile(stdout,"# support = %.*g\n",
- GetMagickPrecision(),(double) resize_filter->support);
+ GetMagickPrecision(),(double) resize_filter->support);
(void) FormatLocaleFile(stdout,"# window-support = %.*g\n",
- GetMagickPrecision(),(double) resize_filter->window_support);
+ GetMagickPrecision(),(double) resize_filter->window_support);
(void) FormatLocaleFile(stdout,"# scale-blur = %.*g\n",
- GetMagickPrecision(), (double)resize_filter->blur);
- if ( filter_type == GaussianFilter || window_type == GaussianFilter )
+ GetMagickPrecision(),(double)resize_filter->blur);
+ if ((filter_type == GaussianFilter) || (window_type == GaussianFilter))
(void) FormatLocaleFile(stdout,"# gaussian-sigma = %.*g\n",
- GetMagickPrecision(), (double)resize_filter->coefficient[0]);
+ GetMagickPrecision(),(double)resize_filter->coefficient[0]);
if ( filter_type == KaiserFilter || window_type == KaiserFilter )
(void) FormatLocaleFile(stdout,"# kaiser-beta = %.*g\n",
- GetMagickPrecision(),
- (double)resize_filter->coefficient[0]);
+ GetMagickPrecision(),(double)resize_filter->coefficient[0]);
(void) FormatLocaleFile(stdout,"# practical-support = %.*g\n",
- GetMagickPrecision(), (double)support);
+ GetMagickPrecision(), (double)support);
if ( filter_type == CubicFilter || window_type == CubicFilter )
(void) FormatLocaleFile(stdout,"# B,C = %.*g,%.*g\n",
- GetMagickPrecision(),(double)B, GetMagickPrecision(),(double)C);
+ GetMagickPrecision(),(double)B, GetMagickPrecision(),(double)C);
(void) FormatLocaleFile(stdout,"\n");
/*
- Output values of resulting filter graph -- for graphing
- filter result.
+ Output values of resulting filter graph -- for graphing filter result.
*/
for (x=0.0; x <= support; x+=0.01f)
- (void) FormatLocaleFile(stdout,"%5.2lf\t%.*g\n",x,GetMagickPrecision(),
- (double) GetResizeFilterWeight(resize_filter,x));
- /* A final value so gnuplot can graph the 'stop' properly. */
+ (void) FormatLocaleFile(stdout,"%5.2lf\t%.*g\n",x,
+ GetMagickPrecision(),(double)
+ GetResizeFilterWeight(resize_filter,x));
+ /*
+ A final value so gnuplot can graph the 'stop' properly.
+ */
(void) FormatLocaleFile(stdout,"%5.2lf\t%.*g\n",support,
GetMagickPrecision(),0.0);
}
MagickExport Image *AdaptiveResizeImage(const Image *image,
const size_t columns,const size_t rows,ExceptionInfo *exception)
{
- return(InterpolativeResizeImage(image,columns,rows,MeshInterpolatePixel,
- exception));
+ Image
+ *resize_image;
+
+ resize_image=InterpolativeResizeImage(image,columns,rows,MeshInterpolatePixel,
+ exception);
+ return(resize_image);
}
\f
/*
% o filter: Image filter to use.
%
*/
+
+MagickPrivate double *GetResizeFilterCoefficient(
+ const ResizeFilter *resize_filter)
+{
+ assert(resize_filter != (ResizeFilter *) NULL);
+ assert(resize_filter->signature == MagickSignature);
+ return((double *) resize_filter->coefficient);
+}
+
+MagickPrivate double GetResizeFilterBlur(
+ const ResizeFilter *resize_filter)
+{
+ assert(resize_filter != (ResizeFilter *) NULL);
+ assert(resize_filter->signature == MagickSignature);
+ return(resize_filter->blur);
+}
+
+MagickPrivate double GetResizeFilterScale(
+ const ResizeFilter *resize_filter)
+{
+ assert(resize_filter != (ResizeFilter *) NULL);
+ assert(resize_filter->signature == MagickSignature);
+ return(resize_filter->scale);
+}
+
+MagickPrivate double GetResizeFilterWindowSupport(
+ const ResizeFilter *resize_filter)
+{
+ assert(resize_filter != (ResizeFilter *) NULL);
+ assert(resize_filter->signature == MagickSignature);
+ return(resize_filter->window_support);
+}
+
+MagickPrivate ResizeWeightingFunctionType GetResizeFilterWeightingType(
+ const ResizeFilter *resize_filter)
+{
+ assert(resize_filter != (ResizeFilter *) NULL);
+ assert(resize_filter->signature == MagickSignature);
+ return(resize_filter->filterWeightingType);
+}
+
+MagickPrivate ResizeWeightingFunctionType GetResizeFilterWindowWeightingType(
+ const ResizeFilter *resize_filter)
+{
+ assert(resize_filter != (ResizeFilter *) NULL);
+ assert(resize_filter->signature == MagickSignature);
+ return(resize_filter->windowWeightingType);
+}
+
MagickPrivate double GetResizeFilterSupport(
const ResizeFilter *resize_filter)
{
% o x: the point.
%
*/
-MagickPrivate double GetResizeFilterWeight(
- const ResizeFilter *resize_filter,const double x)
+MagickPrivate double GetResizeFilterWeight(const ResizeFilter *resize_filter,
+ const double x)
{
double
scale,
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
resize_image=CloneImage(image,columns,rows,MagickTrue,exception);
if (resize_image == (Image *) NULL)
return((Image *) NULL);
- if( IfMagickFalse(SetImageStorageClass(resize_image,DirectClass,exception)) )
+ if (SetImageStorageClass(resize_image,DirectClass,exception) == MagickFalse)
{
resize_image=DestroyImage(resize_image);
return((Image *) NULL);
}
status=MagickTrue;
progress=0;
- image_view=AcquireVirtualCacheView(image);
- resize_view=AcquireAuthenticCacheView(resize_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ resize_view=AcquireAuthenticCacheView(resize_image,exception);
scale.x=(double) image->columns/resize_image->columns;
scale.y=(double) image->rows/resize_image->rows;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- dynamic_number_threads(image,image->columns,image->rows,1)
+ magick_threads(image,resize_image,resize_image->rows,1)
#endif
for (y=0; y < (ssize_t) resize_image->rows; y++)
{
register ssize_t
i;
- if (GetPixelMask(resize_image,q) != 0)
+ if (GetPixelReadMask(resize_image,q) == 0)
{
q+=GetPixelChannels(resize_image);
continue;
}
q+=GetPixelChannels(resize_image);
}
- if( IfMagickFalse(SyncCacheViewAuthenticPixels(resize_view,exception)) )
- continue;
+ if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
+ status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
#endif
proceed=SetImageProgress(image,InterpolativeResizeImageTag,progress++,
image->rows);
- if( IfMagickFalse(proceed) )
+ if (proceed == MagickFalse)
status=MagickFalse;
}
}
MagickBooleanType
status;
+ MemoryInfo
+ *pixel_info;
+
register gfloat
*q;
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
/*
Honor liquid resize size limitations.
*/
- for (width=image->columns; columns >= (2*width-1); width*=2);
- for (height=image->rows; rows >= (2*height-1); height*=2);
+ for (width=image->columns; columns >= (2*width-1); width*=2) ;
+ for (height=image->rows; rows >= (2*height-1); height*=2) ;
resize_image=ResizeImage(image,width,height,image->filter,exception);
if (resize_image == (Image *) NULL)
return((Image *) NULL);
resize_image=DestroyImage(resize_image);
return(rescale_image);
}
- pixels=(gfloat *) AcquireQuantumMemory(image->columns,image->rows*
+ pixel_info=AcquireVirtualMemory(image->columns,image->rows*
GetPixelChannels(image)*sizeof(*pixels));
- if (pixels == (gfloat *) NULL)
+ if (pixel_info == (MemoryInfo *) NULL)
return((Image *) NULL);
+ pixels=(gfloat *) GetVirtualMemoryBlob(pixel_info);
status=MagickTrue;
q=pixels;
- image_view=AcquireVirtualCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
}
}
image_view=DestroyCacheView(image_view);
- carver=lqr_carver_new_ext(pixels,image->columns,image->rows,
- GetPixelChannels(image),LQR_COLDEPTH_32F);
+ carver=lqr_carver_new_ext(pixels,(int) image->columns,(int) image->rows,
+ (int) GetPixelChannels(image),LQR_COLDEPTH_32F);
if (carver == (LqrCarver *) NULL)
{
- pixels=(gfloat *) RelinquishMagickMemory(pixels);
+ pixel_info=RelinquishVirtualMemory(pixel_info);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
+ lqr_carver_set_preserve_input_image(carver);
lqr_status=lqr_carver_init(carver,(int) delta_x,rigidity);
- lqr_status=lqr_carver_resize(carver,columns,rows);
+ lqr_status=lqr_carver_resize(carver,(int) columns,(int) rows);
(void) lqr_status;
rescale_image=CloneImage(image,lqr_carver_get_width(carver),
lqr_carver_get_height(carver),MagickTrue,exception);
if (rescale_image == (Image *) NULL)
{
- pixels=(gfloat *) RelinquishMagickMemory(pixels);
+ pixel_info=RelinquishVirtualMemory(pixel_info);
return((Image *) NULL);
}
- if( IfMagickFalse(SetImageStorageClass(rescale_image,DirectClass,exception)) )
+ if (SetImageStorageClass(rescale_image,DirectClass,exception) == MagickFalse)
{
- pixels=(gfloat *) RelinquishMagickMemory(pixels);
+ pixel_info=RelinquishVirtualMemory(pixel_info);
rescale_image=DestroyImage(rescale_image);
return((Image *) NULL);
}
- rescale_view=AcquireAuthenticCacheView(rescale_image);
+ rescale_view=AcquireAuthenticCacheView(rescale_image,exception);
(void) lqr_carver_scan_reset(carver);
while (lqr_carver_scan_ext(carver,&x_offset,&y_offset,(void **) &packet) != 0)
{
SetPixelChannel(rescale_image,channel,ClampToQuantum(QuantumRange*
packet[i]),q);
}
- if( IfMagickFalse(SyncCacheViewAuthenticPixels(rescale_view,exception)) )
+ if (SyncCacheViewAuthenticPixels(rescale_view,exception) == MagickFalse)
break;
}
rescale_view=DestroyCacheView(rescale_view);
+ pixel_info=RelinquishVirtualMemory(pixel_info);
lqr_carver_destroy(carver);
return(rescale_image);
}
{
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagnifyImage() is a convenience method that scales an image proportionally
-% to twice its size.
+% MagnifyImage() doubles the size of the image with a pixel art scaling
+% algorithm.
%
% The format of the MagnifyImage method is:
%
*/
MagickExport Image *MagnifyImage(const Image *image,ExceptionInfo *exception)
{
+#define MagnifyImageTag "Magnify/Image"
+
+ CacheView
+ *image_view,
+ *magnify_view;
+
Image
*magnify_image;
- assert(image != (Image *) NULL);
+ MagickBooleanType
+ status;
+
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
+ /*
+ Initialize magnified image attributes.
+ */
+ assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- magnify_image=ResizeImage(image,2*image->columns,2*image->rows,SplineFilter,
+ magnify_image=CloneImage(image,2*image->columns,2*image->rows,MagickTrue,
exception);
+ if (magnify_image == (Image *) NULL)
+ return((Image *) NULL);
+ /*
+ Magnify image.
+ */
+ status=MagickTrue;
+ progress=0;
+ image_view=AcquireVirtualCacheView(image,exception);
+ magnify_view=AcquireAuthenticCacheView(magnify_image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(image,magnify_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(magnify_view,0,2*y,magnify_image->columns,2,
+ exception);
+ if (q == (Quantum *) NULL)
+ {
+ status=MagickFalse;
+ continue;
+ }
+ /*
+ Magnify this row of pixels.
+ */
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ MagickRealType
+ intensity[9];
+
+ register const Quantum
+ *restrict p;
+
+ register Quantum
+ *restrict r;
+
+ register ssize_t
+ i;
+
+ size_t
+ channels;
+
+ p=GetCacheViewVirtualPixels(image_view,x-1,y-1,3,3,exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ continue;
+ }
+ channels=GetPixelChannels(image);
+ for (i=0; i < 9; i++)
+ intensity[i]=GetPixelIntensity(image,p+i*channels);
+ r=q;
+ if ((fabs(intensity[1]-intensity[7]) < MagickEpsilon) ||
+ (fabs(intensity[3]-intensity[5]) < MagickEpsilon))
+ {
+ /*
+ Clone center pixel.
+ */
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ r+=GetPixelChannels(magnify_image);
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ r+=(magnify_image->columns-1)*GetPixelChannels(magnify_image);
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ r+=GetPixelChannels(magnify_image);
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ }
+ else
+ {
+ /*
+ Selectively clone pixel.
+ */
+ if (fabs(intensity[1]-intensity[3]) < MagickEpsilon)
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[3*channels+i];
+ else
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ r+=GetPixelChannels(magnify_image);
+ if (fabs(intensity[1]-intensity[5]) < MagickEpsilon)
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[5*channels+i];
+ else
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ r+=(magnify_image->columns-1)*GetPixelChannels(magnify_image);
+ if (fabs(intensity[3]-intensity[7]) < MagickEpsilon)
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[3*channels+i];
+ else
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ r+=GetPixelChannels(magnify_image);
+ if (fabs(intensity[5]-intensity[7]) < MagickEpsilon)
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[5*channels+i];
+ else
+ for (i=0; i < (ssize_t) channels; i++)
+ r[i]=p[4*channels+i];
+ }
+ q+=2*GetPixelChannels(magnify_image);
+ }
+ if (SyncCacheViewAuthenticPixels(magnify_view,exception) == MagickFalse)
+ status=MagickFalse;
+ if (image->progress_monitor != (MagickProgressMonitor) NULL)
+ {
+ MagickBooleanType
+ proceed;
+
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_MagnifyImage)
+#endif
+ proceed=SetImageProgress(image,MagnifyImageTag,progress++,image->rows);
+ if (proceed == MagickFalse)
+ status=MagickFalse;
+ }
+ }
+ magnify_view=DestroyCacheView(magnify_view);
+ image_view=DestroyCacheView(image_view);
+ if (status == MagickFalse)
+ magnify_image=DestroyImage(magnify_image);
return(magnify_image);
}
\f
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
%
% The format of the ResizeImage method is:
%
-% Image *ResizeImage(Image *image,const size_t columns,
-% const size_t rows,const FilterTypes filter,const double blur,
-% ExceptionInfo *exception)
+% Image *ResizeImage(Image *image,const size_t columns,const size_t rows,
+% const FilterTypes filter,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o filter: Image filter to use.
%
-% o blur: the blur factor where > 1 is blurry, < 1 is sharp. Typically set
-% this to 1.0.
-%
% o exception: return any errors or warnings in this structure.
%
*/
scale=MagickMax(1.0/x_factor+MagickEpsilon,1.0);
support=scale*GetResizeFilterSupport(resize_filter);
storage_class=support > 0.5 ? DirectClass : image->storage_class;
- if( IfMagickFalse(SetImageStorageClass(resize_image,storage_class,exception)) )
+ if (SetImageStorageClass(resize_image,storage_class,exception) == MagickFalse)
return(MagickFalse);
if (support < 0.5)
{
if (contributions == (ContributionInfo **) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
status=MagickTrue;
scale=PerceptibleReciprocal(scale);
- image_view=AcquireVirtualCacheView(image);
- resize_view=AcquireAuthenticCacheView(resize_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ resize_view=AcquireAuthenticCacheView(resize_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- dynamic_number_threads(image,image->columns,image->rows,1)
+ magick_threads(image,resize_image,resize_image->columns,1)
#endif
for (x=0; x < (ssize_t) resize_image->columns; x++)
{
+ const int
+ id = GetOpenMPThreadId();
+
double
bisect,
density;
start=(ssize_t) MagickMax(bisect-support+0.5,0.0);
stop=(ssize_t) MagickMin(bisect+support+0.5,(double) image->columns);
density=0.0;
- contribution=contributions[GetOpenMPThreadId()];
+ contribution=contributions[id];
for (n=0; n < (stop-start); n++)
{
contribution[n].pixel=start+n;
(resize_traits == UndefinedPixelTrait))
continue;
if (((resize_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(resize_image,q) != 0))
+ (GetPixelReadMask(resize_image,q) == 0))
{
j=(ssize_t) (MagickMin(MagickMax(bisect,(double) start),(double)
stop-1.0)+0.5);
}
q+=GetPixelChannels(resize_image);
}
- if( IfMagickFalse(SyncCacheViewAuthenticPixels(resize_view,exception)) )
+ if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
#pragma omp critical (MagickCore_HorizontalFilter)
#endif
proceed=SetImageProgress(image,ResizeImageTag,(*offset)++,span);
- if( IfMagickFalse(proceed) )
+ if (proceed == MagickFalse)
status=MagickFalse;
}
}
ContributionInfo
**restrict contributions;
- MagickBooleanType
- status;
-
- PixelInfo
- zero;
-
double
scale,
support;
+ MagickBooleanType
+ status;
+
ssize_t
y;
scale=MagickMax(1.0/y_factor+MagickEpsilon,1.0);
support=scale*GetResizeFilterSupport(resize_filter);
storage_class=support > 0.5 ? DirectClass : image->storage_class;
- if( IfMagickFalse(SetImageStorageClass(resize_image,storage_class,exception)) )
+ if (SetImageStorageClass(resize_image,storage_class,exception) == MagickFalse)
return(MagickFalse);
if (support < 0.5)
{
if (contributions == (ContributionInfo **) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
status=MagickTrue;
scale=PerceptibleReciprocal(scale);
- (void) ResetMagickMemory(&zero,0,sizeof(zero));
- image_view=AcquireVirtualCacheView(image);
- resize_view=AcquireAuthenticCacheView(resize_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ resize_view=AcquireAuthenticCacheView(resize_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- dynamic_number_threads(image,image->columns,image->rows,1)
+ magick_threads(image,resize_image,resize_image->rows,1)
#endif
for (y=0; y < (ssize_t) resize_image->rows; y++)
{
+ const int
+ id = GetOpenMPThreadId();
+
double
bisect,
density;
start=(ssize_t) MagickMax(bisect-support+0.5,0.0);
stop=(ssize_t) MagickMin(bisect+support+0.5,(double) image->rows);
density=0.0;
- contribution=contributions[GetOpenMPThreadId()];
+ contribution=contributions[id];
for (n=0; n < (stop-start); n++)
{
contribution[n].pixel=start+n;
(resize_traits == UndefinedPixelTrait))
continue;
if (((resize_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(resize_image,q) != 0))
+ (GetPixelReadMask(resize_image,q) == 0))
{
j=(ssize_t) (MagickMin(MagickMax(bisect,(double) start),(double)
stop-1.0)+0.5);
}
q+=GetPixelChannels(resize_image);
}
- if( IfMagickFalse(SyncCacheViewAuthenticPixels(resize_view,exception)) )
+ if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
#pragma omp critical (MagickCore_VerticalFilter)
#endif
proceed=SetImageProgress(image,ResizeImageTag,(*offset)++,span);
- if( IfMagickFalse(proceed) )
+ if (proceed == MagickFalse)
status=MagickFalse;
}
}
MagickExport Image *ResizeImage(const Image *image,const size_t columns,
const size_t rows,const FilterTypes filter,ExceptionInfo *exception)
{
-#define WorkLoadFactor 0.265
+ double
+ x_factor,
+ y_factor;
FilterTypes
filter_type;
MagickOffsetType
offset;
- double
- x_factor,
- y_factor;
-
MagickSizeType
span;
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
*/
x_factor=(double) columns/(double) image->columns;
y_factor=(double) rows/(double) image->rows;
- if ((x_factor*y_factor) > WorkLoadFactor)
+ if (x_factor > y_factor)
filter_image=CloneImage(image,columns,image->rows,MagickTrue,exception);
else
filter_image=CloneImage(image,image->columns,rows,MagickTrue,exception);
filter_type=PointFilter;
else
if ((image->storage_class == PseudoClass) ||
- image->alpha_trait == BlendPixelTrait ||
+ (image->alpha_trait == BlendPixelTrait) ||
((x_factor*y_factor) > 1.0))
filter_type=MitchellFilter;
resize_filter=AcquireResizeFilter(image,filter_type,MagickFalse,exception);
Resize image.
*/
offset=0;
- if ((x_factor*y_factor) > WorkLoadFactor)
+ if (x_factor > y_factor)
{
span=(MagickSizeType) (filter_image->columns+rows);
status=HorizontalFilter(resize_filter,image,filter_image,x_factor,span,
*x_offset,
y;
+ PointInfo
+ sample_offset;
+
/*
Initialize sampled image attributes.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
sample_image=CloneImage(image,columns,rows,MagickTrue,exception);
if (sample_image == (Image *) NULL)
return((Image *) NULL);
+ /*
+ Set the sampling offset, default is in the mid-point of sample regions.
+ */
+ sample_offset.x=sample_offset.y=0.5-MagickEpsilon;
+ {
+ const char
+ *value;
+
+ value=GetImageArtifact(image,"sample:offset");
+ if (value != (char *) NULL)
+ {
+ GeometryInfo
+ geometry_info;
+
+ MagickStatusType
+ flags;
+
+ (void) ParseGeometry(value,&geometry_info);
+ flags=ParseGeometry(value,&geometry_info);
+ sample_offset.x=sample_offset.y=geometry_info.rho/100.0-MagickEpsilon;
+ if ((flags & SigmaValue) != 0)
+ sample_offset.y=geometry_info.sigma/100.0-MagickEpsilon;
+ }
+ }
/*
Allocate scan line buffer and column offset buffers.
*/
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
for (x=0; x < (ssize_t) sample_image->columns; x++)
- x_offset[x]=(ssize_t) (((double) x+0.5)*image->columns/
+ x_offset[x]=(ssize_t) ((((double) x+sample_offset.x)*image->columns)/
sample_image->columns);
/*
Sample each row.
*/
status=MagickTrue;
progress=0;
- image_view=AcquireVirtualCacheView(image);
- sample_view=AcquireAuthenticCacheView(sample_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ sample_view=AcquireAuthenticCacheView(sample_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(progress,status) \
- dynamic_number_threads(image,image->columns,image->rows,1)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,sample_image,1,1)
#endif
for (y=0; y < (ssize_t) sample_image->rows; y++)
{
if (status == MagickFalse)
continue;
- y_offset=(ssize_t) (((double) y+0.5)*image->rows/
+ y_offset=(ssize_t) ((((double) y+sample_offset.y)*image->rows)/
sample_image->rows);
p=GetCacheViewVirtualPixels(image_view,0,y_offset,image->columns,1,
exception);
register ssize_t
i;
- if (GetPixelMask(sample_image,q) != 0)
+ if (GetPixelReadMask(sample_image,q) == 0)
{
q+=GetPixelChannels(sample_image);
continue;
}
q+=GetPixelChannels(sample_image);
}
- if( IfMagickFalse(SyncCacheViewAuthenticPixels(sample_view,exception)) )
+ if (SyncCacheViewAuthenticPixels(sample_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
#pragma omp critical (MagickCore_SampleImage)
#endif
proceed=SetImageProgress(image,SampleImageTag,progress++,image->rows);
- if( IfMagickFalse(proceed) )
+ if (proceed == MagickFalse)
status=MagickFalse;
}
}
*image_view,
*scale_view;
- Image
- *scale_image;
-
- MagickBooleanType
- next_column,
- next_row,
- proceed;
-
double
alpha,
gamma,
*x_vector,
*y_vector;
+ Image
+ *scale_image;
+
+ MagickBooleanType
+ next_column,
+ next_row,
+ proceed,
+ status;
+
PixelChannel
channel;
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
scale_image=CloneImage(image,columns,rows,MagickTrue,exception);
if (scale_image == (Image *) NULL)
return((Image *) NULL);
- if( IfMagickFalse(SetImageStorageClass(scale_image,DirectClass,exception)) )
+ if (SetImageStorageClass(scale_image,DirectClass,exception) == MagickFalse)
{
scale_image=DestroyImage(scale_image);
return((Image *) NULL);
for (i=0; i < (ssize_t) (GetPixelChannels(image)*image->columns); i++)
y_vector[i]=0.0;
n=0;
- image_view=AcquireVirtualCacheView(image);
- scale_view=AcquireAuthenticCacheView(scale_image);
+ status=MagickTrue;
+ image_view=AcquireVirtualCacheView(image,exception);
+ scale_view=AcquireAuthenticCacheView(scale_image,exception);
for (y=0; y < (ssize_t) scale_image->rows; y++)
{
register const Quantum
register ssize_t
x;
+ if (status == MagickFalse)
+ break;
q=QueueCacheViewAuthenticPixels(scale_view,0,y,scale_image->columns,1,
exception);
if (q == (Quantum *) NULL)
- break;
+ {
+ status=MagickFalse;
+ break;
+ }
alpha=1.0;
if (scale_image->rows == image->rows)
{
p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
exception);
if (p == (const Quantum *) NULL)
- break;
+ {
+ status=MagickFalse;
+ break;
+ }
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (GetPixelMask(image,p) != 0)
+ if (GetPixelReadMask(image,p) == 0)
{
p+=GetPixelChannels(image);
continue;
*/
while (scale.y < span.y)
{
- if( IfMagickTrue(next_row) && (number_rows < (ssize_t) image->rows))
+ if ((next_row != MagickFalse) &&
+ (number_rows < (ssize_t) image->rows))
{
/*
Read a new scanline.
p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
exception);
if (p == (const Quantum *) NULL)
- break;
+ {
+ status=MagickFalse;
+ break;
+ }
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (GetPixelMask(image,p) != 0)
+ if (GetPixelReadMask(image,p) == 0)
{
p+=GetPixelChannels(image);
continue;
scale.y=(double) scale_image->rows/(double) image->rows;
next_row=MagickTrue;
}
- if( IfMagickTrue(next_row) && (number_rows < (ssize_t) image->rows))
+ if ((next_row != MagickFalse) && (number_rows < (ssize_t) image->rows))
{
/*
Read a new scanline.
p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
exception);
if (p == (const Quantum *) NULL)
- break;
+ {
+ status=MagickFalse;
+ break;
+ }
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (GetPixelMask(image,p) != 0)
+ if (GetPixelReadMask(image,p) == 0)
{
p+=GetPixelChannels(image);
continue;
*/
for (x=0; x < (ssize_t) scale_image->columns; x++)
{
- if (GetPixelMask(scale_image,q) != 0)
+ if (GetPixelReadMask(scale_image,q) == 0)
{
q+=GetPixelChannels(scale_image);
continue;
scale.x=(double) scale_image->columns/(double) image->columns;
while (scale.x >= span.x)
{
- if( IfMagickTrue(next_column) )
+ if (next_column != MagickFalse)
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
pixel[i]=0.0;
}
if (scale.x > 0)
{
- if( IfMagickTrue(next_column) )
+ if (next_column != MagickFalse)
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
pixel[i]=0.0;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
pixel[i]+=span.x*scanline[(x-1)*GetPixelChannels(image)+i];
}
- if( IfMagickFalse(next_column) &&
+ if ((next_column == MagickFalse) &&
((ssize_t) n < (ssize_t) scale_image->columns))
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
*/
for (x=0; x < (ssize_t) scale_image->columns; x++)
{
- if (GetPixelMask(scale_image,q) != 0)
+ if (GetPixelReadMask(scale_image,q) == 0)
{
q+=GetPixelChannels(scale_image);
continue;
scale_scanline[x*MaxPixelChannels+channel]),q);
continue;
}
- SetPixelChannel(scale_image,channel,ClampToQuantum(
- scale_scanline[x*MaxPixelChannels+channel]),q);
+ SetPixelChannel(scale_image,channel,ClampToQuantum(scale_scanline[
+ x*MaxPixelChannels+channel]),q);
}
q+=GetPixelChannels(scale_image);
}
}
- if( IfMagickFalse(SyncCacheViewAuthenticPixels(scale_view,exception)) )
- break;
+ if (SyncCacheViewAuthenticPixels(scale_view,exception) == MagickFalse)
+ {
+ status=MagickFalse;
+ break;
+ }
proceed=SetImageProgress(image,ScaleImageTag,(MagickOffsetType) y,
image->rows);
- if( IfMagickFalse(proceed) )
- break;
+ if (proceed == MagickFalse)
+ {
+ status=MagickFalse;
+ break;
+ }
}
scale_view=DestroyCacheView(scale_view);
image_view=DestroyCacheView(image_view);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if( IfMagickTrue(image->debug) )
+ if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
if (thumbnail_image == (Image *) NULL)
return(thumbnail_image);
(void) ParseAbsoluteGeometry("0x0+0+0",&thumbnail_image->page);
- if( IfMagickFalse(thumbnail_image->alpha_trait) )
+ if (thumbnail_image->alpha_trait != BlendPixelTrait)
(void) SetImageAlphaChannel(thumbnail_image,OpaqueAlphaChannel,exception);
thumbnail_image->depth=8;
thumbnail_image->interlace=NoInterlace;
image->magick_filename);
(void) SetImageProperty(thumbnail_image,"Thumb::URI",value,exception);
(void) CopyMagickString(value,image->magick_filename,MaxTextExtent);
- if( IfMagickTrue(GetPathAttributes(image->filename,&attributes)) )
+ if ( IfMagickTrue(GetPathAttributes(image->filename,&attributes)) )
{
(void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
attributes.st_mtime);
projects / imagemagick / blobdiff