public class Node {

    public final int NUMBER_OF_NEIGHBOURS;
    private int height;
    private char status;

    private Node[] neighbours;

    public Node(int height) {
        this(height, 4);
    }

    public Node(int height, int NUMBER_OF_NEIGHBOURS) {
        this.NUMBER_OF_NEIGHBOURS = NUMBER_OF_NEIGHBOURS;
        this.height = height;
        this.neighbours = new Node[this.NUMBER_OF_NEIGHBOURS];
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public void setNeighbours(Node[] neighbours) {
        this.neighbours = neighbours;
    }

    public Node getNeighbour(int neighbour) {
        return neighbours[neighbour];
    }

    public void setNeighbour(int neighbour, Node node) {
        this.neighbours[neighbour] = node;
    }

    public char getStatus() {
        return status;
    }

    public void setStatus(char status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return Integer.toString(this.height);
    }
}

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.WritableRaster;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class GrayRgbBmpArray {

    public final int mask = 0b00000000_00000000_00000000_11111111;
    public int[][] imageInByte;
    public int[][] outputArray;
    private String fullInputFileName;
    private String fullOutputFileName;
    private BufferedImage originalImage;

    public GrayRgbBmpArray(String fullInputFileName, String fullOutputFileName) {
        this.fullInputFileName = fullInputFileName;
        this.fullOutputFileName = fullOutputFileName;
    }

    static BufferedImage deepCopy(BufferedImage bi) {
        ColorModel cm = bi.getColorModel();
        boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
        WritableRaster raster = bi.copyData(null);
        //System.out.println(cm.toString() + " " + raster.toString());
        return new BufferedImage(cm, raster, isAlphaPremultiplied, null);
    }

    public void readToArray() {
        try {
            originalImage = ImageIO.read(new File(fullInputFileName));
            imageInByte = new int[originalImage.getHeight()][originalImage.getWidth()];
            outputArray = new int[originalImage.getHeight()][originalImage.getWidth()];
            int input, blue_channel, invert;
            for (int i = 0; i< originalImage.getHeight(); i++) {
                for (int k = 0; k < originalImage.getWidth(); k++) {
                    input = originalImage.getRGB(k, i);
                    //System.out.println(Integer.toBinaryString(input));
                    blue_channel =  input & mask;
                    invert = blue_channel ^ mask;
                    //System.out.println(invert);
                    imageInByte[i][k] = invert;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void writeToFile(int underWaterColorX, int  underWaterColorY) {
        if (outputArray == null || outputArray.length == 0 || outputArray[0].length == 0) {
            System.out.println("Нет данных для вывода в файл");
            return;
        }

        int height = outputArray.length;
        int width = outputArray[0].length;
        int blue_channel;
        // координаты пикселя исходного изображения с которого берется цвет для закраски затопленных плиток
        int underWaterColor = originalImage.getRGB(underWaterColorX, underWaterColorY);
        // результирующую картинку создаем как копию исходной
        BufferedImage image = deepCopy(originalImage);

        for (int i = 0; i < height; i++) {
            for (int k = 0; k < width; k++) {
                if (outputArray[i][k] == -1) {
                    // для затопленных плиток высота установлена в -1
                    image.setRGB(k,i, underWaterColor);
                } else {
                    blue_channel = outputArray[i][k]^mask;
                    image.setRGB(k,i, 0b11111111_00000000_00000000_00000000
                            | blue_channel << 16 | blue_channel << 8 | blue_channel);
                }
            }
        }

        try {
            ImageIO.write(image, "bmp", new FileOutputStream(fullOutputFileName));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    public static int[][] Calculate(int[][] inputArray, int oceanLevel, int maxLevel) {
        // oceanLevel - уровень океана, ячейки граничащие с океаном на этом уровне сухие
        // maxLevel - максимальный уровень подъема воды
        if (inputArray == null || oceanLevel < 0 || maxLevel < oceanLevel) {
            System.out.println("Неконсистентные параметры");
            return null;
        }

        // массив четырехсвязных узлов (плиток)
        int height = inputArray.length;  // строки
        int width = inputArray[0].length; // столбцы
        Node[][] nodes = new Node[height][width];

        int underWater = oceanLevel - 1;
        int maxIslandLevel = 0;

        // заполняем массив узлами
        for (int i = 0; i < height; i++ ) {
            for (int k = 0; k < width; k++) {
                nodes[i][k] = new Node(inputArray[i][k]);
                nodes[i][k].setStatus('n');  // статус еще не определялся
                // определяем максимальную высоту (уровень) острова
                if (inputArray[i][k] > maxIslandLevel) {
                    maxIslandLevel = inputArray[i][k];
                }
            }
        }

        // если заданный уровень океана выше уровня острова, нет смысла считать пустые слои
        int startLevel;
        if (maxIslandLevel < maxLevel) {
            startLevel = maxIslandLevel;
        } else {
            startLevel = maxLevel;
        }

        // записываем связи узлов
        for (int i = 0; i < height; i++ ) {
            for (int k = 0; k < width; k++) {
                nodes[i][k].setNeighbours(new Node[] {  (k > 0) ? nodes[i][k-1] : null,
                                                        (i > 0) ? nodes[i-1][k] : null,
                                                        (k+1 < width) ? nodes[i][k+1] : null,
                                                        (i+1 < height) ? nodes[i+1][k] : null } );
            }
        }

        char st;  // переменная для кеширования статуса
        Node tmpNode; // переменная для кеширования узла
        Node nextNode; // в эту переменную сохраняем следующий узел при обходе периметра
        Node neighbourNode; // переменная для перебора соседей

        Queue<Node> queue = new LinkedList<>();
        for (int currentLevel = startLevel; currentLevel > underWater ; currentLevel--) {
            // на каждом уровне для каждой плитки ниже текущего уровня от периметра проводим поиск в ширину,
            // если она ниже текущего уровня и не имеет установленных постоянных статусов, то ставим временный
            // статус w - под водой, плитки раные текущему уровню или превышающие его не переходим
            // они являются барьером на текущем уровне
            queue.clear(); // очередь для поиска в ширину

            // обходим периметр и помещаем его в очередь на поиск в ширину
            tmpNode = nodes[0][0];
            int direction = 2; // начинаем идти вправо из нулевого узла
            while (tmpNode != null) {
                st = tmpNode.getStatus();
                if (st != 'D' && st != 'W' && tmpNode.getHeight() < currentLevel) {
                    tmpNode.setStatus('w');
                    queue.add(tmpNode);
                }

                nextNode = tmpNode.getNeighbour(direction);
                // если дошли до конца измерения, меняем направление на следующее
                if (nextNode == null) {
                    if (direction == 2) {
                        direction = 3;
                    }
                    else if (direction == 3)
                    {
                        direction = 0;
                    }
                    else if (direction == 0)
                    {
                        direction = 1;
                    } else {
                        break;
                    }
                    nextNode = tmpNode.getNeighbour(direction);
                }
                tmpNode = nextNode;
            }

            int processedNodes = queue.size();
            // выполняем для очереди поиск в ширину добавляя следующие узлы для обхода в очередь
            while (!queue.isEmpty()) {
                tmpNode = queue.poll();
                for (int j = 0; j < tmpNode.NUMBER_OF_NEIGHBOURS; j++) {
                    neighbourNode = tmpNode.getNeighbour(j);
                    if (neighbourNode == null) {
                        continue;
                    }

                    st = neighbourNode.getStatus();
                    if (st == 'w' || st == 'D' || st == 'W' || neighbourNode.getHeight() >= currentLevel) {
                        continue;
                    }
                    neighbourNode.setStatus('w');
                    queue.add(neighbourNode);
                    processedNodes++;
                }
            }

            System.out.println("Level = " + currentLevel + ",  processedNodes = " + processedNodes);

            // все плитки не имеющие постоянного статуса D (dry) или W (wet) и не имеющие временного
            // статуса w получают постоянный статус, статус w сбрасывается в u - unknown
            for (int i = 0; i < height; i++ ) {
                for (int k = 0; k < width; k++) {
                    tmpNode = nodes[i][k];
                    st = tmpNode.getStatus();
                    if (st == 'D' || st == 'W') {
                        continue;
                    }

                    if (tmpNode.getHeight() == currentLevel) {
                        tmpNode.setStatus('D');
                    } else if (st == 'w') {
                        tmpNode.setStatus('u');
                    } else if (currentLevel == maxLevel) {
                        tmpNode.setStatus('D');
                    } else {
                        tmpNode.setStatus('W');
                    }
                }
            }
        }

        for (int i = 0; i < height; i++ ) {
            for (int k = 0; k < width; k++) {
                // плитки не получившие постоянный статус и находящиеся ниже уровня океана
                tmpNode = nodes[i][k];
                st = tmpNode.getStatus();
                if (st != 'D' && st != 'W') {
                    tmpNode.setStatus('W');
                }
            }
        }

        // формируем результирующий массив
        int[][] outputArray = new int[height][width];
        for (int i = 0; i < height; i++ ) {
            for (int k = 0; k < width; k++) {
                tmpNode = nodes[i][k];
                if (tmpNode.getStatus() == 'W') {
                    outputArray[i][k] = -1;
                } else {
                    outputArray[i][k] = tmpNode.getHeight();
                }
            }
        }

        return outputArray;
    }
}

        // на входе нужен файл с 8-битной глубиной цвета и использованием 256 градаций серого, если хочется чтобы 
        // затопленные плитки имели цвет отличный от градаций серого, можно добавить цветной пиксель
        GrayRgbBmpArray grba = new GrayRgbBmpArray("C:\\temp\\test.bmp", "C:\\temp\\output.bmp");
        // считываем исходную картинку в массив
        grba.readToArray();
        // расчет, остаточный уровень океана может быть от 0 до 255, максимальный уровень подъема при наводнении от 0 до инта
        // если нужно затопить весь отсров уровень должен быть больше 255
        // можно устанавливать равные, тогда получим вид острова затопленного до определенной высоты
        // если собрать последовательно сверху такие срезы, то можно сделать гифку отлива))
        grba.outputArray = Island.Calculate(grba.imageInByte, 1, 260);
        // выводим результат в файл, цвет для затопленных плиток берется от пикселя исходной картинки с координатами (0,0)
        // можно указать любую другую координату для цветного пикселя в исходном файле
        grba.writeToFile(0, 0);