BitmapRegionDecoderExample.java

Go to the documentation of this file.

package com.navigine.examples;
 
import java.util.Arrays;
import java.util.List;

public class BitmapRegionDecoderExample {
    private BitmapRegionDecoder decoder;
    private byte[] imageData;
 
    public BitmapRegionDecoderExample() {
        loadSampleImageData();
    }

    private void loadSampleImageData() {
        // Simulate loading image data (in real app, this would be from file or network)
        imageData = new byte[] {
            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG header
            // ... more image data would be here
        };
        System.out.println("Sample image data loaded (" + imageData.length + " bytes)");
    }

    public void demonstrateBitmapRegionDecoderMethods() {
        if (imageData == null) {
            System.err.println("No image data available");
            return;
        }
 
        // [java_BitmapRegionDecoder_newInstance]
        // Create new instance of BitmapRegionDecoder
        decoder = BitmapRegionDecoder.newInstance(imageData);
        System.out.println("Created BitmapRegionDecoder instance");
        // [java_BitmapRegionDecoder_newInstance]
 
        // Demonstrate rectangle creation and usage
        demonstrateRectangleUsage();
 
        // Demonstrate region decoding
        demonstrateRegionDecoding();
 
        // Demonstrate different sample sizes
        demonstrateSampleSizes();
 
        // Demonstrate multiple regions
        demonstrateMultipleRegions();
    }

    public void demonstrateRectangleUsage() {
        // [java_Rectangle_constructor]
        // Create rectangle with x, y, width, height
        Rectangle rect1 = new Rectangle(10, 20, 100, 150);
        System.out.println("Created rectangle: x=" + rect1.getX() + ", y=" + rect1.getY() + 
                          ", width=" + rect1.getWidth() + ", height=" + rect1.getHeight());
        // [java_Rectangle_constructor]
 
        // [java_Rectangle_getX]
        // Get X coordinate
        int x = rect1.getX();
        System.out.println("Rectangle X coordinate: " + x);
        // [java_Rectangle_getX]
 
        // [java_Rectangle_getY]
        // Get Y coordinate
        int y = rect1.getY();
        System.out.println("Rectangle Y coordinate: " + y);
        // [java_Rectangle_getY]
 
        // [java_Rectangle_getWidth]
        // Get width
        int width = rect1.getWidth();
        System.out.println("Rectangle width: " + width);
        // [java_Rectangle_getWidth]
 
        // [java_Rectangle_getHeight]
        // Get height
        int height = rect1.getHeight();
        System.out.println("Rectangle height: " + height);
        // [java_Rectangle_getHeight]
 
        // Create different rectangles for different use cases
        Rectangle fullImage = new Rectangle(0, 0, 1024, 768);
        Rectangle topLeft = new Rectangle(0, 0, 512, 384);
        Rectangle center = new Rectangle(256, 192, 512, 384);
        Rectangle bottomRight = new Rectangle(512, 384, 512, 384);
 
        System.out.println("Created different rectangles for different regions");
    }

    public void demonstrateRegionDecoding() {
        if (decoder == null) {
            System.err.println("Decoder not initialized");
            return;
        }
 
        // Create a sample rectangle
        Rectangle sampleRect = new Rectangle(50, 50, 200, 200);
 
        // [java_BitmapRegionDecoder_decodeRegion]
        // Decode region with sample size 1 (full resolution)
        ImageWrapper decodedImage = decoder.decodeRegion(sampleRect, 1);
        System.out.println("Decoded region: " + sampleRect.getWidth() + "x" + sampleRect.getHeight() + " at sample size 1");
        // [java_BitmapRegionDecoder_decodeRegion]
 
        // Demonstrate the decoded image
        demonstrateDecodedImage(decodedImage, "Sample Region");
    }

    public void demonstrateSampleSizes() {
        if (decoder == null) {
            return;
        }
 
        Rectangle testRect = new Rectangle(0, 0, 400, 300);
 
        // Decode with different sample sizes
        List<Float> sampleSizes = Arrays.asList(1.0f, 2.0f, 4.0f, 8.0f);
 
        for (float sampleSize : sampleSizes) {
            // [java_BitmapRegionDecoder_decodeRegion_sampleSize]
            // Decode region with specific sample size
            ImageWrapper decodedImage = decoder.decodeRegion(testRect, sampleSize);
            System.out.println("Decoded region with sample size " + sampleSize + ": " + 
                              (int)(testRect.getWidth() / sampleSize) + "x" + (int)(testRect.getHeight() / sampleSize));
            // [java_BitmapRegionDecoder_decodeRegion_sampleSize]
 
            demonstrateDecodedImage(decodedImage, "Sample Size " + sampleSize);
        }
    }

    public void demonstrateMultipleRegions() {
        if (decoder == null) {
            return;
        }
 
        // Define multiple regions to decode
        List<Rectangle> regions = Arrays.asList(
            new Rectangle(0, 0, 256, 256),      // Top-left quadrant
            new Rectangle(256, 0, 256, 256),    // Top-right quadrant
            new Rectangle(0, 256, 256, 256),    // Bottom-left quadrant
            new Rectangle(256, 256, 256, 256)   // Bottom-right quadrant
        );
 
        System.out.println("=== Decoding Multiple Regions ===");
        for (int i = 0; i < regions.size(); i++) {
            Rectangle region = regions.get(i);
            
            // [java_BitmapRegionDecoder_decodeRegion_multiple]
            // Decode multiple regions
            ImageWrapper decodedImage = decoder.decodeRegion(region, 1);
            System.out.println("Region " + (i + 1) + ": " + region.getWidth() + "x" + region.getHeight() + 
                              " at (" + region.getX() + ", " + region.getY() + ")");
            // [java_BitmapRegionDecoder_decodeRegion_multiple]
 
            demonstrateDecodedImage(decodedImage, "Region " + (i + 1));
        }
    }

    public void demonstrateDecodedImage(ImageWrapper image, String description) {
        System.out.println("--- " + description + " ---");
        System.out.println("Image dimensions: " + image.getWidth() + "x" + image.getHeight());
        System.out.println("Image format: " + image.getFormat());
        System.out.println("Image data size: " + image.getData().length + " bytes");
        System.out.println("---");
    }

    public void demonstrateAdvancedFeatures() {
        System.out.println("=== Advanced BitmapRegionDecoder Features ===");
 
        if (imageData == null) {
            return;
        }
 
        // Create multiple decoders for different images
        List<byte[]> imageDataList = Arrays.asList(
            imageData,
            new byte[] { (byte) 0xFF, (byte) 0xD8, (byte) 0xFF, (byte) 0xE0 }, // JPEG header
            new byte[] { 0x47, 0x49, 0x46, 0x38 } // GIF header
        );
 
        for (int i = 0; i < imageDataList.size(); i++) {
            try {
                // [java_BitmapRegionDecoder_newInstance_advanced]
                // Create decoder for different image types
                BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(imageDataList.get(i));
                System.out.println("Created decoder for image type " + (i + 1));
                // [java_BitmapRegionDecoder_newInstance_advanced]
 
                // Test decoding with different regions
                Rectangle testRect = new Rectangle(0, 0, 100, 100);
                ImageWrapper decodedImage = decoder.decodeRegion(testRect, 1);
                System.out.println("Successfully decoded region from image type " + (i + 1));
 
            } catch (Exception e) {
                System.err.println("Failed to decode image type " + (i + 1) + ": " + e.getMessage());
            }
        }
    }

    public void demonstrateErrorHandling() {
        System.out.println("=== Error Handling ===");
 
        // Test with invalid image data
        byte[] invalidData = new byte[] { 0x00, 0x01, 0x02, 0x03 };
 
        try {
            // [java_BitmapRegionDecoder_newInstance_error]
            // Create decoder with invalid data
            BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(invalidData);
            System.out.println("Created decoder with invalid data");
            // [java_BitmapRegionDecoder_newInstance_error]
 
            // Try to decode region
            Rectangle rect = new Rectangle(0, 0, 50, 50);
            ImageWrapper image = decoder.decodeRegion(rect, 1);
            System.out.println("Successfully decoded region from invalid data");
 
        } catch (Exception e) {
            System.out.println("Expected error when creating decoder with invalid data: " + e.getMessage());
        }
 
        // Test with invalid rectangle
        if (decoder != null) {
            try {
                Rectangle invalidRect = new Rectangle(-10, -10, 100, 100);
                ImageWrapper image = decoder.decodeRegion(invalidRect, 1);
                System.out.println("Successfully decoded region with negative coordinates");
 
            } catch (Exception e) {
                System.out.println("Expected error with invalid rectangle: " + e.getMessage());
            }
        }
    }

    public void demonstratePerformanceOptimization() {
        System.out.println("=== Performance Optimization ===");
 
        if (decoder == null) {
            return;
        }
 
        // Test different sample sizes for performance
        Rectangle largeRect = new Rectangle(0, 0, 800, 600);
        List<Float> sampleSizes = Arrays.asList(1.0f, 2.0f, 4.0f, 8.0f, 16.0f);
 
        for (float sampleSize : sampleSizes) {
            long startTime = System.currentTimeMillis();
            
            ImageWrapper image = decoder.decodeRegion(largeRect, sampleSize);
            
            long endTime = System.currentTimeMillis();
            System.out.println("Sample size " + sampleSize + ": " + (endTime - startTime) + "ms, " +
                              "Output size: " + image.getWidth() + "x" + image.getHeight());
        }
    }

    public void demonstrateRectangleManipulation() {
        System.out.println("=== Rectangle Manipulation ===");
 
        // Create base rectangle
        Rectangle baseRect = new Rectangle(100, 100, 200, 150);
        System.out.println("Base rectangle: " + baseRect.getX() + ", " + baseRect.getY() + 
                          ", " + baseRect.getWidth() + "x" + baseRect.getHeight());
 
        // Create different variations
        List<Rectangle> variations = Arrays.asList(
            new Rectangle(baseRect.getX(), baseRect.getY(), baseRect.getWidth() / 2, baseRect.getHeight()), // Half width
            new Rectangle(baseRect.getX(), baseRect.getY(), baseRect.getWidth(), baseRect.getHeight() / 2), // Half height
            new Rectangle(baseRect.getX() + 50, baseRect.getY() + 25, baseRect.getWidth() - 100, baseRect.getHeight() - 50), // Centered smaller
            new Rectangle(0, 0, baseRect.getWidth(), baseRect.getHeight()) // Top-left aligned
        );
 
        for (int i = 0; i < variations.size(); i++) {
            Rectangle rect = variations.get(i);
            System.out.println("Variation " + (i + 1) + ": " + rect.getX() + ", " + rect.getY() + 
                              ", " + rect.getWidth() + "x" + rect.getHeight());
        }
    }

    public void runExample() {
        System.out.println("=== BitmapRegionDecoder Example ===");
        
        demonstrateBitmapRegionDecoderMethods();
        demonstrateRectangleManipulation();
        demonstrateAdvancedFeatures();
        demonstrateErrorHandling();
        demonstratePerformanceOptimization();
        
        // Wait a bit for processing
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("=== Example completed ===");
    }

    public static void main(String[] args) {
        BitmapRegionDecoderExample example = new BitmapRegionDecoderExample();
        example.runExample();
    }
}