python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-02-04 21:50:54 +03:00
Code Issues Packages Projects Releases Wiki Activity

separate 8 and 32 bpc implementations

Browse Source
This commit is contained in:
homm 2016-05-05 12:53:22 +03:00
parent e47002dec3
commit 7693da9287
1 changed files with 153 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
libImaging/Resample.c
View File

@ -85,7 +85,7 @@ static inline UINT8 clip8(int in)
Imaging Imaging
ImagingResampleHorizontal(Imaging imIn, int xsize, struct filter *filterp) ImagingResampleHorizontal_8bpc(Imaging imIn, int xsize, struct filter *filterp)
{ {
ImagingSectionCookie cookie; ImagingSectionCookie cookie;
Imaging imOut; Imaging imOut;
@ -183,57 +183,140 @@ ImagingResampleHorizontal(Imaging imIn, int xsize, struct filter *filterp)
ss0 += ((UINT8) imIn->image8[yy][x]) * k[x - xmin]; ss0 += ((UINT8) imIn->image8[yy][x]) * k[x - xmin];
imOut->image8[yy][xx] = clip8(ss0); imOut->image8[yy][xx] = clip8(ss0);
} }
} else { } else if (imIn->type == IMAGING_TYPE_UINT8) {
switch(imIn->type) { /* n-bit grayscale */
case IMAGING_TYPE_UINT8: if (imIn->bands == 2) {
/* n-bit grayscale */ for (xx = 0; xx < xsize; xx++) {
if (imIn->bands == 2) { xmin = xbounds[xx * 2 + 0];
for (xx = 0; xx < xsize; xx++) { xmax = xbounds[xx * 2 + 1];
xmin = xbounds[xx * 2 + 0]; k = &kk[xx * kmax];
xmax = xbounds[xx * 2 + 1]; ss0 = ss1 = 1 << (PRECISION_BITS -1);
k = &kk[xx * kmax]; for (x = xmin; x < xmax; x++) {
ss0 = ss1 = 1 << (PRECISION_BITS -1); ss0 += ((UINT8) imIn->image[yy][x*4 + 0]) * k[x - xmin];
for (x = xmin; x < xmax; x++) { ss1 += ((UINT8) imIn->image[yy][x*4 + 3]) * k[x - xmin];
ss0 += ((UINT8) imIn->image[yy][x*4 + 0]) * k[x - xmin];
ss1 += ((UINT8) imIn->image[yy][x*4 + 3]) * k[x - xmin];
}
imOut->image[yy][xx*4 + 0] = clip8(ss0);
imOut->image[yy][xx*4 + 3] = clip8(ss1);
}
} else if (imIn->bands == 3) {
for (xx = 0; xx < xsize; xx++) {
xmin = xbounds[xx * 2 + 0];
xmax = xbounds[xx * 2 + 1];
k = &kk[xx * kmax];
ss0 = ss1 = ss2 = 1 << (PRECISION_BITS -1);
for (x = xmin; x < xmax; x++) {
ss0 += ((UINT8) imIn->image[yy][x*4 + 0]) * k[x - xmin];
ss1 += ((UINT8) imIn->image[yy][x*4 + 1]) * k[x - xmin];
ss2 += ((UINT8) imIn->image[yy][x*4 + 2]) * k[x - xmin];
}
imOut->image[yy][xx*4 + 0] = clip8(ss0);
imOut->image[yy][xx*4 + 1] = clip8(ss1);
imOut->image[yy][xx*4 + 2] = clip8(ss2);
}
} else {
for (xx = 0; xx < xsize; xx++) {
xmin = xbounds[xx * 2 + 0];
xmax = xbounds[xx * 2 + 1];
k = &kk[xx * kmax];
ss0 = ss1 = ss2 = ss3 = 1 << (PRECISION_BITS -1);
for (x = xmin; x < xmax; x++) {
ss0 += ((UINT8) imIn->image[yy][x*4 + 0]) * k[x - xmin];
ss1 += ((UINT8) imIn->image[yy][x*4 + 1]) * k[x - xmin];
ss2 += ((UINT8) imIn->image[yy][x*4 + 2]) * k[x - xmin];
ss3 += ((UINT8) imIn->image[yy][x*4 + 3]) * k[x - xmin];
}
imOut->image[yy][xx*4 + 0] = clip8(ss0);
imOut->image[yy][xx*4 + 1] = clip8(ss1);
imOut->image[yy][xx*4 + 2] = clip8(ss2);
imOut->image[yy][xx*4 + 3] = clip8(ss3);
} }
imOut->image[yy][xx*4 + 0] = clip8(ss0);
imOut->image[yy][xx*4 + 3] = clip8(ss1);
} }
break; } else if (imIn->bands == 3) {
for (xx = 0; xx < xsize; xx++) {
xmin = xbounds[xx * 2 + 0];
xmax = xbounds[xx * 2 + 1];
k = &kk[xx * kmax];
ss0 = ss1 = ss2 = 1 << (PRECISION_BITS -1);
for (x = xmin; x < xmax; x++) {
ss0 += ((UINT8) imIn->image[yy][x*4 + 0]) * k[x - xmin];
ss1 += ((UINT8) imIn->image[yy][x*4 + 1]) * k[x - xmin];
ss2 += ((UINT8) imIn->image[yy][x*4 + 2]) * k[x - xmin];
}
imOut->image[yy][xx*4 + 0] = clip8(ss0);
imOut->image[yy][xx*4 + 1] = clip8(ss1);
imOut->image[yy][xx*4 + 2] = clip8(ss2);
}
} else {
for (xx = 0; xx < xsize; xx++) {
xmin = xbounds[xx * 2 + 0];
xmax = xbounds[xx * 2 + 1];
k = &kk[xx * kmax];
ss0 = ss1 = ss2 = ss3 = 1 << (PRECISION_BITS -1);
for (x = xmin; x < xmax; x++) {
ss0 += ((UINT8) imIn->image[yy][x*4 + 0]) * k[x - xmin];
ss1 += ((UINT8) imIn->image[yy][x*4 + 1]) * k[x - xmin];
ss2 += ((UINT8) imIn->image[yy][x*4 + 2]) * k[x - xmin];
ss3 += ((UINT8) imIn->image[yy][x*4 + 3]) * k[x - xmin];
}
imOut->image[yy][xx*4 + 0] = clip8(ss0);
imOut->image[yy][xx*4 + 1] = clip8(ss1);
imOut->image[yy][xx*4 + 2] = clip8(ss2);
imOut->image[yy][xx*4 + 3] = clip8(ss3);
}
}
}
}
ImagingSectionLeave(&cookie);
free(kk);
free(xbounds);
return imOut;
}
Imaging
ImagingResampleHorizontal_32bpc(Imaging imIn, int xsize, struct filter *filterp)
{
ImagingSectionCookie cookie;
Imaging imOut;
double support, scale, filterscale;
double center, ww, ss;
int xx, yy, x, kmax, xmin, xmax;
int *xbounds;
double *k, *kk;
/* prepare for horizontal stretch */
filterscale = scale = (float) imIn->xsize / xsize;
if (filterscale < 1.0) {
filterscale = 1.0;
}
/* determine support size (length of resampling filter) */
support = filterp->support * filterscale;
/* maximum number of coofs */
kmax = (int) ceil(support) * 2 + 1;
// check for overflow
if (xsize > SIZE_MAX / (kmax * sizeof(double)))
return (Imaging) ImagingError_MemoryError();
// sizeof(double) should be greater than 0 as well
if (xsize > SIZE_MAX / (2 * sizeof(double)))
return (Imaging) ImagingError_MemoryError();
/* coefficient buffer */
kk = malloc(xsize * kmax * sizeof(double));
if ( ! kk)
return (Imaging) ImagingError_MemoryError();
xbounds = malloc(xsize * 2 * sizeof(int));
if ( ! xbounds) {
free(kk);
return (Imaging) ImagingError_MemoryError();
}
for (xx = 0; xx < xsize; xx++) {
k = &kk[xx * kmax];
center = (xx + 0.5) * scale;
ww = 0.0;
ss = 1.0 / filterscale;
xmin = (int) floor(center - support);
if (xmin < 0)
xmin = 0;
xmax = (int) ceil(center + support);
if (xmax > imIn->xsize)
xmax = imIn->xsize;
for (x = xmin; x < xmax; x++) {
double w = filterp->filter((x - center + 0.5) * ss);
k[x - xmin] = w;
ww += w;
}
for (x = 0; x < xmax - xmin; x++) {
if (ww != 0.0)
k[x] /= ww;
}
xbounds[xx * 2 + 0] = xmin;
xbounds[xx * 2 + 1] = xmax;
}
imOut = ImagingNew(imIn->mode, xsize, imIn->ysize);
if ( ! imOut) {
free(kk);
free(xbounds);
return NULL;
}
ImagingSectionEnter(&cookie);
/* horizontal stretch */
for (yy = 0; yy < imOut->ysize; yy++) {
switch(imIn->type) {
case IMAGING_TYPE_INT32: case IMAGING_TYPE_INT32:
/* 32-bit integer */ /* 32-bit integer */
for (xx = 0; xx < xsize; xx++) { for (xx = 0; xx < xsize; xx++) {
@ -242,8 +325,8 @@ ImagingResampleHorizontal(Imaging imIn, int xsize, struct filter *filterp)
k = &kk[xx * kmax]; k = &kk[xx * kmax];
ss = 0.0; ss = 0.0;
for (x = xmin; x < xmax; x++) for (x = xmin; x < xmax; x++)
ss += (IMAGING_PIXEL_I(imIn, x, yy)) * k[x - xmin]; ss += IMAGING_PIXEL_I(imIn, x, yy) * k[x - xmin];
IMAGING_PIXEL_I(imOut, xx, yy) = (int) ss; IMAGING_PIXEL_I(imOut, xx, yy) = lround(ss);
} }
break; break;
case IMAGING_TYPE_FLOAT32: case IMAGING_TYPE_FLOAT32:
@ -258,7 +341,6 @@ ImagingResampleHorizontal(Imaging imIn, int xsize, struct filter *filterp)
IMAGING_PIXEL_F(imOut, xx, yy) = ss; IMAGING_PIXEL_F(imOut, xx, yy) = ss;
} }
break; break;
}
} }
} }
ImagingSectionLeave(&cookie); ImagingSectionLeave(&cookie);
@ -274,12 +356,26 @@ ImagingResample(Imaging imIn, int xsize, int ysize, int filter)
Imaging imTemp1, imTemp2, imTemp3; Imaging imTemp1, imTemp2, imTemp3;
Imaging imOut; Imaging imOut;
struct filter *filterp; struct filter *filterp;
Imaging (*ResampleHorizontal)(Imaging imIn, int xsize, struct filter *filterp);
if (strcmp(imIn->mode, "P") == 0 || strcmp(imIn->mode, "1") == 0) if (strcmp(imIn->mode, "P") == 0 || strcmp(imIn->mode, "1") == 0)
return (Imaging) ImagingError_ModeError(); return (Imaging) ImagingError_ModeError();
if (imIn->type == IMAGING_TYPE_SPECIAL) if (imIn->image8) {
return (Imaging) ImagingError_ModeError(); ResampleHorizontal = ImagingResampleHorizontal_8bpc;
} else {
switch(imIn->type) {
case IMAGING_TYPE_UINT8:
ResampleHorizontal = ImagingResampleHorizontal_8bpc;
break;
case IMAGING_TYPE_INT32:
case IMAGING_TYPE_FLOAT32:
ResampleHorizontal = ImagingResampleHorizontal_32bpc;
break;
default:
return (Imaging) ImagingError_ModeError();
}
}
/* check filter */ /* check filter */
switch (filter) { switch (filter) {
@ -299,7 +395,7 @@ ImagingResample(Imaging imIn, int xsize, int ysize, int filter)
} }
/* two-pass resize, first pass */ /* two-pass resize, first pass */
imTemp1 = ImagingResampleHorizontal(imIn, xsize, filterp); imTemp1 = ResampleHorizontal(imIn, xsize, filterp);
if ( ! imTemp1) if ( ! imTemp1)
return NULL; return NULL;
@ -310,7 +406,7 @@ ImagingResample(Imaging imIn, int xsize, int ysize, int filter)
return NULL; return NULL;
/* second pass */ /* second pass */
imTemp3 = ImagingResampleHorizontal(imTemp2, ysize, filterp); imTemp3 = ResampleHorizontal(imTemp2, ysize, filterp);
ImagingDelete(imTemp2); ImagingDelete(imTemp2);
if ( ! imTemp3) if ( ! imTemp3)
return NULL; return NULL;