Skip to content

ADFA-3290 | Implement smart boundary detection for dynamic margins #1170

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
jatezzz wants to merge 1 commit into from
+159 −15
Closed

ADFA-3290 | Implement smart boundary detection for dynamic margins #1170

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 31 additions & 15 deletions .../java/org/appdevforall/codeonthego/computervision/ui/viewmodel/ComputerVisionViewModel.kt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@ import android.util.Log
import androidx.exifinterface.media.ExifInterface
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.gson.Gson
import kotlinx.coroutines.Dispatchers
import org.appdevforall.codeonthego.computervision.data.repository.ComputerVisionRepository
import org.appdevforall.codeonthego.computervision.domain.MarginAnnotationParser
import org.appdevforall.codeonthego.computervision.ui.ComputerVisionEffect
Expand All @@ -23,8 +23,10 @@ import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.appdevforall.codeonthego.computervision.R
import org.appdevforall.codeonthego.computervision.utils.CvAnalyticsUtil
import org.appdevforall.codeonthego.computervision.utils.SmartBoundaryDetector

class ComputerVisionViewModel(
private val repository: ComputerVisionRepository,
Expand Down Expand Up @@ -107,22 +109,36 @@ class ComputerVisionViewModel(
private fun loadImageFromUri(uri: Uri) {
viewModelScope.launch {
try {
val bitmap = uriToBitmap(uri)
if (bitmap != null) {
val result = withContext(Dispatchers.Default) {
val bitmap = uriToBitmap(uri) ?: return@withContext null

val rotatedBitmap = handleImageRotation(uri, bitmap)
_uiState.update {
it.copy(
currentBitmap = rotatedBitmap,
imageUri = uri,
detections = emptyList(),
visualizedBitmap = null,
leftGuidePct = 0.2f, // Reset to default
rightGuidePct = 0.8f, // Reset to default
parsedAnnotations = emptyMap() // Reset on new image
)
}
} else {
val (leftBoundPx, rightBoundPx) = SmartBoundaryDetector.detectSmartBoundaries(rotatedBitmap)

val widthFloat = rotatedBitmap.width.toFloat()
val leftPct = leftBoundPx / widthFloat
val rightPct = rightBoundPx / widthFloat

Triple(rotatedBitmap, leftPct, rightPct)
}

if (result == null) {
_uiEffect.send(ComputerVisionEffect.ShowToast(R.string.msg_no_image_selected))
return@launch
}

val (rotatedBitmap, leftPct, rightPct) = result

_uiState.update {
it.copy(
currentBitmap = rotatedBitmap,
imageUri = uri,
detections = emptyList(),
visualizedBitmap = null,
leftGuidePct = leftPct,
rightGuidePct = rightPct,
parsedAnnotations = emptyMap() // Reset on new image
)
}
} catch (e: Exception) {
Log.e(TAG, "Error loading image from URI", e)
Expand Down
32 changes: 32 additions & 0 deletions ...age-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/utils/BitmapUtils.kt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,11 +3,14 @@ package org.appdevforall.codeonthego.computervision.utils
import android.graphics.Bitmap
import android.graphics.Color
import android.graphics.RectF
import kotlin.math.abs
import kotlin.math.exp
import kotlin.math.roundToInt

object BitmapUtils {

private const val EDGE_DETECTION_THRESHOLD = 30

fun preprocessForOcr(bitmap: Bitmap, blockSize: Int = 31, c: Int = 15): Bitmap {
val width = bitmap.width
val height = bitmap.height
Expand Down Expand Up @@ -38,6 +41,35 @@ object BitmapUtils {
return Bitmap.createBitmap(bitmap, left, top, w, h)
}

fun calculateVerticalProjection(bitmap: Bitmap): FloatArray {
val width = bitmap.width
val height = bitmap.height
val pixels = IntArray(width * height)
bitmap.getPixels(pixels, 0, width, 0, 0, width, height)

val projection = FloatArray(width)
if (width < 3 || height == 0) {
return projection
}

for (y in 0 until height) {
val rowOffset = y * width
for (x in 1 until width - 1) {
val leftPixel = pixels[rowOffset + x - 1]
val rightPixel = pixels[rowOffset + x + 1]

val rLeft = (leftPixel shr 16) and 0xFF
val rRight = (rightPixel shr 16) and 0xFF

val diff = abs(rLeft - rRight)
if (diff > EDGE_DETECTION_THRESHOLD) {
projection[x] += 1f
}
}
}
return projection
}

private fun toGrayscale(pixels: IntArray): IntArray {
val gray = IntArray(pixels.size)
for (i in pixels.indices) {
Expand Down
96 changes: 96 additions & 0 deletions .../src/main/java/org/appdevforall/codeonthego/computervision/utils/SmartBoundaryDetector.kt
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,96 @@
package org.appdevforall.codeonthego.computervision.utils

import android.graphics.Bitmap
import org.appdevforall.codeonthego.computervision.utils.BitmapUtils.calculateVerticalProjection

object SmartBoundaryDetector {

private const val DEFAULT_EDGE_IGNORE_PERCENT = 0.05f
private const val LEFT_ZONE_END_PERCENT = 0.4f
private const val RIGHT_ZONE_START_PERCENT = 0.6f
private const val MIN_GAP_WIDTH_PERCENT = 0.02
private const val PRIMARY_ACTIVITY_THRESHOLD = 0.05f
private const val FALLBACK_ACTIVITY_THRESHOLD = 0.01f
private const val LEFT_FALLBACK_BOUND_PERCENT = 0.15f
private const val RIGHT_FALLBACK_BOUND_PERCENT = 0.85f

fun detectSmartBoundaries(
bitmap: Bitmap,
edgeIgnorePercent: Float = DEFAULT_EDGE_IGNORE_PERCENT
): Pair<Int, Int> {
val width = bitmap.width
val projection = calculateVerticalProjection(bitmap)
val minimumGapWidth = (width * MIN_GAP_WIDTH_PERCENT).toInt()

val ignoredEdgePixels = (width * edgeIgnorePercent).toInt()
val leftZoneEnd = (width * LEFT_ZONE_END_PERCENT).toInt()
val rightZoneStart = (width * RIGHT_ZONE_START_PERCENT).toInt()
val rightZoneEnd = width - ignoredEdgePixels

val leftSignal = projection.copyOfRange(ignoredEdgePixels, leftZoneEnd)
var (leftBound, leftGapLength) = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels)
if (leftBound == null || leftGapLength < minimumGapWidth) {
leftBound = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels, normalizeSignal = true).first
}

val rightSignal = projection.copyOfRange(rightZoneStart, rightZoneEnd)
var (rightBound, rightGapLength) = findBestGapMidpoint(rightSignal, offset = rightZoneStart)
if (rightBound == null || rightGapLength < minimumGapWidth) {
rightBound = findBestGapMidpoint(rightSignal, offset = rightZoneStart, normalizeSignal = true).first
}

val finalLeftBound = leftBound ?: (width * LEFT_FALLBACK_BOUND_PERCENT).toInt()
val finalRightBound = rightBound ?: (width * RIGHT_FALLBACK_BOUND_PERCENT).toInt()
return Pair(finalLeftBound, finalRightBound)
Comment on lines +17 to +44
Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai bot Apr 9, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue | 🟠 Major

Validate edgeIgnorePercent and range bounds before copyOfRange.

Current logic can throw IllegalArgumentException when callers pass invalid edgeIgnorePercent (e.g., negative or too large), because computed start/end indices may invert.

🛡️ Proposed fix 
     fun detectSmartBoundaries(
         bitmap: Bitmap,
         edgeIgnorePercent: Float = DEFAULT_EDGE_IGNORE_PERCENT
     ): Pair<Int, Int> {
         val width = bitmap.width
+        if (width <= 0) {
+            return Pair(0, 0)
+        }
+
+        val safeEdgeIgnorePercent = edgeIgnorePercent.coerceIn(0f, 0.49f)
         val projection = calculateVerticalProjection(bitmap)
         val minimumGapWidth = (width * MIN_GAP_WIDTH_PERCENT).toInt()
 
-        val ignoredEdgePixels = (width * edgeIgnorePercent).toInt()
-        val leftZoneEnd = (width * LEFT_ZONE_END_PERCENT).toInt()
-        val rightZoneStart = (width * RIGHT_ZONE_START_PERCENT).toInt()
-        val rightZoneEnd = width - ignoredEdgePixels
+        val ignoredEdgePixels = (width * safeEdgeIgnorePercent).toInt()
+        val leftZoneEnd = (width * LEFT_ZONE_END_PERCENT).toInt().coerceAtLeast(ignoredEdgePixels)
+        val rightZoneStart = (width * RIGHT_ZONE_START_PERCENT).toInt().coerceIn(0, width)
+        val rightZoneEnd = (width - ignoredEdgePixels).coerceAtLeast(rightZoneStart)
 
         val leftSignal = projection.copyOfRange(ignoredEdgePixels, leftZoneEnd)
         var (leftBound, leftGapLength) = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels)
         if (leftBound == null || leftGapLength < minimumGapWidth) {
             leftBound = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels, normalizeSignal = true).first
         }
 
         val rightSignal = projection.copyOfRange(rightZoneStart, rightZoneEnd)
         var (rightBound, rightGapLength) = findBestGapMidpoint(rightSignal, offset = rightZoneStart)
         if (rightBound == null || rightGapLength < minimumGapWidth) {
             rightBound = findBestGapMidpoint(rightSignal, offset = rightZoneStart, normalizeSignal = true).first
         }
 
-        val finalLeftBound = leftBound ?: (width * LEFT_FALLBACK_BOUND_PERCENT).toInt()
-        val finalRightBound = rightBound ?: (width * RIGHT_FALLBACK_BOUND_PERCENT).toInt()
+        val fallbackLeft = (width * LEFT_FALLBACK_BOUND_PERCENT).toInt()
+        val fallbackRight = (width * RIGHT_FALLBACK_BOUND_PERCENT).toInt()
+        val finalLeftBound = (leftBound ?: fallbackLeft).coerceIn(0, width - 1)
+        val finalRightBound = (rightBound ?: fallbackRight).coerceIn(finalLeftBound, width - 1)
         return Pair(finalLeftBound, finalRightBound)
     }
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
fun detectSmartBoundaries(
bitmap: Bitmap,
edgeIgnorePercent: Float = DEFAULT_EDGE_IGNORE_PERCENT
): Pair<Int, Int> {
val width = bitmap.width
val projection = calculateVerticalProjection(bitmap)
val minimumGapWidth = (width * MIN_GAP_WIDTH_PERCENT).toInt()
val ignoredEdgePixels = (width * edgeIgnorePercent).toInt()
val leftZoneEnd = (width * LEFT_ZONE_END_PERCENT).toInt()
val rightZoneStart = (width * RIGHT_ZONE_START_PERCENT).toInt()
val rightZoneEnd = width - ignoredEdgePixels
val leftSignal = projection.copyOfRange(ignoredEdgePixels, leftZoneEnd)
var (leftBound, leftGapLength) = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels)
if (leftBound == null || leftGapLength < minimumGapWidth) {
leftBound = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels, normalizeSignal = true).first
}
val rightSignal = projection.copyOfRange(rightZoneStart, rightZoneEnd)
var (rightBound, rightGapLength) = findBestGapMidpoint(rightSignal, offset = rightZoneStart)
if (rightBound == null || rightGapLength < minimumGapWidth) {
rightBound = findBestGapMidpoint(rightSignal, offset = rightZoneStart, normalizeSignal = true).first
}
val finalLeftBound = leftBound ?: (width * LEFT_FALLBACK_BOUND_PERCENT).toInt()
val finalRightBound = rightBound ?: (width * RIGHT_FALLBACK_BOUND_PERCENT).toInt()
return Pair(finalLeftBound, finalRightBound)
fun detectSmartBoundaries(
bitmap: Bitmap,
edgeIgnorePercent: Float = DEFAULT_EDGE_IGNORE_PERCENT
): Pair<Int, Int> {
val width = bitmap.width
if (width <= 0) {
return Pair(0, 0)
}
val safeEdgeIgnorePercent = edgeIgnorePercent.coerceIn(0f, 0.49f)
val projection = calculateVerticalProjection(bitmap)
val minimumGapWidth = (width * MIN_GAP_WIDTH_PERCENT).toInt()
val ignoredEdgePixels = (width * safeEdgeIgnorePercent).toInt()
val leftZoneEnd = (width * LEFT_ZONE_END_PERCENT).toInt().coerceAtLeast(ignoredEdgePixels)
val rightZoneStart = (width * RIGHT_ZONE_START_PERCENT).toInt().coerceIn(0, width)
val rightZoneEnd = (width - ignoredEdgePixels).coerceAtLeast(rightZoneStart)
val leftSignal = projection.copyOfRange(ignoredEdgePixels, leftZoneEnd)
var (leftBound, leftGapLength) = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels)
if (leftBound == null || leftGapLength < minimumGapWidth) {
leftBound = findBestGapMidpoint(leftSignal, offset = ignoredEdgePixels, normalizeSignal = true).first
}
val rightSignal = projection.copyOfRange(rightZoneStart, rightZoneEnd)
var (rightBound, rightGapLength) = findBestGapMidpoint(rightSignal, offset = rightZoneStart)
if (rightBound == null || rightGapLength < minimumGapWidth) {
rightBound = findBestGapMidpoint(rightSignal, offset = rightZoneStart, normalizeSignal = true).first
}
val fallbackLeft = (width * LEFT_FALLBACK_BOUND_PERCENT).toInt()
val fallbackRight = (width * RIGHT_FALLBACK_BOUND_PERCENT).toInt()
val finalLeftBound = (leftBound ?: fallbackLeft).coerceIn(0, width - 1)
val finalRightBound = (rightBound ?: fallbackRight).coerceIn(finalLeftBound, width - 1)
return Pair(finalLeftBound, finalRightBound)
}
🤖 Prompt for AI Agents 
Verify each finding against the current code and only fix it if needed.

In
`@cv-image-to-xml/src/main/java/org/appdevforall/codeonthego/computervision/utils/SmartBoundaryDetector.kt`
around lines 17 - 44, The detectSmartBoundaries function can pass invalid
start/end indices into projection.copyOfRange when edgeIgnorePercent is negative
or too large; before slicing the projection (and before using
leftZoneEnd/rightZoneStart/rightZoneEnd) clamp and validate computed indices:
compute ignoredEdgePixels = clamp((width * edgeIgnorePercent).toInt(), 0,
width), ensure leftZoneEnd = min((width * LEFT_ZONE_END_PERCENT).toInt(), width)
and rightZoneStart = max((width * RIGHT_ZONE_START_PERCENT).toInt(), 0), and
ensure rightZoneEnd = max(width - ignoredEdgePixels, rightZoneStart); if any
computed slice would be empty or inverted, skip findBestGapMidpoint calls and
fall back to LEFT_FALLBACK_BOUND_PERCENT/RIGHT_FALLBACK_BOUND_PERCENT (or call
findBestGapMidpoint with an empty-safe path like normalizeSignal=true) so
copyOfRange is never called with invalid ranges in detectSmartBoundaries while
keeping references to calculateVerticalProjection and findBestGapMidpoint.

}

private fun findBestGapMidpoint(
signalSegment: FloatArray,
offset: Int = 0,
normalizeSignal: Boolean = false
): Pair<Int?, Int> {
if (signalSegment.isEmpty()) {
return Pair(null, 0)
}

val signal = if (normalizeSignal) {
val minValue = signalSegment.minOrNull() ?: 0f
FloatArray(signalSegment.size) { index -> signalSegment[index] - minValue }
} else {
signalSegment
}

val activityThresholdMultiplier = if (normalizeSignal) {
FALLBACK_ACTIVITY_THRESHOLD
} else {
PRIMARY_ACTIVITY_THRESHOLD
}
val threshold = (signal.maxOrNull() ?: 0f) * activityThresholdMultiplier

var maxGapLength = 0
var maxGapMidpoint: Int? = null
var currentGapStart = -1
var previousIsActive = false

signal.forEachIndexed { index, value ->
val isActive = value > threshold
if (previousIsActive && !isActive) {
currentGapStart = index
}

val isGapClosing = currentGapStart != -1 && (index + 1 == signal.size || (!isActive && signal[index + 1] > threshold))
if (isGapClosing) {
val gapLength = index - currentGapStart + 1
if (gapLength > maxGapLength) {
maxGapLength = gapLength
maxGapMidpoint = currentGapStart + (gapLength / 2)
}
currentGapStart = -1
}

previousIsActive = isActive
}

return Pair(maxGapMidpoint?.plus(offset), maxGapLength)
}
}
Loading