#define WLUT_WIDTH 1024
struct _ResampleFilter
{
- Image
- *image;
-
CacheView
*view;
+ Image
+ *image;
+
ExceptionInfo
*exception;
debug;
/* Information about image being resampled */
- long
+ ssize_t
image_area;
InterpolatePixelMethod
filter_lut[WLUT_WIDTH],
support;
- unsigned long
+ size_t
signature;
};
\f
%
% Usage Example...
% resample_filter=AcquireResampleFilter(image,exception);
-% for (y=0; y < (long) image->rows; y++) {
-% for (x=0; x < (long) image->columns; x++) {
+% for (y=0; y < (ssize_t) image->rows; y++) {
+% for (x=0; x < (ssize_t) image->columns; x++) {
% X= ....; Y= ....;
% ScaleResampleFilter(resample_filter, ... scaling vectors ...);
% (void) ResamplePixelColor(resample_filter,X,Y,&pixel);
resample_filter->debug=IsEventLogging();
resample_filter->signature=MagickSignature;
- resample_filter->image_area = (long) resample_filter->image->columns *
- resample_filter->image->rows;
+ resample_filter->image_area=(ssize_t) (resample_filter->image->columns*
+ resample_filter->image->rows);
resample_filter->average_defined = MagickFalse;
/* initialise the resampling filter settings */
return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
}
-static inline long NearestNeighbor(MagickRealType x)
+static inline ssize_t NearestNeighbor(MagickRealType x)
{
if (x >= 0.0)
- return((long) (x+0.5));
- return((long) (x-0.5));
+ return((ssize_t) (x+0.5));
+ return((ssize_t) (x-0.5));
}
static MagickBooleanType InterpolateResampleFilter(
register const PixelPacket
*p;
- register long
+ register ssize_t
i;
assert(resample_filter != (ResampleFilter *) NULL);
alpha[16],
gamma;
- p=GetCacheViewVirtualPixels(resample_filter->view,(long) floor(x)-1,(long)
- floor(y)-1,4,4,resample_filter->exception);
+ p=GetCacheViewVirtualPixels(resample_filter->view,(ssize_t) floor(x)-1,
+ (ssize_t) floor(y)-1,4,4,resample_filter->exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
alpha[i]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
+ alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
PointInfo
delta;
- p=GetCacheViewVirtualPixels(resample_filter->view,(long) floor(x)-1,(long)
- floor(y)-1,4,4,resample_filter->exception);
+ p=GetCacheViewVirtualPixels(resample_filter->view,(ssize_t) floor(x)-1,
+ (ssize_t) floor(y)-1,4,4,resample_filter->exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
alpha[i]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
+ alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
delta,
epsilon;
- p=GetCacheViewVirtualPixels(resample_filter->view,(long) floor(x),(long)
- floor(y),2,2,resample_filter->exception);
+ p=GetCacheViewVirtualPixels(resample_filter->view,(ssize_t) floor(x),
+ (ssize_t) floor(y),2,2,resample_filter->exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
}
case FilterInterpolatePixel:
{
+ CacheView
+ *filter_view;
+
Image
*excerpt_image,
*filter_image;
RectangleInfo
geometry;
- CacheView
- *filter_view;
-
geometry.width=4L;
geometry.height=4L;
- geometry.x=(long) floor(x)-1L;
- geometry.y=(long) floor(y)-1L;
+ geometry.x=(ssize_t) floor(x)-1L;
+ geometry.y=(ssize_t) floor(y)-1L;
excerpt_image=ExcerptImage(resample_filter->image,&geometry,
resample_filter->exception);
if (excerpt_image == (Image *) NULL)
MagickPixelPacket
pixels[1];
- p=GetCacheViewVirtualPixels(resample_filter->view,(long) floor(x),(long)
- floor(y),1,1,resample_filter->exception);
+ p=GetCacheViewVirtualPixels(resample_filter->view,(ssize_t) floor(x),
+ (ssize_t) floor(y),1,1,resample_filter->exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
delta,
luminance;
- p=GetCacheViewVirtualPixels(resample_filter->view,(long) floor(x),(long)
- floor(y),2,2,resample_filter->exception);
+ p=GetCacheViewVirtualPixels(resample_filter->view,(ssize_t) floor(x),
+ (ssize_t) floor(y),2,2,resample_filter->exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
alpha[i]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
+ alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
}
case SplineInterpolatePixel:
{
- long
- j,
- n;
-
MagickPixelPacket
pixels[16];
PointInfo
delta;
- p=GetCacheViewVirtualPixels(resample_filter->view,(long) floor(x)-1,(long)
- floor(y)-1,4,4,resample_filter->exception);
+ ssize_t
+ j,
+ n;
+
+ p=GetCacheViewVirtualPixels(resample_filter->view,(ssize_t) floor(x)-1,
+ (ssize_t) floor(y)-1,4,4,resample_filter->exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
alpha[n]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[n]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
+ alpha[n]=QuantumScale*((MagickRealType)
+ GetAlphaPixelComponent(p));
pixels[n].red*=alpha[n];
pixels[n].green*=alpha[n];
pixels[n].blue*=alpha[n];
MagickBooleanType
status;
- long u,v, uw,v1,v2, hit;
+ ssize_t u,v, uw,v1,v2, hit;
double u1;
double U,V,Q,DQ,DDQ;
double divisor_c,divisor_m;
u = -By/2A +/- sqrt(F/A)
Which has been pre-calculated above.
*/
- v1 = (long)(v0 - resample_filter->sqrtA); /* range of scan lines */
- v2 = (long)(v0 + resample_filter->sqrtA + 1);
+ v1 = (ssize_t)(v0 - resample_filter->sqrtA); /* range of scan lines */
+ v2 = (ssize_t)(v0 + resample_filter->sqrtA + 1);
u1 = u0 + (v1-v0)*resample_filter->slope - resample_filter->sqrtU; /* start of scanline for v=v1 */
- uw = (long)(2*resample_filter->sqrtU)+1; /* width of parallelogram */
+ uw = (ssize_t)(2*resample_filter->sqrtU)+1; /* width of parallelogram */
/*
Do weighted resampling of all pixels, within the scaled ellipse,
*/
DDQ = 2*resample_filter->A;
for( v=v1; v<=v2; v++, u1+=resample_filter->slope ) {
- u = (long)u1; /* first pixel in scanline ( floor(u1) ) */
+ u = (ssize_t)u1; /* first pixel in scanline ( floor(u1) ) */
U = (double)u-u0; /* location of that pixel, relative to u0,v0 */
V = (double)v-v0;
DQ = resample_filter->A*(2.0*U+1) + resample_filter->B*V;
/* get the scanline of pixels for this v */
- pixels=GetCacheViewVirtualPixels(resample_filter->view,u,v,(unsigned long) uw,
+ pixels=GetCacheViewVirtualPixels(resample_filter->view,u,v,(size_t) uw,
1,resample_filter->exception);
if (pixels == (const PixelPacket *) NULL)
return(MagickFalse);
Finialize results of resampling
*/
divisor_m = 1.0/divisor_m;
- pixel->opacity = (MagickRealType) RoundToQuantum(divisor_m*pixel->opacity);
+ pixel->opacity = (MagickRealType) ClampToQuantum(divisor_m*pixel->opacity);
divisor_c = 1.0/divisor_c;
- pixel->red = (MagickRealType) RoundToQuantum(divisor_c*pixel->red);
- pixel->green = (MagickRealType) RoundToQuantum(divisor_c*pixel->green);
- pixel->blue = (MagickRealType) RoundToQuantum(divisor_c*pixel->blue);
+ pixel->red = (MagickRealType) ClampToQuantum(divisor_c*pixel->red);
+ pixel->green = (MagickRealType) ClampToQuantum(divisor_c*pixel->green);
+ pixel->blue = (MagickRealType) ClampToQuantum(divisor_c*pixel->blue);
if (resample_filter->image->colorspace == CMYKColorspace)
- pixel->index = (MagickRealType) RoundToQuantum(divisor_c*pixel->index);
+ pixel->index = (MagickRealType) ClampToQuantum(divisor_c*pixel->index);
return(MagickTrue);
}
\f
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
resample_filter->image->filename);
resample_filter->virtual_pixel=method;
- (void) SetCacheViewVirtualPixelMethod(resample_filter->view,method);
+ if (method != UndefinedVirtualPixelMethod)
+ (void) SetCacheViewVirtualPixelMethod(resample_filter->view,method);
return(MagickTrue);
}