FuzzyCompare uses function reference and caches configuration to avoid calculations inside the loop

Author: DanielJette

Library/src/main/java/dev/testify/core/processor/ParallelPixelProcessor.kt

@@ -34,6 +34,8 @@ import java.nio.IntBuffer
 import java.util.BitSet
 import kotlin.math.ceil
 
+typealias AnalyzePixelFunction = (baselinePixel: Int, currentPixel: Int, position: Pair<Int, Int>) -> Boolean
+
 /**
  * A class that allows for parallel processing of pixels in a bitmap.
  *
@@ -136,7 +138,7 @@ class ParallelPixelProcessor private constructor(
      * @param analyzer The analyzer function to call for each pixel.
      * @return True if all pixels pass the analyzer function, false otherwise.
      */
-    fun analyze(analyzer: (baselinePixel: Int, currentPixel: Int, position: Pair<Int, Int>) -> Boolean): Boolean {
+    fun analyze(analyzer: AnalyzePixelFunction): Boolean {
         val (width, height, baselineBuffer, currentBuffer) = prepareBuffers()
 
         val chunkData = getChunkData(width, height)

Library/src/main/java/dev/testify/core/processor/compare/FuzzyCompare.kt

@@ -25,6 +25,7 @@
 package dev.testify.core.processor.compare
 
 import android.graphics.Bitmap
+import android.graphics.Rect
 import com.github.ajalt.colormath.RGB
 import dev.testify.core.TestifyConfiguration
 import dev.testify.core.processor.ParallelPixelProcessor
@@ -43,9 +44,30 @@ import dev.testify.core.processor.compare.colorspace.calculateDeltaE
  * @param parallelProcessorConfiguration - The configuration for the [ParallelPixelProcessor].
  */
 internal class FuzzyCompare(
-    private val configuration: TestifyConfiguration,
+    configuration: TestifyConfiguration,
     private val parallelProcessorConfiguration: ParallelProcessorConfiguration = ParallelProcessorConfiguration()
 ) {
+    private val exclusionRects: Set<Rect> = configuration.exclusionRects
+    private val exactness: Float = configuration.exactness ?: 1f
+
+    private val analyzePixelFunction: (baselinePixel: Int, currentPixel: Int) -> Boolean =
+        if (configuration.hasExactness) { baselinePixel, currentPixel ->
+            val baselineLab = RGB.fromInt(baselinePixel).toLAB()
+            val currentLab = RGB.fromInt(currentPixel).toLAB()
+
+            val deltaE = calculateDeltaE(
+                baselineLab.l,
+                baselineLab.a,
+                baselineLab.b,
+                currentLab.l,
+                currentLab.a,
+                currentLab.b
+            )
+            ((100.0 - deltaE) / 100.0f >= exactness)
+        }
+        else { baselinePixel, currentPixel ->
+            baselinePixel == currentPixel
+        }
 
     fun compareBitmaps(baselineBitmap: Bitmap, currentBitmap: Bitmap): Boolean {
         if (baselineBitmap.height != currentBitmap.height) {
@@ -69,31 +91,13 @@ internal class FuzzyCompare(
                     /* return  */ true
                 } else {
                     var exclude = false
-                    for (rect in configuration.exclusionRects) {
+                    for (rect in exclusionRects) {
                         if (rect.contains(x, y)) {
                             exclude = true
                             break
                         }
                     }
-                    when {
-                        exclude -> true // return ^analyze
-                        configuration.hasExactness -> {
-                            val baselineLab = RGB.fromInt(baselinePixel).toLAB()
-                            val currentLab = RGB.fromInt(currentPixel).toLAB()
-
-                            val deltaE = calculateDeltaE(
-                                baselineLab.l,
-                                baselineLab.a,
-                                baselineLab.b,
-                                currentLab.l,
-                                currentLab.a,
-                                currentLab.b
-                            )
-                            ((100.0 - deltaE) / 100.0f >= configuration.exactness!!) // return ^analyze
-                        }
-
-                        else -> baselinePixel == currentPixel // return ^analyze
-                    }
+                    exclude || analyzePixelFunction(baselinePixel, currentPixel)
                 }
             }
     }

Library/src/test/java/dev/testify/core/processor/ParallelPixelProcessorTest.kt

@@ -23,6 +23,7 @@
  */
 package dev.testify.core.processor
 
+import android.graphics.Bitmap
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -48,11 +49,15 @@ class ParallelPixelProcessorTest {
         }
     }
 
-    fun setUp(maxNumberOfChunkThreads: Int? = null): ParallelPixelProcessor {
+    private fun setUp(
+        maxNumberOfChunkThreads: Int? = null,
+        baseline: Bitmap = mockBitmap(),
+        current: Bitmap = mockBitmap()
+    ): ParallelPixelProcessor {
         return ParallelPixelProcessor
             .create(forceSingleThreadedExecution(maxNumberOfChunkThreads))
-            .baseline(mockBitmap())
-            .current(mockBitmap())
+            .baseline(baseline)
+            .current(current)
     }
 
     @After
@@ -62,45 +67,45 @@ class ParallelPixelProcessorTest {
     }
 
     @Test
-    fun default() {
+    fun `WHEN bitmap is processed THEN analyze every pixel`() {
         val pixelProcessor = setUp(maxNumberOfChunkThreads = 1)
 
-        val index = AtomicInteger(0)
+        val analyzed = AtomicInteger(0)
         pixelProcessor.analyze { _, _, _ ->
-            index.incrementAndGet()
+            analyzed.incrementAndGet()
             true
         }
-        assertEquals(DEFAULT_BITMAP_WIDTH * DEFAULT_BITMAP_HEIGHT, index.get())
+        assertEquals(DEFAULT_BITMAP_WIDTH * DEFAULT_BITMAP_HEIGHT, analyzed.get())
     }
 
     @Test
-    fun twoCores() {
+    fun `WHEN processor has two threads THEN analyze every pixel`() {
         val pixelProcessor = setUp(maxNumberOfChunkThreads = 2)
 
-        val index = AtomicInteger(0)
+        val analyzed = AtomicInteger(0)
         pixelProcessor.analyze { _, _, _ ->
-            index.incrementAndGet()
+            analyzed.incrementAndGet()
             true
         }
 
-        assertEquals(DEFAULT_BITMAP_WIDTH * DEFAULT_BITMAP_HEIGHT, index.get())
+        assertEquals(DEFAULT_BITMAP_WIDTH * DEFAULT_BITMAP_HEIGHT, analyzed.get())
     }
 
     @Test
-    fun oddNumberOfCores() {
+    fun `WHEN there are an odd number of threads THEN analyze every pixel`() {
         val pixelProcessor = setUp(maxNumberOfChunkThreads = 7)
 
-        val index = AtomicInteger(0)
+        val analyzed = AtomicInteger(0)
         pixelProcessor.analyze { _, _, _ ->
-            index.incrementAndGet()
+            analyzed.incrementAndGet()
             true
         }
 
-        assertEquals(DEFAULT_BITMAP_WIDTH * DEFAULT_BITMAP_HEIGHT, index.get())
+        assertEquals(DEFAULT_BITMAP_WIDTH * DEFAULT_BITMAP_HEIGHT, analyzed.get())
     }
 
     @Test
-    fun oddNumberOfPixels() {
+    fun `WHEN there are an odd number of pixels THEN analyze every pixel`() {
         val pixelProcessor = ParallelPixelProcessor
             .create(ParallelProcessorConfiguration(requestedNumberOfChunkThreads = 2))
             .baseline(mockBitmap(3, 3))
@@ -112,28 +117,43 @@ class ParallelPixelProcessorTest {
             0 to 2, 1 to 2, 2 to 2
         )
 
-        val index = AtomicInteger(0)
+        val analyzed = AtomicInteger(0)
         pixelProcessor.analyze { _, _, (x, y) ->
             assertTrue(expected.remove(x to y))
-            index.incrementAndGet()
+            analyzed.incrementAndGet()
             true
         }
-        assertEquals(9, index.get())
+        assertEquals(9, analyzed.get())
         assertTrue(expected.isEmpty())
     }
 
+    /**
+     * Assert that the position at [index] matches the expected [position]
+     */
     private fun ParallelPixelProcessor.assertPosition(index: Int, position: Pair<Int, Int>) {
         val (x, y) = this.getPosition(index, DEFAULT_BITMAP_WIDTH)
         assertEquals(position, x to y)
     }
 
     @Test
-    fun multicoreChunks() {
+    fun `WHEN using multiple threads THEN the positions map correctly`() {
         setUp(maxNumberOfChunkThreads = 2).run {
             assertPosition(7, 7 to 0)
             assertPosition(500, 500 to 0)
             assertPosition(1500, 420 to 1)
             assertPosition(2200, 40 to 2)
         }
     }
+
+    @Test
+    fun `WHEN a single pixel is different THEN fail early AND do not analyze every pixel`() {
+        val pixelProcessor = setUp(maxNumberOfChunkThreads = 1)
+
+        val analyzed = AtomicInteger(0)
+        pixelProcessor.analyze { _, _, (x, y) ->
+            analyzed.incrementAndGet()
+            (x != 1) || (y != 0)
+        }
+        assertEquals(2, analyzed.get())
+    }
 }