BitmapRegionDecoderExample.swift

Go to the documentation of this file.

import Foundation
 
/**
 * BitmapRegionDecoder usage example for Swift
 * Demonstrates working with bitmap region decoding, image processing, and rectangle operations
 */
class BitmapRegionDecoderExample: NSObject {
    private var decoder: BitmapRegionDecoder?
    private var imageData: Data?
 
    override init() {
        super.init()
        loadSampleImageData()
    }
 
    /**
     * Load sample image data for demonstration
     */
    private func loadSampleImageData() {
        // Simulate loading image data (in real app, this would be from file or network)
        let pngHeader: [UInt8] = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A] // PNG header
        imageData = Data(pngHeader)
        print("Sample image data loaded (\‍(imageData!.count) bytes)")
    }
 
    /**
     * Demonstrate BitmapRegionDecoder methods
     */
    func demonstrateBitmapRegionDecoderMethods() {
        guard let imageData = imageData else {
            print("No image data available")
            return
        }
 
        // [swift_BitmapRegionDecoder_newInstance]
        // Create new instance of BitmapRegionDecoder
        decoder = BitmapRegionDecoder.newInstance(data: imageData)
        print("Created BitmapRegionDecoder instance")
        // [swift_BitmapRegionDecoder_newInstance]
 
        // Demonstrate rectangle creation and usage
        demonstrateRectangleUsage()
 
        // Demonstrate region decoding
        demonstrateRegionDecoding()
 
        // Demonstrate different sample sizes
        demonstrateSampleSizes()
 
        // Demonstrate multiple regions
        demonstrateMultipleRegions()
    }
 
    /**
     * Demonstrate Rectangle usage
     */
    func demonstrateRectangleUsage() {
        // [swift_Rectangle_constructor]
        // Create rectangle with x, y, width, height
        let rect1 = Rectangle(x: 10, y: 20, width: 100, height: 150)
        print("Created rectangle: x=\‍(rect1.x), y=\‍(rect1.y), width=\‍(rect1.width), height=\‍(rect1.height)")
        // [swift_Rectangle_constructor]
 
        // [swift_Rectangle_getX]
        // Get X coordinate
        let x = rect1.x
        print("Rectangle X coordinate: \‍(x)")
        // [swift_Rectangle_getX]
 
        // [swift_Rectangle_getY]
        // Get Y coordinate
        let y = rect1.y
        print("Rectangle Y coordinate: \‍(y)")
        // [swift_Rectangle_getY]
 
        // [swift_Rectangle_getWidth]
        // Get width
        let width = rect1.width
        print("Rectangle width: \‍(width)")
        // [swift_Rectangle_getWidth]
 
        // [swift_Rectangle_getHeight]
        // Get height
        let height = rect1.height
        print("Rectangle height: \‍(height)")
        // [swift_Rectangle_getHeight]
 
        // Create different rectangles for different use cases
        let fullImage = Rectangle(x: 0, y: 0, width: 1024, height: 768)
        let topLeft = Rectangle(x: 0, y: 0, width: 512, height: 384)
        let center = Rectangle(x: 256, y: 192, width: 512, height: 384)
        let bottomRight = Rectangle(x: 512, y: 384, width: 512, height: 384)
 
        print("Created different rectangles for different regions")
    }
 
    /**
     * Demonstrate region decoding
     */
    func demonstrateRegionDecoding() {
        guard let decoder = decoder else {
            print("Decoder not initialized")
            return
        }
 
        // Create a sample rectangle
        let sampleRect = Rectangle(x: 50, y: 50, width: 200, height: 200)
 
        // [swift_BitmapRegionDecoder_decodeRegion]
        // Decode region with sample size 1 (full resolution)
        let decodedImage = decoder.decodeRegion(rect: sampleRect, sampleSize: 1)
        print("Decoded region: \‍(sampleRect.width)x\‍(sampleRect.height) at sample size 1")
        // [swift_BitmapRegionDecoder_decodeRegion]
 
        // Demonstrate the decoded image
        demonstrateDecodedImage(decodedImage, description: "Sample Region")
    }
 
    /**
     * Demonstrate different sample sizes
     */
    func demonstrateSampleSizes() {
        guard let decoder = decoder else { return }
 
        let testRect = Rectangle(x: 0, y: 0, width: 400, height: 300)
 
        // Decode with different sample sizes
        let sampleSizes: [Float] = [1.0, 2.0, 4.0, 8.0]
 
        for sampleSize in sampleSizes {
            // [swift_BitmapRegionDecoder_decodeRegion_sampleSize]
            // Decode region with specific sample size
            let decodedImage = decoder.decodeRegion(rect: testRect, sampleSize: sampleSize)
            print("Decoded region with sample size \‍(sampleSize): \‍(Int(testRect.width / sampleSize))x\‍(Int(testRect.height / sampleSize))")
            // [swift_BitmapRegionDecoder_decodeRegion_sampleSize]
 
            demonstrateDecodedImage(decodedImage, description: "Sample Size \‍(sampleSize)")
        }
    }
 
    /**
     * Demonstrate multiple regions
     */
    func demonstrateMultipleRegions() {
        guard let decoder = decoder else { return }
 
        // Define multiple regions to decode
        let regions = [
            Rectangle(x: 0, y: 0, width: 256, height: 256),      // Top-left quadrant
            Rectangle(x: 256, y: 0, width: 256, height: 256),    // Top-right quadrant
            Rectangle(x: 0, y: 256, width: 256, height: 256),    // Bottom-left quadrant
            Rectangle(x: 256, y: 256, width: 256, height: 256)   // Bottom-right quadrant
        ]
 
        print("=== Decoding Multiple Regions ===")
        for (index, region) in regions.enumerated() {
            // [swift_BitmapRegionDecoder_decodeRegion_multiple]
            // Decode multiple regions
            let decodedImage = decoder.decodeRegion(rect: region, sampleSize: 1)
            print("Region \‍(index + 1): \‍(region.width)x\‍(region.height) at (\‍(region.x), \‍(region.y))")
            // [swift_BitmapRegionDecoder_decodeRegion_multiple]
 
            demonstrateDecodedImage(decodedImage, description: "Region \‍(index + 1)")
        }
    }
 
    /**
     * Demonstrate decoded image usage
     */
    func demonstrateDecodedImage(_ image: Any, description: String) {
        print("--- \‍(description) ---")
        // Note: In real implementation, you would access image properties here
        print("Image decoded successfully")
        print("---")
    }
 
    /**
     * Demonstrate advanced bitmap region decoder features
     */
    func demonstrateAdvancedFeatures() {
        print("=== Advanced BitmapRegionDecoder Features ===")
 
        guard let imageData = imageData else { return }
 
        // Create multiple decoders for different images
        let imageDataList = [
            imageData,
            Data([0xFF, 0xD8, 0xFF, 0xE0]), // JPEG header
            Data([0x47, 0x49, 0x46, 0x38])  // GIF header
        ]
 
        for (index, data) in imageDataList.enumerated() {
            do {
                // [swift_BitmapRegionDecoder_newInstance_advanced]
                // Create decoder for different image types
                let decoder = BitmapRegionDecoder.newInstance(data: data)
                print("Created decoder for image type \‍(index + 1)")
                // [swift_BitmapRegionDecoder_newInstance_advanced]
 
                // Test decoding with different regions
                let testRect = Rectangle(x: 0, y: 0, width: 100, height: 100)
                let decodedImage = decoder.decodeRegion(rect: testRect, sampleSize: 1)
                print("Successfully decoded region from image type \‍(index + 1)")
 
            } catch {
                print("Failed to decode image type \‍(index + 1): \‍(error)")
            }
        }
    }
 
    /**
     * Demonstrate error handling
     */
    func demonstrateErrorHandling() {
        print("=== Error Handling ===")
 
        // Test with invalid image data
        let invalidData = Data([0x00, 0x01, 0x02, 0x03])
 
        do {
            // [swift_BitmapRegionDecoder_newInstance_error]
            // Create decoder with invalid data
            let decoder = BitmapRegionDecoder.newInstance(data: invalidData)
            print("Created decoder with invalid data")
            // [swift_BitmapRegionDecoder_newInstance_error]
 
            // Try to decode region
            let rect = Rectangle(x: 0, y: 0, width: 50, height: 50)
            let image = decoder.decodeRegion(rect: rect, sampleSize: 1)
            print("Successfully decoded region from invalid data")
 
        } catch {
            print("Expected error when creating decoder with invalid data: \‍(error)")
        }
 
        // Test with invalid rectangle
        if let decoder = decoder {
            do {
                let invalidRect = Rectangle(x: -10, y: -10, width: 100, height: 100)
                let image = decoder.decodeRegion(rect: invalidRect, sampleSize: 1)
                print("Successfully decoded region with negative coordinates")
 
            } catch {
                print("Expected error with invalid rectangle: \‍(error)")
            }
        }
    }
 
    /**
     * Demonstrate performance optimization
     */
    func demonstratePerformanceOptimization() {
        print("=== Performance Optimization ===")
 
        guard let decoder = decoder else { return }
 
        // Test different sample sizes for performance
        let largeRect = Rectangle(x: 0, y: 0, width: 800, height: 600)
        let sampleSizes: [Float] = [1.0, 2.0, 4.0, 8.0, 16.0]
 
        for sampleSize in sampleSizes {
            let startTime = Date()
            
            let image = decoder.decodeRegion(rect: largeRect, sampleSize: sampleSize)
            
            let elapsedTime = Date().timeIntervalSince(startTime) * 1000
            print("Sample size \‍(sampleSize): \‍(Int(elapsedTime))ms")
        }
    }
 
    /**
     * Demonstrate rectangle manipulation
     */
    func demonstrateRectangleManipulation() {
        print("=== Rectangle Manipulation ===")
 
        // Create base rectangle
        let baseRect = Rectangle(x: 100, y: 100, width: 200, height: 150)
        print("Base rectangle: \‍(baseRect.x), \‍(baseRect.y), \‍(baseRect.width)x\‍(baseRect.height)")
 
        // Create different variations
        let variations = [
            Rectangle(x: baseRect.x, y: baseRect.y, width: baseRect.width / 2, height: baseRect.height), // Half width
            Rectangle(x: baseRect.x, y: baseRect.y, width: baseRect.width, height: baseRect.height / 2), // Half height
            Rectangle(x: baseRect.x + 50, y: baseRect.y + 25, width: baseRect.width - 100, height: baseRect.height - 50), // Centered smaller
            Rectangle(x: 0, y: 0, width: baseRect.width, height: baseRect.height) // Top-left aligned
        ]
 
        for (index, rect) in variations.enumerated() {
            print("Variation \‍(index + 1): \‍(rect.x), \‍(rect.y), \‍(rect.width)x\‍(rect.height)")
        }
    }
 
    /**
     * Main demonstration method
     */
    func runExample() {
        print("=== BitmapRegionDecoder Example ===")
        
        demonstrateBitmapRegionDecoderMethods()
        demonstrateRectangleManipulation()
        demonstrateAdvancedFeatures()
        demonstrateErrorHandling()
        demonstratePerformanceOptimization()
        
        // Wait a bit for processing
        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
            print("=== Example completed ===")
        }
    }
}
 
/**
 * Function to run the example
 */
func main() {
    let example = BitmapRegionDecoderExample()
    example.runExample()
    
    // Keep the app running for a while to see the output
    RunLoop.main.run(until: Date().addingTimeInterval(10.0))
}
 
// Run the example
main()