Merge pull request #155 from ashtanko/feature/advanced_image_processing

Advanced image processing examples

Author: ashtanko

README.md

@@ -22,22 +22,22 @@
 
 ### Metrics
 ```text
-15199 number of properties
-10523 number of functions
-8940 number of classes
+15258 number of properties
+10538 number of functions
+8941 number of classes
 239 number of packages
-3531 number of kt files
+3533 number of kt files
 ```
 
 
 ### Complexity Report
 ```text
-266642 lines of code (loc)
-165721 source lines of code (sloc)
-121060 logical lines of code (lloc)
-72547 comment lines of code (cloc)
-25022 cyclomatic complexity (mcc)
-20410 cognitive complexity
+266898 lines of code (loc)
+165936 source lines of code (sloc)
+121212 logical lines of code (lloc)
+72548 comment lines of code (cloc)
+25066 cyclomatic complexity (mcc)
+20459 cognitive complexity
 0 number of total code smells
 43 comment source ratio
 206 mcc per 1,000 lloc

api/Kotlin-Lab.api

@@ -19686,6 +19686,17 @@ public final class dev/shtanko/concurrency/coroutines/actors/ExampleKt {
 	public static synthetic fun main ([Ljava/lang/String;)V
 }
 
+public final class dev/shtanko/concurrency/coroutines/examples/AdvancedImageProcessingKt {
+	public static final fun applyRegionSpecificFilter (Ljava/awt/image/BufferedImage;)Ljava/awt/image/BufferedImage;
+	public static final fun blendSegment (Ljava/awt/image/BufferedImage;Ljava/awt/image/BufferedImage;)Ljava/awt/image/BufferedImage;
+	public static final fun detectEdges (Ljava/awt/image/BufferedImage;)Ljava/awt/image/BufferedImage;
+	public static final fun main ()V
+	public static synthetic fun main ([Ljava/lang/String;)V
+	public static final fun mergeSegments (Ljava/util/List;II)Ljava/awt/image/BufferedImage;
+	public static final fun processImageParallel (Ljava/awt/image/BufferedImage;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public static final fun segmentImage (Ljava/awt/image/BufferedImage;I)Ljava/util/List;
+}
+
 public final class dev/shtanko/concurrency/coroutines/examples/AtomicBankTransfer : dev/shtanko/concurrency/coroutines/examples/IAtomicBankTransfer {
 	public static final field Companion Ldev/shtanko/concurrency/coroutines/examples/AtomicBankTransfer$Companion;
 	public fun <init> ()V
@@ -19733,6 +19744,8 @@ public abstract interface class dev/shtanko/concurrency/coroutines/examples/IAto
 }
 
 public final class dev/shtanko/concurrency/coroutines/examples/ImageProcessingKt {
+	public static final field MAX_COLOR I
+	public static final field MAX_COLOR_VALUE I
 	public static final fun adjustBrightness (Ljava/awt/image/BufferedImage;I)Ljava/awt/image/BufferedImage;
 	public static synthetic fun adjustBrightness$default (Ljava/awt/image/BufferedImage;IILjava/lang/Object;)Ljava/awt/image/BufferedImage;
 	public static final fun applySepia (Ljava/awt/image/BufferedImage;)Ljava/awt/image/BufferedImage;

src/main/kotlin/dev/shtanko/concurrency/coroutines/examples/AdvancedImageProcessing.kt

@@ -0,0 +1,133 @@
+package dev.shtanko.concurrency.coroutines.examples
+
+import dev.shtanko.utils.ResourceFilePath
+import dev.shtanko.utils.readImageBytes
+import java.awt.Color
+import java.awt.image.BufferedImage
+import kotlin.math.sqrt
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.runBlocking
+
+private const val KERNEL_RADIUS = 1
+
+private val KERNEL_X = arrayOf(
+    intArrayOf(-1, 0, 1),
+    intArrayOf(-2, 0, 2),
+    intArrayOf(-1, 0, 1),
+)
+
+private val KERNEL_Y = arrayOf(
+    intArrayOf(-1, -2, -1),
+    intArrayOf(0, 0, 0),
+    intArrayOf(1, 2, 1),
+)
+
+suspend fun processImageParallel(image: BufferedImage): BufferedImage = coroutineScope {
+    val segments = segmentImage(image, numberOfSegments = 8)
+
+    val processedRegions = segments.map { segment ->
+        async(Dispatchers.Default) {
+            val edges = detectEdges(segment)
+            val filtered = applyRegionSpecificFilter(segment)
+            blendSegment(filtered, edges)
+        }
+    }
+
+    val finalImage = mergeSegments(processedRegions.awaitAll(), image.width, image.height)
+    return@coroutineScope finalImage
+}
+
+fun segmentImage(image: BufferedImage, numberOfSegments: Int): List<BufferedImage> {
+    val heightPerSegment = image.height / numberOfSegments
+    return List(numberOfSegments) { i ->
+        val y = i * heightPerSegment
+        val h = if (i == numberOfSegments - 1) image.height - y else heightPerSegment
+        image.getSubimage(0, y, image.width, h)
+    }
+}
+
+fun detectEdges(image: BufferedImage): BufferedImage {
+    val w = image.width
+    val h = image.height
+    val edgeImage = BufferedImage(w, h, BufferedImage.TYPE_INT_RGB)
+
+    for (y in KERNEL_RADIUS until h - KERNEL_RADIUS) {
+        for (x in KERNEL_RADIUS until w - KERNEL_RADIUS) {
+            var gx = 0
+            var gy = 0
+
+            for (ky in -KERNEL_RADIUS..KERNEL_RADIUS) {
+                for (kx in -KERNEL_RADIUS..KERNEL_RADIUS) {
+                    val pixel = Color(image.getRGB(x + kx, y + ky)).red
+                    gx += pixel * KERNEL_X[ky + KERNEL_RADIUS][kx + KERNEL_RADIUS]
+                    gy += pixel * KERNEL_Y[ky + KERNEL_RADIUS][kx + KERNEL_RADIUS]
+                }
+            }
+
+            val magnitude = sqrt((gx * gx + gy * gy).toDouble())
+                .toInt()
+                .coerceIn(0, MAX_COLOR_VALUE)
+            val gray = Color(magnitude, magnitude, magnitude)
+            edgeImage.setRGB(x, y, gray.rgb)
+        }
+    }
+
+    return edgeImage
+}
+
+fun applyRegionSpecificFilter(image: BufferedImage): BufferedImage {
+    val output = BufferedImage(image.width, image.height, BufferedImage.TYPE_INT_RGB)
+    for (y in 0 until image.height) {
+        for (x in 0 until image.width) {
+            val c = Color(image.getRGB(x, y))
+            val r = MAX_COLOR - c.red
+            val g = MAX_COLOR - c.green
+            val b = MAX_COLOR - c.blue
+            output.setRGB(x, y, Color(r, g, b).rgb)
+        }
+    }
+    return output
+}
+
+fun blendSegment(filtered: BufferedImage, edges: BufferedImage): BufferedImage {
+    val w = filtered.width
+    val h = filtered.height
+    val blended = BufferedImage(w, h, BufferedImage.TYPE_INT_RGB)
+
+    for (y in 0 until h) {
+        for (x in 0 until w) {
+            val c1 = Color(filtered.getRGB(x, y))
+            val c2 = Color(edges.getRGB(x, y))
+
+            val r = ((c1.red + c2.red) / 2).coerceIn(0, MAX_COLOR)
+            val g = ((c1.green + c2.green) / 2).coerceIn(0, MAX_COLOR)
+            val b = ((c1.blue + c2.blue) / 2).coerceIn(0, MAX_COLOR)
+
+            blended.setRGB(x, y, Color(r, g, b).rgb)
+        }
+    }
+
+    return blended
+}
+
+fun mergeSegments(segments: List<BufferedImage>, totalWidth: Int, totalHeight: Int): BufferedImage {
+    val result = BufferedImage(totalWidth, totalHeight, BufferedImage.TYPE_INT_RGB)
+    var currentY = 0
+    for (segment in segments) {
+        result.graphics.drawImage(segment, 0, currentY, null)
+        currentY += segment.height
+    }
+    return result
+}
+
+fun main() = runBlocking {
+    val path: ResourceFilePath = "images/bd.jpg"
+    val inputImage = decodeImage(path.readImageBytes())
+    val result = processImageParallel(inputImage)
+
+    val resultBytes = result.toByteArray()
+    display(resultBytes)
+}

src/main/kotlin/dev/shtanko/concurrency/coroutines/examples/ImageProcessing.kt

@@ -27,21 +27,21 @@ private const val SEPIA_BLUE_SCALE_R = 0.272
 private const val SEPIA_BLUE_SCALE_G = 0.534
 private const val SEPIA_BLUE_SCALE_B = 0.131
 
-private const val MAX_COLOR_VALUE = 255
+const val MAX_COLOR_VALUE = 255
 private const val BRIGHTNESS_ADJUSTMENT = 40
 
 private const val DEFAULT_THRESHOLD = 128
 private const val RGB_COMPONENT_COUNT = 3
 private const val MIN_COLOR = 0
-private const val MAX_COLOR = 255
+const val MAX_COLOR = 255
 
 private const val KERNEL_SIZE = 3
 private const val KERNEL_CENTER = KERNEL_SIZE / 2
 
 private val GAUSSIAN_KERNEL = arrayOf(
     doubleArrayOf(1.0 / 16, 2.0 / 16, 1.0 / 16),
     doubleArrayOf(2.0 / 16, 4.0 / 16, 2.0 / 16),
-    doubleArrayOf(1.0 / 16, 2.0 / 16, 1.0 / 16)
+    doubleArrayOf(1.0 / 16, 2.0 / 16, 1.0 / 16),
 )
 
 fun toGrayscale(image: BufferedImage): BufferedImage {

src/test/kotlin/dev/shtanko/concurrency/coroutines/examples/AdvancedImageProcessingTest.kt

@@ -0,0 +1,121 @@
+package dev.shtanko.concurrency.coroutines.examples
+
+import java.awt.Color
+import java.awt.image.BufferedImage
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+private const val MAX_COLOR = 255
+
+class AdvancedImageProcessingTest {
+    private fun createSolidColorImage(width: Int, height: Int, color: Color): BufferedImage {
+        return BufferedImage(width, height, BufferedImage.TYPE_INT_RGB).apply {
+            for (x in 0 until width) {
+                for (y in 0 until height) {
+                    setRGB(x, y, color.rgb)
+                }
+            }
+        }
+    }
+
+    private fun imagesAreEqual(img1: BufferedImage, img2: BufferedImage): Boolean {
+        if (img1.width != img2.width || img1.height != img2.height) return false
+        for (x in 0 until img1.width) {
+            for (y in 0 until img1.height) {
+                if (img1.getRGB(x, y) != img2.getRGB(x, y)) return false
+            }
+        }
+        return true
+    }
+
+    @Test
+    fun `applyRegionSpecificFilter inverts colors imagesAreEqual`() {
+        val original = createSolidColorImage(5, 5, Color(50, 100, 150))
+        val expected = createSolidColorImage(5, 5, Color(205, 155, 105)) // 255 - original colors
+        val inverted = applyRegionSpecificFilter(original)
+
+        assertTrue(imagesAreEqual(expected, inverted))
+    }
+
+    @Test
+    fun `detectEdges returns black image for uniform color`() {
+        val image = createSolidColorImage(10, 10, Color(100, 100, 100))
+        val edges = detectEdges(image)
+
+        for (x in 1 until edges.width - 1) {
+            for (y in 1 until edges.height - 1) {
+                val rgb = Color(edges.getRGB(x, y))
+                assertTrue(rgb.red < 10, "Expected low edge intensity, got ${rgb.red}")
+                assertEquals(rgb.red, rgb.green)
+                assertEquals(rgb.green, rgb.blue)
+            }
+        }
+    }
+
+    @Test
+    fun `applyRegionSpecificFilter inverts colors`() {
+        val original = createSolidColorImage(5, 5, Color(50, 100, 150))
+        val inverted = applyRegionSpecificFilter(original)
+
+        for (x in 0 until original.width) {
+            for (y in 0 until original.height) {
+                val originalColor = Color(original.getRGB(x, y))
+                val invertedColor = Color(inverted.getRGB(x, y))
+
+                assertEquals(MAX_COLOR - originalColor.red, invertedColor.red)
+                assertEquals(MAX_COLOR - originalColor.green, invertedColor.green)
+                assertEquals(MAX_COLOR - originalColor.blue, invertedColor.blue)
+            }
+        }
+    }
+
+    @Test
+    fun `blendSegment averages colors of two images`() {
+        val img1 = createSolidColorImage(4, 4, Color(100, 150, 200))
+        val img2 = createSolidColorImage(4, 4, Color(50, 50, 50))
+
+        val blended = blendSegment(img1, img2)
+        for (x in 0 until blended.width) {
+            for (y in 0 until blended.height) {
+                val c = Color(blended.getRGB(x, y))
+                assertEquals((100 + 50) / 2, c.red)
+                assertEquals((150 + 50) / 2, c.green)
+                assertEquals((200 + 50) / 2, c.blue)
+            }
+        }
+    }
+
+    @Test
+    fun `segmentImage splits image into correct number of segments`() {
+        val image = createSolidColorImage(10, 10, Color.BLACK)
+        val segments = segmentImage(image, 3)
+        assertEquals(3, segments.size)
+        val totalHeight = segments.sumOf { it.height }
+        assertEquals(image.height, totalHeight)
+        segments.forEach {
+            assertEquals(image.width, it.width)
+        }
+    }
+
+    @Test
+    fun `mergeSegments recombines images vertically`() {
+        val img1 = createSolidColorImage(4, 2, Color.RED)
+        val img2 = createSolidColorImage(4, 3, Color.GREEN)
+        val merged = mergeSegments(listOf(img1, img2), 4, 5)
+
+        assertEquals(4, merged.width)
+        assertEquals(5, merged.height)
+
+        for (x in 0 until 4) {
+            for (y in 0 until 2) {
+                assertEquals(Color.RED.rgb, merged.getRGB(x, y))
+            }
+        }
+        for (x in 0 until 4) {
+            for (y in 2 until 5) {
+                assertEquals(Color.GREEN.rgb, merged.getRGB(x, y))
+            }
+        }
+    }
+}