Изменение размера изображения vStack Overflow

Некоторый простой код для обработки размеров переносится:

Для всех случаев применяется следующая легенда:

• w1 — ширина исходного изображения
• h1 — высота исходного изображения
• пикселей — массив int с данными пикселей
• w2 — желаемая ширина
• h2 — желаемая высота
• retval — это возвращаемое значение, это новый массив пикселей, который содержит манипулируемое изображение.

Для линейной интерполяции:

Я не могу найти это на моем диске в настоящее время (проблемы с новым жестким диском), поэтому включил Bilinear:

Для билинейной интерполяции:

Билинейная интерполяционная функция

int* resizeBilinear(int* pixels, int w1, int h1, int w2, int h2)
{
int* retval = new int[w2*h2] ;
int a, b, c, d, x, y, index ;
float x_ratio = ((float)(w1-1))/w2 ;
float y_ratio = ((float)(h1-1))/h2 ;
float x_diff, y_diff, blue, red, green ;
int offset = 0 ;
for (int i=0;i<h2;i++) {
for (int j=0;j<w2;j++) {
x = (int)(x_ratio * j) ;
y = (int)(y_ratio * i) ;
x_diff = (x_ratio * j) - x ;
y_diff = (y_ratio * i) - y ;
index = (y*w1+x) ;
a = pixels[index] ;
b = pixels[index+1] ;
c = pixels[index+w1] ;
d = pixels[index+w1+1] ;

// blue element
// Yb = Ab(1-w1)(1-h1) + Bb(w1)(1-h1) + Cb(h1)(1-w1) + Db(wh)
blue = (a&0xff)*(1-x_diff)*(1-y_diff) + (b&0xff)*(x_diff)*(1-y_diff) +
(c&0xff)*(y_diff)*(1-x_diff)   + (d&0xff)*(x_diff*y_diff);

// green element
// Yg = Ag(1-w1)(1-h1) + Bg(w1)(1-h1) + Cg(h1)(1-w1) + Dg(wh)
green = ((a>>8)&0xff)*(1-x_diff)*(1-y_diff) + ((b>>8)&0xff)*(x_diff)*(1-y_diff) +
((c>>8)&0xff)*(y_diff)*(1-x_diff)   + ((d>>8)&0xff)*(x_diff*y_diff);

// red element
// Yr = Ar(1-w1)(1-h1) + Br(w1)(1-h1) + Cr(h1)(1-w1) + Dr(wh)
red = ((a>>16)&0xff)*(1-x_diff)*(1-y_diff) + ((b>>16)&0xff)*(x_diff)*(1-y_diff) +
((c>>16)&0xff)*(y_diff)*(1-x_diff)   + ((d>>16)&0xff)*(x_diff*y_diff);

retval[offset++] =
0xff000000 | // hardcoded alpha
((((int)red)<<16)&0xff0000) |
((((int)green)<<8)&0xff00) |
((int)blue) ;
}
}
return retval;
}

Для ближайшего соседа:

int* resizePixels(int* pixels,int w1,int h1,int w2,int h2)
{
int* retval = new int[w2*h2] ;
// EDIT: added +1 to remedy an early rounding problem
int x_ratio = (int)((w1<<16)/w2) +1;
int y_ratio = (int)((h1<<16)/h2) +1;
//int x_ratio = (int)((w1<<16)/w2) ;
//int y_ratio = (int)((h1<<16)/h2) ;
int x2, y2 ;
for (int i=0;i<h2;i++) {
for (int j=0;j<w2;j++) {
x2 = ((j*x_ratio)>>16) ;
y2 = ((i*y_ratio)>>16) ;
retval[(i*w2)+j] = pixels[(y2*w1)+x2] ;
}
}
return retval;
}

Теперь вышеприведенный код разработан так, чтобы быть переносимым и должен работать с очень небольшими изменениями в C ++, C, C # и Java (я использовал приведенный выше код для всех 4 при необходимости), что устраняет необходимость во внешней библиотеке и позволяет вам обрабатывать любой массив пикселей, если вы можете представить их в формате для кода выше.

Чтобы поместить обработанное изображение в середину черного фона, все, что вам нужно сделать, это скопировать данные в массив оригинала в нужных местах и ​​заполнить все остальные местоположения значениями черного цвета 🙂

Надеюсь, что это помогает, поскольку у меня нет времени комментировать все это в настоящее время, однако я могу, если необходимо, быть позже, сегодня или завтра 🙂