Bicubic Interpolation

/// <summary>
/// Bicubic resize algorithm suitable for use in Silverlight
/// </summary>
/// <param name="src"></param>
/// <param name="dest"></param>
/// <remarks>Original Source For This Function - http://www.codeproject.com/KB/recipes/aforge.aspx</remarks>
public static void resizeBicubic(System.Windows.Media.Imaging.WriteableBitmap src, WriteableBitmap dest)
{
    int height = src.PixelHeight;
    int width = src.PixelWidth;

    int newHeight = dest.PixelHeight;
    int newWidth = dest.PixelWidth;

    double xFactor = (double)width / newWidth;
    double yFactor = (double)height / newHeight;

    // coordinates of source points and cooefficiens
    double ox, oy, dx, dy, k1, k2;
    int ox1, oy1, ox2, oy2;
    // destination pixel values
    double r, g, b;
    // width and height decreased by 1
    int ymax = height - 1;
    int xmax = width - 1;

    int p;
    // RGB
    for (int y = 0; y < newHeight; y++)
    {
        // Y coordinates
        oy = (double)y * yFactor - 0.5f;
        oy1 = (int)oy;
        dy = oy - (double)oy1;

        for (int x = 0; x < newWidth; x++)
        {
            // X coordinates
            ox = (double)x * xFactor - 0.5f;
            ox1 = (int)ox;
            dx = ox - (double)ox1;

            // initial pixel value
            r = g = b = 0;

            for (int n = -1; n < 3; n++)
            {
                // get Y cooefficient
                k1 = BiCubicKernel(dy - (double)n);

                oy2 = oy1 + n;
                if (oy2 < 0)
                    oy2 = 0;
                if (oy2 > ymax)
                    oy2 = ymax;

                for (int m = -1; m < 3; m++)
                {
                    // get X cooefficient
                    k2 = k1 * BiCubicKernel((double)m - dx);

                    ox2 = ox1 + m;
                    if (ox2 < 0)
                        ox2 = 0;
                    if (ox2 > xmax)
                        ox2 = xmax;

                    // get pixel of original image
                   // p = src + oy2 * srcStride + ox2 * 3;
                    int srcPixel=src.Pixels[ox2+(width*oy2)];

                    r += k2 * ((srcPixel>>16) & 0xff);
                    g += k2 * ((srcPixel >>8) & 0xff);
                    b += k2 * (srcPixel & 0xff);
                }
            }

            
            dest.Pixels[x+(newWidth*y)]=(int)(0xff000000 | ((byte)r<<16) | ((byte)g<<8) |(byte) b);

        }
       
    }
}

public static double BiCubicKernel(double x)
{
    if (x > 2.0)
        return 0.0;

    double a, b, c, d;
    double xm1 = x - 1.0;
    double xp1 = x + 1.0;
    double xp2 = x + 2.0;

    a = (xp2 <= 0.0) ? 0.0 : xp2 * xp2 * xp2;
    b = (xp1 <= 0.0) ? 0.0 : xp1 * xp1 * xp1;
    c = (x <= 0.0) ? 0.0 : x * x * x;
    d = (xm1 <= 0.0) ? 0.0 : xm1 * xm1 * xm1;

    return (0.16666666666666666667 * (a - (4.0 * b) + (6.0 * c) - (4.0 * d)));
}