package com.qft.optical import kotlin.math.abs import kotlin.math.max import kotlin.math.min /** * Pure geometry used by the optical scanner. Kept Android-free so it can be * unit tested on the host JVM. */ data class LockRect( val left: Int, val top: Int, val width: Int, val height: Int, ) { val right: Int get() = left + width val bottom: Int get() = top + height fun clamp(frameWidth: Int, frameHeight: Int): LockRect { val l = left.coerceIn(0, (frameWidth - 1).coerceAtLeast(0)) val t = top.coerceIn(0, (frameHeight - 1).coerceAtLeast(0)) val r = right.coerceIn(l + 1, frameWidth.coerceAtLeast(l + 1)) val b = bottom.coerceIn(t + 1, frameHeight.coerceAtLeast(t + 1)) return LockRect(l, t, r - l, b - t) } fun expand(frameWidth: Int, frameHeight: Int, factor: Float): LockRect { val f = factor.coerceAtLeast(1f) val cx = left + width / 2f val cy = top + height / 2f val w = (width * f).toInt().coerceAtLeast(96) val h = (height * f).toInt().coerceAtLeast(96) return LockRect((cx - w / 2f).toInt(), (cy - h / 2f).toInt(), w, h) .clamp(frameWidth, frameHeight) } fun smoothToward(target: LockRect, alpha: Float): LockRect { val a = alpha.coerceIn(0f, 1f) fun mix(x: Int, y: Int) = (x + (y - x) * a).toInt() return LockRect( mix(left, target.left), mix(top, target.top), mix(width, target.width), mix(height, target.height), ) } fun areaFraction(frameWidth: Int, frameHeight: Int): Float { val total = frameWidth.toLong() * frameHeight.toLong() if (total <= 0L) return 1f return ((width.toLong() * height.toLong()).toDouble() / total.toDouble()).toFloat() } fun materiallyDiffers(other: LockRect?): Boolean { if (other == null) return true val d = abs(left - other.left) + abs(top - other.top) + abs(width - other.width) + abs(height - other.height) return d > max(width, height) / 18 } /** Intersection-over-union for consecutive finder-point measurements. */ fun overlap(other: LockRect?): Float { if (other == null) return 0f val l = max(left, other.left) val t = max(top, other.top) val r = min(right, other.right) val b = min(bottom, other.bottom) val intersection = max(0, r - l).toLong() * max(0, b - t).toLong() val union = width.toLong() * height.toLong() + other.width.toLong() * other.height.toLong() - intersection return if (union <= 0L) 0f else (intersection.toDouble() / union.toDouble()).toFloat() } companion object { /** * ZXing normally returns the finder-pattern centers. Their bounding box * is smaller than the full symbol, so enlarge to roughly 1.28x and force * a square ROI. This keeps the complete quiet zone while discarding most * of the camera frame after lock-on. */ fun fromPoints( points: List>, frameWidth: Int, frameHeight: Int, ): LockRect? { if (points.size < 3 || frameWidth < 2 || frameHeight < 2) return null val minX = points.minOf { it.first } val maxX = points.maxOf { it.first } val minY = points.minOf { it.second } val maxY = points.maxOf { it.second } val span = max(maxX - minX, maxY - minY) if (span < 24f) return null val side = (span * 1.28f).toInt().coerceAtLeast(128) val cx = (minX + maxX) * 0.5f val cy = (minY + maxY) * 0.5f return LockRect( (cx - side / 2f).toInt(), (cy - side / 2f).toInt(), side, side, ).clamp(frameWidth, frameHeight) } fun centeredSearch(frameWidth: Int, frameHeight: Int, fraction: Float = 0.92f): LockRect { val f = fraction.coerceIn(0.5f, 1f) val w = (frameWidth * f).toInt().coerceAtLeast(1) val h = (frameHeight * f).toInt().coerceAtLeast(1) return LockRect((frameWidth - w) / 2, (frameHeight - h) / 2, w, h) } } }