Compare commits
7 Commits
master
...
feature/pg
| Author | SHA1 | Date |
|---|---|---|
 Dan
|
9e55ffa944 | 5 months ago |
|
Dan
|
3ed31a0d81 | 5 months ago |
|
Dan
|
e25eadc566 | 5 months ago |
|
Dan
|
e4ecfa6997 | 5 months ago |
|
Dan
|
17f0a1f202 | 5 months ago |
|
Dan
|
2d98941f63 | 5 months ago |
|
Dan
|
39635fedff | 5 months ago |
8 changed files with 1650 additions and 18 deletions
@ -0,0 +1,548 @@ |
|||||
|
package com.quillstudios.pokegoalshelper.capture |
||||
|
|
||||
|
import android.content.Context |
||||
|
import android.graphics.Bitmap |
||||
|
import android.graphics.PixelFormat |
||||
|
import android.hardware.display.DisplayManager |
||||
|
import android.hardware.display.VirtualDisplay |
||||
|
import android.media.Image |
||||
|
import android.media.ImageReader |
||||
|
import android.media.projection.MediaProjection |
||||
|
import android.os.Handler |
||||
|
import android.os.Looper |
||||
|
import com.quillstudios.pokegoalshelper.utils.PGHLog |
||||
|
import com.quillstudios.pokegoalshelper.stitching.ImageStitcher |
||||
|
import kotlinx.coroutines.* |
||||
|
import java.io.File |
||||
|
import java.io.FileOutputStream |
||||
|
import java.util.concurrent.ConcurrentLinkedQueue |
||||
|
import java.util.concurrent.CountDownLatch |
||||
|
import java.util.concurrent.TimeUnit |
||||
|
import java.util.concurrent.atomic.AtomicBoolean |
||||
|
import java.util.concurrent.atomic.AtomicInteger |
||||
|
|
||||
|
/** |
||||
|
* Long screenshot capture system that works alongside existing MediaProjection setup. |
||||
|
* |
||||
|
* Features: |
||||
|
* - Independent capture system using shared MediaProjection |
||||
|
* - Manual screenshot collection management |
||||
|
* - Thread-safe screenshot queue |
||||
|
* - Proper memory management and cleanup |
||||
|
* - Error handling and recovery |
||||
|
* - Image storage and retrieval |
||||
|
*/ |
||||
|
class LongScreenshotCapture( |
||||
|
private val context: Context, |
||||
|
private val handler: Handler = Handler(Looper.getMainLooper()) |
||||
|
) |
||||
|
{ |
||||
|
companion object |
||||
|
{ |
||||
|
private const val TAG = "LongScreenshotCapture" |
||||
|
private const val BUFFER_COUNT = 2 |
||||
|
private const val CAPTURE_TIMEOUT_MS = 5000L |
||||
|
private const val MAX_SCREENSHOTS = 50 |
||||
|
} |
||||
|
|
||||
|
// Core components |
||||
|
private var mediaProjection: MediaProjection? = null |
||||
|
|
||||
|
// Screen dimensions |
||||
|
private var screenWidth = 0 |
||||
|
private var screenHeight = 0 |
||||
|
private var screenDensity = 0 |
||||
|
|
||||
|
// State management |
||||
|
private val isInitialized = AtomicBoolean(false) |
||||
|
private val isCapturing = AtomicBoolean(false) |
||||
|
private val screenshotCount = AtomicInteger(0) |
||||
|
|
||||
|
// Screenshot collection |
||||
|
private val capturedScreenshots = ConcurrentLinkedQueue<CapturedScreenshot>() |
||||
|
private val captureScope = CoroutineScope(Dispatchers.IO + SupervisorJob()) |
||||
|
|
||||
|
// Image stitching |
||||
|
private val imageStitcher: ImageStitcher by lazy { ImageStitcher(context) } |
||||
|
|
||||
|
// Storage |
||||
|
private val storageDir: File by lazy { |
||||
|
File(context.filesDir, "long_screenshots").apply { |
||||
|
if (!exists()) mkdirs() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Callbacks |
||||
|
private var progressCallback: ((count: Int) -> Unit)? = null |
||||
|
private var errorCallback: ((error: String) -> Unit)? = null |
||||
|
private var stitchingProgressCallback: ((progress: Float, message: String) -> Unit)? = null |
||||
|
private var stitchingCompleteCallback: ((result: ImageStitcher.StitchingResult) -> Unit)? = null |
||||
|
|
||||
|
// Configuration |
||||
|
private var keepIndividualScreenshots = true // Keep originals when stitching |
||||
|
private var debugMode = false // Debug mode for development/testing |
||||
|
|
||||
|
/** |
||||
|
* Initialize the long screenshot system (lightweight - no VirtualDisplay needed) |
||||
|
*/ |
||||
|
fun initialize(mediaProjection: MediaProjection, screenWidth: Int, screenHeight: Int, screenDensity: Int): Boolean |
||||
|
{ |
||||
|
if (isInitialized.get()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "Long screenshot capture already initialized") |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🔧 Initializing long screenshot capture system") |
||||
|
|
||||
|
this.mediaProjection = mediaProjection |
||||
|
this.screenWidth = screenWidth |
||||
|
this.screenHeight = screenHeight |
||||
|
this.screenDensity = screenDensity |
||||
|
|
||||
|
// Note: We don't create our own VirtualDisplay/ImageReader since Android doesn't allow |
||||
|
// multiple VirtualDisplays from the same MediaProjection. Instead, we'll capture |
||||
|
// screenshots by requesting them from the existing screen capture system. |
||||
|
|
||||
|
isInitialized.set(true) |
||||
|
PGHLog.i(TAG, "✅ Long screenshot capture system initialized successfully (lightweight mode)") |
||||
|
return true |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error initializing long screenshot capture", e) |
||||
|
cleanup() |
||||
|
return false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Start long screenshot collection session |
||||
|
*/ |
||||
|
fun startCollection(): Boolean |
||||
|
{ |
||||
|
if (!isInitialized.get()) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Cannot start collection - not initialized") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
if (isCapturing.get()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ Collection already in progress") |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🚀 Starting long screenshot collection") |
||||
|
|
||||
|
// Clear any previous screenshots |
||||
|
clearStoredScreenshots() |
||||
|
capturedScreenshots.clear() |
||||
|
screenshotCount.set(0) |
||||
|
|
||||
|
isCapturing.set(true) |
||||
|
PGHLog.i(TAG, "✅ Long screenshot collection started") |
||||
|
|
||||
|
return true |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error starting collection", e) |
||||
|
errorCallback?.invoke("Failed to start collection: ${e.message}") |
||||
|
return false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Capture a single frame manually (on-demand) |
||||
|
* This will be called by the service which will provide the actual image data |
||||
|
*/ |
||||
|
fun captureFrame(imageData: Bitmap?): Boolean |
||||
|
{ |
||||
|
if (!isCapturing.get()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ Cannot capture - collection not active") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
if (screenshotCount.get() >= MAX_SCREENSHOTS) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ Maximum screenshots reached ($MAX_SCREENSHOTS)") |
||||
|
errorCallback?.invoke("Maximum screenshots reached") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
return try |
||||
|
{ |
||||
|
PGHLog.d(TAG, "📸 Processing manual frame capture") |
||||
|
|
||||
|
if (imageData != null) |
||||
|
{ |
||||
|
PGHLog.d(TAG, "📸 Image data received, processing...") |
||||
|
|
||||
|
// Process the bitmap in a coroutine |
||||
|
captureScope.launch { |
||||
|
processBitmapAsync(imageData) |
||||
|
} |
||||
|
return true |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ No image data provided") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error capturing frame", e) |
||||
|
errorCallback?.invoke("Capture failed: ${e.message}") |
||||
|
false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Stop collection and return captured screenshots |
||||
|
*/ |
||||
|
fun finishCollection(): List<CapturedScreenshot> |
||||
|
{ |
||||
|
if (!isCapturing.get()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ No collection in progress") |
||||
|
return emptyList() |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🏁 Finishing long screenshot collection") |
||||
|
|
||||
|
isCapturing.set(false) |
||||
|
|
||||
|
val screenshots = capturedScreenshots.toList() |
||||
|
PGHLog.i(TAG, "✅ Collection finished with ${screenshots.size} screenshots") |
||||
|
|
||||
|
return screenshots |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error finishing collection", e) |
||||
|
errorCallback?.invoke("Failed to finish collection: ${e.message}") |
||||
|
return emptyList() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Stop collection and automatically stitch screenshots into a single image |
||||
|
*/ |
||||
|
fun finishCollectionAndStitch() |
||||
|
{ |
||||
|
if (!isCapturing.get()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ No collection in progress") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🏁 Finishing collection and starting stitching process") |
||||
|
|
||||
|
val screenshots = finishCollection() |
||||
|
if (screenshots.isEmpty()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ No screenshots to stitch") |
||||
|
stitchingCompleteCallback?.invoke( |
||||
|
ImageStitcher.StitchingResult(false, errorMessage = "No screenshots to stitch") |
||||
|
) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// Start stitching process |
||||
|
captureScope.launch { |
||||
|
stitchScreenshots(screenshots) |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error starting stitching process", e) |
||||
|
stitchingCompleteCallback?.invoke( |
||||
|
ImageStitcher.StitchingResult(false, errorMessage = "Failed to start stitching: ${e.message}") |
||||
|
) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private suspend fun stitchScreenshots(screenshots: List<CapturedScreenshot>) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🧩 Starting stitching process with ${screenshots.size} screenshots") |
||||
|
|
||||
|
// Notify progress |
||||
|
stitchingProgressCallback?.invoke(0.1f, "Starting image stitching...") |
||||
|
|
||||
|
// Perform stitching |
||||
|
val result = imageStitcher.stitchScreenshots(screenshots) |
||||
|
|
||||
|
// If stitching succeeded and we don't want to keep individual screenshots, clean them up |
||||
|
// Debug mode always keeps screenshots for analysis |
||||
|
if (result.success && !keepIndividualScreenshots && !debugMode) |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🧹 Cleaning up individual screenshots as requested") |
||||
|
screenshots.forEach { screenshot -> |
||||
|
try |
||||
|
{ |
||||
|
File(screenshot.filePath).delete() |
||||
|
PGHLog.d(TAG, "🗑️ Deleted: ${screenshot.filename}") |
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ Failed to delete: ${screenshot.filename}", e) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
else if (debugMode) |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🐛 Debug mode: Keeping all individual screenshots for analysis") |
||||
|
} |
||||
|
|
||||
|
// Notify completion |
||||
|
PGHLog.i(TAG, "🧩 Stitching process completed: success=${result.success}") |
||||
|
stitchingCompleteCallback?.invoke(result) |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error during stitching process", e) |
||||
|
stitchingCompleteCallback?.invoke( |
||||
|
ImageStitcher.StitchingResult(false, errorMessage = "Stitching failed: ${e.message}") |
||||
|
) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Cancel current collection |
||||
|
*/ |
||||
|
fun cancelCollection() |
||||
|
{ |
||||
|
if (!isCapturing.get()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ No collection to cancel") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "❌ Canceling long screenshot collection") |
||||
|
|
||||
|
isCapturing.set(false) |
||||
|
|
||||
|
// Clear captured screenshots |
||||
|
capturedScreenshots.clear() |
||||
|
screenshotCount.set(0) |
||||
|
clearStoredScreenshots() |
||||
|
|
||||
|
PGHLog.i(TAG, "✅ Collection canceled") |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error canceling collection", e) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Get current screenshot count |
||||
|
*/ |
||||
|
fun getScreenshotCount(): Int = screenshotCount.get() |
||||
|
|
||||
|
/** |
||||
|
* Check if collection is active |
||||
|
*/ |
||||
|
fun isCollectionActive(): Boolean = isCapturing.get() |
||||
|
|
||||
|
/** |
||||
|
* Set progress callback |
||||
|
*/ |
||||
|
fun setProgressCallback(callback: (count: Int) -> Unit) |
||||
|
{ |
||||
|
this.progressCallback = callback |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Set error callback |
||||
|
*/ |
||||
|
fun setErrorCallback(callback: (error: String) -> Unit) |
||||
|
{ |
||||
|
this.errorCallback = callback |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Set stitching progress callback |
||||
|
*/ |
||||
|
fun setStitchingProgressCallback(callback: (progress: Float, message: String) -> Unit) |
||||
|
{ |
||||
|
this.stitchingProgressCallback = callback |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Set stitching completion callback |
||||
|
*/ |
||||
|
fun setStitchingCompleteCallback(callback: (result: ImageStitcher.StitchingResult) -> Unit) |
||||
|
{ |
||||
|
this.stitchingCompleteCallback = callback |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Configure whether to keep individual screenshots when stitching |
||||
|
* @param keep true to keep individual screenshots, false to delete them after stitching |
||||
|
*/ |
||||
|
fun setKeepIndividualScreenshots(keep: Boolean) |
||||
|
{ |
||||
|
this.keepIndividualScreenshots = keep |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Enable debug mode for stitching development |
||||
|
* In debug mode, individual screenshots are always kept and additional logging is enabled |
||||
|
* @param enabled true to enable debug mode |
||||
|
*/ |
||||
|
fun setDebugMode(enabled: Boolean) |
||||
|
{ |
||||
|
this.debugMode = enabled |
||||
|
if (enabled) |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🐛 Debug mode enabled for long screenshot stitching") |
||||
|
this.keepIndividualScreenshots = true // Always keep screenshots in debug mode |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private suspend fun processBitmapAsync(bitmap: Bitmap) = withContext(Dispatchers.IO) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
val timestamp = System.currentTimeMillis() |
||||
|
val filename = "screenshot_${timestamp}.png" |
||||
|
val file = File(storageDir, filename) |
||||
|
|
||||
|
// Save bitmap to file |
||||
|
saveBitmapToFile(bitmap, file) |
||||
|
|
||||
|
val screenshot = CapturedScreenshot( |
||||
|
id = timestamp, |
||||
|
filename = filename, |
||||
|
filePath = file.absolutePath, |
||||
|
timestamp = timestamp, |
||||
|
width = bitmap.width, |
||||
|
height = bitmap.height |
||||
|
) |
||||
|
|
||||
|
capturedScreenshots.offer(screenshot) |
||||
|
val count = screenshotCount.incrementAndGet() |
||||
|
|
||||
|
PGHLog.i(TAG, "📸 Screenshot #$count captured: $filename") |
||||
|
|
||||
|
// Notify progress on main thread |
||||
|
handler.post { |
||||
|
progressCallback?.invoke(count) |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error processing bitmap", e) |
||||
|
errorCallback?.invoke("Failed to save screenshot: ${e.message}") |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
// Always recycle the bitmap after processing |
||||
|
if (!bitmap.isRecycled) { |
||||
|
bitmap.recycle() |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
private fun saveBitmapToFile(bitmap: Bitmap, file: File) |
||||
|
{ |
||||
|
FileOutputStream(file).use { stream -> |
||||
|
bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun clearStoredScreenshots() |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
storageDir.listFiles()?.forEach { file -> |
||||
|
if (file.name.startsWith("screenshot_") && file.name.endsWith(".png")) |
||||
|
{ |
||||
|
file.delete() |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error clearing stored screenshots", e) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Clean up resources |
||||
|
*/ |
||||
|
fun cleanup() |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🧹 Cleaning up long screenshot capture") |
||||
|
|
||||
|
isCapturing.set(false) |
||||
|
isInitialized.set(false) |
||||
|
|
||||
|
// Cancel any ongoing coroutines |
||||
|
captureScope.cancel() |
||||
|
|
||||
|
// Clear collections |
||||
|
capturedScreenshots.clear() |
||||
|
screenshotCount.set(0) |
||||
|
|
||||
|
// Clear stored files |
||||
|
clearStoredScreenshots() |
||||
|
|
||||
|
// Clean up stitcher |
||||
|
imageStitcher.cleanup() |
||||
|
|
||||
|
// Clear references |
||||
|
mediaProjection = null |
||||
|
progressCallback = null |
||||
|
errorCallback = null |
||||
|
stitchingProgressCallback = null |
||||
|
stitchingCompleteCallback = null |
||||
|
|
||||
|
PGHLog.i(TAG, "✅ Long screenshot capture cleaned up") |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error during cleanup", e) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Data class representing a captured screenshot |
||||
|
*/ |
||||
|
data class CapturedScreenshot( |
||||
|
val id: Long, |
||||
|
val filename: String, |
||||
|
val filePath: String, |
||||
|
val timestamp: Long, |
||||
|
val width: Int, |
||||
|
val height: Int |
||||
|
) |
||||
@ -0,0 +1,574 @@ |
|||||
|
package com.quillstudios.pokegoalshelper.stitching |
||||
|
|
||||
|
import android.graphics.Bitmap |
||||
|
import android.util.Log |
||||
|
import com.quillstudios.pokegoalshelper.capture.CapturedScreenshot |
||||
|
import com.quillstudios.pokegoalshelper.utils.PGHLog |
||||
|
import com.quillstudios.pokegoalshelper.utils.MatUtils.use |
||||
|
import com.quillstudios.pokegoalshelper.utils.MatUtils.useMats |
||||
|
import com.quillstudios.pokegoalshelper.utils.MatUtils.releaseSafely |
||||
|
import kotlinx.coroutines.* |
||||
|
import org.opencv.android.Utils |
||||
|
import org.opencv.core.* |
||||
|
import org.opencv.imgproc.Imgproc |
||||
|
import org.opencv.imgcodecs.Imgcodecs |
||||
|
import java.io.File |
||||
|
import java.io.FileOutputStream |
||||
|
import kotlin.math.* |
||||
|
|
||||
|
/** |
||||
|
* OpenCV-based image stitching engine for combining long screenshots. |
||||
|
* |
||||
|
* Features: |
||||
|
* - Template matching for overlap detection |
||||
|
* - Precise alignment using correlation coefficients |
||||
|
* - Vertical image concatenation with blending |
||||
|
* - Quality assessment for stitching results |
||||
|
* - Memory optimization for large image processing |
||||
|
* - Error recovery for failed stitching operations |
||||
|
*/ |
||||
|
class ImageStitcher( |
||||
|
private val context: android.content.Context |
||||
|
) |
||||
|
{ |
||||
|
companion object |
||||
|
{ |
||||
|
private const val TAG = "ImageStitcher" |
||||
|
|
||||
|
// Template matching parameters |
||||
|
private const val MIN_OVERLAP_RATIO = 0.1f // 10% minimum overlap |
||||
|
private const val MAX_OVERLAP_RATIO = 0.8f // 80% maximum overlap |
||||
|
private const val CORRELATION_THRESHOLD = 0.3f // Template matching threshold (real screenshots often have lower correlation) |
||||
|
|
||||
|
// Memory management |
||||
|
private const val MAX_IMAGE_DIMENSION = 4096 // Max width/height for processing |
||||
|
private const val TILE_PROCESSING_SIZE = 1024 // Process in tiles to save memory |
||||
|
|
||||
|
// Quality assessment |
||||
|
private const val MIN_QUALITY_SCORE = 0.6f // Minimum acceptable quality |
||||
|
} |
||||
|
|
||||
|
// Storage |
||||
|
private val outputDir: File by lazy { |
||||
|
File(context.filesDir, "stitched_screenshots").apply { |
||||
|
if (!exists()) mkdirs() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Processing scope |
||||
|
private val stitchingScope = CoroutineScope(Dispatchers.IO + SupervisorJob()) |
||||
|
|
||||
|
/** |
||||
|
* Result of stitching operation |
||||
|
*/ |
||||
|
data class StitchingResult( |
||||
|
val success: Boolean, |
||||
|
val outputPath: String? = null, |
||||
|
val qualityScore: Float = 0f, |
||||
|
val errorMessage: String? = null, |
||||
|
val processedCount: Int = 0, |
||||
|
val finalDimensions: Pair<Int, Int>? = null |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* Overlap detection result |
||||
|
*/ |
||||
|
data class OverlapInfo( |
||||
|
val detected: Boolean, |
||||
|
val offsetY: Int = 0, |
||||
|
val confidence: Float = 0f, |
||||
|
val overlapHeight: Int = 0 |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* Stitch a list of screenshots into a single long image |
||||
|
*/ |
||||
|
suspend fun stitchScreenshots(screenshots: List<CapturedScreenshot>): StitchingResult = withContext(Dispatchers.IO) |
||||
|
{ |
||||
|
if (screenshots.isEmpty()) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "No screenshots to stitch") |
||||
|
return@withContext StitchingResult(false, errorMessage = "No screenshots provided") |
||||
|
} |
||||
|
|
||||
|
if (screenshots.size == 1) |
||||
|
{ |
||||
|
PGHLog.i(TAG, "Single screenshot - copying to output") |
||||
|
return@withContext copySingleScreenshot(screenshots[0]) |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🧩 Starting stitching process with ${screenshots.size} screenshots") |
||||
|
|
||||
|
// Load and validate all images |
||||
|
val imageMats = loadScreenshotMats(screenshots) |
||||
|
if (imageMats.isEmpty()) |
||||
|
{ |
||||
|
return@withContext StitchingResult(false, errorMessage = "Failed to load screenshot images") |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
// Perform stitching |
||||
|
val stitchingResult = performStitching(imageMats, screenshots) |
||||
|
return@withContext stitchingResult |
||||
|
|
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
// Clean up loaded images |
||||
|
releaseSafely(*imageMats.toTypedArray()) |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error during stitching process", e) |
||||
|
return@withContext StitchingResult(false, errorMessage = "Stitching failed: ${e.message}") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun loadScreenshotMats(screenshots: List<CapturedScreenshot>): List<Mat> |
||||
|
{ |
||||
|
val imageMats = mutableListOf<Mat>() |
||||
|
|
||||
|
for ((index, screenshot) in screenshots.withIndex()) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
PGHLog.d(TAG, "📖 Loading screenshot ${index + 1}: ${screenshot.filename}") |
||||
|
|
||||
|
val mat = Imgcodecs.imread(screenshot.filePath, Imgcodecs.IMREAD_COLOR) |
||||
|
if (mat.empty()) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Failed to load image: ${screenshot.filePath}") |
||||
|
continue |
||||
|
} |
||||
|
|
||||
|
// Validate image dimensions |
||||
|
if (mat.cols() == 0 || mat.rows() == 0) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Invalid image dimensions: ${mat.cols()}x${mat.rows()}") |
||||
|
mat.release() |
||||
|
continue |
||||
|
} |
||||
|
|
||||
|
// Scale down if image is too large for processing |
||||
|
val scaledMat = scaleImageIfNeeded(mat) |
||||
|
if (scaledMat != mat) |
||||
|
{ |
||||
|
mat.release() |
||||
|
} |
||||
|
|
||||
|
imageMats.add(scaledMat) |
||||
|
PGHLog.d(TAG, "✅ Loaded image ${index + 1}: ${scaledMat.cols()}x${scaledMat.rows()}") |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error loading screenshot ${index + 1}", e) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
PGHLog.i(TAG, "📖 Loaded ${imageMats.size}/${screenshots.size} images successfully") |
||||
|
return imageMats |
||||
|
} |
||||
|
|
||||
|
private fun scaleImageIfNeeded(mat: Mat): Mat |
||||
|
{ |
||||
|
val maxDim = max(mat.cols(), mat.rows()) |
||||
|
if (maxDim <= MAX_IMAGE_DIMENSION) |
||||
|
{ |
||||
|
return mat |
||||
|
} |
||||
|
|
||||
|
val scale = MAX_IMAGE_DIMENSION.toFloat() / maxDim |
||||
|
val newWidth = (mat.cols() * scale).toInt() |
||||
|
val newHeight = (mat.rows() * scale).toInt() |
||||
|
|
||||
|
PGHLog.d(TAG, "🔄 Scaling image from ${mat.cols()}x${mat.rows()} to ${newWidth}x${newHeight}") |
||||
|
|
||||
|
val scaledMat = Mat() |
||||
|
Imgproc.resize(mat, scaledMat, Size(newWidth.toDouble(), newHeight.toDouble())) |
||||
|
return scaledMat |
||||
|
} |
||||
|
|
||||
|
|
||||
|
private suspend fun performStitching(imageMats: List<Mat>, screenshots: List<CapturedScreenshot>): StitchingResult |
||||
|
{ |
||||
|
if (imageMats.size != screenshots.size) |
||||
|
{ |
||||
|
return StitchingResult(false, errorMessage = "Image count mismatch") |
||||
|
} |
||||
|
|
||||
|
// Start with first image |
||||
|
var result = imageMats[0].clone() |
||||
|
var currentHeight = result.rows() |
||||
|
var processedCount = 1 |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🧩 Starting with base image: ${result.cols()}x${result.rows()}") |
||||
|
|
||||
|
// Process each subsequent image |
||||
|
for (i in 1 until imageMats.size) |
||||
|
{ |
||||
|
val currentImage = imageMats[i] |
||||
|
PGHLog.d(TAG, "🔍 Processing image ${i + 1}/${imageMats.size}") |
||||
|
|
||||
|
// Detect overlap with previous section |
||||
|
val overlapInfo = detectOverlap(result, currentImage, currentHeight) |
||||
|
|
||||
|
val newResult = if (!overlapInfo.detected) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ No overlap detected for image ${i + 1}, appending directly") |
||||
|
// Append without overlap |
||||
|
appendImageDirectly(result, currentImage) |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
PGHLog.i(TAG, "✅ Overlap detected: offset=${overlapInfo.offsetY}, confidence=${overlapInfo.confidence}") |
||||
|
// Blend with overlap |
||||
|
blendImageWithOverlap(result, currentImage, overlapInfo) |
||||
|
} |
||||
|
|
||||
|
// Release old result and update to new one |
||||
|
result.release() |
||||
|
result = newResult |
||||
|
currentHeight = result.rows() |
||||
|
processedCount++ |
||||
|
|
||||
|
// Yield to prevent blocking |
||||
|
kotlinx.coroutines.yield() |
||||
|
} |
||||
|
|
||||
|
// Assess final quality |
||||
|
val qualityScore = assessStitchingQuality(result, imageMats.size) |
||||
|
PGHLog.i(TAG, "📊 Stitching quality score: $qualityScore") |
||||
|
|
||||
|
if (qualityScore < MIN_QUALITY_SCORE) |
||||
|
{ |
||||
|
PGHLog.w(TAG, "⚠️ Low quality stitching result: $qualityScore < $MIN_QUALITY_SCORE") |
||||
|
} |
||||
|
|
||||
|
// Save result |
||||
|
val outputPath = saveStitchedImage(result) |
||||
|
return if (outputPath != null) |
||||
|
{ |
||||
|
PGHLog.i(TAG, "✅ Stitching completed: ${result.cols()}x${result.rows()}, saved to: $outputPath") |
||||
|
StitchingResult( |
||||
|
success = true, |
||||
|
outputPath = outputPath, |
||||
|
qualityScore = qualityScore, |
||||
|
processedCount = processedCount, |
||||
|
finalDimensions = Pair(result.cols(), result.rows()) |
||||
|
) |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
StitchingResult(false, errorMessage = "Failed to save stitched image") |
||||
|
} |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
// Always clean up the result Mat |
||||
|
result.release() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun detectOverlap(baseImage: Mat, newImage: Mat, searchStartY: Int): OverlapInfo |
||||
|
{ |
||||
|
PGHLog.d(TAG, "🔍 Overlap detection: base=${baseImage.cols()}x${baseImage.rows()}, new=${newImage.cols()}x${newImage.rows()}") |
||||
|
|
||||
|
// For screenshots, let's assume a typical overlap of about 10-30% from the bottom of the base image |
||||
|
// This is much more reliable than complex template matching for UI screenshots |
||||
|
|
||||
|
val assumedOverlapRatio = 0.2f // Assume 20% overlap |
||||
|
val overlapHeight = (baseImage.rows() * assumedOverlapRatio).toInt() |
||||
|
val overlapStartY = baseImage.rows() - overlapHeight |
||||
|
|
||||
|
// Validate this makes sense |
||||
|
if (overlapHeight < 50 || overlapHeight > baseImage.rows() / 2) |
||||
|
{ |
||||
|
PGHLog.d(TAG, "⚠️ Calculated overlap doesn't make sense: $overlapHeight px") |
||||
|
return OverlapInfo(false) |
||||
|
} |
||||
|
|
||||
|
// Simple validation - check if the bottom of base image and top of new image are similar |
||||
|
val similarity = checkImageSimilarity(baseImage, newImage, overlapStartY, overlapHeight) |
||||
|
|
||||
|
PGHLog.d(TAG, "🎯 Simple overlap check: startY=$overlapStartY, height=$overlapHeight, similarity=$similarity") |
||||
|
|
||||
|
if (similarity > 0.3f) // Lower threshold for screenshots |
||||
|
{ |
||||
|
PGHLog.i(TAG, "✅ Simple overlap detected: startY=$overlapStartY, height=$overlapHeight, similarity=$similarity") |
||||
|
return OverlapInfo( |
||||
|
detected = true, |
||||
|
offsetY = overlapStartY, |
||||
|
confidence = similarity, |
||||
|
overlapHeight = overlapHeight |
||||
|
) |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
PGHLog.d(TAG, "🔍 No reliable overlap found - similarity $similarity too low") |
||||
|
return OverlapInfo(false) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun checkImageSimilarity(baseImage: Mat, newImage: Mat, overlapStartY: Int, overlapHeight: Int): Float |
||||
|
{ |
||||
|
val baseOverlap = Mat() |
||||
|
val newOverlap = Mat() |
||||
|
val result = Mat() |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
// Extract overlap regions |
||||
|
val baseRect = Rect(0, overlapStartY, baseImage.cols(), overlapHeight) |
||||
|
val newRect = Rect(0, 0, newImage.cols(), overlapHeight) |
||||
|
|
||||
|
baseImage.submat(baseRect).copyTo(baseOverlap) |
||||
|
newImage.submat(newRect).copyTo(newOverlap) |
||||
|
|
||||
|
// Simple correlation check |
||||
|
Imgproc.matchTemplate(baseOverlap, newOverlap, result, Imgproc.TM_CCOEFF_NORMED) |
||||
|
val minMaxResult = Core.minMaxLoc(result) |
||||
|
|
||||
|
return minMaxResult.maxVal.toFloat() |
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error checking similarity", e) |
||||
|
return 0f |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
baseOverlap.release() |
||||
|
newOverlap.release() |
||||
|
result.release() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
private fun appendImageDirectly(baseImage: Mat, newImage: Mat): Mat |
||||
|
{ |
||||
|
val combinedHeight = baseImage.rows() + newImage.rows() |
||||
|
val combinedWidth = max(baseImage.cols(), newImage.cols()) |
||||
|
|
||||
|
return Mat(combinedHeight, combinedWidth, baseImage.type()).apply { |
||||
|
try |
||||
|
{ |
||||
|
// Copy base image to top |
||||
|
val baseRect = Rect(0, 0, baseImage.cols(), baseImage.rows()) |
||||
|
baseImage.copyTo(this.submat(baseRect)) |
||||
|
|
||||
|
// Copy new image to bottom |
||||
|
val newRect = Rect(0, baseImage.rows(), newImage.cols(), newImage.rows()) |
||||
|
newImage.copyTo(this.submat(newRect)) |
||||
|
|
||||
|
PGHLog.d(TAG, "📎 Appended image directly: ${this.cols()}x${this.rows()}") |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error appending image", e) |
||||
|
this.release() |
||||
|
throw e |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun blendImageWithOverlap(baseImage: Mat, newImage: Mat, overlapInfo: OverlapInfo): Mat |
||||
|
{ |
||||
|
// Calculate dimensions |
||||
|
val overlapStartY = overlapInfo.offsetY |
||||
|
val overlapHeight = min(overlapInfo.overlapHeight, baseImage.rows() - overlapStartY) |
||||
|
val nonOverlapHeight = newImage.rows() - overlapHeight |
||||
|
val combinedHeight = baseImage.rows() + newImage.rows() - overlapHeight // Subtract overlap to avoid duplication |
||||
|
val combinedWidth = max(baseImage.cols(), newImage.cols()) |
||||
|
|
||||
|
PGHLog.d(TAG, "🎨 Blend calculation: baseH=${baseImage.rows()}, newH=${newImage.rows()}") |
||||
|
PGHLog.d(TAG, "🎨 Overlap: startY=$overlapStartY, height=$overlapHeight") |
||||
|
PGHLog.d(TAG, "🎨 Result: combinedH=$combinedHeight, nonOverlapH=$nonOverlapHeight") |
||||
|
|
||||
|
return Mat(combinedHeight, combinedWidth, baseImage.type()).apply { |
||||
|
try |
||||
|
{ |
||||
|
// Copy entire base image first |
||||
|
val baseRect = Rect(0, 0, baseImage.cols(), baseImage.rows()) |
||||
|
baseImage.submat(baseRect).copyTo(this.submat(baseRect)) |
||||
|
|
||||
|
// Calculate where the new image should start (after base image minus overlap) |
||||
|
val newImageStartY = baseImage.rows() - overlapHeight |
||||
|
|
||||
|
// Blend overlap region (in the base image area) |
||||
|
if (overlapHeight > 0) |
||||
|
{ |
||||
|
blendOverlapRegion( |
||||
|
baseImage, newImage, this, |
||||
|
newImageStartY, overlapHeight |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
// Copy non-overlapping part of new image |
||||
|
if (nonOverlapHeight > 0) |
||||
|
{ |
||||
|
val newBottomRect = Rect(0, baseImage.rows(), newImage.cols(), nonOverlapHeight) |
||||
|
val newSourceRect = Rect(0, overlapHeight, newImage.cols(), nonOverlapHeight) |
||||
|
newImage.submat(newSourceRect).copyTo(this.submat(newBottomRect)) |
||||
|
} |
||||
|
|
||||
|
PGHLog.d(TAG, "🎨 Blended image with overlap: ${this.cols()}x${this.rows()}") |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error blending image", e) |
||||
|
this.release() |
||||
|
throw e |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun blendOverlapRegion(baseImage: Mat, newImage: Mat, result: Mat, startY: Int, height: Int) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
PGHLog.d(TAG, "🎨 Blending overlap: startY=$startY, height=$height") |
||||
|
|
||||
|
// Define rectangles for blending |
||||
|
val resultBlendRect = Rect(0, startY, min(baseImage.cols(), newImage.cols()), height) |
||||
|
val baseOverlapRect = Rect(0, startY, baseImage.cols(), height) |
||||
|
val newOverlapRect = Rect(0, 0, newImage.cols(), height) |
||||
|
|
||||
|
val baseOverlap = Mat() |
||||
|
val newOverlap = Mat() |
||||
|
val blended = Mat() |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
baseImage.submat(baseOverlapRect).copyTo(baseOverlap) |
||||
|
newImage.submat(newOverlapRect).copyTo(newOverlap) |
||||
|
|
||||
|
// Linear blend: 50% base + 50% new |
||||
|
Core.addWeighted(baseOverlap, 0.5, newOverlap, 0.5, 0.0, blended) |
||||
|
blended.copyTo(result.submat(resultBlendRect)) |
||||
|
|
||||
|
PGHLog.d(TAG, "🎨 Blend completed successfully") |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
baseOverlap.release() |
||||
|
newOverlap.release() |
||||
|
blended.release() |
||||
|
} |
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error in overlap blending", e) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun assessStitchingQuality(stitchedImage: Mat, originalCount: Int): Float |
||||
|
{ |
||||
|
// Simple quality assessment based on: |
||||
|
// 1. Image dimensions (reasonable aspect ratio) |
||||
|
// 2. Non-zero pixels ratio |
||||
|
// 3. Smoothness metric |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
val aspectRatio = stitchedImage.rows().toFloat() / stitchedImage.cols() |
||||
|
val aspectScore = if (aspectRatio > 1.0f) min(1.0f, aspectRatio / (originalCount * 2)) else 0.2f |
||||
|
|
||||
|
// Check for reasonable content (non-zero pixels) |
||||
|
val nonZeroPixels = Core.countNonZero(Mat().apply { |
||||
|
Imgproc.cvtColor(stitchedImage, this, Imgproc.COLOR_BGR2GRAY) |
||||
|
}) |
||||
|
val totalPixels = stitchedImage.total().toInt() |
||||
|
val contentScore = nonZeroPixels.toFloat() / totalPixels |
||||
|
|
||||
|
val finalScore = (aspectScore + contentScore) / 2.0f |
||||
|
return min(1.0f, max(0.0f, finalScore)) |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error assessing quality", e) |
||||
|
return 0.5f // Default moderate quality |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun saveStitchedImage(image: Mat): String? |
||||
|
{ |
||||
|
return try |
||||
|
{ |
||||
|
val timestamp = System.currentTimeMillis() |
||||
|
val filename = "stitched_screenshot_${timestamp}.png" |
||||
|
val outputFile = File(outputDir, filename) |
||||
|
|
||||
|
val success = Imgcodecs.imwrite(outputFile.absolutePath, image) |
||||
|
if (success) |
||||
|
{ |
||||
|
PGHLog.i(TAG, "💾 Saved stitched image: ${outputFile.absolutePath}") |
||||
|
outputFile.absolutePath |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Failed to save stitched image") |
||||
|
null |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error saving stitched image", e) |
||||
|
null |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private fun copySingleScreenshot(screenshot: CapturedScreenshot): StitchingResult |
||||
|
{ |
||||
|
return try |
||||
|
{ |
||||
|
val timestamp = System.currentTimeMillis() |
||||
|
val filename = "single_screenshot_${timestamp}.png" |
||||
|
val outputFile = File(outputDir, filename) |
||||
|
|
||||
|
// Copy file |
||||
|
File(screenshot.filePath).copyTo(outputFile, overwrite = true) |
||||
|
|
||||
|
StitchingResult( |
||||
|
success = true, |
||||
|
outputPath = outputFile.absolutePath, |
||||
|
qualityScore = 1.0f, |
||||
|
processedCount = 1, |
||||
|
finalDimensions = Pair(screenshot.width, screenshot.height) |
||||
|
) |
||||
|
|
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error copying single screenshot", e) |
||||
|
StitchingResult(false, errorMessage = "Failed to copy single screenshot: ${e.message}") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Clean up resources and cancel any ongoing operations |
||||
|
*/ |
||||
|
fun cleanup() |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
PGHLog.i(TAG, "🧹 Cleaning up ImageStitcher") |
||||
|
stitchingScope.cancel() |
||||
|
} |
||||
|
catch (e: Exception) |
||||
|
{ |
||||
|
PGHLog.e(TAG, "❌ Error during cleanup", e) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue