next_row,
proceed;
- PixelInfo
- pixel,
+ MagickRealType
+ alpha,
+ gamma,
+ pixel[MaxPixelChannels],
*scale_scanline,
*scanline,
*x_vector,
- *y_vector,
- zero;
+ *y_vector;
- MagickRealType
- alpha;
+ PixelChannel
+ channel;
+
+ PixelTrait
+ scale_traits,
+ traits;
PointInfo
scale,
i;
ssize_t
+ n,
number_rows,
y;
/*
Allocate memory.
*/
- x_vector=(PixelInfo *) AcquireQuantumMemory((size_t) image->columns,
- sizeof(*x_vector));
+ x_vector=(MagickRealType *) AcquireQuantumMemory((size_t) image->columns,
+ GetPixelChannels(image)*sizeof(*x_vector));
scanline=x_vector;
if (image->rows != scale_image->rows)
- scanline=(PixelInfo *) AcquireQuantumMemory((size_t) image->columns,
- sizeof(*scanline));
- scale_scanline=(PixelInfo *) AcquireQuantumMemory((size_t)
- scale_image->columns,sizeof(*scale_scanline));
- y_vector=(PixelInfo *) AcquireQuantumMemory((size_t) image->columns,
- sizeof(*y_vector));
- if ((scanline == (PixelInfo *) NULL) ||
- (scale_scanline == (PixelInfo *) NULL) ||
- (x_vector == (PixelInfo *) NULL) ||
- (y_vector == (PixelInfo *) NULL))
+ scanline=(MagickRealType *) AcquireQuantumMemory((size_t) image->columns,
+ GetPixelChannels(image)*sizeof(*scanline));
+ scale_scanline=(MagickRealType *) AcquireQuantumMemory((size_t)
+ scale_image->columns,GetPixelChannels(scale_image)*sizeof(*scale_scanline));
+ y_vector=(MagickRealType *) AcquireQuantumMemory((size_t) image->columns,
+ GetPixelChannels(image)*sizeof(*y_vector));
+ if ((scanline == (MagickRealType *) NULL) ||
+ (scale_scanline == (MagickRealType *) NULL) ||
+ (x_vector == (MagickRealType *) NULL) ||
+ (y_vector == (MagickRealType *) NULL))
{
scale_image=DestroyImage(scale_image);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
next_row=MagickTrue;
span.y=1.0;
scale.y=(double) scale_image->rows/(double) image->rows;
- (void) ResetMagickMemory(y_vector,0,(size_t) image->columns*
- sizeof(*y_vector));
- GetPixelInfo(image,&pixel);
- (void) ResetMagickMemory(&zero,0,sizeof(zero));
- i=0;
+ for (i=0; i < (ssize_t) (GetPixelChannels(image)*image->columns); i++)
+ y_vector[i]=0.0;
+ n=0;
image_view=AcquireCacheView(image);
scale_view=AcquireCacheView(scale_image);
for (y=0; y < (ssize_t) scale_image->rows; y++)
register const Quantum
*restrict p;
- register PixelInfo
- *restrict s,
- *restrict t;
-
register Quantum
*restrict q;
/*
Read a new scanline.
*/
- p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
+ p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (image->matte != MagickFalse)
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ if ((traits & BlendPixelTrait) == 0)
+ {
+ x_vector[x*GetPixelChannels(image)+i]=(MagickRealType) p[i];
+ continue;
+ }
alpha=QuantumScale*GetPixelAlpha(image,p);
- x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(image,p));
- x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(image,p));
- x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(image,p));
- if (image->matte != MagickFalse)
- x_vector[x].alpha=(MagickRealType) GetPixelAlpha(image,p);
- if (image->colorspace == CMYKColorspace)
- x_vector[x].black=(MagickRealType) (alpha*GetPixelBlack(image,p));
+ x_vector[x*GetPixelChannels(image)+i]=alpha*p[i];
+ }
p+=GetPixelChannels(image);
}
}
/*
Read a new scanline.
*/
- p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
+ p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (image->matte != MagickFalse)
- alpha=QuantumScale*
- GetPixelAlpha(image,p);
- x_vector[x].red=(MagickRealType) (alpha*
- GetPixelRed(image,p));
- x_vector[x].green=(MagickRealType) (alpha*
- GetPixelGreen(image,p));
- x_vector[x].blue=(MagickRealType) (alpha*
- GetPixelBlue(image,p));
- if (image->colorspace == CMYKColorspace)
- x_vector[x].black=(MagickRealType) (alpha*
- GetPixelBlack(image,p));
- if (image->matte != MagickFalse)
- x_vector[x].alpha=(MagickRealType)
- GetPixelAlpha(image,p);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ if ((traits & BlendPixelTrait) == 0)
+ {
+ x_vector[x*GetPixelChannels(image)+i]=(MagickRealType)
+ p[i];
+ continue;
+ }
+ alpha=QuantumScale*GetPixelAlpha(image,p);
+ x_vector[x*GetPixelChannels(image)+i]=alpha*p[i];
+ }
p+=GetPixelChannels(image);
}
number_rows++;
}
for (x=0; x < (ssize_t) image->columns; x++)
- {
- y_vector[x].red+=scale.y*x_vector[x].red;
- y_vector[x].green+=scale.y*x_vector[x].green;
- y_vector[x].blue+=scale.y*x_vector[x].blue;
- if (scale_image->colorspace == CMYKColorspace)
- y_vector[x].black+=scale.y*x_vector[x].black;
- if (scale_image->matte != MagickFalse)
- y_vector[x].alpha+=scale.y*x_vector[x].alpha;
- }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ y_vector[x*GetPixelChannels(image)+i]+=scale.y*
+ x_vector[x*GetPixelChannels(image)+i];
span.y-=scale.y;
scale.y=(double) scale_image->rows/(double) image->rows;
next_row=MagickTrue;
/*
Read a new scanline.
*/
- p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
+ p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- if (image->matte != MagickFalse)
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ if ((traits & BlendPixelTrait) == 0)
+ {
+ x_vector[x*GetPixelChannels(image)+i]=(MagickRealType) p[i];
+ continue;
+ }
alpha=QuantumScale*GetPixelAlpha(image,p);
- x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(image,p));
- x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(image,p));
- x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(image,p));
- if (image->colorspace == CMYKColorspace)
- x_vector[x].black=(MagickRealType) (alpha*
- GetPixelBlack(image,p));
- if (image->matte != MagickFalse)
- x_vector[x].alpha=(MagickRealType) GetPixelAlpha(image,p);
+ x_vector[x*GetPixelChannels(image)+i]=alpha*p[i];
+ }
p+=GetPixelChannels(image);
}
number_rows++;
next_row=MagickFalse;
}
- s=scanline;
for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel.red=y_vector[x].red+span.y*x_vector[x].red;
- pixel.green=y_vector[x].green+span.y*x_vector[x].green;
- pixel.blue=y_vector[x].blue+span.y*x_vector[x].blue;
- if (image->colorspace == CMYKColorspace)
- pixel.black=y_vector[x].black+span.y*x_vector[x].black;
- if (image->matte != MagickFalse)
- pixel.alpha=y_vector[x].alpha+span.y*x_vector[x].alpha;
- s->red=pixel.red;
- s->green=pixel.green;
- s->blue=pixel.blue;
- if (scale_image->colorspace == CMYKColorspace)
- s->black=pixel.black;
- if (scale_image->matte != MagickFalse)
- s->alpha=pixel.alpha;
- s++;
- y_vector[x]=zero;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ pixel[i]=y_vector[x*GetPixelChannels(image)+i]+span.y*
+ x_vector[x*GetPixelChannels(image)+i];
+ scanline[x*GetPixelChannels(image)+i]=pixel[i];
+ y_vector[x*GetPixelChannels(image)+i]=0.0;
+ }
}
scale.y-=span.y;
if (scale.y <= 0)
/*
Transfer scanline to scaled image.
*/
- s=scanline;
for (x=0; x < (ssize_t) scale_image->columns; x++)
{
- if (scale_image->matte != MagickFalse)
- alpha=QuantumScale*s->alpha;
- alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
- SetPixelRed(scale_image,ClampToQuantum(alpha*s->red),q);
- SetPixelGreen(scale_image,ClampToQuantum(alpha*s->green),q);
- SetPixelBlue(scale_image,ClampToQuantum(alpha*s->blue),q);
- if (scale_image->colorspace == CMYKColorspace)
- SetPixelBlack(scale_image,ClampToQuantum(alpha*s->black),q);
- if (scale_image->matte != MagickFalse)
- SetPixelAlpha(scale_image,ClampToQuantum(s->alpha),q);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ if (traits == UndefinedPixelTrait)
+ continue;
+ channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ scale_traits=GetPixelChannelMapTraits(scale_image,channel);
+ if (scale_traits == UndefinedPixelTrait)
+ continue;
+ if ((scale_traits & BlendPixelTrait) == 0)
+ {
+ q[channel]=ClampToQuantum(scanline[x*
+ GetPixelChannels(image)+i]);
+ continue;
+ }
+ alpha=QuantumScale*scanline[x*GetPixelChannels(image)+
+ GetPixelChannelMapChannel(image,AlphaPixelChannel)];
+ gamma=1.0/(fabs((double) alpha) <= MagickEpsilon ? 1.0 : alpha);
+ q[channel]=ClampToQuantum(gamma*scanline[x*
+ GetPixelChannels(image)+i]);
+ }
q+=GetPixelChannels(scale_image);
- s++;
}
}
else
{
+ ssize_t
+ n;
+
/*
Scale X direction.
*/
- pixel=zero;
next_column=MagickFalse;
+ n=0;
span.x=1.0;
- s=scanline;
- t=scale_scanline;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ pixel[i]=0.0;
for (x=0; x < (ssize_t) image->columns; x++)
{
scale.x=(double) scale_image->columns/(double) image->columns;
{
if (next_column != MagickFalse)
{
- pixel=zero;
- t++;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ pixel[i]=0.0;
+ n++;
}
- pixel.red+=span.x*s->red;
- pixel.green+=span.x*s->green;
- pixel.blue+=span.x*s->blue;
- if (scale_image->colorspace == CMYKColorspace)
- pixel.black+=span.x*s->black;
- if (image->matte != MagickFalse)
- pixel.alpha+=span.x*s->alpha;
- t->red=pixel.red;
- t->green=pixel.green;
- t->blue=pixel.blue;
- if (scale_image->colorspace == CMYKColorspace)
- t->black=pixel.black;
- if (scale_image->matte != MagickFalse)
- t->alpha=pixel.alpha;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ pixel[i]+=span.x*scanline[x*GetPixelChannels(image)+i];
+ scale_scanline[n*GetPixelChannels(scale_image)+i]=pixel[i];
+ }
scale.x-=span.x;
span.x=1.0;
next_column=MagickTrue;
{
if (next_column != MagickFalse)
{
- pixel=zero;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ pixel[i]=0.0;
+ n++;
next_column=MagickFalse;
- t++;
}
- pixel.red+=scale.x*s->red;
- pixel.green+=scale.x*s->green;
- pixel.blue+=scale.x*s->blue;
- if (scale_image->colorspace == CMYKColorspace)
- pixel.black+=scale.x*s->black;
- if (scale_image->matte != MagickFalse)
- pixel.alpha+=scale.x*s->alpha;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ pixel[i]+=scale.x*scanline[x*GetPixelChannels(image)+i];
span.x-=scale.x;
}
- s++;
}
if (span.x > 0)
{
- s--;
- pixel.red+=span.x*s->red;
- pixel.green+=span.x*s->green;
- pixel.blue+=span.x*s->blue;
- if (scale_image->colorspace == CMYKColorspace)
- pixel.black+=span.x*s->black;
- if (scale_image->matte != MagickFalse)
- pixel.alpha+=span.x*s->alpha;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ pixel[i]+=span.x*scanline[(x-1)*GetPixelChannels(image)+i];
}
if ((next_column == MagickFalse) &&
- ((ssize_t) (t-scale_scanline) < (ssize_t) scale_image->columns))
+ ((ssize_t) n < (ssize_t) scale_image->columns))
{
- t->red=pixel.red;
- t->green=pixel.green;
- t->blue=pixel.blue;
- if (scale_image->colorspace == CMYKColorspace)
- t->black=pixel.black;
- if (scale_image->matte != MagickFalse)
- t->alpha=pixel.alpha;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ scale_scanline[n*GetPixelChannels(image)+i]=pixel[i];
}
/*
Transfer scanline to scaled image.
*/
- t=scale_scanline;
for (x=0; x < (ssize_t) scale_image->columns; x++)
{
- if (scale_image->matte != MagickFalse)
- alpha=QuantumScale*s->alpha;
- alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
- SetPixelRed(scale_image,ClampToQuantum(alpha*t->red),q);
- SetPixelGreen(scale_image,ClampToQuantum(alpha*t->green),q);
- SetPixelBlue(scale_image,ClampToQuantum(alpha*t->blue),q);
- if (scale_image->colorspace == CMYKColorspace)
- SetPixelBlack(scale_image,ClampToQuantum(alpha*t->black),q);
- if (scale_image->matte != MagickFalse)
- SetPixelAlpha(scale_image,ClampToQuantum(t->alpha),q);
- t++;
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ if (traits == UndefinedPixelTrait)
+ continue;
+ channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+ scale_traits=GetPixelChannelMapTraits(scale_image,channel);
+ if (scale_traits == UndefinedPixelTrait)
+ continue;
+ if ((scale_traits & BlendPixelTrait) == 0)
+ {
+ q[channel]=ClampToQuantum(scale_scanline[x*
+ GetPixelChannels(scale_image)+i]);
+ continue;
+ }
+ alpha=QuantumScale*scanline[x*GetPixelChannels(image)+
+ GetPixelChannelMapChannel(image,AlphaPixelChannel)];
+ gamma=1.0/(fabs((double) alpha) <= MagickEpsilon ? 1.0 : alpha);
+ q[channel]=ClampToQuantum(gamma*scale_scanline[
+ GetPixelChannels(scale_image)+i]);
+ }
q+=GetPixelChannels(scale_image);
}
}
/*
Free allocated memory.
*/
- y_vector=(PixelInfo *) RelinquishMagickMemory(y_vector);
- scale_scanline=(PixelInfo *) RelinquishMagickMemory(scale_scanline);
+ y_vector=(MagickRealType *) RelinquishMagickMemory(y_vector);
+ scale_scanline=(MagickRealType *) RelinquishMagickMemory(scale_scanline);
if (scale_image->rows != image->rows)
- scanline=(PixelInfo *) RelinquishMagickMemory(scanline);
- x_vector=(PixelInfo *) RelinquishMagickMemory(x_vector);
+ scanline=(MagickRealType *) RelinquishMagickMemory(scanline);
+ x_vector=(MagickRealType *) RelinquishMagickMemory(x_vector);
scale_image->type=image->type;
return(scale_image);
}
projects / imagemagick / commitdiff