Image Interpolation - Need different approach

Question

I'm having problems with built in Java image interpolation methods and haven't had any success finding a way to create my own, or using a different existing one. Basically I'd like to interpolate using a peak-picking method, similar to nearest neighbor except that it will consider all neighbors and take the value that has the highest alpha value. The overall goal is to never throw away the highest value when scaling down. An example would be an image that is 2x4:
[120][50][75][150]
[100][80][100][10]
If I scaled the image down to 2x2 the resulting image would look like:
[120][150]
[100][100]
The values above represent the alpha values in each pixel. Not sure if this "peak picking" method has a mathematical name so I'm not sure what to search for. Any help would be greatly appreciated.

Answer 1

That's not really similar to nearest neighbor at all, but here's a start
    public static BufferedImage customResize(BufferedImage src,
                                            int targetWidth,
                                            int targetHeight) {
        BufferedImage scaled = new BufferedImage(targetWidth,
                                                 targetHeight,
                                                 BufferedImage.TYPE_INT_ARGB);
        int srcWidth = src.getWidth();
        int srcHeight = src.getHeight();
        float ratioX = ((float) srcWidth) / targetWidth;
        float ratioY = ((float) srcHeight) / targetHeight;
        for (int x = 0; x < srcWidth; x++) {
            for (int y = 0; y < srcHeight; y++) {
                int beginNearestX = (int) Math.floor((x - .5f) * ratioX);
                int endNearestX = (int) Math.ceil((x + .5f) * ratioX);
                int beginNearestY = (int) Math.floor((y - .5f) * ratioY);
                int endNearestY = (int) Math.ceil((y + .5f) * ratioY);
                int peakPickARGB = 0;
                int peakAlpha = -1;
                /*traverse the area of pixels in the source image that are
                 *mapped to the pixel in the scaled image*/
                for (int x2 = beginNearestX; x2 <= endNearestX; x2++) {
                    for (int y2 = beginNearestY; y2 <= endNearestY; y2++) {
                        if (x2 < 0 || x2 > srcWidth ||
                                y2 < 0 || y2 > srcHeight)
                            continue;
                        int srcRGB = src.getRGB(x2, y2);
                        int alpha = (srcRGB << 24) & 0xff;
                        if (alpha > peakAlpha) {
                            peakAlpha = alpha;
                            peakPickARGB = srcRGB;
                //set the the "peak-pick"
                scaled.setRGB(x, y, peakPickARGB);
        return scaled;
    }I tried to keep the code simple so you can see how it might be done, but there are certainly some good optimizations that can be made. And this "peak-pick" interpolation won't really work well when scalling up an image.