BitmapRegionDecoderExample.m

Go to the documentation of this file.

#import "BitmapRegionDecoderExample.h"

@implementation BitmapRegionDecoderExample
 
- (instancetype)init {
    self = [super init];
    if (self) {
        [self loadSampleImageData];
    }
    return self;
}

- (void)loadSampleImageData {
    // Simulate loading image data (in real app, this would be from file or network)
    uint8_t pngHeader[] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }; // PNG header
    self.imageData = [NSData dataWithBytes:pngHeader length:sizeof(pngHeader)];
    NSLog(@"Sample image data loaded (%lu bytes)", (unsigned long)self.imageData.length);
}

- (void)demonstrateBitmapRegionDecoderMethods {
    if (self.imageData == nil) {
        NSLog(@"No image data available");
        return;
    }
 
    // [objc_BitmapRegionDecoder_newInstance]
    // Create new instance of BitmapRegionDecoder
    self.decoder = [NCBitmapRegionDecoder newInstanceWithData:self.imageData];
    NSLog(@"Created BitmapRegionDecoder instance");
    // [objc_BitmapRegionDecoder_newInstance]
 
    // Demonstrate rectangle creation and usage
    [self demonstrateRectangleUsage];
 
    // Demonstrate region decoding
    [self demonstrateRegionDecoding];
 
    // Demonstrate different sample sizes
    [self demonstrateSampleSizes];
 
    // Demonstrate multiple regions
    [self demonstrateMultipleRegions];
}

- (void)demonstrateRectangleUsage {
    // [objc_Rectangle_constructor]
    // Create rectangle with x, y, width, height
    NCRectangle *rect1 = [[NCRectangle alloc] initWithX:10 y:20 width:100 height:150];
    NSLog(@"Created rectangle: x=%d, y=%d, width=%d, height=%d", rect1.x, rect1.y, rect1.width, rect1.height);
    // [objc_Rectangle_constructor]
 
    // [objc_Rectangle_getX]
    // Get X coordinate
    int32_t x = rect1.x;
    NSLog(@"Rectangle X coordinate: %d", x);
    // [objc_Rectangle_getX]
 
    // [objc_Rectangle_getY]
    // Get Y coordinate
    int32_t y = rect1.y;
    NSLog(@"Rectangle Y coordinate: %d", y);
    // [objc_Rectangle_getY]
 
    // [objc_Rectangle_getWidth]
    // Get width
    int32_t width = rect1.width;
    NSLog(@"Rectangle width: %d", width);
    // [objc_Rectangle_getWidth]
 
    // [objc_Rectangle_getHeight]
    // Get height
    int32_t height = rect1.height;
    NSLog(@"Rectangle height: %d", height);
    // [objc_Rectangle_getHeight]
 
    // Create different rectangles for different use cases
    NCRectangle *fullImage = [[NCRectangle alloc] initWithX:0 y:0 width:1024 height:768];
    NCRectangle *topLeft = [[NCRectangle alloc] initWithX:0 y:0 width:512 height:384];
    NCRectangle *center = [[NCRectangle alloc] initWithX:256 y:192 width:512 height:384];
    NCRectangle *bottomRight = [[NCRectangle alloc] initWithX:512 y:384 width:512 height:384];
 
    NSLog(@"Created different rectangles for different regions");
}

- (void)demonstrateRegionDecoding {
    if (self.decoder == nil) {
        NSLog(@"Decoder not initialized");
        return;
    }
 
    // Create a sample rectangle
    NCRectangle *sampleRect = [[NCRectangle alloc] initWithX:50 y:50 width:200 height:200];
 
    // [objc_BitmapRegionDecoder_decodeRegion]
    // Decode region with sample size 1 (full resolution)
    id decodedImage = [self.decoder decodeRegionWithRect:sampleRect sampleSize:1];
    NSLog(@"Decoded region: %dx%d at sample size 1", sampleRect.width, sampleRect.height);
    // [objc_BitmapRegionDecoder_decodeRegion]
 
    // Demonstrate the decoded image
    [self demonstrateDecodedImage:decodedImage withDescription:@"Sample Region"];
}

- (void)demonstrateSampleSizes {
    if (self.decoder == nil) {
        return;
    }
 
    NCRectangle *testRect = [[NCRectangle alloc] initWithX:0 y:0 width:400 height:300];
 
            // Decode with different sample sizes
        NSArray<NSNumber *> *sampleSizes = @[@1.0f, @2.0f, @4.0f, @8.0f];
 
        for (NSNumber *sampleSizeNumber in sampleSizes) {
            float sampleSize = sampleSizeNumber.floatValue;
            
            // [objc_BitmapRegionDecoder_decodeRegion_sampleSize]
            // Decode region with specific sample size
            id decodedImage = [self.decoder decodeRegionWithRect:testRect sampleSize:sampleSize];
            NSLog(@"Decoded region with sample size %.1f: %dx%d", sampleSize,
                  (int)(testRect.width / sampleSize), (int)(testRect.height / sampleSize));
            // [objc_BitmapRegionDecoder_decodeRegion_sampleSize]
 
                    [self demonstrateDecodedImage:decodedImage withDescription:[NSString stringWithFormat:@"Sample Size %.1f", sampleSize]];
    }
}

- (void)demonstrateMultipleRegions {
    if (self.decoder == nil) {
        return;
    }
 
    // Define multiple regions to decode
    NSArray<NCRectangle *> *regions = @[
        [[NCRectangle alloc] initWithX:0 y:0 width:256 height:256],      // Top-left quadrant
        [[NCRectangle alloc] initWithX:256 y:0 width:256 height:256],    // Top-right quadrant
        [[NCRectangle alloc] initWithX:0 y:256 width:256 height:256],    // Bottom-left quadrant
        [[NCRectangle alloc] initWithX:256 y:256 width:256 height:256]   // Bottom-right quadrant
    ];
 
    NSLog(@"=== Decoding Multiple Regions ===");
    for (int i = 0; i < regions.count; i++) {
        NCRectangle *region = regions[i];
        
        // [objc_BitmapRegionDecoder_decodeRegion_multiple]
        // Decode multiple regions
        id decodedImage = [self.decoder decodeRegionWithRect:region sampleSize:1];
        NSLog(@"Region %d: %dx%d at (%d, %d)", i + 1, region.width, region.height, region.x, region.y);
        // [objc_BitmapRegionDecoder_decodeRegion_multiple]
 
        [self demonstrateDecodedImage:decodedImage withDescription:[NSString stringWithFormat:@"Region %d", i + 1]];
    }
}

- (void)demonstrateDecodedImage:(id)image withDescription:(NSString *)description {
    NSLog(@"--- %@ ---", description);
    // Note: In real implementation, you would access image properties here
    NSLog(@"Image decoded successfully");
    NSLog(@"---");
}

- (void)demonstrateAdvancedFeatures {
    NSLog(@"=== Advanced BitmapRegionDecoder Features ===");
 
    if (self.imageData == nil) {
        return;
    }
 
    // Create multiple decoders for different images
    NSArray<NSData *> *imageDataList = @[
        self.imageData,
        [NSData dataWithBytes:(uint8_t[]){0xFF, 0xD8, 0xFF, 0xE0} length:4], // JPEG header
        [NSData dataWithBytes:(uint8_t[]){0x47, 0x49, 0x46, 0x38} length:4]  // GIF header
    ];
 
    for (int i = 0; i < imageDataList.count; i++) {
        @try {
            // [objc_BitmapRegionDecoder_newInstance_advanced]
            // Create decoder for different image types
            NCBitmapRegionDecoder *decoder = [NCBitmapRegionDecoder newInstanceWithData:imageDataList[i]];
            NSLog(@"Created decoder for image type %d", i + 1);
            // [objc_BitmapRegionDecoder_newInstance_advanced]
 
            // Test decoding with different regions
            NCRectangle *testRect = [[NCRectangle alloc] initWithX:0 y:0 width:100 height:100];
            id decodedImage = [decoder decodeRegionWithRect:testRect sampleSize:1];
            NSLog(@"Successfully decoded region from image type %d", i + 1);
 
        } @catch (NSException *exception) {
            NSLog(@"Failed to decode image type %d: %@", i + 1, exception.reason);
        }
    }
}

- (void)demonstrateErrorHandling {
    NSLog(@"=== Error Handling ===");
 
    // Test with invalid image data
    NSData *invalidData = [NSData dataWithBytes:(uint8_t[]){0x00, 0x01, 0x02, 0x03} length:4];
 
    @try {
        // [objc_BitmapRegionDecoder_newInstance_error]
        // Create decoder with invalid data
        NCBitmapRegionDecoder *decoder = [NCBitmapRegionDecoder newInstanceWithData:invalidData];
        NSLog(@"Created decoder with invalid data");
        // [objc_BitmapRegionDecoder_newInstance_error]
 
        // Try to decode region
        NCRectangle *rect = [[NCRectangle alloc] initWithX:0 y:0 width:50 height:50];
        id image = [decoder decodeRegionWithRect:rect sampleSize:1];
        NSLog(@"Successfully decoded region from invalid data");
 
    } @catch (NSException *exception) {
        NSLog(@"Expected error when creating decoder with invalid data: %@", exception.reason);
    }
 
    // Test with invalid rectangle
    if (self.decoder != nil) {
        @try {
            NCRectangle *invalidRect = [[NCRectangle alloc] initWithX:-10 y:-10 width:100 height:100];
            id image = [self.decoder decodeRegionWithRect:invalidRect sampleSize:1];
            NSLog(@"Successfully decoded region with negative coordinates");
 
        } @catch (NSException *exception) {
            NSLog(@"Expected error with invalid rectangle: %@", exception.reason);
        }
    }
}

- (void)demonstratePerformanceOptimization {
    NSLog(@"=== Performance Optimization ===");
 
    if (self.decoder == nil) {
        return;
    }
 
    // Test different sample sizes for performance
    NCRectangle *largeRect = [[NCRectangle alloc] initWithX:0 y:0 width:800 height:600];
    NSArray<NSNumber *> *sampleSizes = @[@1.0f, @2.0f, @4.0f, @8.0f, @16.0f];
 
    for (NSNumber *sampleSizeNumber in sampleSizes) {
        float sampleSize = sampleSizeNumber.floatValue;
        
        NSDate *startTime = [NSDate date];
        
        id image = [self.decoder decodeRegionWithRect:largeRect sampleSize:sampleSize];
        
        NSTimeInterval elapsedTime = [[NSDate date] timeIntervalSinceDate:startTime] * 1000;
        NSLog(@"Sample size %.1f: %.0fms", sampleSize, elapsedTime);
    }
}

- (void)demonstrateRectangleManipulation {
    NSLog(@"=== Rectangle Manipulation ===");
 
    // Create base rectangle
    NCRectangle *baseRect = [[NCRectangle alloc] initWithX:100 y:100 width:200 height:150];
    NSLog(@"Base rectangle: %d, %d, %dx%d", baseRect.x, baseRect.y, baseRect.width, baseRect.height);
 
    // Create different variations
    NSArray<NCRectangle *> *variations = @[
        [[NCRectangle alloc] initWithX:baseRect.x y:baseRect.y width:baseRect.width / 2 height:baseRect.height], // Half width
        [[NCRectangle alloc] initWithX:baseRect.x y:baseRect.y width:baseRect.width height:baseRect.height / 2], // Half height
        [[NCRectangle alloc] initWithX:baseRect.x + 50 y:baseRect.y + 25 width:baseRect.width - 100 height:baseRect.height - 50], // Centered smaller
        [[NCRectangle alloc] initWithX:0 y:0 width:baseRect.width height:baseRect.height] // Top-left aligned
    ];
 
    for (int i = 0; i < variations.count; i++) {
        NCRectangle *rect = variations[i];
        NSLog(@"Variation %d: %d, %d, %dx%d", i + 1, rect.x, rect.y, rect.width, rect.height);
    }
}

- (void)runExample {
    NSLog(@"=== BitmapRegionDecoder Example ===");
    
    [self demonstrateBitmapRegionDecoderMethods];
    [self demonstrateRectangleManipulation];
    [self demonstrateAdvancedFeatures];
    [self demonstrateErrorHandling];
    [self demonstratePerformanceOptimization];
    
    // Wait a bit for processing
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"=== Example completed ===");
    });
}
 
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        BitmapRegionDecoderExample *example = [[BitmapRegionDecoderExample alloc] init];
        [example runExample];
        
        // Keep the app running for a while to see the output
        [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:10.0]];
    }
    return 0;
}