ADFA-4033 | Improve OCR sanitization, value cleaners, and widget support

cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/domain/WidgetTagParser.kt

@@ -6,7 +6,7 @@ package org.appdevforall.codeonthego.computervision.domain
  */
 internal object WidgetTagParser {
     private val tagRegex = Regex("^(?i)(B|P|D|T|C|R|SW|S)-[A-Z0-9_]+$")
-    private val tagExtractRegex = Regex("^(?i)([A-Z0-9\\s]+)([\\s\\-_.]+)([A-Z0-9_\\-]+)")
+    private val tagExtractRegex = Regex("^(?i)(B|P|D|T|C|R|SW|S|8|8W|S8)([\\s\\-_.,|/]*)([A-Z0-9_\\-]+)")
     private val VALID_PREFIXES = setOf("B", "P", "D", "T", "C", "R", "SW", "S")
 
     fun isTag(text: String): Boolean {
@@ -75,7 +75,9 @@ internal object WidgetTagParser {
     private fun isValidTagMatch(match: MatchResult): Boolean {
         val separator = match.groupValues[2]
         val rawToken = match.groupValues[3]
-        return !(separator.isEmpty() && rawToken.firstOrNull()?.isLetter() == true)
+
+        if (separator.isNotEmpty()) return true
+        return rawToken.all(::isNumericLikeOcrChar)
     }
 
     private fun normalizePrefix(rawPrefix: String): String {
@@ -121,6 +123,6 @@ internal object WidgetTagParser {
      * Determines whether a character is a digit or a letter frequently confused with a digit by OCR.
      */
     private fun isNumericLikeOcrChar(char: Char): Boolean {
-        return char.isDigit() || char in setOf('O', 'I', 'L', 'Z', 'S', 'B', '!')
+        return char.isDigit() || char.uppercaseChar() in setOf('O', 'I', 'L', 'Z', 'S', 'B', '!')
     }
 }

cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/domain/grammar/UiGrammarValidator.kt

@@ -9,7 +9,9 @@ class UiGrammarValidator {
         CheckBoxGrammar,
         SwitchGrammar,
         RadioGroupGrammar,
-        SliderGrammar
+        SliderGrammar,
+        ButtonGrammar,
+        TextViewGrammar,
     ).associateBy { it.tag }
 
     fun enforceGrammar(rawParsedAttributes: Map<String, String>, tag: String): Map<String, String> {

cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/domain/grammar/WidgetGrammar.kt

@@ -27,7 +27,9 @@ interface LayoutGrammar : WidgetGrammar {
             AttributeKey.GRAVITY.xmlName to CategoricalValidator(GravityValueSet.values),
             AttributeKey.LAYOUT_WEIGHT.xmlName to PassThroughValidator,
             AttributeKey.PADDING.xmlName to DimensionValidator,
-            AttributeKey.VISIBILITY.xmlName to CategoricalValidator(VisibilityValueSet.values)
+            AttributeKey.VISIBILITY.xmlName to CategoricalValidator(VisibilityValueSet.values),
+            AttributeKey.BACKGROUND.xmlName to PassThroughValidator,
+            AttributeKey.BACKGROUND_TINT.xmlName to PassThroughValidator
         )
 }
 
@@ -64,10 +66,7 @@ object ImageViewGrammar : LayoutGrammar {
     override val tag = "ImageView"
 
     override val attributes = super.attributes + mapOf(
-        AttributeKey.SRC.xmlName to PassThroughValidator,
-        AttributeKey.LAYOUT_GRAVITY.xmlName to CategoricalValidator(GravityValueSet.values),
-        AttributeKey.BACKGROUND.xmlName to PassThroughValidator,
-        AttributeKey.BACKGROUND_TINT.xmlName to PassThroughValidator
+        AttributeKey.SRC.xmlName to PassThroughValidator
     )
 }
 
@@ -108,3 +107,17 @@ object SliderGrammar : LayoutGrammar {
         AttributeKey.STYLE.xmlName to SliderStyleValidator
     )
 }
+
+object TextViewGrammar : TextGrammar {
+    override val tag = "TextView"
+    override val attributes = super.attributes + mapOf(
+        AttributeKey.TEXT.xmlName to PassThroughValidator
+    )
+}
+
+object ButtonGrammar : TextGrammar {
+    override val tag = "Button"
+    override val attributes = super.attributes + mapOf(
+        AttributeKey.TEXT.xmlName to PassThroughValidator
+    )
+}

cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/domain/parser/AttributeModels.kt

@@ -18,6 +18,18 @@ object GravityValueSet : AttributeValueSet {
     )
 }
 
+object DimensionValueSet : AttributeValueSet {
+    const val WRAP_CONTENT = "wrap_content"
+    const val MATCH_PARENT = "match_parent"
+
+    override val values = listOf(WRAP_CONTENT, MATCH_PARENT)
+
+    val matchKeywords = setOf("match", "parent")
+    val wrapKeywords = setOf("wrap", "content", "wrapcan")
+
+    val allKeywords = matchKeywords + wrapKeywords
+}
+
 object VisibilityValueSet : AttributeValueSet {
     override val values = listOf(
         "visible",

cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/domain/parser/FuzzyAttributeParser.kt

@@ -25,6 +25,13 @@ object FuzzyAttributeParser {
         ValueType.RAW to ValueCleaner { it }
     )
 
+    private val numericTypes = setOf(
+        ValueType.DIMENSION,
+        ValueType.SP_DIMENSION,
+        ValueType.INTEGER,
+        ValueType.FLOAT
+    )
+
     fun parse(annotation: String?, tag: String): Map<String, String> {
         if (annotation.isNullOrBlank()) return emptyMap()
 
@@ -73,8 +80,19 @@ object FuzzyAttributeParser {
     }
 
     private fun shouldTreatTokenAsValue(token: String, currentKey: AttributeKey?): Boolean {
-        if (currentKey != AttributeKey.INPUT_TYPE) return false
-        return token.trim().lowercase() in inputTypeValues
+        val lowerToken = token.trim().lowercase()
+
+        return when {
+            currentKey == AttributeKey.INPUT_TYPE && lowerToken in inputTypeValues -> true
+            currentKey?.valueType == ValueType.COLOR && isColorToken(lowerToken) -> true
+            currentKey?.valueType == ValueType.DIMENSION && DimensionValueSet.allKeywords.any { it in lowerToken } -> true
+            currentKey?.valueType in numericTypes -> lowerToken.any { it.isDigit() }
+            else -> false
+        }
+    }
+
+    private fun isColorToken(token: String): Boolean {
+        return token.startsWith("#") || token.startsWith("@") || token in ColorCleaner.colorMap
     }
 
     private fun flushAttribute(key: AttributeKey?, rawValue: String, tag: String, destination: MutableMap<String, String>) {
@@ -85,7 +103,9 @@ object FuzzyAttributeParser {
 
         if (cleanedValue.isNotEmpty()) {
             val (xmlAttr, finalValue) = resolveXmlAttribute(key, cleanedValue, tag)
-            destination[xmlAttr] = finalValue
+            if (!destination.containsKey(xmlAttr)) {
+                destination[xmlAttr] = finalValue
+            }
         }
     }
 

cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/domain/parser/ValueCleanersImpl.kt

@@ -24,66 +24,49 @@ internal object TextContentCleaner : ValueCleaner {
 
 
 internal object NumberCleaner : ValueCleaner {
-    private val ocrLetterOToZeroRegex = Regex("[oO]")
-    private val ocrLetterIToOneRegex = Regex("[lI]")
-    private val ocrLetterZToTwoRegex = Regex("[zZ]")
-    private val ocrLetterSToFiveRegex = Regex("[sS]")
-    private val ocrLetterBToSixRegex = Regex("[bB]")
+    private val ocrCharMap = mapOf(
+        'O' to '0', 'A' to '0', '@' to '0', 'Q' to '0',
+        'L' to '1', 'I' to '1', '|' to '1', '!' to '1', '/' to '1', '\\' to '1',
+        '(' to '1', ')' to '1', '[' to '1', ']' to '1',
+        'Z' to '2', 'S' to '5', 'B' to '6'
+    )
 
     override fun clean(rawValue: String): String {
-        val match = Regex("-?[\\doOlIzZsSbB]+").find(rawValue) ?: return rawValue
-        return match.value
-            .replace(ocrLetterOToZeroRegex, "0")
-            .replace(ocrLetterIToOneRegex, "1")
-            .replace(ocrLetterZToTwoRegex, "2")
-            .replace(ocrLetterSToFiveRegex, "5")
-            .replace(ocrLetterBToSixRegex, "6")
+        val translated = rawValue.map { ocrCharMap[it.uppercaseChar()] ?: it }.joinToString("")
+        return Regex("-?\\d+").find(translated)?.value ?: rawValue
     }
 }
 
 internal object DimensionCleaner : ValueCleaner {
-    private val matchKeywords = setOf("match", "parent")
-    private val wrapKeywords = setOf("wrap", "content", "wrapcan")
-    private val DIMENSION_CONSTANTS = listOf("wrap_content", "match_parent")
-    private val explicitDimensionRegex = Regex("^(-?\\d+)(dp|sp|px|dip)$")
+    private val leadingNumberRegex = Regex("^-?\\d+")
 
     override fun clean(rawValue: String): String {
-        val trimmedValue = rawValue.trim()
-        val normalized = trimmedValue.lowercase().replace(" ", "_")
+        val trimmedValue = rawValue.trim().lowercase()
+        val normalized = trimmedValue.replace(" ", "_")
 
-        if (matchKeywords.any { it in normalized }) return "match_parent"
-        if (wrapKeywords.any { it in normalized }) return "wrap_content"
+        if (DimensionValueSet.matchKeywords.any { it in normalized }) return DimensionValueSet.MATCH_PARENT
+        if (DimensionValueSet.wrapKeywords.any { it in normalized }) return DimensionValueSet.WRAP_CONTENT
 
-        val fuzzyResult = FuzzySearch.extractOne(normalized, DIMENSION_CONSTANTS)
+        val fuzzyResult = FuzzySearch.extractOne(normalized, DimensionValueSet.values)
         if (fuzzyResult.score >= 60) return fuzzyResult.string
 
-        val fixedUnit = normalized.replace(Regex("0p$|op$|olp$"), "dp")
-        explicitDimensionRegex.matchEntire(fixedUnit)?.let { match ->
-            val normalizedNumber = normalizeOcrDimensionNumber(match.groupValues[1])
-            return normalizedNumber + match.groupValues[2]
-        }
-
-        val numericPart = NumberCleaner.clean(fixedUnit.replace("_", ""))
-        val normalizedNumericPart = normalizeOcrDimensionNumber(numericPart)
-
-        return if (numericPart != fixedUnit) "${normalizedNumericPart}dp" else trimmedValue
-    }
+        val unitMatch = Regex("(dp|sp|px|in|mm|pt)$").find(trimmedValue)
+        val originalUnit = unitMatch?.value ?: "dp"
 
-    private fun normalizeOcrDimensionNumber(numericPart: String): String {
-        if (!numericPart.matches(Regex("-?\\d+"))) return numericPart
+        val firstToken = trimmedValue.substringBefore(" ")
+        val rawNumber = firstToken.removeSuffix(originalUnit).trim()
+        val numericPart = NumberCleaner.clean(rawNumber)
 
-        val isNegative = numericPart.startsWith("-")
-        val numericValue = numericPart.toLongOrNull() ?: return numericPart
-        val canonical = numericValue.toString()
-        val unsignedCanonical = canonical.removePrefix("-")
+        val numMatch = leadingNumberRegex.find(numericPart)?.value
+            ?: return trimmedValue
+        val correctedNum = removeOcrTrailingZero(numMatch)
 
-        // OCR sometimes reads the trailing "dp" as a single zero, turning 150dp into 1500.
-        if (unsignedCanonical.endsWith('0') && unsignedCanonical.toLong() >= 1000L) {
-            val normalizedValue = numericValue / 10L
-            return normalizedValue.toString()
-        }
+        return "$correctedNum$originalUnit"
+    }
 
-        return if (isNegative && numericValue == 0L) "0" else canonical
+    private fun removeOcrTrailingZero(num: String): String {
+        val isOcrArtifact = num.endsWith("0") && (num.toLongOrNull() ?: 0L) >= 1000L
+        return if (isOcrArtifact) num.dropLast(1) else num
     }
 }
 
@@ -96,8 +79,10 @@ internal object SpDimensionCleaner : ValueCleaner {
 }
 
 internal object ColorCleaner : ValueCleaner {
-    private val colorMap = mapOf(
-        "red" to "#FF0000", "rel" to "#FF0000", "green" to "#00FF00", "blue" to "#0000FF",
+    val colorMap = mapOf(
+        "red" to "#FF0000", "rel" to "#FF0000", "rad" to "#FF0000", "reo" to "#FF0000",
+        "green" to "#00FF00",
+        "blue" to "#0000FF", "ine" to "#0000FF", "hne" to "#0000FF", "hlue" to "#0000FF", "ane" to "#0000FF", "lne" to "#0000FF",
         "black" to "#000000", "white" to "#FFFFFF", "gray" to "#808080",
         "grey" to "#808080", "dark_gray" to "#A9A9A9", "yellow" to "#FFFF00",
         "cyan" to "#00FFFF", "magenta" to "#FF00FF", "purple" to "#800080",
@@ -109,13 +94,14 @@ internal object ColorCleaner : ValueCleaner {
 
     override fun clean(rawValue: String): String {
         if (rawValue.startsWith("#") || rawValue.startsWith("@")) return rawValue
-        val normalizedValue = rawValue.lowercase().replace(" ", "_")
+
+        val normalizedValue = rawValue.lowercase().replace(Regex("[^a-z_]"), "").replace(" ", "_")
 
         val exactColor = colorMap[normalizedValue]
         if (exactColor != null) return exactColor
 
         val result = FuzzySearch.extractOne(normalizedValue, colorMap.keys.toList())
-        return if (result.score >= 75) colorMap[result.string] ?: rawValue else rawValue
+        return if (result.score >= 70) colorMap[result.string] ?: rawValue else rawValue
     }
 }
 

cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/domain/parser/sanitizer/OcrSanitizerRules.kt

@@ -3,8 +3,9 @@ package org.appdevforall.codeonthego.computervision.domain.parser.sanitizer
 
 class ColorSanitizer : DictionaryRegexSanitizer() {
     override val rawRules = mapOf(
-        "backgroundired" to "background red",
-        "backgroundred" to "background red"
+        "backgroundired" to "background: red",
+        "backgroundred" to "background: red",
+        "\\bback[a-z]*[-_.]?\\s*[:;]\\s*" to "background: "
     )
 }
 
@@ -16,8 +17,8 @@ class TextAttributeSanitizer : DictionaryRegexSanitizer() {
 
 class DimensionSanitizer : DictionaryRegexSanitizer() {
     override val rawRules = mapOf(
-        "[il]ayout\\.?\\s*w[io]l?[td]h\\.?" to "layout_width:",
-        "layout\\s*hei[sck]+t\\.?" to "layout_height:",
+        "[il]ay[a-z]*[-_.\\s]*w[a-z0-9]*\\.?\\s*[:;]\\s*" to "layout_width: ",
+        "[il]ay[a-z]*[-_.\\s]*hei[a-z0-9]*\\.?\\s*[:;]\\s*" to "layout_height: ",
         "m?w?at[ce]h[-_\\s]?p[ar]+ent" to "match_parent"
     )
 }
@@ -31,6 +32,8 @@ class MarginPaddingSanitizer : DictionaryRegexSanitizer() {
 
 class StructureSanitizer : DictionaryRegexSanitizer() {
     override val rawRules = mapOf(
-        "horizontal\\s+gravity\\s*:\\s*center\\s+layout" to "layout_gravity: center_horizontal"
+        "horizontal\\s+gravity\\s*:\\s*center\\s+layout" to "layout_gravity: center_horizontal",
+        "\\b[ilL][dl]\\b\\s*[:;]?" to "id: ",
+        "\\bS[ec][rt]\\b\\s*[:;]?" to "src: "
     )
 }