Oklab in "Posterize"

Author: lbalazscs

src/main/java/pixelitor/filters/Posterize.java

@@ -14,12 +14,16 @@
  * You should have received a copy of the GNU General Public License
  * along with Pixelitor. If not, see <http://www.gnu.org/licenses/>.
  */
+
 package pixelitor.filters;
 
+import pixelitor.filters.gui.EnumParam;
 import pixelitor.filters.gui.GroupedRangeParam;
 import pixelitor.filters.gui.IntChoiceParam;
 import pixelitor.filters.gui.RangeParam;
 import pixelitor.filters.lookup.RGBLookup;
+import pixelitor.filters.util.ColorSpace;
+import pixelitor.utils.ColorSpaces;
 import pixelitor.utils.Dithering;
 import pixelitor.utils.ImageUtils;
 
@@ -30,17 +34,26 @@
 import static pixelitor.utils.Texts.i18n;
 
 /**
- * Posterize filter
+ * The "Posterize" filter.
  */
 public class Posterize extends ParametrizedFilter {
     public static final String NAME = i18n("posterize");
 
     @Serial
     private static final long serialVersionUID = 4448706459360371642L;
 
-    private final RangeParam redLevels = new RangeParam(i18n("red"), 1, 2, 8);
-    private final RangeParam greenLevels = new RangeParam(i18n("green"), 1, 2, 8);
-    private final RangeParam blueLevels = new RangeParam(i18n("blue"), 1, 2, 8);
+    private final EnumParam<ColorSpace> colorSpace = ColorSpace.asParam();
+
+    private final RangeParam levels1 = new RangeParam(i18n("red"), 1, 2, 8);
+    private final RangeParam levels2 = new RangeParam(i18n("green"), 1, 2, 8);
+    private final RangeParam levels3 = new RangeParam(i18n("blue"), 1, 2, 8);
+
+    private final GroupedRangeParam levelsParam = new GroupedRangeParam("Levels",
+        new RangeParam[]{
+            levels1,
+            levels2,
+            levels3
+        }, true);
 
     private final RangeParam ditheringAmountParam = new RangeParam("Dithering Amount (%)", 0, 0, 100);
     private final IntChoiceParam ditheringMethodParam = Dithering.createDitheringChoices();
@@ -51,34 +64,171 @@ public Posterize() {
         ditheringAmountParam.setupEnableOtherIfNotZero(ditheringMethodParam);
 
         initParams(
-            new GroupedRangeParam("Levels",
-                new RangeParam[]{
-                    redLevels,
-                    greenLevels,
-                    blueLevels
-                }, true),
+            colorSpace,
+            levelsParam,
             ditheringAmountParam,
             ditheringMethodParam
         );
+
+        colorSpace.addOnChangeTask(this::updateSliders);
+    }
+
+    private void updateSliders() {
+        switch (colorSpace.getSelected()) {
+            case SRGB -> {
+                levels1.setName(i18n("red"));
+                levels2.setName(i18n("green"));
+                levels3.setName(i18n("blue"));
+            }
+            case OKLAB -> {
+                levels1.setName("Green-Red (a)");
+                levels2.setName("Blue-Yellow (b)");
+                levels3.setName("Lightness");
+            }
+        }
+        levelsParam.updateGUIAppearance();
     }
 
     @Override
     public BufferedImage transform(BufferedImage src, BufferedImage dest) {
-        RGBLookup posterizerLookup = RGBLookup.createForPosterize(
-            redLevels.getValue(), greenLevels.getValue(), blueLevels.getValue());
+        return switch (colorSpace.getSelected()) {
+            case SRGB -> posterizeSrgb(src, dest);
+            case OKLAB -> posterizeOklab(src, dest);
+        };
+    }
+
+    private BufferedImage posterizeSrgb(BufferedImage src, BufferedImage dest) {
+        RGBLookup srgbLookup = RGBLookup.createForPosterize(
+            levels1.getValue(), levels2.getValue(), levels3.getValue());
 
-        boolean ditheringEnabled = ditheringAmountParam.getValue() != 0;
+        boolean ditheringEnabled = ditheringAmountParam.isNotZero();
         if (ditheringEnabled) {
-            return posterizeAndDither(src, dest, posterizerLookup);
+            return posterizeSrgbWithDithering(src, dest, srgbLookup);
         }
 
-        // simple case
-        BufferedImageOp filterOp = posterizerLookup.asFastLookupOp();
+        // simple case for sRGB without dithering
+        BufferedImageOp filterOp = srgbLookup.asFastLookupOp();
         filterOp.filter(src, dest);
         return dest;
     }
 
-    private BufferedImage posterizeAndDither(BufferedImage src, BufferedImage dest, RGBLookup rgbLookup) {
+    private BufferedImage posterizeOklab(BufferedImage src, BufferedImage dest) {
+        int aLevels = levels1.getValue();
+        int bLevels = levels2.getValue();
+        int lLevels = levels3.getValue();
+
+        boolean ditheringEnabled = ditheringAmountParam.isNotZero();
+        double diffusionStrength = ditheringAmountParam.getPercentage();
+        int ditheringMethod = ditheringMethodParam.getValue();
+
+        int width = src.getWidth();
+
+        int[] srcPixels = ImageUtils.getPixels(src);
+        int[] destPixels = ImageUtils.getPixels(dest);
+        int numPixels = srcPixels.length;
+        int[] inputPixels;
+
+        // Pre-pass to find the actual min/max range of a and b channels for this image.
+        // This adapts the quantization to the image's content, avoiding the perceptual
+        // artifacts caused by a fixed, symmetric range.
+        float minA = Float.MAX_VALUE, maxA = Float.MIN_VALUE;
+        float minB = Float.MAX_VALUE, maxB = Float.MIN_VALUE;
+
+        for (int srcPixel : srcPixels) {
+            float[] oklab = ColorSpaces.srgbToOklab(srcPixel);
+            float a = oklab[1];
+            float b = oklab[2];
+
+            if (a < minA) {
+                minA = a;
+            }
+            if (a > maxA) {
+                maxA = a;
+            }
+            if (b < minB) {
+                minB = b;
+            }
+            if (b > maxB) {
+                maxB = b;
+            }
+        }
+
+        if (ditheringEnabled) {
+            // use a copy of the image for dithering to diffuse errors
+            inputPixels = ImageUtils.getPixels(ImageUtils.copyImage(src));
+        } else {
+            // no dithering, process source pixels directly
+            inputPixels = srcPixels;
+        }
+
+        for (int i = 0; i < numPixels; i++) {
+            int inRGB = inputPixels[i];
+            // always get the alpha from the original, unmodified source image
+            int alpha = srcPixels[i] & 0xFF000000;
+
+            float[] oklab = ColorSpaces.srgbToOklab(inRGB);
+
+            // quantize L, a, b channels
+            float quantizedL = quantizeFloat(oklab[0], lLevels, 0.0f, 1.0f);
+            // use the calculated dynamic range
+            float quantizedA = quantizeFloat(oklab[1], aLevels, minA, maxA);
+            float quantizedB = quantizeFloat(oklab[2], bLevels, minB, maxB);
+
+            float[] quantizedOklab = {quantizedL, quantizedA, quantizedB};
+
+            int outRGB = ColorSpaces.oklabToSrgb(quantizedOklab);
+
+            if (ditheringEnabled) {
+                int r = (inRGB >>> 16) & 0xFF;
+                int g = (inRGB >>> 8) & 0xFF;
+                int b = inRGB & 0xFF;
+
+                int outR = (outRGB >>> 16) & 0xFF;
+                int outG = (outRGB >>> 8) & 0xFF;
+                int outB = outRGB & 0xFF;
+
+                double errorR = (r - outR) * diffusionStrength;
+                double errorG = (g - outG) * diffusionStrength;
+                double errorB = (b - outB) * diffusionStrength;
+                Dithering.ditherRGB(ditheringMethod, inputPixels, i, width, numPixels, errorR, errorG, errorB);
+            }
+
+            destPixels[i] = alpha | (outRGB & 0x00FFFFFF);
+        }
+
+        return dest;
+    }
+
+    /**
+     * Quantizes a float value to a specified number of levels within a given range.
+     */
+    private static float quantizeFloat(float value, int numLevels, float min, float max) {
+        if (numLevels <= 1) {
+            return min + (max - min) / 2.0f;
+        }
+        float range = max - min;
+
+        // prevent division by zero.
+        if (range == 0.0f) {
+            return min;
+        }
+
+        // normalize value to 0-1 range
+        float normalizedValue = (value - min) / range;
+        // clamp to handle out-of-gamut values and ensure it's < 1.0 for level calculation
+        normalizedValue = Math.max(0.0f, Math.min(normalizedValue, 0.999999f));
+
+        // find the discrete level, an integer from 0 to numLevels-1
+        int level = (int) (normalizedValue * numLevels);
+
+        // map the discrete level back to a value in the 0-1 range
+        float quantizedNormalized = (float) level / (numLevels - 1);
+
+        // scale back to the original min-max range
+        return min + quantizedNormalized * range;
+    }
+
+    private BufferedImage posterizeSrgbWithDithering(BufferedImage src, BufferedImage dest, RGBLookup rgbLookup) {
         double diffusionStrength = ditheringAmountParam.getPercentage();
         int ditheringMethod = ditheringMethodParam.getValue();
 
@@ -125,4 +275,4 @@ public boolean isAnimatable() {
     public boolean supportsGray() {
         return false;
     }
-}
+}

src/main/java/pixelitor/filters/gui/GroupedRangeParam.java

@@ -30,6 +30,7 @@
 
 import static java.util.stream.Collectors.joining;
 import static pixelitor.filters.gui.RandomizeMode.ALLOW_RANDOMIZE;
+import static pixelitor.gui.utils.SliderSpinner.LabelPosition.NONE;
 
 /**
  * Two or more {@link RangeParam} objects that are grouped visually,
@@ -83,6 +84,11 @@ public GroupedRangeParam(String name, RangeParam[] children, boolean linked) {
         super(name, ALLOW_RANDOMIZE);
         this.children = children;
 
+        for (RangeParam child : children) {
+            child.setAddResetButton(true);
+            child.setLabelPosition(NONE);
+        }
+
         linkedModel = new JToggleButton.ToggleButtonModel();
 
         linkedByDefault = linked;
@@ -99,6 +105,17 @@ public JComponent createGUI() {
         return gui;
     }
 
+    public void updateGUIAppearance() {
+        if (paramGUI != null) {
+            for (RangeParam child : children) {
+                child.updateGUIAppearance(true);
+            }
+            GroupedRangeParamGUI gui = (GroupedRangeParamGUI) paramGUI;
+            gui.revalidate();
+            gui.repaint();
+        }
+    }
+
     private static RangeParam[] createChildren(String[] names,
                                                int min, int def, int max) {
         RangeParam[] children = new RangeParam[names.length];

src/main/java/pixelitor/filters/gui/GroupedRangeParamGUI.java

@@ -25,7 +25,6 @@
 import java.awt.GridBagLayout;
 
 import static javax.swing.BorderFactory.createTitledBorder;
-import static pixelitor.gui.utils.SliderSpinner.LabelPosition.NONE;
 import static pixelitor.utils.Texts.i18n;
 
 /**
@@ -57,13 +56,15 @@ public GroupedRangeParamGUI(GroupedRangeParam model) {
     private void addSliderSpinners() {
         for (int i = 0; i < numChildren; i++) {
             RangeParam param = model.getRangeParam(i);
-            // doesn't call param.createGUI() because we don't want another border
-            sliders[i] = new SliderSpinner(param, NONE, true);
+            sliders[i] = (SliderSpinner) param.createGUI();
             sliders[i].setupTicks();
 
             String name = param.getName();
             sliders[i].setName(name);
-            gbh.addLabelAndControl(name + ":", sliders[i], i);
+
+            JLabel label = new JLabel(name + ":", SwingConstants.RIGHT);
+            sliders[i].setLabel(label);
+            gbh.addTwoControls(label, sliders[i], i);
         }
     }
 

src/main/java/pixelitor/filters/gui/RangeParam.java

@@ -51,8 +51,8 @@ public class RangeParam extends AbstractFilterParam implements BoundedRangeModel
     private double value;
 
     private boolean adjusting;
-    private final boolean addResetButton;
-    private final SliderSpinner.LabelPosition labelPosition;
+    private boolean addResetButton;
+    private SliderSpinner.LabelPosition labelPosition;
 
     private ChangeEvent changeEvent = null;
     private final EventListenerList listenerList = new EventListenerList();
@@ -156,9 +156,9 @@ public void scaledLinkWith(RangeParam other, double multiplier) {
             other.getValueAsDouble() / multiplier));
     }
 
-    public void updateGUIAppearance() {
+    public void updateGUIAppearance(boolean revalidate) {
         if (paramGUI != null) {
-            ((SliderSpinner) paramGUI).updateAppearance();
+            ((SliderSpinner) paramGUI).updateAppearance(revalidate);
         }
     }
 
@@ -258,6 +258,10 @@ public boolean isZero() {
         return getValue() == 0;
     }
 
+    public boolean isNotZero() {
+        return getValue() != 0;
+    }
+
     @Override
     public int getValue() {
         return (int) value;
@@ -424,6 +428,14 @@ public void setDefaultValue(double newDefault) {
         defaultValue = Math.clamp(newDefault, minValue, maxValue);
     }
 
+    public void setAddResetButton(boolean addResetButton) {
+        this.addResetButton = addResetButton;
+    }
+
+    public void setLabelPosition(SliderSpinner.LabelPosition labelPosition) {
+        this.labelPosition = labelPosition;
+    }
+
     @Override
     public boolean isAnimatable() {
         return true;