Merge "Fixed bug on smoothing." into androidx-main

Author: ssancho14

graphics/graphics-shapes/src/androidTest/java/androidx/graphics/shapes/RoundedPolygonTest.kt

@@ -109,4 +109,107 @@ class RoundedPolygonTest {
         assertEqualish(0.5f, lowerEdge.p3.x)
         assertEqualish(0.0f, lowerEdge.p3.y)
     }
-}
+
+    /*
+     * In the following tests, we check how much was cut for the top left (vertex 0) and bottom
+     * left corner (vertex 3).
+     * In particular, both vertex are competing for space in the left side.
+     *
+     *   Vertex 0            Vertex 1
+     *      *---------------------*
+     *      |                     |
+     *      *---------------------*
+     *   Vertex 3            Vertex 2
+     */
+    private val points = 20
+
+    @Test
+    fun unevenSmoothingTest() {
+        // Vertex 3 has the default 0.5 radius, 0 smoothing.
+        // Vertex 0 has 0.4 radius, and smoothing varying from 0 to 1.
+        repeat(points + 1) {
+            val smooth = it.toFloat() / points
+            doUnevenSmoothTest(
+                CornerRounding(0.4f, smooth),
+                expectedV0SX = 0.4f * (1 + smooth),
+                expectedV0SY = (0.4f * (1 + smooth)).coerceAtMost(0.5f),
+                expectedV3SY = 0.5f,
+            )
+        }
+    }
+
+    @Test
+    fun unevenSmoothingTest2() {
+        // Vertex 3 has 0.2f radius and 0.2f smoothing, so it takes at most 0.4f
+        // Vertex 0 has 0.4f radius and smoothing varies from 0 to 1, when it reaches 0.5 it starts
+        // competing with vertex 3 for space.
+        repeat(points + 1) {
+            val smooth = it.toFloat() / points
+
+            val smoothWantedV0 = 0.4f * smooth
+            val smoothWantedV3 = 0.2f
+
+            // There is 0.4f room for smoothing
+            val factor = (0.4f / (smoothWantedV0 + smoothWantedV3)).coerceAtMost(1f)
+            doUnevenSmoothTest(
+                CornerRounding(0.4f, smooth),
+                expectedV0SX = 0.4f * (1 + smooth),
+                expectedV0SY = 0.4f + factor * smoothWantedV0,
+                expectedV3SY = 0.2f + factor * smoothWantedV3,
+                rounding3 = CornerRounding(0.2f, 1f)
+            )
+        }
+    }
+
+    @Test
+    fun unevenSmoothingTest3() {
+        // Vertex 3 has 0.6f radius.
+        // Vertex 0 has 0.4f radius and smoothing varies from 0 to 1. There is no room for smoothing
+        // on the segment between these vertices, but vertex 0 can still have smoothing on the top
+        // side.
+        repeat(points + 1) {
+            val smooth = it.toFloat() / points
+
+            doUnevenSmoothTest(
+                CornerRounding(0.4f, smooth),
+                expectedV0SX = 0.4f * (1 + smooth),
+                expectedV0SY = 0.4f,
+                expectedV3SY = 0.6f,
+                rounding3 = CornerRounding(0.6f)
+            )
+        }
+    }
+
+    private fun doUnevenSmoothTest(
+        // Corner rounding parameter for vertex 0 (top left)
+        rounding0: CornerRounding,
+        expectedV0SX: Float, // Expected total cut from vertex 0 towards vertex 1
+        expectedV0SY: Float, // Expected total cut from vertex 0 towards vertex 3
+        expectedV3SY: Float, // Expected total cut from vertex 3 towards vertex 0
+        // Corner rounding parameter for vertex 3 (bottom left)
+        rounding3: CornerRounding = CornerRounding(0.5f)
+    ) {
+        val p0 = PointF(0f, 0f)
+        val p1 = PointF(5f, 0f)
+        val p2 = PointF(5f, 1f)
+        val p3 = PointF(0f, 1f)
+
+        val pvRounding = listOf(
+            rounding0,
+            CornerRounding.Unrounded,
+            CornerRounding.Unrounded,
+            rounding3,
+        )
+        val polygon = RoundedPolygon(
+            vertices = listOf(p0, p1, p2, p3),
+            perVertexRounding = pvRounding
+        )
+        val (e01, _, _, e30) = polygon.features.filterIsInstance<RoundedPolygon.Edge>()
+        val msg = "r0 = ${show(rounding0)}, r3 = ${show(rounding3)}"
+        assertEqualish(expectedV0SX, e01.cubics.first().p0.x, msg)
+        assertEqualish(expectedV0SY, e30.cubics.first().p3.y, msg)
+        assertEqualish(expectedV3SY, 1f - e30.cubics.first().p0.y, msg)
+    }
+
+    private fun show(cr: CornerRounding) = "(r=${cr.radius}, s=${cr.smoothing})"
+}

graphics/graphics-shapes/src/androidTest/java/androidx/graphics/shapes/TestUtils.kt

@@ -45,8 +45,8 @@ fun assertPointLessish(expected: PointF, actual: PointF) {
     assertTrue(actual.y <= expected.y + Epsilon)
 }
 
-fun assertEqualish(expected: Float, actual: Float) {
-    assertEquals(expected, actual, Epsilon)
+fun assertEqualish(expected: Float, actual: Float, message: String? = null) {
+    assertEquals(message ?: "", expected, actual, Epsilon)
 }
 
 fun assertInBounds(shape: CubicShape, minPoint: PointF, maxPoint: PointF) {

graphics/graphics-shapes/src/main/java/androidx/graphics/shapes/RoundedPolygon.kt

@@ -228,21 +228,20 @@ class RoundedPolygon {
                 sideSize / expectedRoundCut to 0f
             } else if (expectedCut > sideSize) {
                 // We can do full rounding, but not full smoothing.
-                1f to (sideSize - expectedRoundCut) / expectedCut
+                1f to (sideSize - expectedRoundCut) / (expectedCut - expectedRoundCut)
             } else {
                 // There is enough room for rounding & smoothing.
-                0f to 1f
+                1f to 1f
             }
         }
-
         // Create and store list of beziers for each [potentially] rounded corner
         for (i in 0 until n) {
             // allowedCuts[0] is for the side from the previous corner to this one,
             // allowedCuts[1] is for the side from this corner to the next one.
             val allowedCuts = (0..1).map { delta ->
                 val (roundCutRatio, cutRatio) = cutAdjusts[(i + n - 1 + delta) % n]
                 roundedCorners[i].expectedRoundCut * roundCutRatio +
-                    roundedCorners[i].expectedCut * cutRatio
+                    (roundedCorners[i].expectedCut - roundedCorners[i].expectedRoundCut) * cutRatio
             }
             corners.add(
                 roundedCorners[i].getCubics(