Би-кубический алгоритм изменения размера изображения

Question

Я пытался узнать об алгоритмах изменения размера изображения, таких как алгоритмы ближайшего соседа, би-кубические и билинейные интерполяционные алгоритмы. Я немного изучил математику, и теперь я смотрю на существующие реализации, чтобы понять и оценить, как они работают.

Я начал с this implementation Двухуровневое изменение размера, которое я нашел в коде Google, который использует OpenCV, и предоставляет тестовый и примерный код. Я использовал его в качестве отправной точки для моей собственной реализации, которая не использует OpenCV, а просто работает на сырой растрового изображения, содержащегося в std::vector<unsigned char>:

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 components = 3; 
    const int bytes_per_row = src_width * components; 

    const int components2 = components; 
    const int bytes_per_row2 = dest_width * components; 

    int a, b, c, d, index; 
    unsigned char Ca, Cb, Cc; 
    unsigned char C[5]; 
    unsigned char d0, d2, d3, a0, a1, a2, a3; 

    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; 

      index = y * bytes_per_row + x * components; 
      a = y * bytes_per_row + (x + 1) * components; 
      b = (y + 1) * bytes_per_row + x * components; 
      c = (y + 1) * bytes_per_row + (x + 1) * components; 

      for (int k = 0; k < 3; ++k) 
      { 
       for (int jj = 0; jj <= 3; ++jj) 
       { 
        d0 = in[(y - 1 + jj) * bytes_per_row + (x - 1) * components + k] - in[(y - 1 + jj) * bytes_per_row + (x) * components + k]; 
        d2 = in[(y - 1 + jj) * bytes_per_row + (x + 1) * components + k] - in[(y - 1 + jj) * bytes_per_row + (x) * components + k]; 
        d3 = in[(y - 1 + jj) * bytes_per_row + (x + 2) * components + k] - in[(y - 1 + jj) * bytes_per_row + (x) * components + k]; 
        a0 = in[(y - 1 + jj) * bytes_per_row + (x) * components + k]; 
        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; 
        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; 
        Cc = a0 + a1 * dy + a2 * dy * dy + a3* dy * dy * dy; 
        out[i * bytes_per_row2 + j * components2 + k] = Cc; 
       } 
      } 
     } 
    } 

    return out; 
} 

Теперь, насколько я могу видеть, , эта реализация фатально ущербной, из-за линии:

d0 = in[(y - 1 + jj) * bytes_per_row + (x - 1) * components + k] - in[(y - 1 + jj) * bytes_per_row + (x) * components + k]; 

Мне кажется, что эта линия будет всегда доступ к индексу массива вне пределов, когда y is 0. И y всегда будет 0 изначально, потому что y инициализируется y = ty * i, а i - переменная итератора, начинающаяся с 0. Так как y всегда начинается с 0, выражение (y - 1 + jj) * bytes_per_row + (x - 1) * components + k (которое используется для вычисления ИНДЕКСА МАШИН) всегда будет отрицательным. И ... очевидно, что индекс отрицательного массива недействителен.

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

Answer 1

Один из способов сделать это, чтобы определить GetPixel функция():

GetPixel(int x, int y, int channel) 
{ 
    if (x >= 0 && x <= width-1) 
     if (y >=0 && y <= height-1) 
     return QueriedPixelFromImage(x,y,channel); 
    return 0; // out of bounds 
} 

Вы замените

d0 = in[(y - 1 + jj) * bytes_per_row + (x - 1) * components + k] 

по

d0 = GetPixel(x-1,y-1+jj,k) 

Answer 2

Я побежал некоторый тестовый код, чтобы убедиться, что я ничего не хватает, но, насколько я вижу, что вы действительно правильно:

#include <iostream> 

int main() 
{ 

    int components = 3; 

    const float tx = 200/50; 
    const float ty = 200/50 ; 
    int bytes_per_row = 1000 ; 

    for (int i = 0; i < 5; ++i) 
    { 
    for (int j = 0; j < 5; ++j) 
    { 
     const int x = int(tx * j); 
     const int y = int(ty * i); 

     for (int k = 0; k < 3; ++k) 
     { 
      for (int jj = 0; jj <= 3; ++jj) 
      { 
       std::cout << "calc: " << (y - 1 + jj) * bytes_per_row + (x - 1) * components + k << std::endl ; 
      } 
     } 
    } 
    } 
} 

Я посмотрел на код на сайте вы предоставили и ему не похоже на очень большой проект. Поэтому, возможно, вам следует связаться с разработчиками проекта и посмотреть, не помогут ли они. Существует контактный адрес электронной почты на первой странице http://code.google.com/a/eclipselabs.org/p/bicubic-interpolation-image-processing/