Extract isoline executor

Author: kylecorry31

src/main/kotlin/com/kylecorry/sol/math/interpolation/Interpolation.kt

@@ -1,6 +1,8 @@
 package com.kylecorry.sol.math.interpolation
 
 import com.kylecorry.sol.math.Vector2
+import com.kylecorry.sol.shared.Executor
+import com.kylecorry.sol.shared.SequentialExecutor
 import kotlin.math.ceil
 import kotlin.math.floor
 
@@ -135,36 +137,20 @@ object Interpolation {
      * Interpolates the isoline for a grid of values using the Marching Squares algorithm.
      * @param grid A 2D grid of point to value pairs. The points should be equidistant. It is recommended to supply 1 extra row and column on each side of the grid to ensure the isoline extends to the edges.
      * @param threshold The value to use as the isoline threshold.
+     * @param executor The executor of the isoline calculations to optionally process in parallel. Defaults to sequential processing.
      * @param interpolator A function that takes a percentage (0 to 1) and two values (percent from a to b), and returns the interpolated point.
      * @return A list of isoline segments.
      */
     fun <T> getIsoline(
         grid: List<List<Pair<T, Float>>>,
         threshold: Float,
+        executor: Executor = SequentialExecutor(),
         interpolator: (percent: Float, a: T, b: T) -> T
     ): List<IsolineSegment<T>> {
         return MarchingSquares.getIsoline(
             grid,
             threshold,
-            interpolator
-        )
-    }
-
-    /**
-     * Interpolates the isoline for a grid of values using the Marching Squares algorithm. This function returns the calculators so it can be calculated in parallel.
-     * @param grid A 2D grid of point to value pairs. The points should be equidistant. It is recommended to supply 1 extra row and column on each side of the grid to ensure the isoline extends to the edges.
-     * @param threshold The value to use as the isoline threshold.
-     * @param interpolator A function that takes a percentage (0 to 1) and two values (percent from a to b), and returns the interpolated point.
-     * @return A list of isoline segment calculators.
-     */
-    fun <T> getIsolineCalculators(
-        grid: List<List<Pair<T, Float>>>,
-        threshold: Float,
-        interpolator: (percent: Float, a: T, b: T) -> T
-    ): List<() -> List<IsolineSegment<T>>> {
-        return MarchingSquares.getIsolineCalculators(
-            grid,
-            threshold,
+            executor,
             interpolator
         )
     }

src/main/kotlin/com/kylecorry/sol/math/interpolation/MarchingSquares.kt

@@ -1,17 +1,20 @@
 package com.kylecorry.sol.math.interpolation
 
 import com.kylecorry.sol.math.SolMath
+import com.kylecorry.sol.shared.Executor
+import com.kylecorry.sol.shared.SequentialExecutor
 import kotlin.math.max
 import kotlin.math.min
 
 internal object MarchingSquares {
 
-    fun <T> getIsolineCalculators(
+    fun <T> getIsoline(
         grid: List<List<Pair<T, Float>>>,
         threshold: Float,
+        executor: Executor = SequentialExecutor(),
         interpolator: (percent: Float, a: T, b: T) -> T
-    ): List<() -> List<IsolineSegment<T>>> {
-        val squares = mutableListOf<List<Pair<T, Float>>>()
+    ): List<IsolineSegment<T>> {
+        val calculators = mutableListOf<() -> List<IsolineSegment<T>>>()
         for (i in 0 until grid.size - 1) {
             for (j in 0 until grid[i].size - 1) {
                 val square = listOf(
@@ -20,24 +23,13 @@ internal object MarchingSquares {
                     grid[i + 1][j + 1],
                     grid[i + 1][j]
                 )
-                squares.add(square)
-            }
-        }
-
-        return squares.map { square ->
-            {
-                marchingSquares(square, threshold, interpolator)
+                calculators.add {
+                    marchingSquares(square, threshold, interpolator)
+                }
             }
         }
-    }
 
-    fun <T> getIsoline(
-        grid: List<List<Pair<T, Float>>>,
-        threshold: Float,
-        interpolator: (percent: Float, a: T, b: T) -> T
-    ): List<IsolineSegment<T>> {
-        val calculators = getIsolineCalculators(grid, threshold, interpolator)
-        return calculators.flatMap { it() }
+        return executor.map(calculators).flatten()
     }
 
     private fun <T> marchingSquares(

src/main/kotlin/com/kylecorry/sol/shared/Executor.kt

@@ -0,0 +1,16 @@
+package com.kylecorry.sol.shared
+
+interface Executor {
+    /**
+     * Execute tasks that map to a value.
+     * @param tasks the tasks
+     * @return the evaluated values in the same order as the tasks
+     */
+    fun <T> map(tasks: List<() -> T>): List<T>
+
+    /**
+     * Execute tasks.
+     * @param tasks the tasks
+     */
+    fun run(tasks: List<() -> Unit>)
+}

src/main/kotlin/com/kylecorry/sol/shared/SequentialExecutor.kt

@@ -0,0 +1,11 @@
+package com.kylecorry.sol.shared
+
+class SequentialExecutor : Executor {
+    override fun <T> map(tasks: List<() -> T>): List<T> {
+        return tasks.map { it() }
+    }
+
+    override fun run(tasks: List<() -> Unit>) {
+        tasks.forEach { it() }
+    }
+}

src/test/kotlin/com/kylecorry/sol/math/interpolation/InterpolationTest.kt

@@ -4,6 +4,7 @@ import com.kylecorry.sol.math.Vector2
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
+import kotlin.math.abs
 
 class InterpolationTest {
 
@@ -36,7 +37,7 @@ class InterpolationTest {
     fun linearVector() {
         val point1 = Vector2(0f, 0f)
         val point2 = Vector2(2f, 4f)
-        
+
         assertEquals(0f, Interpolation.linear(0f, point1, point2), 0.0001f)
         assertEquals(2f, Interpolation.linear(1f, point1, point2), 0.0001f)
         assertEquals(4f, Interpolation.linear(2f, point1, point2), 0.0001f)
@@ -65,7 +66,7 @@ class InterpolationTest {
         val point1 = Vector2(1f, 1f)
         val point2 = Vector2(2f, 4f)
         val point3 = Vector2(3f, 9f)
-        
+
         assertEquals(1f, Interpolation.cubic(1f, point0, point1, point2, point3), 0.0001f)
         assertEquals(4f, Interpolation.cubic(2f, point0, point1, point2, point3), 0.0001f)
         assertEquals(2.25f, Interpolation.cubic(1.5f, point0, point1, point2, point3), 0.0001f)
@@ -83,16 +84,16 @@ class InterpolationTest {
         // 3 points (quadratic interpolation)
         val xs = listOf(0f, 1f, 2f)
         val ys = listOf(0f, 1f, 4f)
-        
+
         assertEquals(0f, Interpolation.interpolate(0f, xs, ys), 0.0001f)
         assertEquals(1f, Interpolation.interpolate(1f, xs, ys), 0.0001f)
         assertEquals(4f, Interpolation.interpolate(2f, xs, ys), 0.0001f)
         assertEquals(0.25f, Interpolation.interpolate(0.5f, xs, ys), 0.0001f)
-        
+
         // 4 points (cubic interpolation)
         val xs2 = listOf(0f, 1f, 2f, 3f)
         val ys2 = listOf(0f, 1f, 8f, 27f)
-        
+
         assertEquals(0f, Interpolation.interpolate(0f, xs2, ys2), 0.0001f)
         assertEquals(1f, Interpolation.interpolate(1f, xs2, ys2), 0.0001f)
         assertEquals(8f, Interpolation.interpolate(2f, xs2, ys2), 0.0001f)
@@ -104,19 +105,19 @@ class InterpolationTest {
     fun getMultiplesBetweenFloat() {
         val result1 = Interpolation.getMultiplesBetween(0f, 10f, 2f)
         assertEquals(listOf(0f, 2f, 4f, 6f, 8f, 10f), result1)
-        
+
         val result2 = Interpolation.getMultiplesBetween(1f, 9f, 2f)
         assertEquals(listOf(2f, 4f, 6f, 8f), result2)
-        
+
         val result3 = Interpolation.getMultiplesBetween(0f, 2f, 0.5f)
         assertEquals(listOf(0f, 0.5f, 1f, 1.5f, 2f), result3)
-        
+
         val result4 = Interpolation.getMultiplesBetween(-5f, 5f, 2.5f)
         assertEquals(listOf(-5f, -2.5f, 0f, 2.5f, 5f), result4)
-        
+
         val result5 = Interpolation.getMultiplesBetween(0.1f, 0.4f, 1f)
         assertTrue(result5.isEmpty())
-        
+
         val result6 = Interpolation.getMultiplesBetween(2f, 2f, 1f)
         assertEquals(listOf(2f), result6)
     }
@@ -125,22 +126,22 @@ class InterpolationTest {
     fun getMultiplesBetweenDouble() {
         val result1 = Interpolation.getMultiplesBetween(0.0, 10.0, 2.0)
         assertEquals(listOf(0.0, 2.0, 4.0, 6.0, 8.0, 10.0), result1)
-        
+
         val result2 = Interpolation.getMultiplesBetween(1.0, 9.0, 2.0)
         assertEquals(listOf(2.0, 4.0, 6.0, 8.0), result2)
-        
+
         val result3 = Interpolation.getMultiplesBetween(0.0, 2.0, 0.5)
         assertEquals(listOf(0.0, 0.5, 1.0, 1.5, 2.0), result3)
-        
+
         val result4 = Interpolation.getMultiplesBetween(-5.0, 5.0, 2.5)
         assertEquals(listOf(-5.0, -2.5, 0.0, 2.5, 5.0), result4)
-        
+
         val result5 = Interpolation.getMultiplesBetween(0.1, 0.4, 1.0)
         assertTrue(result5.isEmpty())
-        
+
         val result6 = Interpolation.getMultiplesBetween(2.0, 2.0, 1.0)
         assertEquals(listOf(2.0), result6)
-        
+
         val result7 = Interpolation.getMultiplesBetween(0.0, 0.31, 0.1)
         assertEquals(4, result7.size)
         assertEquals(0.0, result7[0], 0.0001)
@@ -149,4 +150,46 @@ class InterpolationTest {
         assertEquals(0.3, result7[3], 0.0001)
     }
 
+    @Test
+    fun getIsoline() {
+        val grid = listOf(
+            listOf(Vector2(0f, 0f) to 0f, Vector2(1f, 0f) to 0f, Vector2(2f, 0f) to 0f),
+            listOf(Vector2(0f, 1f) to 0f, Vector2(1f, 1f) to 1f, Vector2(2f, 1f) to 0f),
+            listOf(Vector2(0f, 2f) to 0f, Vector2(1f, 2f) to 0f, Vector2(2f, 2f) to 0f)
+        )
+
+        val isolines = Interpolation.getIsoline(grid, 0.5f) { pct, a, b ->
+            Vector2(a.x + (b.x - a.x) * pct, a.y + (b.y - a.y) * pct)
+        }
+
+        assertEquals(4, isolines.size)
+
+        assertSegment(isolines[0], 1f, 0.5f, 0.5f, 1f)
+        assertSegment(isolines[1], 1f, 0.5f, 1.5f, 1f)
+        assertSegment(isolines[2], 0.5f, 1f, 1f, 1.5f)
+        assertSegment(isolines[3], 1.5f, 1f, 1f, 1.5f)
+    }
+
+    private fun assertSegment(
+        segment: IsolineSegment<Vector2>,
+        x1: Float,
+        y1: Float,
+        x2: Float,
+        y2: Float,
+        threshold: Float = 0.001f
+    ) {
+        val start = segment.start
+        val end = segment.end
+
+        val match1 = (abs(start.x - x1) < threshold && abs(start.y - y1) < threshold &&
+                abs(end.x - x2) < threshold && abs(end.y - y2) < threshold)
+
+        val match2 = (abs(start.x - x2) < threshold && abs(start.y - y2) < threshold &&
+                abs(end.x - x1) < threshold && abs(end.y - y1) < threshold)
+
+        assertTrue(
+            match1 || match2,
+            "Expected ($x1, $y1)-($x2, $y2) but got (${start.x}, ${start.y})-(${end.x}, ${end.y})"
+        )
+    }
 }

src/test/kotlin/com/kylecorry/sol/shared/SequentialExecutorTest.kt

@@ -0,0 +1,36 @@
+package com.kylecorry.sol.shared
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class SequentialExecutorTest {
+
+    @Test
+    fun map() {
+        val executor = SequentialExecutor()
+        val tasks = listOf(
+            { 1 },
+            { 2 },
+            { 3 }
+        )
+
+        val result = executor.map(tasks)
+
+        assertEquals(listOf(1, 2, 3), result)
+    }
+
+    @Test
+    fun run() {
+        val executor = SequentialExecutor()
+        val result = mutableListOf<Int>()
+        val tasks = listOf<() -> Unit>(
+            { result.add(1) },
+            { result.add(2) },
+            { result.add(3) }
+        )
+
+        executor.run(tasks)
+
+        assertEquals(listOf(1, 2, 3), result)
+    }
+}