Alpha opacity

commons/src/commonMain/kotlin/org/jetbrains/letsPlot/commons/colorspace/Converters.kt

@@ -15,14 +15,14 @@ fun rgbFromHcl(hcl: HCL, alpha: Double = 1.0): Color {
     val luv = luvFromHcl(hcl)
     val xyz = xyzFromLuv(luv)
     val rgb = rgbFromXyz(xyz)
-    return rgb.changeAlpha((255 * alpha).roundToInt())
+    return rgb.changeAlpha(alpha)
 }
 
 
 fun rgbFromLab(lab: LAB, alpha: Double = 1.0): Color {
     val xyz = xyzFromLab(lab)
     val rgb = rgbFromXyz(xyz)
-    return rgb.changeAlpha((255 * alpha).roundToInt())
+    return rgb.changeAlpha(alpha)
 }
 
 

commons/src/commonMain/kotlin/org/jetbrains/letsPlot/commons/colorspace/HSL.kt

@@ -77,5 +77,5 @@ fun rgbFromHsl(hsl: HSL, alpha: Double = 1.0): Color {
         ((g1 + m) * 255).roundToInt(),
         ((b1 + m) * 255).roundToInt(),
         (255 * 1.0).roundToInt()
-    ).changeAlpha((255 * alpha).roundToInt())
+    ).changeAlpha(alpha)
 }

commons/src/commonMain/kotlin/org/jetbrains/letsPlot/commons/values/Color.kt

@@ -56,13 +56,13 @@ class Color @JvmOverloads constructor(
         }
     }
 
+    fun toHexColorNoAlpha(): String {
+        return "#" + toColorPart(red) + toColorPart(green) + toColorPart(blue)
+    }
+
     fun toHexColor(): String {
-        val rgb = "#" + toColorPart(red) + toColorPart(green) + toColorPart(blue)
-        if (alpha == 255) {
-            return rgb
-        } else {
-            return rgb + toColorPart(alpha)
-        }
+        val rgb = toHexColorNoAlpha()
+        return if (alpha == 255) rgb else rgb + toColorPart(alpha)
     }
 
     override fun hashCode(): Int {
@@ -243,43 +243,33 @@ class Color @JvmOverloads constructor(
         }
 
         fun parseRGB(text: String): Color {
-            val firstParen = findNext(text, "(", 0)
-            val prefix = text.substring(0, firstParen)
-
-            val firstComma = findNext(text, ",", firstParen + 1)
-            val secondComma = findNext(text, ",", firstComma + 1)
-
-            var thirdComma = -1
-
-            when {
-                prefix == RGBA -> thirdComma = findNext(text, ",", secondComma + 1)
-                prefix == COLOR -> thirdComma = text.indexOf(",", secondComma + 1)
-                prefix != RGB -> throw IllegalArgumentException(text)
+            val firstParen = text.indexOf("(")
+            val lastParen = text.lastIndexOf(")")
+            if (firstParen == -1 || lastParen == -1 || lastParen < firstParen) {
+                throw IllegalArgumentException("Invalid color value: $text")
             }
 
-            val lastParen = findNext(text, ")", thirdComma + 1)
-            val red = text.substring(firstParen + 1, firstComma).trim { it <= ' ' }.toInt()
-            val green = text.substring(firstComma + 1, secondComma).trim { it <= ' ' }.toInt()
+            val prefix = text.substring(0, firstParen)
+            val components = text.substring(firstParen + 1, lastParen).split(",").map(String::trim)
 
-            val blue: Int
-            val alpha: Int
-            if (thirdComma == -1) {
-                blue = text.substring(secondComma + 1, lastParen).trim { it <= ' ' }.toInt()
-                alpha = 255
-            } else {
-                blue = text.substring(secondComma + 1, thirdComma).trim { it <= ' ' }.toInt()
-                alpha = (text.substring(thirdComma + 1, lastParen).trim { it <= ' ' }.toFloat() * 255).roundToInt()
+            when (prefix) {
+                RGB -> require(components.size == 3) { "RGB color format requires exactly 3 components: $text" }
+                RGBA -> require(components.size == 4) { "RGBA color format requires exactly 4 components: $text" }
+                COLOR -> require(components.size in 3..4) { "'color()' format requires 3 or 4 components: $text" }
+                else -> throw IllegalArgumentException("Unsupported RGB color format: $text")
             }
 
-            return Color(red, green, blue, alpha)
-        }
+            return try {
+                val red = components[0].toInt()
+                val green = components[1].toInt()
+                val blue = components[2].toInt()
+                val opacity = components.getOrNull(3)?.toFloat() ?: 1f
+                val alpha = (opacity * 255).roundToInt()
 
-        private fun findNext(s: String, what: String, from: Int): Int {
-            val result = s.indexOf(what, from)
-            if (result == -1) {
-                throw IllegalArgumentException("text=$s what=$what from=$from")
+                Color(red, green, blue, alpha)
+            } catch (e: NumberFormatException) {
+                throw IllegalArgumentException("Invalid color value: $text", e)
             }
-            return result
         }
 
         fun parseHex(hexColor: String): Color {
@@ -328,4 +318,4 @@ class Color @JvmOverloads constructor(
             }
         }
     }
-}
+}

commons/src/commonMain/kotlin/org/jetbrains/letsPlot/commons/values/Colors.kt

@@ -180,7 +180,9 @@ object Colors {
      *     - rgba(r, g, b, a)
      *     - color(r, g, b, a)
      *     - #rrggbb
+     *     - #rrggbbaa
      *     - #rgb
+     *     - #rgba
      *     - white, green, etc.
      */
     fun parseColor(c: String): Color {
@@ -313,10 +315,6 @@ object Colors {
         return Color(red, green, blue)
     }
 
-    fun withOpacity(c: Color, opacity: Double): Color {
-        return c.changeAlpha(max(0, min(255, round(255 * opacity).toInt())))
-    }
-
     fun contrast(color: Color, other: Color): Double {
         return (luminance(color) + .05) / (luminance(other) + .05)
     }

commons/src/commonTest/kotlin/org/jetbrains/letsPlot/commons/values/ColorTest.kt

@@ -36,6 +36,16 @@ class ColorTest {
         assertEquals("#11223344", Color(0x11, 0x22, 0x33, 0x44).toHexColor())
     }
 
+    @Test
+    fun toHexColorNoAlpha() {
+        assertEquals("#112233", Color(0x11, 0x22, 0x33, 0x44).toHexColorNoAlpha())
+    }
+
+    @Test
+    fun changeAlphaDoubleRoundsToNearestByte() {
+        assertEquals(128, Color.RED.changeAlpha(0.5).alpha)
+    }
+
     @Test
     fun parseRGB() {
         assertEquals(Color.RED, Color.parseRGB("rgb(255,0,0)"))
@@ -46,6 +56,24 @@ class ColorTest {
         assertEquals(Color.RED, Color.parseRGB("rgba(255,0,0,1.0)"))
     }
 
+    @Test
+    fun rgbaRequiresAlpha() {
+        val e = assertFailsWith<IllegalArgumentException> {
+            Color.parseRGB("rgba(220, 240, 255)")
+        }
+
+        assertEquals("RGBA color format requires exactly 4 components: rgba(220, 240, 255)", e.message)
+    }
+
+    @Test
+    fun rgbRejectsExtraAlpha() {
+        val e = assertFailsWith<IllegalArgumentException> {
+            Color.parseRGB("rgb(220, 240, 255, 0.5)")
+        }
+
+        assertEquals("RGB color format requires exactly 3 components: rgb(220, 240, 255, 0.5)", e.message)
+    }
+
     @Test
     fun parseColRGB() {
         assertEquals(Color.BLUE, Color.parseRGB("color(0,0,255)"))
@@ -56,6 +84,15 @@ class ColorTest {
         assertEquals(Color.BLUE, Color.parseRGB("color(0,0,255,1.0)"))
     }
 
+    @Test
+    fun colorRejectsWrongComponentCount() {
+        val e = assertFailsWith<IllegalArgumentException> {
+            Color.parseRGB("color(0,0)")
+        }
+
+        assertEquals("'color()' format requires 3 or 4 components: color(0,0)", e.message)
+    }
+
     @Test
     fun parseRgbWithSpaces() {
         assertEquals(Color.RED, Color.parseRGB("rgb(255, 0, 0)"))
@@ -75,4 +112,4 @@ class ColorTest {
             Color.parseRGB("rbg(255, 0, )")
         }
     }
-}
+}

commons/src/commonTest/kotlin/org/jetbrains/letsPlot/commons/values/ColorsTest.kt

@@ -37,6 +37,11 @@ class ColorsTest {
         assertEquals(Color.RED, Colors.parseColor(Color.RED.toHexColor()))
     }
 
+    @Test
+    fun parseHexWithAlpha() {
+        assertEquals(Color(0, 255, 0, 128), Colors.parseColor("#00ff0080"))
+    }
+
     @Test
     fun parseRGB() {
         assertEquals(Color.RED, Colors.parseColor("rgb(255,0,0)"))
@@ -112,6 +117,13 @@ class ColorsTest {
         assertColors(Color(0, 0, 128), HSL(240.0, 1.0, 0.25)) // navy
     }
 
+    @Test
+    fun `color space conversions apply alpha`() {
+        assertEquals(128, rgbFromHsl(HSL(0.0, 1.0, 0.5), alpha = 0.5).alpha)
+        assertEquals(128, rgbFromHcl(HCL(15.0, 100.0, 65.0), alpha = 0.5).alpha)
+        assertEquals(128, rgbFromLab(LAB(l = 43.579, a = 45.164, b = 36.823), alpha = 0.5).alpha)
+    }
+
     @Test
     fun hcl() {
         fun assertHclToRgb(hcl: HCL, hexRgb: String) {

datamodel/src/commonMain/kotlin/org/jetbrains/letsPlot/datamodel/svg/dom/SvgDsl.kt

@@ -264,7 +264,7 @@ fun SvgSlimGroup.slimLine(
     config: SvgSlimShape.() -> Unit = {},
     ): SvgSlimShape {
     val el = SvgSlimElements.line(x1, y1, x2, y2)
-    stroke?.let { el.setStroke(it, 1.0) }
+    stroke?.let { el.setStroke(it) }
     strokeWidth?.let { el.setStrokeWidth(it.toDouble()) }
     el.apply(config)
     el.appendTo(this)
@@ -282,8 +282,8 @@ fun SvgSlimGroup.slimRect(
     config: SvgSlimShape.() -> Unit = {},
     ): SvgSlimShape {
     val el = SvgSlimElements.rect(x.toDouble(), y.toDouble(), width.toDouble(), height.toDouble())
-    stroke?.let { el.setStroke(it, 1.0) }
-    fill?.let { el.setFill(it, 1.0) }
+    stroke?.let { el.setStroke(it) }
+    fill?.let { el.setFill(it) }
     strokeWidth?.let { el.setStrokeWidth(it.toDouble()) }
 
     el.apply(config)
@@ -301,8 +301,8 @@ fun SvgSlimGroup.slimCircle(
     config: SvgSlimShape.() -> Unit = {},
     ): SvgSlimShape {
     val el = SvgSlimElements.circle(cx.toDouble(), cy.toDouble(), r.toDouble())
-    stroke?.let { el.setStroke(it, 1.0) }
-    fill?.let { el.setFill(it, 1.0) }
+    stroke?.let { el.setStroke(it) }
+    fill?.let { el.setFill(it) }
     strokeWidth?.let { el.setStrokeWidth(it.toDouble()) }
 
     el.apply(config)
@@ -318,8 +318,8 @@ fun SvgSlimGroup.slimPath(
     config: SvgSlimShape.() -> Unit = {},
     ): SvgSlimShape {
     val el = SvgSlimElements.path(pathData)
-    stroke?.let { el.setStroke(it, 1.0) }
-    fill?.let { el.setFill(it, 1.0) }
+    stroke?.let { el.setStroke(it) }
+    fill?.let { el.setFill(it) }
     strokeWidth?.let { el.setStrokeWidth(it.toDouble()) }
     el.apply(config)
     el.appendTo(this)

datamodel/src/commonMain/kotlin/org/jetbrains/letsPlot/datamodel/svg/dom/SvgUtils.kt

@@ -9,40 +9,38 @@ import org.jetbrains.letsPlot.commons.geometry.DoubleVector
 import org.jetbrains.letsPlot.commons.intern.observable.property.Property
 import org.jetbrains.letsPlot.commons.intern.observable.property.WritableProperty
 import org.jetbrains.letsPlot.commons.values.Color
-import kotlin.math.max
-import kotlin.math.min
 
 object SvgUtils {
-    private val OPACITY_TABLE: DoubleArray = DoubleArray(256)
-
-    init {
-        for (alpha in 0..255) {
-            OPACITY_TABLE[alpha] = alpha / 255.0
-        }
-    }
+    private val OPACITY_TABLE: DoubleArray = DoubleArray(256) { alpha -> alpha / 255.0 }
+    private val OPACITY_STRING_TABLE: Array<String> = Array(256) { alpha -> OPACITY_TABLE[alpha].toString() }
 
     fun opacity(c: Color): Double {
         return OPACITY_TABLE[c.alpha]
     }
 
-    fun alpha2opacity(colorAlpha: Int): Double {
-        return OPACITY_TABLE[colorAlpha]
+    private fun opacityString(c: Color): String {
+        return OPACITY_STRING_TABLE[c.alpha]
     }
 
-    fun toARGB(c: Color): Int {
-        return toARGB(c.red, c.green, c.blue, c.alpha)
+    fun splitColorAndOpacity(color: Color): Pair<String, String?> {
+        return color.toHexColorNoAlpha() to if (color.alpha < 255) opacityString(color) else null
     }
 
-    fun toARGB(c: Color, alpha: Double): Int {
-        return toARGB(
-            c.red,
-            c.green,
-            c.blue,
-            max(0.0, min(255.0, alpha * 255)).toInt()
-        )
+    fun fillAndOpacityStyle(color: Color, separator: String = ""): String {
+        val (fill, fillOpacity) = splitColorAndOpacity(color)
+        return buildString {
+            append("fill:$fill;$separator")
+            if (fillOpacity != null) {
+                append("fill-opacity:$fillOpacity;$separator")
+            }
+        }
+    }
+
+    fun toARGB(c: Color): Int {
+        return toARGB(c.red, c.green, c.blue, c.alpha)
     }
 
-    fun toARGB(r: Int, g: Int, b: Int, alpha: Int): Int {
+    private fun toARGB(r: Int, g: Int, b: Int, alpha: Int): Int {
         val rgb = (r shl 16) + (g shl 8) + b
         return (alpha shl 24) + rgb
     }

datamodel/src/commonMain/kotlin/org/jetbrains/letsPlot/datamodel/svg/dom/slim/SlimBase.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.letsPlot.datamodel.svg.dom.slim
 
 import org.jetbrains.letsPlot.commons.values.Color
+import org.jetbrains.letsPlot.datamodel.svg.dom.SvgUtils
 import org.jetbrains.letsPlot.datamodel.svg.dom.SvgTransform
 
 internal abstract class SlimBase protected constructor(val elementName: String) :
@@ -41,18 +42,16 @@ internal abstract class SlimBase protected constructor(val elementName: String)
         internal val ATTR_COUNT = ATTR_KEYS.size
     }
 
-    override fun setFill(c: Color, alpha: Double) {
-        setAttribute(fill, c.toHexColor())
-        if (alpha < 1.0) {
-            setAttribute(fillOpacity, alpha.toString())
-        }
+    override fun setFill(c: Color) {
+        val (color, opacity) = SvgUtils.splitColorAndOpacity(c)
+        setAttribute(fill, color)
+        opacity?.let { setAttribute(fillOpacity, it) }
     }
 
-    override fun setStroke(c: Color, alpha: Double) {
-        setAttribute(stroke, c.toHexColor())
-        if (alpha < 1.0) {
-            setAttribute(strokeOpacity, alpha.toString())
-        }
+    override fun setStroke(c: Color) {
+        val (color, opacity) = SvgUtils.splitColorAndOpacity(c)
+        setAttribute(stroke, color)
+        opacity?.let { setAttribute(strokeOpacity, it) }
     }
 
     override fun setStrokeWidth(v: Double) {

datamodel/src/commonMain/kotlin/org/jetbrains/letsPlot/datamodel/svg/dom/slim/SvgSlimShape.kt

@@ -9,8 +9,8 @@ import org.jetbrains.letsPlot.commons.values.Color
 import org.jetbrains.letsPlot.datamodel.svg.dom.SvgTransform
 
 interface SvgSlimShape : SvgSlimObject {
-    fun setFill(c: Color, alpha: Double)
-    fun setStroke(c: Color, alpha: Double)
+    fun setFill(c: Color)
+    fun setStroke(c: Color)
     fun setStrokeWidth(v: Double)
     fun setStrokeDashArray(v: String)
     fun strokeDashOffset(v: Double)