rn-remove-image-bg 0.0.10

package/android/src/main/java/com/margelo/nitro/rnremoveimagebg/HybridImageBackgroundRemover.kt

@@ -0,0 +1,189 @@
+package com.margelo.nitro.rnremoveimagebg
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Build
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmentation
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmenterOptions
+import com.margelo.nitro.rnremoveimagebg.HybridImageBackgroundRemoverSpec
+import com.margelo.nitro.rnremoveimagebg.NativeRemoveBackgroundOptions
+import com.margelo.nitro.rnremoveimagebg.OutputFormat
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.NitroModules
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
+import kotlin.math.max
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class HybridImageBackgroundRemover : HybridImageBackgroundRemoverSpec() {
+    override val memorySize: Long
+        get() = 0L
+
+    private val segmenter by lazy {
+        val options = SubjectSegmenterOptions.Builder()
+            .enableForegroundBitmap()
+            .build()
+        SubjectSegmentation.getClient(options)
+    }
+
+    override fun removeBackground(imagePath: String, options: NativeRemoveBackgroundOptions): Promise<String> {
+        return Promise.async {
+            withContext(Dispatchers.Default) {
+                processImage(imagePath, options)
+            }
+        }
+    }
+
+    private suspend fun processImage(imagePath: String, options: NativeRemoveBackgroundOptions): String {
+        val cleanPath = if (imagePath.startsWith("file://")) imagePath.substring(7) else imagePath
+        val file = File(cleanPath)
+        
+        if (!file.exists() || !file.canRead()) {
+            throw Exception("File does not exist or is not readable: $imagePath")
+        }
+        
+        // Decode with downsampling for large images
+        val bitmap = decodeBitmapEfficiently(cleanPath, options.maxDimension.toInt())
+            ?: throw Exception("Could not decode image at path: $imagePath")
+
+        val inputImage = InputImage.fromBitmap(bitmap, 0)
+
+        return suspendCoroutine { continuation ->
+            segmenter.process(inputImage)
+                .addOnSuccessListener { result ->
+                    val foregroundBitmap = result.foregroundBitmap
+                    if (foregroundBitmap != null) {
+                        try {
+                            val context = NitroModules.applicationContext
+                            if (context == null) {
+                                bitmap.recycle()
+                                foregroundBitmap.recycle()
+                                continuation.resumeWithException(Exception("Application Context is null"))
+                                return@addOnSuccessListener
+                            }
+                            
+                            val outputPath = saveImage(
+                                foregroundBitmap,
+                                context.cacheDir,
+                                options.format,
+                                options.quality.toInt()
+                            )
+                            
+                            bitmap.recycle()
+                            foregroundBitmap.recycle()
+                            continuation.resume(outputPath)
+                        } catch (e: Exception) {
+                            bitmap.recycle()
+                            foregroundBitmap.recycle()
+                            continuation.resumeWithException(e)
+                        }
+                    } else {
+                        bitmap.recycle()
+                        continuation.resumeWithException(Exception("Could not generate foreground bitmap"))
+                    }
+                }
+                .addOnFailureListener { e ->
+                    bitmap.recycle()
+                    continuation.resumeWithException(e)
+                }
+        }
+    }
+
+    /**
+     * Decode bitmap with efficient sampling for large images
+     */
+    private fun decodeBitmapEfficiently(path: String, maxDimension: Int): Bitmap? {
+        // First, get image dimensions without loading into memory
+        val boundsOptions = BitmapFactory.Options().apply {
+            inJustDecodeBounds = true
+        }
+        BitmapFactory.decodeFile(path, boundsOptions)
+        
+        val imageWidth = boundsOptions.outWidth
+        val imageHeight = boundsOptions.outHeight
+        
+        if (imageWidth <= 0 || imageHeight <= 0) {
+            return null
+        }
+        
+        // Calculate sample size
+        val sampleSize = calculateInSampleSize(imageWidth, imageHeight, maxDimension)
+        
+        // Decode with sample size
+        val decodeOptions = BitmapFactory.Options().apply {
+            inSampleSize = sampleSize
+            inPreferredConfig = Bitmap.Config.ARGB_8888
+        }
+        
+        return BitmapFactory.decodeFile(path, decodeOptions)
+    }
+
+    /**
+     * Calculate optimal inSampleSize for downsampling
+     */
+    private fun calculateInSampleSize(width: Int, height: Int, maxDimension: Int): Int {
+        var sampleSize = 1
+        val maxSize = max(width, height)
+        
+        if (maxSize > maxDimension) {
+            val halfWidth = width / 2
+            val halfHeight = height / 2
+            
+            // Calculate the largest inSampleSize value that is a power of 2
+            // and keeps both dimensions above the requested max dimension
+            while ((halfWidth / sampleSize) >= maxDimension && 
+                   (halfHeight / sampleSize) >= maxDimension) {
+                sampleSize *= 2
+            }
+        }
+        
+        return sampleSize
+    }
+
+    /**
+     * Save bitmap to cache directory with specified format and quality
+     */
+    @Suppress("DEPRECATION")
+    private fun saveImage(
+        bitmap: Bitmap,
+        outputDir: File,
+        format: OutputFormat,
+        quality: Int
+    ): String {
+        val compressFormat = when (format) {
+            OutputFormat.WEBP -> {
+                // Use lossy for quality < 100 (smaller files), lossless for 100
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                    if (quality < 100) Bitmap.CompressFormat.WEBP_LOSSY
+                    else Bitmap.CompressFormat.WEBP_LOSSLESS
+                } else {
+                    // Pre-Android 11 uses deprecated WEBP format
+                    Bitmap.CompressFormat.WEBP
+                }
+            }
+            OutputFormat.PNG -> Bitmap.CompressFormat.PNG
+        }
+        
+        val extension = when (format) {
+            OutputFormat.WEBP -> "webp"
+            OutputFormat.PNG -> "png"
+        }
+        
+        val outputFile = File(outputDir, "bg_removed_${UUID.randomUUID()}.$extension")
+        
+        FileOutputStream(outputFile).use { outStream ->
+            // For PNG, quality is ignored (always lossless)
+            // For WEBP, use the provided quality
+            val finalQuality = if (format == OutputFormat.PNG) 100 else quality
+            bitmap.compress(compressFormat, finalQuality, outStream)
+        }
+        
+        return outputFile.absolutePath
+    }
+}

package/android/src/main/java/com/margelo/nitro/rnremoveimagebg/NitroRnRemoveImageBgPackage.kt

@@ -0,0 +1,31 @@
+package com.margelo.nitro.rnremoveimagebg
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class NitroRnRemoveImageBgPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return null
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider { HashMap() }
+  }
+
+
+
+  companion object {
+    init {
+      try {
+        System.loadLibrary("NitroRnRemoveImageBg")
+        println("🔥 Loaded native library: NitroRnRemoveImageBg")
+      } catch (e: Throwable) {
+        println("❌ Failed to load NitroRnRemoveImageBg: $e")
+      }
+      NitroRnRemoveImageBgOnLoad.initializeNative()
+    }
+  }
+}

package/app.plugin.js

@@ -0,0 +1,12 @@
+const { createRunOncePlugin } = require('@expo/config-plugins');
+const pkg = require('./package.json');
+
+const withRnRemoveImageBg = (config) => {
+  return config;
+};
+
+module.exports = createRunOncePlugin(
+  withRnRemoveImageBg,
+  pkg.name,
+  pkg.version
+);

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroRnRemoveImageBg
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once

package/ios/HybridImageBackgroundRemover.swift

@@ -0,0 +1,224 @@
+import Foundation
+import Vision
+import CoreImage
+import UIKit
+import CoreML
+import UniformTypeIdentifiers
+
+class HybridImageBackgroundRemover: HybridImageBackgroundRemoverSpec {
+    var memorySize: Int {
+        return 0
+    }
+    
+    // Reuse CIContext for better performance
+    private let ciContext: CIContext = {
+        // Use Metal for hardware acceleration if available
+        if let metalDevice = MTLCreateSystemDefaultDevice() {
+            return CIContext(mtlDevice: metalDevice, options: [.cacheIntermediates: false])
+        }
+        return CIContext(options: [.useSoftwareRenderer: false, .cacheIntermediates: false])
+    }()
+    
+    // Lazy load CoreML model for iOS < 17
+    private lazy var coreMLModel: VNCoreMLModel? = {
+        guard let modelURL = Bundle(for: HybridImageBackgroundRemover.self).url(forResource: "U2Netp", withExtension: "mlmodelc") else {
+            return nil
+        }
+        guard let model = try? MLModel(contentsOf: modelURL) else {
+            return nil
+        }
+        return try? VNCoreMLModel(for: model)
+    }()
+
+    func removeBackground(imagePath: String, options: NativeRemoveBackgroundOptions) throws -> Promise<String> {
+        return Promise.async { [self] in
+            let maxDimension = Int(options.maxDimension)
+            let format = options.format
+            let quality = Int(options.quality)
+            
+            // Handle both absolute paths and file:// URLs
+            let cleanPath = imagePath.hasPrefix("file://") ? String(imagePath.dropFirst(7)) : imagePath
+            let fileUrl = URL(fileURLWithPath: cleanPath)
+            
+            // Validate file exists
+            guard FileManager.default.fileExists(atPath: fileUrl.path) else {
+                throw RuntimeError.error(withMessage: "File does not exist: \(imagePath)")
+            }
+            
+            guard var inputImage = CIImage(contentsOf: fileUrl) else {
+                throw RuntimeError.error(withMessage: "Could not load image from path: \(imagePath)")
+            }
+            
+            // Downsample large images for better performance
+            inputImage = self.downsampleIfNeeded(inputImage, maxDimension: maxDimension)
+
+            var maskImage: CIImage?
+
+            if #available(iOS 17.0, *) {
+                // Use Vision's native foreground instance mask
+                let request = VNGenerateForegroundInstanceMaskRequest()
+                let handler = VNImageRequestHandler(ciImage: inputImage, options: [:])
+                try handler.perform([request])
+
+                if let result = request.results?.first {
+                    let maskPixelBuffer = try result.generateScaledMaskForImage(forInstances: result.allInstances, from: handler)
+                    maskImage = CIImage(cvPixelBuffer: maskPixelBuffer)
+                }
+            } else {
+                // Fallback to CoreML (U2Netp) for iOS < 17
+                maskImage = try self.processWithCoreML(inputImage: inputImage)
+            }
+
+            guard let mask = maskImage else {
+                throw RuntimeError.error(withMessage: "Failed to generate mask")
+            }
+
+            // Apply the mask to the original image
+            let maskedImage = inputImage.applyingFilter("CIBlendWithMask", parameters: [
+                kCIInputMaskImageKey: mask
+            ])
+
+            // Render and save
+            return try self.saveImage(maskedImage, format: format, quality: quality)
+        }
+    }
+    
+    /// Downsample image if it exceeds maxDimension
+    private func downsampleIfNeeded(_ image: CIImage, maxDimension: Int) -> CIImage {
+        let width = image.extent.width
+        let height = image.extent.height
+        let maxDim = CGFloat(maxDimension)
+        
+        guard width > maxDim || height > maxDim else {
+            return image
+        }
+        
+        let scale: CGFloat
+        if width > height {
+            scale = maxDim / width
+        } else {
+            scale = maxDim / height
+        }
+        
+        return image.transformed(by: CGAffineTransform(scaleX: scale, y: scale))
+    }
+    
+    /// Save processed image to disk
+    private func saveImage(_ image: CIImage, format: OutputFormat, quality: Int) throws -> String {
+        guard let cgImage = ciContext.createCGImage(image, from: image.extent) else {
+            throw RuntimeError.error(withMessage: "Failed to render masked image")
+        }
+        
+        let uiImage = UIImage(cgImage: cgImage)
+        let tempDir = FileManager.default.temporaryDirectory
+        let uuid = UUID().uuidString
+        
+        let data: Data?
+        let fileName: String
+        
+        switch format {
+        case .png:
+            data = uiImage.pngData()
+            fileName = "bg_removed_\(uuid).png"
+        case .webp:
+            // iOS doesn't natively support WEBP encoding
+            // Use HEIC on iOS 17+ (supports alpha), otherwise fall back to PNG
+            if #available(iOS 17.0, *) {
+                data = uiImage.heicData()
+                fileName = "bg_removed_\(uuid).heic"
+            } else {
+                data = uiImage.pngData()
+                fileName = "bg_removed_\(uuid).png"
+            }
+        }
+        
+        guard let imageData = data else {
+            throw RuntimeError.error(withMessage: "Failed to encode image")
+        }
+        
+        let fileURL = tempDir.appendingPathComponent(fileName)
+        try imageData.write(to: fileURL)
+        
+        return fileURL.path
+    }
+
+    private func processWithCoreML(inputImage: CIImage) throws -> CIImage? {
+        guard let vnModel = coreMLModel else {
+            throw RuntimeError.error(withMessage: "Could not load U2Netp model")
+        }
+
+        let request = VNCoreMLRequest(model: vnModel)
+        request.imageCropAndScaleOption = .scaleFill
+
+        let handler = VNImageRequestHandler(ciImage: inputImage, options: [:])
+        try handler.perform([request])
+
+        // Try VNPixelBufferObservation first
+        if let results = request.results as? [VNPixelBufferObservation], let observation = results.first {
+            return CIImage(cvPixelBuffer: observation.pixelBuffer)
+        }
+        
+        // Fallback to VNCoreMLFeatureValueObservation (MultiArray)
+        if let results = request.results as? [VNCoreMLFeatureValueObservation],
+           let feature = results.first?.featureValue.multiArrayValue {
+            return try self.convertMultiArrayToImage(multiArray: feature, originalSize: inputImage.extent.size)
+        }
+        
+        throw RuntimeError.error(withMessage: "No valid result from CoreML model")
+    }
+    
+    private func convertMultiArrayToImage(multiArray: MLMultiArray, originalSize: CGSize) throws -> CIImage? {
+        // U2Net output is typically [1, 1, H, W] where H,W are usually 320x320
+        guard multiArray.shape.count >= 3 else {
+            throw RuntimeError.error(withMessage: "Unexpected MultiArray shape: \(multiArray.shape)")
+        }
+        
+        let height = multiArray.shape[multiArray.shape.count - 2].intValue
+        let width = multiArray.shape[multiArray.shape.count - 1].intValue
+        
+        // Create grayscale bitmap from MultiArray
+        var pixelBuffer: CVPixelBuffer?
+        let status = CVPixelBufferCreate(
+            kCFAllocatorDefault,
+            width,
+            height,
+            kCVPixelFormatType_OneComponent8,
+            nil,
+            &pixelBuffer
+        )
+        
+        guard status == kCVReturnSuccess, let buffer = pixelBuffer else {
+            throw RuntimeError.error(withMessage: "Failed to create pixel buffer")
+        }
+        
+        CVPixelBufferLockBaseAddress(buffer, [])
+        defer { CVPixelBufferUnlockBaseAddress(buffer, []) }
+        
+        guard let baseAddress = CVPixelBufferGetBaseAddress(buffer) else {
+            throw RuntimeError.error(withMessage: "Failed to get pixel buffer base address")
+        }
+        
+        let pointer = baseAddress.assumingMemoryBound(to: UInt8.self)
+        
+        // Copy and normalize values from MultiArray (0.0-1.0) to UInt8 (0-255)
+        for y in 0..<height {
+            for x in 0..<width {
+                let index = y * width + x
+                let value = multiArray[[0, 0, y as NSNumber, x as NSNumber]].floatValue
+                pointer[index] = UInt8(min(max(value * 255.0, 0), 255))
+            }
+        }
+        
+        // Convert to CIImage and scale to original size
+        let maskImage = CIImage(cvPixelBuffer: buffer)
+        let scaleX = originalSize.width / CGFloat(width)
+        let scaleY = originalSize.height / CGFloat(height)
+        return maskImage.transformed(by: CGAffineTransform(scaleX: scaleX, y: scaleY))
+    }
+}
+
+@_cdecl("createHybridImageBackgroundRemover")
+public func createHybridImageBackgroundRemover() -> UnsafeMutableRawPointer {
+  let hybridObject = HybridImageBackgroundRemover()
+  return hybridObject.getCxxWrapper().toUnsafe()
+}

package/ios/NitroRnRemoveImageBgOnLoad.mm

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroRnRemoveImageBg-Swift-Cxx-Bridge.hpp"
+
+extern "C" void* createHybridImageBackgroundRemover();
+
+@interface NitroRnRemoveImageBgOnLoad : NSObject
+@end
+
+@implementation NitroRnRemoveImageBgOnLoad
+
++ (void)load {
+  margelo::nitro::HybridObjectRegistry::registerHybridObjectConstructor(
+    "ImageBackgroundRemover",
+    []() -> std::shared_ptr<margelo::nitro::HybridObject> {
+      void* unsafe = createHybridImageBackgroundRemover();
+      return margelo::nitro::rnremoveimagebg::bridge::swift::create_std__shared_ptr_HybridImageBackgroundRemoverSpec_(unsafe);
+    }
+  );
+}
+
+@end

package/lib/ImageProcessing.d.ts

@@ -0,0 +1,167 @@
+import * as ImageManipulator from 'expo-image-manipulator';
+import type { OutputFormat, NativeRemoveBackgroundOptions } from './specs/ImageBackgroundRemover.nitro';
+export type { OutputFormat, NativeRemoveBackgroundOptions };
+export interface CompressImageOptions {
+    /**
+     * Maximum file size in KB (default: 250)
+     */
+    maxSizeKB?: number;
+    /**
+     * Initial image width (default: 1024)
+     */
+    width?: number;
+    /**
+     * Initial image height (default: 1024)
+     */
+    height?: number;
+    /**
+     * Initial compression quality (0-1, default: 0.85)
+     */
+    quality?: number;
+    /**
+     * Image format (default: WEBP)
+     */
+    format?: ImageManipulator.SaveFormat;
+}
+export interface GenerateThumbhashOptions {
+    /**
+     * Thumbhash size (default: 32)
+     */
+    size?: number;
+}
+/**
+ * Options for background removal
+ */
+export interface RemoveBgImageOptions {
+    /**
+     * Maximum dimension (width or height) for processing
+     * Larger images will be downsampled for better performance
+     * @default 2048
+     */
+    maxDimension?: number;
+    /**
+     * Output image format
+     * - PNG: Lossless, larger file size, best for transparency
+     * - WEBP: Smaller file size, good quality
+     * @default 'PNG'
+     */
+    format?: OutputFormat;
+    /**
+     * Quality for WEBP format (0-100)
+     * Ignored when format is PNG
+     * @default 100
+     */
+    quality?: number;
+    /**
+     * Progress callback (0-100)
+     * Note: Progress is approximate and may not be linear
+     */
+    onProgress?: (progress: number) => void;
+    /**
+     * Use cached result if available
+     * @default true
+     */
+    useCache?: boolean;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * Compress image to WebP format with configurable options
+ */
+export declare function compressImage(uri: string, options?: CompressImageOptions): Promise<string>;
+/**
+ * Generate thumbhash from image URI (Native/Mobile)
+ */
+export declare function generateThumbhash(imageUri: string, options?: GenerateThumbhashOptions): Promise<string>;
+/**
+ * Remove background from image using native ML models
+ *
+ * @param uri - File path or file:// URI to the source image
+ * @param options - Processing options
+ * @returns Promise resolving to a URI suitable for use with `<Image>` component.
+ *   - **iOS/Android**: File path (`file:///path/to/cache/bg_removed_xxx.png`)
+ *   - **Web**: Data URL (`data:image/png;base64,...`)
+ *
+ * @throws {BackgroundRemovalError} When image cannot be processed
+ *
+ * @example
+ * ```typescript
+ * const result = await removeBgImage('file:///path/to/photo.jpg')
+ * // Use directly in Image component
+ * <Image source={{ uri: result }} />
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With options
+ * const result = await removeBgImage('file:///path/to/photo.jpg', {
+ *   maxDimension: 1024,
+ *   format: 'WEBP',
+ *   quality: 90,
+ *   onProgress: (p) => console.log(`Progress: ${p}%`)
+ * })
+ * ```
+ */
+export declare function removeBgImage(uri: string, options?: RemoveBgImageOptions): Promise<string>;
+/**
+ * Backward compatibility alias for removeBgImage
+ * @deprecated Use removeBgImage instead
+ */
+export declare const removeBackground: typeof removeBgImage;
+/**
+ * Clear the background removal cache
+ * @param deleteFiles - Also delete cached files from disk (default: false)
+ */
+export declare function clearCache(deleteFiles?: boolean): Promise<void>;
+/**
+ * Get the current cache size
+ */
+export declare function getCacheSize(): number;
+/**
+ * Handle low memory conditions by clearing the cache
+ * Call this when your app receives memory warnings
+ *
+ * @param deleteFiles - Also delete cached files from disk (default: true)
+ * @returns Number of entries that were cleared
+ *
+ * @example
+ * ```typescript
+ * import { AppState } from 'react-native'
+ * import { onLowMemory } from 'rn-remove-image-bg'
+ *
+ * // In your app initialization
+ * AppState.addEventListener('memoryWarning', () => {
+ *   onLowMemory()
+ * })
+ * ```
+ */
+export declare function onLowMemory(deleteFiles?: boolean): Promise<number>;
+/**
+ * Configure the background removal cache
+ * Call this early in your app lifecycle to customize cache behavior
+ *
+ * @example
+ * ```typescript
+ * import { configureCache } from 'rn-remove-image-bg'
+ *
+ * configureCache({
+ *   maxEntries: 100,
+ *   maxAgeMinutes: 60,
+ *   persistToDisk: true
+ * })
+ * ```
+ */
+export declare function configureCache(config: {
+    maxEntries?: number;
+    maxAgeMinutes?: number;
+    persistToDisk?: boolean;
+    cacheDirectory?: string;
+}): void;
+/**
+ * Get the cache directory path
+ * Useful for debugging or manual cache management
+ */
+export declare function getCacheDirectory(): string;