bitmap_region_decoder_example.dart

Go to the documentation of this file.

import 'dart:async';
import 'dart:io';
import 'dart:typed_data';
import 'package:navigine_sdk/navigine_sdk.dart';

class BitmapRegionDecoderExample {
  BitmapRegionDecoder? _decoder;
  Uint8List? _imageData;
 
  BitmapRegionDecoderExample() {
    _loadSampleImageData();
  }

  void _loadSampleImageData() {
    // Simulate loading image data (in real app, this would be from file or network)
    _imageData = Uint8List.fromList([
      0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG header
      // ... more image data would be here
    ]);
    print("Sample image data loaded (${_imageData!.length} bytes)");
  }

  void demonstrateBitmapRegionDecoderMethods() {
    if (_imageData == null) {
      print("No image data available");
      return;
    }
 
    // [dart_BitmapRegionDecoder_newInstance]
    // Create new instance of BitmapRegionDecoder
    _decoder = BitmapRegionDecoder.newInstance(_imageData!);
    print("Created BitmapRegionDecoder instance");
    // [dart_BitmapRegionDecoder_newInstance]
 
    // Demonstrate rectangle creation and usage
    _demonstrateRectangleUsage();
 
    // Demonstrate region decoding
    _demonstrateRegionDecoding();
 
    // Demonstrate different sample sizes
    _demonstrateSampleSizes();
 
    // Demonstrate multiple regions
    _demonstrateMultipleRegions();
  }

  void _demonstrateRectangleUsage() {
    // [dart_Rectangle_constructor]
    // Create rectangle with x, y, width, height
    Rectangle rect1 = Rectangle(10, 20, 100, 150);
    print(
      "Created rectangle: x=${rect1.x}, y=${rect1.y}, width=${rect1.width}, height=${rect1.height}",
    );
    // [dart_Rectangle_constructor]
 
    // [dart_Rectangle_getX]
    // Get X coordinate
    int x = rect1.x;
    print("Rectangle X coordinate: $x");
    // [dart_Rectangle_getX]
 
    // [dart_Rectangle_getY]
    // Get Y coordinate
    int y = rect1.y;
    print("Rectangle Y coordinate: $y");
    // [dart_Rectangle_getY]
 
    // [dart_Rectangle_getWidth]
    // Get width
    int width = rect1.width;
    print("Rectangle width: $width");
    // [dart_Rectangle_getWidth]
 
    // [dart_Rectangle_getHeight]
    // Get height
    int height = rect1.height;
    print("Rectangle height: $height");
    // [dart_Rectangle_getHeight]
 
    // Create different rectangles for different use cases
    Rectangle fullImage = Rectangle(0, 0, 1024, 768);
    Rectangle topLeft = Rectangle(0, 0, 512, 384);
    Rectangle center = Rectangle(256, 192, 512, 384);
    Rectangle bottomRight = Rectangle(512, 384, 512, 384);
 
    print("Created different rectangles for different regions");
  }

  void _demonstrateRegionDecoding() {
    if (_decoder == null) {
      print("Decoder not initialized");
      return;
    }
 
    // Create a sample rectangle
    Rectangle sampleRect = Rectangle(50, 50, 200, 200);
 
    // [dart_BitmapRegionDecoder_decodeRegion]
    // Decode region with sample size 1 (full resolution)
    ImageWrapper decodedImage = _decoder!.decodeRegion(sampleRect, 1);
    print(
      "Decoded region: ${sampleRect.width}x${sampleRect.height} at sample size 1",
    );
    // [dart_BitmapRegionDecoder_decodeRegion]
 
    // Demonstrate the decoded image
    _demonstrateDecodedImage(decodedImage, "Sample Region");
  }

  void _demonstrateSampleSizes() {
    if (_decoder == null) {
      return;
    }
 
    Rectangle testRect = Rectangle(0, 0, 400, 300);
 
    // Decode with different sample sizes
    List<double> sampleSizes = [1.0, 2.0, 4.0, 8.0];
 
    for (double sampleSize in sampleSizes) {
      // [dart_BitmapRegionDecoder_decodeRegion_sampleSize]
      // Decode region with specific sample size
      ImageWrapper decodedImage = _decoder!.decodeRegion(testRect, sampleSize);
      print(
        "Decoded region with sample size $sampleSize: ${(testRect.width / sampleSize).round()}x${(testRect.height / sampleSize).round()}",
      );
      // [dart_BitmapRegionDecoder_decodeRegion_sampleSize]
 
      _demonstrateDecodedImage(decodedImage, "Sample Size $sampleSize");
    }
  }

  void _demonstrateMultipleRegions() {
    if (_decoder == null) {
      return;
    }
 
    // Define multiple regions to decode
    List<Rectangle> regions = [
      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
    ];
 
    print("=== Decoding Multiple Regions ===");
    for (int i = 0; i < regions.length; i++) {
      Rectangle region = regions[i];
 
      // [dart_BitmapRegionDecoder_decodeRegion_multiple]
      // Decode multiple regions
      ImageWrapper decodedImage = _decoder!.decodeRegion(region, 1);
      print(
        "Region ${i + 1}: ${region.width}x${region.height} at (${region.x}, ${region.y})",
      );
      // [dart_BitmapRegionDecoder_decodeRegion_multiple]
 
      _demonstrateDecodedImage(decodedImage, "Region ${i + 1}");
    }
  }

  void _demonstrateDecodedImage(ImageWrapper image, String description) {
    print("--- $description ---");
    print("Image dimensions: ${image.width}x${image.height}");
    print("Image format: ${image.format}");
    print("Image data size: ${image.data.length} bytes");
    print("---");
  }

  Future<void> demonstrateAdvancedFeatures() async {
    print("=== Advanced BitmapRegionDecoder Features ===");
 
    if (_imageData == null) {
      return;
    }
 
    // Create multiple decoders for different images
    List<Uint8List> imageDataList = [
      _imageData!,
      Uint8List.fromList([0xFF, 0xD8, 0xFF, 0xE0]), // JPEG header
      Uint8List.fromList([0x47, 0x49, 0x46, 0x38]), // GIF header
    ];
 
    for (int i = 0; i < imageDataList.length; i++) {
      try {
        // [dart_BitmapRegionDecoder_newInstance_advanced]
        // Create decoder for different image types
        BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(
          imageDataList[i],
        );
        print("Created decoder for image type ${i + 1}");
        // [dart_BitmapRegionDecoder_newInstance_advanced]
 
        // Test decoding with different regions
        Rectangle testRect = Rectangle(0, 0, 100, 100);
        ImageWrapper decodedImage = decoder.decodeRegion(testRect, 1);
        print("Successfully decoded region from image type ${i + 1}");
      } catch (e) {
        print("Failed to decode image type ${i + 1}: $e");
      }
    }
  }

  void demonstrateErrorHandling() {
    print("=== Error Handling ===");
 
    // Test with invalid image data
    Uint8List invalidData = Uint8List.fromList([0x00, 0x01, 0x02, 0x03]);
 
    try {
      // [dart_BitmapRegionDecoder_newInstance_error]
      // Create decoder with invalid data
      BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(
        invalidData,
      );
      print("Created decoder with invalid data");
      // [dart_BitmapRegionDecoder_newInstance_error]
 
      // Try to decode region
      Rectangle rect = Rectangle(0, 0, 50, 50);
      ImageWrapper image = decoder.decodeRegion(rect, 1);
      print("Successfully decoded region from invalid data");
    } catch (e) {
      print("Expected error when creating decoder with invalid data: $e");
    }
 
    // Test with invalid rectangle
    if (_decoder != null) {
      try {
        Rectangle invalidRect = Rectangle(-10, -10, 100, 100);
        ImageWrapper image = _decoder!.decodeRegion(invalidRect, 1);
        print("Successfully decoded region with negative coordinates");
      } catch (e) {
        print("Expected error with invalid rectangle: $e");
      }
    }
  }

  void demonstratePerformanceOptimization() {
    print("=== Performance Optimization ===");
 
    if (_decoder == null) {
      return;
    }
 
    // Test different sample sizes for performance
    Rectangle largeRect = Rectangle(0, 0, 800, 600);
    List<double> sampleSizes = [1.0, 2.0, 4.0, 8.0, 16.0];
 
    for (double sampleSize in sampleSizes) {
      final stopwatch = Stopwatch()..start();
 
      ImageWrapper image = _decoder!.decodeRegion(largeRect, sampleSize);
 
      stopwatch.stop();
      print(
        "Sample size $sampleSize: ${stopwatch.elapsedMilliseconds}ms, "
        "Output size: ${image.width}x${image.height}",
      );
    }
  }

  void demonstrateRectangleManipulation() {
    print("=== Rectangle Manipulation ===");
 
    // Create base rectangle
    Rectangle baseRect = Rectangle(100, 100, 200, 150);
    print(
      "Base rectangle: ${baseRect.x}, ${baseRect.y}, ${baseRect.width}x${baseRect.height}",
    );
 
    // Create different variations
    List<Rectangle> variations = [
      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 (int i = 0; i < variations.length; i++) {
      Rectangle rect = variations[i];
      print(
        "Variation ${i + 1}: ${rect.x}, ${rect.y}, ${rect.width}x${rect.height}",
      );
    }
  }

  Future<void> runExample() async {
    print("=== BitmapRegionDecoder Example ===");
 
    demonstrateBitmapRegionDecoderMethods();
    demonstrateRectangleManipulation();
    await demonstrateAdvancedFeatures();
    demonstrateErrorHandling();
    demonstratePerformanceOptimization();
 
    // Wait a bit for processing
    await Future.delayed(Duration(seconds: 2));
 
    print("=== Example completed ===");
  }
}

Future<void> main() async {
  BitmapRegionDecoderExample example = BitmapRegionDecoderExample();
  await example.runExample();
}