Refine OverlayView; Remove OcrPostProcessorTest

Author: longipinnatus

app/build.gradle.kts

@@ -13,8 +13,8 @@ android {
         applicationId = "com.longipinnatus.screentrans"
         minSdk = 26
         targetSdk = 37
-        versionCode = 26050201
-        versionName = "0.1.1"
+        versionCode = 26050701
+        versionName = "0.1.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         versionNameSuffix = "-alpha"

app/src/main/kotlin/com/longipinnatus/screentrans/LogActivity.kt

@@ -249,7 +249,7 @@ class LogActivity : ComponentActivity() {
                                 val clipboard = context.getSystemService(CLIPBOARD_SERVICE) as ClipboardManager
                                 val clip = ClipData.newPlainText("log_data", text)
                                 clipboard.setPrimaryClip(clip)
-                                Toast.makeText(context, resources.getString(R.string.copied_to_clipboard), Toast.LENGTH_SHORT).show()
+                                Toast.makeText(context, resources.getString(R.string.copied_to_clipboard, label), Toast.LENGTH_SHORT).show()
                             }
                         )
                     }

app/src/main/kotlin/com/longipinnatus/screentrans/OcrEntities.kt

@@ -75,9 +75,6 @@ data class TextBlock(
     var backgroundColor: Int? = null,
     var colorWeight: Int = 0
 ) : OcrEntity {
-    val firstLineBounds: Rect get() = lines.firstOrNull()?.bounds ?: bounds
-    val lastLineBounds: Rect get() = lines.lastOrNull()?.bounds ?: bounds
-
     fun offset(dx: Int, dy: Int) {
         bounds.offset(dx, dy)
         lines.forEach { it.offset(dx, dy) }

app/src/main/kotlin/com/longipinnatus/screentrans/OverlayView.kt

@@ -6,6 +6,7 @@ import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.RectF
 import android.graphics.Typeface
+import android.os.Build
 import android.text.Layout
 import android.text.StaticLayout
 import android.text.TextPaint
@@ -41,14 +42,14 @@ class OverlayView @JvmOverloads constructor(
                 null
             }
         } ?: Typeface.DEFAULT
-        
+
         val style = when {
             settings.overlayFontBold && settings.overlayFontItalic -> Typeface.BOLD_ITALIC
             settings.overlayFontBold -> Typeface.BOLD
             settings.overlayFontItalic -> Typeface.ITALIC
             else -> Typeface.NORMAL
         }
-        
+
         typeface = Typeface.create(baseTypeface, style)
     }
 
@@ -86,17 +87,17 @@ class OverlayView @JvmOverloads constructor(
 
     fun updateStreamingDeadline(incrementalTextLength: Int) {
         if (incrementalTextLength <= 0) return
-        
+
         val currentTime = System.currentTimeMillis()
         streamingDeadline = max(streamingDeadline, currentTime) + (incrementalTextLength.toLong() * settings.durationPerWordMs)
     }
 
     override fun onDraw(canvas: Canvas) {
         super.onDraw(canvas)
-        
+
         // Get the current view's absolute position offset on the screen
         getLocationOnScreen(locationOnScreen)
-        
+
         val screenWidth = resources.displayMetrics.widthPixels
         val screenHeight = resources.displayMetrics.heightPixels
 
@@ -126,13 +127,15 @@ class OverlayView @JvmOverloads constructor(
             } else {
                 drawHorizontalBlock(canvas, block, text, localLeft, localTop)
             }
+        }
 
-            if (settings.showBoxes) {
+        if (settings.showBoxes) {
+            textBlocks.forEach { block ->
                 debugRect.set(
-                    bounds.left.toFloat() - locationOnScreen[0],
-                    bounds.top.toFloat() - locationOnScreen[1],
-                    bounds.right.toFloat() - locationOnScreen[0],
-                    bounds.bottom.toFloat() - locationOnScreen[1]
+                    block.bounds.left.toFloat() - locationOnScreen[0],
+                    block.bounds.top.toFloat() - locationOnScreen[1],
+                    block.bounds.right.toFloat() - locationOnScreen[0],
+                    block.bounds.bottom.toFloat() - locationOnScreen[1]
                 )
                 canvas.drawRect(debugRect, boxPaint)
             }
@@ -171,31 +174,60 @@ class OverlayView @JvmOverloads constructor(
                 bgPaint.color = Color.argb(alpha, Color.red(it), Color.green(it), Color.blue(it))
             }
         }
-        
-        // Prioritize original line height for font size
-        val originalLineHeight = block.firstLineBounds.height().toFloat()
-        textPaint.textSize = originalLineHeight.coerceIn(12f, 120f)
-        
-        var layout = createStaticLayout(text, targetWidth.toInt())
-        
-        // Scaling strategy: fill the original area as much as possible while maintaining layout consistency
-        if (layout.height > targetHeight * 1.1f) {
-            while (layout.height > targetHeight * 1.1f && textPaint.textSize > 12f) {
-                textPaint.textSize -= 0.5f
-                layout = createStaticLayout(text, targetWidth.toInt())
+
+        // 1. Set font size based on median box height
+        val medianBoxHeight = block.lines.map { it.bounds.height().toFloat() }.median()
+        textPaint.textSize = medianBoxHeight.coerceIn(12f, 120f)
+
+        // Get font metrics for precise height calculation
+        var fm = textPaint.fontMetrics
+        var fontHeight = fm.descent - fm.ascent
+
+        // 2. Calculate line spacing multiplier precisely to match original line distance
+        // Use fontHeight as denominator to eliminate downward drift
+        val lineSpacingMulti = if (block.lines.size > 1) {
+            val dist = block.lines.zipWithNext { a, b -> (b.bounds.top - a.bounds.top).toFloat() }
+                .filter { it > 0 }
+            if (dist.isNotEmpty()) (dist.median() / fontHeight).coerceIn(0.5f, 3.0f) else 1.0f
+        } else 1.0f
+
+        fun buildLayout() = StaticLayout.Builder.obtain(text, 0, text.length, textPaint, max(10, targetWidth.toInt()))
+            .setAlignment(Layout.Alignment.ALIGN_NORMAL)
+            .setLineSpacing(0f, lineSpacingMulti)
+            .setIncludePad(false)
+            .apply {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                    setUseLineSpacingFromFallbacks(false)
+                }
             }
-        } else if (layout.lineCount == 1 && layout.height < targetHeight * 0.8f) {
-            // If only one line and there's plenty of height, scale up to fill width or height
-            while (layout.height < targetHeight * 0.9f && getMaxLineWidth(layout) < targetWidth * 0.9f && textPaint.textSize < originalLineHeight * 1.2f) {
-                textPaint.textSize += 0.5f
-                layout = createStaticLayout(text, targetWidth.toInt())
+            .build()
+
+        var layout = buildLayout()
+
+        // 3. Scaling strategy: shrink text if it wraps more than expected or exceeds target height
+        val expectedLineCount = max(1, block.lines.size)
+        val shouldShrink = {
+            layout.lineCount > expectedLineCount || (expectedLineCount > 1 && layout.height > targetHeight * 1.05f)
+        }
+
+        if (shouldShrink()) {
+            while (shouldShrink() && textPaint.textSize > 12f) {
+                textPaint.textSize -= 0.5f
+                layout = buildLayout()
             }
+            // Update metrics after final size is decided
+            fm = textPaint.fontMetrics
+            fontHeight = fm.descent - fm.ascent
         }
 
+
         val actualTextWidth = getMaxLineWidth(layout)
         val finalWidth = max(targetWidth, actualTextWidth)
         val finalHeight = max(targetHeight, layout.height.toFloat())
 
+        // 4. Calculate vertical offset to center the font in the box height
+        val verticalOffset = (medianBoxHeight - fontHeight) / 2f
+
         val drawRect = RectF(left, top, left + finalWidth, top + finalHeight)
 
         // Check if the drawing area exceeds the current view bounds (screen bounds)
@@ -206,7 +238,8 @@ class OverlayView @JvmOverloads constructor(
         // Use a rectangular box for a "textbox" feel and better coverage of original text
         canvas.drawRect(drawRect, bgPaint)
 
-        canvas.withTranslation(drawRect.left, drawRect.top) {
+        // Apply translation with vertical centering offset
+        canvas.withTranslation(drawRect.left, drawRect.top + verticalOffset) {
             layout.draw(this)
         }
 
@@ -230,17 +263,25 @@ class OverlayView @JvmOverloads constructor(
                 bgPaint.color = Color.argb(alpha, Color.red(it), Color.green(it), Color.blue(it))
             }
         }
-        
-        val originalColWidth = block.firstLineBounds.width().toFloat()
-        var bestTextSize = originalColWidth.coerceIn(12f, 120f)
-        
+
+        // Prioritize median column width for font size
+        val medianColWidth = block.lines.map { it.bounds.width().toFloat() }.median()
+        var bestTextSize = medianColWidth.coerceIn(12f, 120f)
+
+        // Calculate column spacing multiplier from original lines
+        val colSpacingMulti = if (block.lines.size > 1) {
+            val dist = block.lines.zipWithNext { a, b -> kotlin.math.abs(b.bounds.left - a.bounds.left).toFloat() }
+                .filter { it > 0 }
+            if (dist.isNotEmpty()) (dist.median() / medianColWidth).coerceIn(0.8f, 2.5f) else 1.2f
+        } else 1.2f
+
         fun layoutVertical(size: Float): List<List<String>> {
             textPaint.textSize = size
             val paragraphs = text.split("\n")
             val allCols = mutableListOf<List<String>>()
             val charHeight = size * 1.1f
             val maxCharsPerCol = (targetHeight / charHeight).toInt().coerceAtLeast(1)
-            
+
             paragraphs.forEach { para ->
                 if (para.isEmpty()) {
                     allCols.add(emptyList())
@@ -257,17 +298,17 @@ class OverlayView @JvmOverloads constructor(
         }
 
         var columnGroups = layoutVertical(bestTextSize)
-        val colWidth = bestTextSize * 1.2f
+        val colWidth = bestTextSize * colSpacingMulti
 
         // Adjust vertical layout to match the original width
         if (columnGroups.size * colWidth > targetWidth * 1.1f) {
-            while (columnGroups.size * (bestTextSize * 1.2f) > targetWidth * 1.1f && bestTextSize > 12f) {
+            while (columnGroups.size * (bestTextSize * colSpacingMulti) > targetWidth * 1.1f && bestTextSize > 12f) {
                 bestTextSize -= 0.5f
                 columnGroups = layoutVertical(bestTextSize)
             }
         }
 
-        val finalColWidth = bestTextSize * 1.2f
+        val finalColWidth = bestTextSize * colSpacingMulti
         val totalColsWidth = columnGroups.size * finalColWidth
         val finalWidth = max(targetWidth, totalColsWidth)
 
@@ -280,14 +321,19 @@ class OverlayView @JvmOverloads constructor(
 
         canvas.drawRect(drawRect, bgPaint)
 
+        val vFm = textPaint.fontMetrics
+        val vFontHeight = vFm.descent - vFm.ascent
+        val vOffset = (bestTextSize - vFontHeight) / 2f
+
         columnGroups.forEachIndexed { colIdx, chars ->
             // Vertical text is usually right-to-left
             val colX = drawRect.right - (colIdx + 1) * finalColWidth
-            var currentY = drawRect.top
+            var currentY = drawRect.top + vOffset
 
             chars.forEach { charStr ->
                 val charW = textPaint.measureText(charStr)
-                canvas.drawText(charStr, colX + (finalColWidth - charW) / 2, currentY + bestTextSize, textPaint)
+                // Draw text using ascent for precise baseline alignment
+                canvas.drawText(charStr, colX + (finalColWidth - charW) / 2, currentY - vFm.ascent, textPaint)
                 currentY += bestTextSize * 1.1f
             }
         }
@@ -306,12 +352,14 @@ class OverlayView @JvmOverloads constructor(
         return maxW
     }
 
-    private fun createStaticLayout(text: String, width: Int): StaticLayout {
-        return StaticLayout.Builder.obtain(text, 0, text.length, textPaint, max(10, width))
-            .setAlignment(Layout.Alignment.ALIGN_NORMAL)
-            .setLineSpacing(0f, 1.0f)
-            .setIncludePad(false)
-            .build()
+    private fun List<Float>.median(): Float {
+        if (isEmpty()) throw NoSuchElementException("Cannot calculate median of an empty list")
+        val sorted = sorted()
+        return if (size % 2 == 0) {
+            (sorted[size / 2 - 1] + sorted[size / 2]) / 2f
+        } else {
+            sorted[size / 2]
+        }
     }
 
     private fun calculateDelay(): Long {
@@ -320,7 +368,7 @@ class OverlayView @JvmOverloads constructor(
         }
 
         val currentTime = System.currentTimeMillis()
-        
+
         // Explicit check: whether in "streaming translation" mode that requires cumulative budget
         val isStreamingFlow = settings.enableStreaming && !settings.ocrOnly