Scale 2D-Array using Bicubic Interpolation

Question

I want to scale an arbitrary double[][] to another double[][] with different dimensions. The values of the resulting array should be calculated based on the input array using bicubic interpolation.

I know this was done in image processing for decades now, but I was unable to find a library or at least a working code snippet that works for any 2d-array rather than some specific image objects, so that's why I'm asking here.

More specific requirements:

As far as I've understood, the value of any point between the corners of a 3x3-grid can be calculated directly using bicubic interpolation, so the first function I would need is something like

double interpolate(double[][] grid3by3, double x, double y)`

where x and y are between 0.0 and 1.0

The next step would of course be to ease this process so the 3x3 grid is chosen for every point automatically and I can get something like

`double[][] interpolate(double[][] input, int newWidth, int newHeight)`

This will get me a new array with the specified dimensions but with the same borders as the input array.

Where I actually want to get is this:

`double[][] interpolate(double[][] input, int newWidth, int newHeight,
                        double minX, double minY, double maxX, double maxY)`

The min and max values define a bounding box so I can get a subset of the initial array which does not necessarily need to start or end at an exact index value of the input array (e.g. a corner can be at (5,3) or (5.25, 3.7), so you can't just cut off the input array at some index value). This bounding box will become the extent of the new array and the values are interpolated from the input array.

Oh, and just FYI: This is about digital elevation models, so please tell me if my approach is totally wrong in the first place ;)

Answer 1

Just wanted to share how I solved the problem (or rather, I didn't):

For a while, I tried to get my own bicubic interpolation algorithms started (get some inspiration here), and at some point, it even looked like it would actually work, and if you just want a decent approximation to work with numbers, it's probably fine.

But: If you scale an image with you fancy new algorithm, you will see how crappy the results actually are. So unless you really get the math behind it and you know what you're doing (and you don't, because that's why you read this), don't try and code it yourself.

And here's my workaround: Get ImageJ and do something like this:

// works all the same for: byte, short, int
float[] myData;     
// create a new image. change 32 to 16 for short or 8 for byte
ImageStack stack = ImageStack.create(width, height, 1, 32);
stack.setPixels(myData, 1);
ImageProcessor processor = new ImagePlus("", stack).getProcessor();
// crop and scale
processor.setRoi(x, y, rwidth, rheight);
ImageProcessor result = processor.crop().resize(newWidth, newHeight);
// retrieve results
float[] myScaledData = (float[]) result.getPixels();

I know, it's not what it's intended for, and unfortunately, there are no functions for 64 bit datatypes, but the results are of high quality and ImageJ is not that much of a weight to carry around... still, you could copy and paste the relevant code parts, ImageJ is in the public domain.