title: Bi-Cubic Interpolation Algorithm for Image Scaling
body: <p>I'm trying to write a basic bicubic resize algorithm to resize a 24-bit RGB bitmap.  I have a general understanding of <strong><a href="http://www.paulinternet.nl/?page=bicubic" rel="noreferrer">the math</a></strong> involved, and I'm using <a href="http://code.google.com/a/eclipselabs.org/p/bicubic-interpolation-image-processing/source/browse/trunk/libimage.c" rel="noreferrer"><strong>this implementation</strong></a> from Google Code as a guide.  I'm not using any external libraries here - I'm just experimenting with the algorithm itself.  The bitmap is represented as a plain <code>std::vector&lt;unsigned char&gt;</code>:</p>
  
  <pre><code>inline unsigned char getpixel(const std::vector&lt;unsigned char&gt;&amp; in, 
      std::size_t src_width, std::size_t src_height, unsigned x, unsigned y, int channel)
  {
      if (x &lt; src_width &amp;&amp; y &lt; src_height)
          return in[(x * 3 * src_width) + (3 * y) + channel];
  
      return 0;
  }
  
  std::vector&lt;unsigned char&gt; bicubicresize(const std::vector&lt;unsigned char&gt;&amp; in, 
      std::size_t src_width, std::size_t src_height, std::size_t dest_width, std::size_t dest_height)
  {
      std::vector&lt;unsigned char&gt; 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 &lt; dest_height; ++i)
      {
          for (int j = 0; j &lt; 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 &lt; 3; ++k)
              {
                  for (int jj = 0; jj &lt; 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;
  }
  </code></pre>
  
  <p><strong>Problem</strong>: When I use this algorithm to downscale an image, it works except the output image contains all black pixels on the right side for some reason, giving the appearance that it's been "cropped".</p>
  
  <p><strong>Example:</strong></p>
  
  <p>INPUT IMAGE:</p>
  
  <p><img src="https://i.stack.imgur.com/XMncK.jpg" alt="enter image description here"></p>
  
  <p>OUTPUT IMAGE:</p>
  
  <p><img src="https://i.stack.imgur.com/eDv92.jpg" alt="enter image description here">
  <br>
  <br>
  <strong><em>Question</em></strong>: <strong>Reviewing the algorithm, I can't see why this would happen.  Does anyone see the flaw here?</strong></p>