画像スケーリングのための双立方補間アルゴリズム

Question

私は、24ビットRGBビットマップのサイズを変更するための基本バイキュービックサイズ変更アルゴリズムを作成しようとしています。 the mathの一般的な理解があり、Googleコードのthis implementationを参考にしています。私はここで外部ライブラリを使用していません - 私はアルゴリズム自体を実験しています。ビットマップは、プレーン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; 
} 

問題：私はイメージをダウンスケールするために、このアルゴリズムを使用すると、出力画像を与え、何らかの理由で、右側のすべての黒画素を含む除いて、それが動作しますそれが「切り取られた」外観。

例：

入力画像：

出力画像：

質問：アルゴリズムを見直すと、なぜこのようなことが起こるのかわかりません。誰にもこの欠陥が見えますか？

Answer 1

幅と高さを入れ替えないでください。

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

Answer 2

あなたがxとzあなたがgetpixelを呼び出すときに切り替える必要があり、かつgetpixelに、あなたは、インデックス配列使用すべきである：それは非常に悪い書かれていたので、私はこの機能を使用していないお勧め

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

Answer 3

。あなたは2つの畳み込みを作る必要があります：最初にX座標で次にYで。この関数では、これらすべての畳み込みは同時に非常に遅い作業につながります。そして、あなたがjjループボディを見ると、 "d0 = C [0] -C [1];"このループの最後の反復のみがout []配列に対して有効になるため（以前のすべての反復結果は上書きされるため）、jjループの外側に移動することができます。

getpixel(in, src_width, src_height, z, x, k)で

Answer 4

：

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; 
}