New module for postprocessing

Author: pynicolas

.idea/compiler.xml

@@ -4,6 +4,7 @@ plugins {
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.compose) apply false
     alias(libs.plugins.license)
+    alias(libs.plugins.jetbrains.kotlin.jvm) apply false
 }
 
 license {

.idea/gradle.xml

@@ -14,6 +14,7 @@ litert = "1.2.0"
 opencv = "4.11.0"
 assertj = "3.27.3"
 pdfbox = "2.0.27.0"
+jetbrainsKotlinJvm = "2.1.0"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -51,4 +52,5 @@ android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 license =  { id = "com.github.hierynomus.license", version.ref = "license" }
+jetbrains-kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "jetbrainsKotlinJvm" }
 

build.gradle.kts

@@ -0,0 +1 @@
+/build

gradle/libs.versions.toml

@@ -0,0 +1,17 @@
+plugins {
+    id("java-library")
+    alias(libs.plugins.jetbrains.kotlin.jvm)
+}
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+kotlin {
+    compilerOptions {
+        jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11
+    }
+}
+dependencies {
+    testImplementation(libs.junit)
+    testImplementation(libs.assertj)
+}

postprocessing/.gitignore

@@ -0,0 +1,79 @@
+package org.mydomain.postprocessing
+
+import java.awt.image.BufferedImage
+
+data class RawImage(
+    val width: Int,
+    val height: Int,
+    val pixels: IntArray // each Int represents a pixel as 0xAARRGGBB
+) {
+
+    init {
+        require(pixels.size == width * height) { "Pixel array size does not match dimensions" }
+    }
+
+    companion object {
+        fun fromBufferedImage(image: BufferedImage): RawImage {
+            val width = image.width
+            val height = image.height
+            val pixels = IntArray(width * height)
+            for (y in 0 until height) {
+                for (x in 0 until width) {
+                    val rgb = image.getRGB(x, y)
+                    pixels[y * width + x] = rgb
+                }
+            }
+            return RawImage(width, height, pixels)
+        }
+    }
+
+    fun toBufferedImage(): BufferedImage {
+        val image = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                val index = y * width + x
+                image.setRGB(x, y, pixels[index])
+            }
+        }
+        return image
+    }
+
+    fun toGrayscale(): RawImage {
+        val grayPixels = IntArray(width * height)
+        for (i in pixels.indices) {
+            val rgb = pixels[i]
+            val r = (rgb shr 16) and 0xFF
+            val g = (rgb shr 8) and 0xFF
+            val b = rgb and 0xFF
+
+            // See https://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale
+            val gray = (0.3 * r + 0.59 * g + 0.11 * b).toInt().coerceIn(0, 255)
+
+            grayPixels[i] = (gray shl 16) or (gray shl 8) or gray
+        }
+        return RawImage(width, height, grayPixels)
+    }
+
+    fun isColorImage(saturationThreshold: Double = 0.1): Boolean {
+        var totalSaturation = 0.0
+        for (rgb in pixels) {
+            val r = (rgb shr 16) and 0xFF
+            val g = (rgb shr 8) and 0xFF
+            val b = rgb and 0xFF
+
+            val max = maxOf(r, g, b) / 255.0
+            val min = minOf(r, g, b) / 255.0
+
+            val saturation = if (max == 0.0) 0.0 else (max - min) / max
+            totalSaturation += saturation
+        }
+
+        val avgSaturation = totalSaturation / pixels.size
+        println(avgSaturation)
+        return avgSaturation > saturationThreshold
+    }
+}
+
+fun postProcessDocument(original: RawImage): RawImage {
+    return if (original.isColorImage()) original else original.toGrayscale()
+}

postprocessing/build.gradle.kts

@@ -0,0 +1,63 @@
+package org.mydomain.postprocessing
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.Test
+import java.io.File
+import javax.imageio.ImageIO
+
+class PostProcessingTest {
+
+    @Test
+    fun `basic call to RawImage constructor`() {
+        val image = RawImage(3, 2, IntArray(6))
+        assertThat(image.width).isEqualTo(3)
+        assertThat(image.height).isEqualTo(2)
+    }
+
+    @Test
+    fun `RawImage constructor should detect inconsistency in dimensions`() {
+        assertThatThrownBy { RawImage(3, 2, IntArray(5)) }
+            .isInstanceOf(IllegalArgumentException::class.java)
+    }
+
+    @Test
+    fun grayscale() {
+        val original = RawImage(1, 1, intArrayOf(0x00102030))
+        val grayscale = original.toGrayscale()
+        assertThat(grayscale.pixels).hasSize(1)
+        assertThat(grayscale.pixels[0].toString(16)).isEqualTo("1c1c1c")
+        // grayscale conversion formula (applied to 0x00102030)
+        assertThat((0.3*1*16 + 0.59*2*16 + 0.11*3*16).toInt().toString(16)).isEqualTo("1c")
+    }
+
+    @Test
+    fun `detect color image`() {
+        val pink = 0x00FF00FF
+        val gray = 0x00505050
+
+        val grayImage = RawImage(1, 1, intArrayOf(gray))
+        val pinkImage = RawImage(1, 1, intArrayOf(pink))
+
+        assertThat(grayImage.isColorImage()).isFalse()
+        assertThat(pinkImage.isColorImage()).isTrue()
+    }
+
+    @Test
+    fun `run post processing on sample files`() {
+        val inputDir = File("src/test/resources/cropped")
+        val outputDir = File("build/processed_images")
+        outputDir.mkdirs()
+        outputDir.listFiles()?.forEach { f -> f.delete() }
+        val inputFiles = inputDir.listFiles()
+        assertThat(inputFiles).isNotNull.isNotEmpty
+        inputFiles!!.forEach { inputFile ->
+            println(inputFile)
+            val inputImage = RawImage.fromBufferedImage(ImageIO.read(inputFile))
+            val outputImage = postProcessDocument(inputImage)
+            val outputFile = File(outputDir, inputFile.name)
+            ImageIO.write(outputImage.toBufferedImage(), "jpg", outputFile)
+        }
+    }
+
+}