Бикубический алгоритм интерполяции для масштабирования изображения

Я пытаюсь написать основной алгоритм бикубического изменения размера для изменения размера 24-битного RGB-изображения. У меня есть общее понимание математика участвует, и я использую эта реализация из Google Code в качестве руководства. Я не использую здесь никаких внешних библиотек — я просто экспериментирую с самим алгоритмом. Растровое изображение представляется в виде простого std::vector<unsigned char>:

inline unsigned char getpixel(const std::vector<unsigned char>& in,
std::size_t src_width, std::size_t src_height, unsigned x, unsigned y, int channel)
{
if (x < src_width && y < src_height)
return in[(x * 3 * src_width) + (3 * y) + channel];

return 0;
}

std::vector<unsigned char> bicubicresize(const std::vector<unsigned char>& in,
std::size_t src_width, std::size_t src_height, std::size_t dest_width, std::size_t dest_height)
{
std::vector<unsigned char> out(dest_width * dest_height * 3);

const float tx = float(src_width) / dest_width;
const float ty = float(src_height) / dest_height;
const int channels = 3;
const std::size_t row_stride = dest_width * channels;

unsigned char C[5] = { 0 };

for (int i = 0; i < dest_height; ++i)
{
for (int j = 0; j < dest_width; ++j)
{
const int x = int(tx * j);
const int y = int(ty * i);
const float dx = tx * j - x;
const float dy = ty * i - y;

for (int k = 0; k < 3; ++k)
{
for (int jj = 0; jj < 4; ++jj)
{
const int z = y - 1 + jj;
unsigned char a0 = getpixel(in, src_width, src_height, z, x, k);
unsigned char d0 = getpixel(in, src_width, src_height, z, x - 1, k) - a0;
unsigned char d2 = getpixel(in, src_width, src_height, z, x + 1, k) - a0;
unsigned char d3 = getpixel(in, src_width, src_height, z, x + 2, k) - a0;
unsigned char a1 = -1.0 / 3 * d0 + d2 - 1.0 / 6 * d3;
unsigned char a2 = 1.0 / 2 * d0 + 1.0 / 2 * d2;
unsigned char a3 = -1.0 / 6 * d0 - 1.0 / 2 * d2 + 1.0 / 6 * d3;
C[jj] = a0 + a1 * dx + a2 * dx * dx + a3 * dx * dx * dx;

d0 = C[0] - C[1];
d2 = C[2] - C[1];
d3 = C[3] - C[1];
a0 = C[1];
a1 = -1.0 / 3 * d0 + d2 -1.0 / 6 * d3;
a2 = 1.0 / 2 * d0 + 1.0 / 2 * d2;
a3 = -1.0 / 6 * d0 - 1.0 / 2 * d2 + 1.0 / 6 * d3;
out[i * row_stride + j * channels + k] = a0 + a1 * dy + a2 * dy * dy + a3 * dy * dy * dy;
}
}
}
}

return out;
}

проблема: Когда я использую этот алгоритм для уменьшения масштаба изображения, он работает, за исключением того, что выходное изображение по какой-то причине содержит все черные пиксели с правой стороны, создавая впечатление, что оно было «обрезано».

Пример:

ВХОДНОЕ ИЗОБРАЖЕНИЕ:

введите описание изображения здесь

ВЫХОДНОЕ ИЗОБРАЖЕНИЕ:

введите описание изображения здесь

Вопрос: Пересматривая алгоритм, я не понимаю, почему это произошло. Кто-нибудь видит здесь недостаток?

10

Решение

старайтесь не менять ширину и высоту.

   for (int i = 0; i < dest_width; ++i)
{
for (int j = 0; j < dest_height; ++j)
12

Другие решения

Я предлагаю не использовать эту функцию, потому что она была написана очень плохо. Вам нужно сделать две свертки: сначала по координате X, а затем по Y. В этой функции все эти свертки создаются одновременно, что приводит к очень медленной работе. И если вы посмотрите на тело цикла jj, вы можете заметить, что вся вторая часть тела начинается с «d0 = C [0] — C [1];» может быть перемещен за пределы цикла jj, потому что только последняя итерация этого цикла вступает в силу для массива out [] (результаты всех предыдущих итераций будут перезаписаны).

2

Вы должны переключить x а также z когда ты звонишь getpixel, И в getpixel Вы должны индексировать массив, используя:

[(y * 3 * src_width) + (3 * x) + channel]
0

В getpixel(in, src_width, src_height, z, x, k):

z mean horizontal offset
x mean vertical offset

Так что просто нужно пропатчить getpixel ниже приведен исправленный код:

inline unsigned char getpixel(const std::vector<unsigned char>& in,
std::size_t src_width, std::size_t src_height, unsigned y, unsigned x, int channel)
{
if (x < src_width && y < src_height)
return in[(y * 3 * src_width) + (3 * x) + channel];

return 0;
}

std::vector<unsigned char> bicubicresize(const std::vector<unsigned char>& in,
std::size_t src_width, std::size_t src_height, std::size_t dest_width, std::size_t dest_height)
{
std::vector<unsigned char> out(dest_width * dest_height * 3);

const float tx = float(src_width) / dest_width;
const float ty = float(src_height) / dest_height;
const int channels = 3;
const std::size_t row_stride = dest_width * channels;

unsigned char C[5] = { 0 };

for (int i = 0; i < dest_height; ++i)
{
for (int j = 0; j < dest_width; ++j)
{
const int x = int(tx * j);
const int y = int(ty * i);
const float dx = tx * j - x;
const float dy = ty * i - y;

for (int k = 0; k < 3; ++k)
{
for (int jj = 0; jj < 4; ++jj)
{
const int z = y - 1 + jj;
unsigned char a0 = getpixel(in, src_width, src_height, z, x, k);
unsigned char d0 = getpixel(in, src_width, src_height, z, x - 1, k) - a0;
unsigned char d2 = getpixel(in, src_width, src_height, z, x + 1, k) - a0;
unsigned char d3 = getpixel(in, src_width, src_height, z, x + 2, k) - a0;
unsigned char a1 = -1.0 / 3 * d0 + d2 - 1.0 / 6 * d3;
unsigned char a2 = 1.0 / 2 * d0 + 1.0 / 2 * d2;
unsigned char a3 = -1.0 / 6 * d0 - 1.0 / 2 * d2 + 1.0 / 6 * d3;
C[jj] = a0 + a1 * dx + a2 * dx * dx + a3 * dx * dx * dx;

d0 = C[0] - C[1];
d2 = C[2] - C[1];
d3 = C[3] - C[1];
a0 = C[1];
a1 = -1.0 / 3 * d0 + d2 -1.0 / 6 * d3;
a2 = 1.0 / 2 * d0 + 1.0 / 2 * d2;
a3 = -1.0 / 6 * d0 - 1.0 / 2 * d2 + 1.0 / 6 * d3;
out[i * row_stride + j * channels + k] = a0 + a1 * dy + a2 * dy * dy + a3 * dy * dy * dy;
}
}
}
}

return out;
}
0