@umituz/react-native-image 1.1.5 → 1.1.6

package/src/infrastructure/utils/FilterEffects.ts

@@ -0,0 +1,51 @@
+/**
+ * Image Infrastructure - Filter Effects
+ * 
+ * Advanced filter effects and color processing
+ */
+
+export class FilterEffects {
+  static applyVintage(imageData: ImageData): ImageData {
+    let data = FilterEffects.applySepia(imageData, 0.8);
+    const { width, height } = imageData;
+    const centerX = width / 2;
+    const centerY = height / 2;
+    const maxDistance = Math.sqrt(centerX * centerX + centerY * centerY);
+
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const distance = Math.sqrt((x - centerX) ** 2 + (y - centerY) ** 2);
+        const vignette = 1 - (distance / maxDistance) * 0.7;
+        const i = (y * width + x) * 4;
+        
+        data.data[i] *= vignette;
+        data.data[i + 1] *= vignette;
+        data.data[i + 2] *= vignette;
+      }
+    }
+
+    return data;
+  }
+
+  static applySepia(imageData: ImageData, intensity: number = 1): ImageData {
+    const data = new Uint8ClampedArray(imageData.data);
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+
+      data[i] = Math.min(255, (r * (1 - (0.607 * intensity))) + (g * (0.769 * intensity)) + (b * (0.189 * intensity)));
+      data[i + 1] = Math.min(255, (r * (0.349 * intensity)) + (g * (1 - (0.314 * intensity))) + (b * (0.168 * intensity)));
+      data[i + 2] = Math.min(255, (r * (0.272 * intensity)) + (g * (0.534 * intensity)) + (b * (1 - (0.869 * intensity))));
+    }
+    return FilterEffects.createCanvasImageData(imageData.width, imageData.height, data);
+  }
+
+  static createCanvasImageData(
+    width: number,
+    height: number,
+    data: Uint8ClampedArray
+  ): ImageData {
+    return { data, width, height } as ImageData;
+  }
+}

package/src/infrastructure/utils/ImageQualityPresets.ts

@@ -0,0 +1,110 @@
+/**
+ * Image Infrastructure - Quality Presets
+ * 
+ * Predefined quality settings for different use cases
+ */
+
+import type { SaveFormat } from '../../domain/entities/ImageTypes';
+import { IMAGE_CONSTANTS } from '../../domain/entities/ImageConstants';
+
+export interface QualityPreset {
+  format: SaveFormat;
+  quality: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  description: string;
+}
+
+export interface QualityPresets {
+  web: QualityPreset;
+  mobile: QualityPreset;
+  print: QualityPreset;
+  thumbnail: QualityPreset;
+  preview: QualityPreset;
+  archive: QualityPreset;
+}
+
+export const IMAGE_QUALITY_PRESETS: QualityPresets = {
+  web: {
+    format: 'jpeg',
+    quality: 0.8,
+    maxWidth: 1920,
+    maxHeight: 1080,
+    description: 'Optimized for web use with good balance of quality and size',
+  },
+  mobile: {
+    format: 'jpeg',
+    quality: 0.7,
+    maxWidth: 1080,
+    maxHeight: 1920,
+    description: 'Optimized for mobile devices with smaller file size',
+  },
+  print: {
+    format: 'png',
+    quality: 1.0,
+    maxWidth: 3000,
+    maxHeight: 3000,
+    description: 'High quality for printing with maximum detail',
+  },
+  thumbnail: {
+    format: 'jpeg',
+    quality: 0.6,
+    maxWidth: IMAGE_CONSTANTS.thumbnailSize,
+    maxHeight: IMAGE_CONSTANTS.thumbnailSize,
+    description: 'Small thumbnail for preview use',
+  },
+  preview: {
+    format: 'jpeg',
+    quality: 0.5,
+    maxWidth: 800,
+    maxHeight: 600,
+    description: 'Quick preview with very small file size',
+  },
+  archive: {
+    format: 'png',
+    quality: 0.9,
+    description: 'High quality archival storage with lossless compression',
+  },
+};
+
+export class ImageQualityPresetService {
+  static getPreset(name: keyof QualityPresets): QualityPreset {
+    return IMAGE_QUALITY_PRESETS[name];
+  }
+
+  static getAllPresets(): QualityPresets {
+    return IMAGE_QUALITY_PRESETS;
+  }
+
+  static getCustomPreset(options: {
+    format?: SaveFormat;
+    quality?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+  }): QualityPreset {
+    return {
+      format: options.format || 'jpeg',
+      quality: options.quality || IMAGE_CONSTANTS.defaultQuality,
+      maxWidth: options.maxWidth,
+      maxHeight: options.maxHeight,
+      description: 'Custom quality preset',
+    };
+  }
+
+  static optimizeForUseCase(
+    useCase: 'web' | 'mobile' | 'print' | 'thumbnail' | 'preview' | 'archive',
+    customOptions?: Partial<QualityPreset>
+  ): QualityPreset {
+    const preset = IMAGE_QUALITY_PRESETS[useCase];
+    
+    if (!customOptions) {
+      return preset;
+    }
+
+    return {
+      ...preset,
+      ...customOptions,
+      description: `${preset.description} (modified)`,
+    };
+  }
+}

package/src/presentation/hooks/useImage.ts

@@ -6,16 +6,47 @@
 
 import { useImageTransform } from './useImageTransform';
 import { useImageConversion } from './useImageConversion';
+import { useImageFilter } from './useImageFilter';
+import { useImageBatch } from './useImageBatch';
+import { useImageAIEnhancement } from './useImageAIEnhancement';
+import { useImageAnnotation } from './useImageAnnotation';
+import { useImageMetadata } from './useImageMetadata';
 
 export const useImage = () => {
   const transform = useImageTransform();
   const conversion = useImageConversion();
+  const filter = useImageFilter();
+  const batch = useImageBatch();
+  const aiEnhancement = useImageAIEnhancement();
+  const annotation = useImageAnnotation();
+  const metadata = useImageMetadata();
 
   return {
+    // Basic operations
     ...transform,
     ...conversion,
+    // Advanced operations
+    ...filter,
+    ...batch,
+    ...aiEnhancement,
+    ...annotation,
+    ...metadata,
     // Combined state
-    isProcessing: transform.isTransforming || conversion.isConverting,
-    error: transform.transformError || conversion.conversionError,
+    isProcessing: 
+      transform.isTransforming || 
+      conversion.isConverting || 
+      filter.isFiltering || 
+      batch.isBatchProcessing || 
+      aiEnhancement.isEnhancing || 
+      annotation.isAnnotating || 
+      metadata.isExtracting,
+    error: 
+      transform.transformError || 
+      conversion.conversionError || 
+      filter.filterError || 
+      batch.batchError || 
+      aiEnhancement.enhancementError || 
+      annotation.annotationError || 
+      metadata.metadataError,
   };
 };

package/src/presentation/hooks/useImageAIEnhancement.ts

@@ -0,0 +1,33 @@
+/**
+ * Presentation - Image AI Enhancement Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageAIEnhancementService, type AutoEnhancementOptions, type EnhancementResult } from '../../infrastructure/services/ImageAIEnhancementService';
+import { ImageSpecializedEnhancementService } from '../../infrastructure/services/ImageSpecializedEnhancementService';
+
+export const useImageAIEnhancement = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const autoEnhance = useCallback((uri: string, options?: AutoEnhancementOptions) =>
+        execute(() => ImageAIEnhancementService.autoEnhance(uri, options), 'Failed to auto enhance'), [execute]);
+
+    const enhancePortrait = useCallback((uri: string) =>
+        execute(() => ImageSpecializedEnhancementService.enhancePortrait(uri), 'Failed to enhance portrait'), [execute]);
+
+    const enhanceLandscape = useCallback((uri: string) =>
+        execute(() => ImageSpecializedEnhancementService.enhanceLandscape(uri), 'Failed to enhance landscape'), [execute]);
+
+    const analyzeImage = useCallback((uri: string) =>
+        execute(() => ImageAIEnhancementService.analyzeImage(uri), 'Failed to analyze image'), [execute]);
+
+    return {
+        autoEnhance,
+        enhancePortrait,
+        enhanceLandscape,
+        analyzeImage,
+        isEnhancing: isProcessing,
+        enhancementError: error,
+    };
+};

package/src/presentation/hooks/useImageAnnotation.ts

@@ -0,0 +1,32 @@
+/**
+ * Presentation - Image Annotation Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageAnnotationService, type ImageAnnotation, type TextOverlay, type DrawingElement, type WatermarkOptions } from '../../infrastructure/services/ImageAnnotationService';
+
+export const useImageAnnotation = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const addTextOverlay = useCallback((uri: string, overlay: TextOverlay) =>
+        execute(() => ImageAnnotationService.addTextOverlay(uri, overlay), 'Failed to add text'), [execute]);
+
+    const addDrawingElements = useCallback((uri: string, elements: DrawingElement[]) =>
+        execute(() => ImageAnnotationService.addDrawingElements(uri, elements), 'Failed to add drawing'), [execute]);
+
+    const addWatermark = useCallback((uri: string, options: WatermarkOptions) =>
+        execute(() => ImageAnnotationService.addWatermark(uri, options), 'Failed to add watermark'), [execute]);
+
+    const applyAnnotation = useCallback((uri: string, annotation: ImageAnnotation) =>
+        execute(() => ImageAnnotationService.applyAnnotation(uri, annotation), 'Failed to apply annotation'), [execute]);
+
+    return {
+        addTextOverlay,
+        addDrawingElements,
+        addWatermark,
+        applyAnnotation,
+        isAnnotating: isProcessing,
+        annotationError: error,
+    };
+};

package/src/presentation/hooks/useImageBatch.ts

@@ -0,0 +1,33 @@
+/**
+ * Presentation - Image Batch Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageBatchService, type BatchOperation, type BatchProcessingOptions } from '../../infrastructure/services/ImageBatchService';
+import type { ImageFilter } from '../../domain/entities/ImageFilterTypes';
+
+export const useImageBatch = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const processBatch = useCallback((operations: BatchOperation[], options?: BatchProcessingOptions) =>
+        execute(() => ImageBatchService.processBatch(operations, options), 'Failed to process batch'), [execute]);
+
+    const resizeBatch = useCallback((uris: string[], width?: number, height?: number, options?: BatchProcessingOptions & { saveOptions?: any }) =>
+        execute(() => ImageBatchService.resizeBatch(uris, width, height, options), 'Failed to resize batch'), [execute]);
+
+    const compressBatch = useCallback((uris: string[], quality?: number, options?: BatchProcessingOptions) =>
+        execute(() => ImageBatchService.compressBatch(uris, quality, options), 'Failed to compress batch'), [execute]);
+
+    const filterBatch = useCallback((uris: string[], filter: ImageFilter, options?: BatchProcessingOptions) =>
+        execute(() => ImageBatchService.filterBatch(uris, filter, options), 'Failed to filter batch'), [execute]);
+
+    return {
+        processBatch,
+        resizeBatch,
+        compressBatch,
+        filterBatch,
+        isBatchProcessing: isProcessing,
+        batchError: error,
+    };
+};

package/src/presentation/hooks/useImageFilter.ts

@@ -0,0 +1,38 @@
+/**
+ * Presentation - Image Filter Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageFilterService } from '../../infrastructure/services/ImageFilterService';
+import type {
+  ImageFilter,
+  ImageColorAdjustment,
+  ImageQualityMetrics,
+  ImageColorPalette,
+} from '../../domain/entities/ImageFilterTypes';
+
+export const useImageFilter = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const applyFilter = useCallback((uri: string, filter: ImageFilter) =>
+        execute(() => ImageFilterService.applyFilter(uri, filter), 'Failed to apply filter'), [execute]);
+
+    const applyColorAdjustment = useCallback((uri: string, adjustment: ImageColorAdjustment) =>
+        execute(() => ImageFilterService.applyColorAdjustment(uri, adjustment), 'Failed to adjust colors'), [execute]);
+
+    const analyzeQuality = useCallback((uri: string) =>
+        execute(() => ImageFilterService.analyzeQuality(uri), 'Failed to analyze quality'), [execute]);
+
+    const extractColorPalette = useCallback((uri: string, colorCount?: number) =>
+        execute(() => ImageFilterService.extractColorPalette(uri, colorCount), 'Failed to extract colors'), [execute]);
+
+    return {
+        applyFilter,
+        applyColorAdjustment,
+        analyzeQuality,
+        extractColorPalette,
+        isFiltering: isProcessing,
+        filterError: error,
+    };
+};

package/src/presentation/hooks/useImageMetadata.ts

@@ -0,0 +1,28 @@
+/**
+ * Presentation - Image Metadata Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageMetadataService, type ImageMetadataExtractionOptions } from '../../infrastructure/services/ImageMetadataService';
+
+export const useImageMetadata = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const extractMetadata = useCallback((uri: string, options?: ImageMetadataExtractionOptions) =>
+        execute(() => ImageMetadataService.extractMetadata(uri, options), 'Failed to extract metadata'), [execute]);
+
+    const getBasicInfo = useCallback((uri: string) =>
+        execute(() => ImageMetadataService.getBasicInfo(uri), 'Failed to get basic info'), [execute]);
+
+    const hasMetadata = useCallback((uri: string) =>
+        execute(() => ImageMetadataService.hasMetadata(uri), 'Failed to check metadata'), [execute]);
+
+    return {
+        extractMetadata,
+        getBasicInfo,
+        hasMetadata,
+        isExtracting: isProcessing,
+        metadataError: error,
+    };
+};