V0.4.0加入锁定二维码
This commit is contained in:
@@ -0,0 +1,100 @@
|
||||
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
|
||||
}
|
||||
|
||||
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<Pair<Float, Float>>,
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user