BitmapRegionDecoderExample.kt

Go to the documentation of this file.

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
 
/**
 * BitmapRegionDecoder usage example for Kotlin
 * Demonstrates working with bitmap region decoding, image processing, and rectangle operations
 */
class BitmapRegionDecoderExample {
    private var decoder: BitmapRegionDecoder? = null
    private var imageData: ByteArray? = null
 
    init {
        loadSampleImageData()
    }
 
    /**
     * Load sample image data for demonstration
     */
    private fun loadSampleImageData() {
        // Simulate loading image data (in real app, this would be from file or network)
        imageData = byteArrayOf(
            0x89.toByte(), 0x50.toByte(), 0x4E.toByte(), 0x47.toByte(), 
            0x0D.toByte(), 0x0A.toByte(), 0x1A.toByte(), 0x0A.toByte() // PNG header
            // ... more image data would be here
        )
        println("Sample image data loaded (${imageData!!.size} bytes)")
    }
 
    /**
     * Demonstrate BitmapRegionDecoder methods
     */
    fun demonstrateBitmapRegionDecoderMethods() {
        if (imageData == null) {
            System.err.println("No image data available")
            return
        }
 
        // [kotlin_BitmapRegionDecoder_newInstance]
        // Create new instance of BitmapRegionDecoder
        decoder = BitmapRegionDecoder.newInstance(imageData!!)
        println("Created BitmapRegionDecoder instance")
        // [kotlin_BitmapRegionDecoder_newInstance]
 
        // Demonstrate rectangle creation and usage
        demonstrateRectangleUsage()
 
        // Demonstrate region decoding
        demonstrateRegionDecoding()
 
        // Demonstrate different sample sizes
        demonstrateSampleSizes()
 
        // Demonstrate multiple regions
        demonstrateMultipleRegions()
    }
 
    /**
     * Demonstrate Rectangle usage
     */
    fun demonstrateRectangleUsage() {
        // [kotlin_Rectangle_constructor]
        // Create rectangle with x, y, width, height
        val rect1 = Rectangle(10, 20, 100, 150)
        println("Created rectangle: x=${rect1.x}, y=${rect1.y}, width=${rect1.width}, height=${rect1.height}")
        // [kotlin_Rectangle_constructor]
 
        // [kotlin_Rectangle_getX]
        // Get X coordinate
        val x = rect1.x
        println("Rectangle X coordinate: $x")
        // [kotlin_Rectangle_getX]
 
        // [kotlin_Rectangle_getY]
        // Get Y coordinate
        val y = rect1.y
        println("Rectangle Y coordinate: $y")
        // [kotlin_Rectangle_getY]
 
        // [kotlin_Rectangle_getWidth]
        // Get width
        val width = rect1.width
        println("Rectangle width: $width")
        // [kotlin_Rectangle_getWidth]
 
        // [kotlin_Rectangle_getHeight]
        // Get height
        val height = rect1.height
        println("Rectangle height: $height")
        // [kotlin_Rectangle_getHeight]
 
        // Create different rectangles for different use cases
        val fullImage = Rectangle(0, 0, 1024, 768)
        val topLeft = Rectangle(0, 0, 512, 384)
        val center = Rectangle(256, 192, 512, 384)
        val bottomRight = Rectangle(512, 384, 512, 384)
 
        println("Created different rectangles for different regions")
    }
 
    /**
     * Demonstrate region decoding
     */
    fun demonstrateRegionDecoding() {
        val decoder = decoder ?: run {
            System.err.println("Decoder not initialized")
            return
        }
 
        // Create a sample rectangle
        val sampleRect = Rectangle(50, 50, 200, 200)
 
        // [kotlin_BitmapRegionDecoder_decodeRegion]
        // Decode region with sample size 1 (full resolution)
        val decodedImage = decoder.decodeRegion(sampleRect, 1)
        println("Decoded region: ${sampleRect.width}x${sampleRect.height} at sample size 1")
        // [kotlin_BitmapRegionDecoder_decodeRegion]
 
        // Demonstrate the decoded image
        demonstrateDecodedImage(decodedImage, "Sample Region")
    }
 
    /**
     * Demonstrate different sample sizes
     */
    fun demonstrateSampleSizes() {
        val decoder = decoder ?: return
 
        val testRect = Rectangle(0, 0, 400, 300)
 
        // Decode with different sample sizes
        val sampleSizes = listOf(1.0f, 2.0f, 4.0f, 8.0f)
 
        for (sampleSize in sampleSizes) {
            // [kotlin_BitmapRegionDecoder_decodeRegion_sampleSize]
            // Decode region with specific sample size
            val decodedImage = decoder.decodeRegion(testRect, sampleSize)
            println("Decoded region with sample size $sampleSize: ${(testRect.width / sampleSize).toInt()}x${(testRect.height / sampleSize).toInt()}")
            // [kotlin_BitmapRegionDecoder_decodeRegion_sampleSize]
 
            demonstrateDecodedImage(decodedImage, "Sample Size $sampleSize")
        }
    }
 
    /**
     * Demonstrate multiple regions
     */
    fun demonstrateMultipleRegions() {
        val decoder = decoder ?: return
 
        // Define multiple regions to decode
        val regions = listOf(
            Rectangle(0, 0, 256, 256),      // Top-left quadrant
            Rectangle(256, 0, 256, 256),    // Top-right quadrant
            Rectangle(0, 256, 256, 256),    // Bottom-left quadrant
            Rectangle(256, 256, 256, 256)   // Bottom-right quadrant
        )
 
        println("=== Decoding Multiple Regions ===")
        for (i in regions.indices) {
            val region = regions[i]
            
            // [kotlin_BitmapRegionDecoder_decodeRegion_multiple]
            // Decode multiple regions
            val decodedImage = decoder.decodeRegion(region, 1)
            println("Region ${i + 1}: ${region.width}x${region.height} at (${region.x}, ${region.y})")
            // [kotlin_BitmapRegionDecoder_decodeRegion_multiple]
 
            demonstrateDecodedImage(decodedImage, "Region ${i + 1}")
        }
    }
 
    /**
     * Demonstrate decoded image usage
     */
    fun demonstrateDecodedImage(image: ImageWrapper, description: String) {
        println("--- $description ---")
        println("Image dimensions: ${image.width}x${image.height}")
        println("Image format: ${image.format}")
        println("Image data size: ${image.data.size} bytes")
        println("---")
    }
 
    /**
     * Demonstrate advanced bitmap region decoder features
     */
    suspend fun demonstrateAdvancedFeatures() {
        println("=== Advanced BitmapRegionDecoder Features ===")
 
        if (imageData == null) {
            return
        }
 
        // Create multiple decoders for different images
        val imageDataList = listOf(
            imageData!!,
            byteArrayOf(0xFF.toByte(), 0xD8.toByte(), 0xFF.toByte(), 0xE0.toByte()), // JPEG header
            byteArrayOf(0x47.toByte(), 0x49.toByte(), 0x46.toByte(), 0x38.toByte()) // GIF header
        )
 
        for (i in imageDataList.indices) {
            try {
                // [kotlin_BitmapRegionDecoder_newInstance_advanced]
                // Create decoder for different image types
                val decoder = BitmapRegionDecoder.newInstance(imageDataList[i])
                println("Created decoder for image type ${i + 1}")
                // [kotlin_BitmapRegionDecoder_newInstance_advanced]
 
                // Test decoding with different regions
                val testRect = Rectangle(0, 0, 100, 100)
                val decodedImage = decoder.decodeRegion(testRect, 1)
                println("Successfully decoded region from image type ${i + 1}")
 
            } catch (e: Exception) {
                System.err.println("Failed to decode image type ${i + 1}: ${e.message}")
            }
        }
    }
 
    /**
     * Demonstrate error handling
     */
    fun demonstrateErrorHandling() {
        println("=== Error Handling ===")
 
        // Test with invalid image data
        val invalidData = byteArrayOf(0x00.toByte(), 0x01.toByte(), 0x02.toByte(), 0x03.toByte())
 
        try {
            // [kotlin_BitmapRegionDecoder_newInstance_error]
            // Create decoder with invalid data
            val decoder = BitmapRegionDecoder.newInstance(invalidData)
            println("Created decoder with invalid data")
            // [kotlin_BitmapRegionDecoder_newInstance_error]
 
            // Try to decode region
            val rect = Rectangle(0, 0, 50, 50)
            val image = decoder.decodeRegion(rect, 1)
            println("Successfully decoded region from invalid data")
 
        } catch (e: Exception) {
            println("Expected error when creating decoder with invalid data: ${e.message}")
        }
 
        // Test with invalid rectangle
        decoder?.let { decoder ->
            try {
                val invalidRect = Rectangle(-10, -10, 100, 100)
                val image = decoder.decodeRegion(invalidRect, 1)
                println("Successfully decoded region with negative coordinates")
 
            } catch (e: Exception) {
                println("Expected error with invalid rectangle: ${e.message}")
            }
        }
    }
 
    /**
     * Demonstrate performance optimization
     */
    fun demonstratePerformanceOptimization() {
        println("=== Performance Optimization ===")
 
        val decoder = decoder ?: return
 
        // Test different sample sizes for performance
        val largeRect = Rectangle(0, 0, 800, 600)
        val sampleSizes = listOf(1.0f, 2.0f, 4.0f, 8.0f, 16.0f)
 
        for (sampleSize in sampleSizes) {
            val startTime = System.currentTimeMillis()
            
            val image = decoder.decodeRegion(largeRect, sampleSize)
            
            val endTime = System.currentTimeMillis()
            println("Sample size $sampleSize: ${endTime - startTime}ms, " +
                    "Output size: ${image.width}x${image.height}")
        }
    }
 
    /**
     * Demonstrate rectangle manipulation
     */
    fun demonstrateRectangleManipulation() {
        println("=== Rectangle Manipulation ===")
 
        // Create base rectangle
        val baseRect = Rectangle(100, 100, 200, 150)
        println("Base rectangle: ${baseRect.x}, ${baseRect.y}, ${baseRect.width}x${baseRect.height}")
 
        // Create different variations
        val variations = listOf(
            Rectangle(baseRect.x, baseRect.y, baseRect.width / 2, baseRect.height), // Half width
            Rectangle(baseRect.x, baseRect.y, baseRect.width, baseRect.height / 2), // Half height
            Rectangle(baseRect.x + 50, baseRect.y + 25, baseRect.width - 100, baseRect.height - 50), // Centered smaller
            Rectangle(0, 0, baseRect.width, baseRect.height) // Top-left aligned
        )
 
        for (i in variations.indices) {
            val rect = variations[i]
            println("Variation ${i + 1}: ${rect.x}, ${rect.y}, ${rect.width}x${rect.height}")
        }
    }
 
    /**
     * Main demonstration method
     */
    suspend fun runExample() {
        println("=== BitmapRegionDecoder Example ===")
        
        demonstrateBitmapRegionDecoderMethods()
        demonstrateRectangleManipulation()
        demonstrateAdvancedFeatures()
        demonstrateErrorHandling()
        demonstratePerformanceOptimization()
        
        // Wait a bit for processing
        delay(2000)
        
        println("=== Example completed ===")
    }
}
 
/**
 * Function to run the example
 */
fun main() = runBlocking {
    val example = BitmapRegionDecoderExample()
    example.runExample()
}