Recommended Technique

An effective approach would involve implementing a flood fill algorithm.

Code Example

import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.geometry.Point2D;
import javafx.scene.Scene;
import javafx.scene.image.*;
import javafx.scene.layout.HBox;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

import java.util.Stack;

public class UnleashTheKraken extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(final Stage stage) {
        Image original = new Image(
            "http://s12.postimg.org/wofhjvy2h/image_2.jpg"
        );

        WritableImage updated = new WritableImage(
                original.getPixelReader(),
                (int) original.getWidth(),
                (int) original.getHeight()
        );

        Kraken kraken = new Kraken(updated, Color.WHITE);
        kraken.unleash(new Point2D(40,   40), Color.BLUE);
        kraken.unleash(new Point2D(40,  100), Color.RED);
        kraken.unleash(new Point2D(100, 100), Color.GREEN);
        kraken.unleash(new Point2D(120,  40), Color.YELLOW);

        ImageView originalView = new ImageView(original);
        ImageView filledView   = new ImageView(updated);

        HBox layout = new HBox(10, originalView, filledView);
        layout.setPadding(new Insets(10));
        stage.setScene(new Scene(layout));
        stage.show();
    }

    class Kraken {
        private final WritableImage img;
        private final Color targetColor;

        // color matching tolerance level (from 0 to 1);
        private final double E = 0.3;

        public Kraken(WritableImage image, Color targetColor) {
            this.img = image;
            this.targetColor = targetColor;
        }

        public void unleash(Point2D start, Color shade) {
            PixelReader reader = img.getPixelReader();
            PixelWriter writer = img.getPixelWriter();

            Stack<Point2D> stack = new Stack<>();
            stack.push(start);

            while (!stack.isEmpty()) {
                Point2D point = stack.pop();
                int x = (int) point.getX();
                int y = (int) point.getY();
                if (filled(reader, x, y)) {
                    continue;
                }

                writer.setColor(x, y, shade);

                push(stack, x - 1, y - 1);
                push(stack, x - 1, y    );
                push(stack, x - 1, y + 1);
                push(stack, x    , y + 1);
                push(stack, x + 1, y + 1);
                push(stack, x + 1, y    );
                push(stack, x + 1, y - 1);
                push(stack, x,     y - 1);
            }
        }

        private void push(Stack<Point2D> stack, int x, int y) {
            if (x < 0 || x > img.getWidth() ||
                y < 0 || y > img.getHeight()) {
                return;
            }

            stack.push(new Point2D(x, y));
        }

        private boolean filled(PixelReader reader, int x, int y) {
            Color color = reader.getColor(x, y);

            return !withinTolerance(color, targetColor, E);
        }

        private boolean withinTolerance(Color a, Color b, double epsilon) {
            return
                    withinTolerance(a.getRed(),   b.getRed(),   epsilon) &&
                    withinTolerance(a.getGreen(), b.getGreen(), epsilon) &&
                    withinTolerance(a.getBlue(),  b.getBlue(),  epsilon);
        }

        private boolean withinTolerance(double a, double b, double epsilon) {
            return Math.abs(a - b) < epsilon;
        }
    }
}

Responses to additional inquiries

Wouldn't the process of coloring each pixel be time-consuming?

Indeed, each pixel needs to be colored individually in this context. This granular control over pixels is essential for achieving the desired shading effect on images. In computer graphics, manipulating individual pixels is often necessary for precise visual rendering.

Is this method efficient in terms of coloring images?

The provided code demonstrates near-instantaneous coloring on the sample image provided. While it may consume some memory space, all flood fill algorithms require memory utilization. For enhanced efficiency, more advanced and complex algorithms can be employed from resources like the linked Wikipedia page, depending on specific requirements.

Alternative Strategy

If you possess stencil shapes for different regions, applying ColorAdjust effects stacked on stencils could present an alternative. Utilizing hardware-accelerated effects such as ColorAdjust offers optimized performance. However, this approach assumes prior knowledge of the stencil shapes for application, making it less universal than the flood fill technique.

Creating a circle shape with coordinates x, y, and radius r.
Creating a rectangle shape with coordinates x, y, width w, and height h.
Subtracting the rectangle from the circle to create a new region, essentially "cutting" the rectangle out of the circle.
Performing this subtraction process twice for each piece needed.
Setting the fill color of the new region to be blue.
Adding the shape to a node and defining its translation accordingly.

This method involves removing the overlapping area of the circle where the rectangle is positioned.