react-native-camera-vision-pixel-colors 0.1.0

package/ios/PixelAnalyzerEngine.swift

@@ -0,0 +1,346 @@
+import Foundation
+import CoreImage
+import CoreVideo
+import UIKit
+import Accelerate
+
+struct AnalysisOptionsNative {
+  var enableMotionDetection: Bool = false
+  var motionThreshold: Float = 0.1
+  var roi: (x: Float, y: Float, width: Float, height: Float)?
+}
+
+final class PixelAnalyzerEngine {
+  static let shared = PixelAnalyzerEngine()
+  private let gpuQueue = DispatchQueue(label: "pixel.colors.gpu", qos: .userInitiated)
+  private let cacheQueue = DispatchQueue(label: "pixel.colors.cache")
+  private let ciContext: CIContext
+  private var cachedResult: [String: Any] = [
+    "uniqueColorCount": 0,
+    "topColors": [[String: Int]](),
+    "brightestColors": [[String: Int]]()
+  ]
+  private let histogramBins: Int = 64
+  private let maxRawPixelDimension: Int = 1920
+
+  // Motion detection state
+  private var previousGrayscale: [UInt8]?
+  private var previousWidth: Int = 0
+  private var previousHeight: Int = 0
+
+  private init() {
+    self.ciContext = CIContext(options: [.useSoftwareRenderer: false])
+  }
+
+  // Frame processor fast read (sync)
+  func analyzeSync() -> [String: Any] {
+    var result: [String: Any] = [:]
+    cacheQueue.sync {
+      result = self.cachedResult
+    }
+    return result
+  }
+
+  // Async full analysis (GPU)
+  func analyzeAsync(pixelBuffer: CVPixelBuffer, options: AnalysisOptionsNative = AnalysisOptionsNative()) {
+    gpuQueue.async { [weak self] in
+      guard let self = self else { return }
+      let result = self.fullAnalysis(pixelBuffer: pixelBuffer, options: options)
+      self.cacheQueue.async {
+        self.cachedResult = result
+      }
+    }
+  }
+
+  // MARK: - ROI Calculation
+
+  private func calculateROI(config: (x: Float, y: Float, width: Float, height: Float), width: Int, height: Int) -> CGRect {
+    let x = Int(config.x * Float(width))
+    let y = Int(config.y * Float(height))
+    let w = Int(config.width * Float(width))
+    let h = Int(config.height * Float(height))
+    return CGRect(x: x, y: y, width: max(1, w), height: max(1, h))
+  }
+
+  // MARK: - Motion Detection
+
+  private func calculateMotion(pixelBuffer: CVPixelBuffer, threshold: Float) -> [String: Any] {
+    CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+    defer { CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly) }
+
+    let width = CVPixelBufferGetWidth(pixelBuffer)
+    let height = CVPixelBufferGetHeight(pixelBuffer)
+    let totalPixels = width * height
+
+    guard let baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer) else {
+      return ["score": 0.0, "hasMotion": false]
+    }
+
+    let bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer)
+    let pixelFormat = CVPixelBufferGetPixelFormatType(pixelBuffer)
+
+    // Convert to grayscale
+    var currentGrayscale = [UInt8](repeating: 0, count: totalPixels)
+
+    if pixelFormat == kCVPixelFormatType_32BGRA || pixelFormat == kCVPixelFormatType_32ARGB {
+      // BGRA/ARGB format
+      for y in 0..<height {
+        let rowPtr = baseAddress.advanced(by: y * bytesPerRow).assumingMemoryBound(to: UInt8.self)
+        for x in 0..<width {
+          let offset = x * 4
+          let b = Float(rowPtr[offset])
+          let g = Float(rowPtr[offset + 1])
+          let r = Float(rowPtr[offset + 2])
+          currentGrayscale[y * width + x] = UInt8(0.299 * r + 0.587 * g + 0.114 * b)
+        }
+      }
+    } else {
+      // Fallback for other formats - use first channel
+      for y in 0..<height {
+        let rowPtr = baseAddress.advanced(by: y * bytesPerRow).assumingMemoryBound(to: UInt8.self)
+        for x in 0..<width {
+          currentGrayscale[y * width + x] = rowPtr[x * 4]
+        }
+      }
+    }
+
+    // Compare with previous frame
+    guard let previous = previousGrayscale,
+          previousWidth == width,
+          previousHeight == height else {
+      // First frame - save and return zero motion
+      previousGrayscale = currentGrayscale
+      previousWidth = width
+      previousHeight = height
+      return ["score": 0.0, "hasMotion": false]
+    }
+
+    // Calculate motion using vDSP for performance
+    var current = currentGrayscale.map { Float($0) }
+    var prev = previous.map { Float($0) }
+    var diff = [Float](repeating: 0, count: totalPixels)
+
+    // Calculate absolute difference
+    vDSP_vsub(prev, 1, current, 1, &diff, 1, vDSP_Length(totalPixels))
+    vDSP_vabs(diff, 1, &diff, 1, vDSP_Length(totalPixels))
+
+    // Count pixels exceeding threshold
+    let thresholdValue = threshold * 255
+    var changedCount: Float = 0
+    for value in diff {
+      if value > thresholdValue {
+        changedCount += 1
+      }
+    }
+
+    let score = Double(changedCount) / Double(totalPixels)
+
+    // Swap buffers
+    previousGrayscale = currentGrayscale
+    previousWidth = width
+    previousHeight = height
+
+    return ["score": score, "hasMotion": score > Double(threshold)]
+  }
+
+  // MARK: - Raw Pixel Extraction
+
+  private func extractRawPixels(pixelBuffer: CVPixelBuffer, roi: CGRect?) -> Data? {
+    CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+    defer { CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly) }
+
+    var width = CVPixelBufferGetWidth(pixelBuffer)
+    var height = CVPixelBufferGetHeight(pixelBuffer)
+
+    // Apply ROI if provided
+    let extractRect: CGRect
+    if let roi = roi {
+      extractRect = CGRect(
+        x: max(0, min(Int(roi.origin.x), width - 1)),
+        y: max(0, min(Int(roi.origin.y), height - 1)),
+        width: max(1, min(Int(roi.width), width - Int(roi.origin.x))),
+        height: max(1, min(Int(roi.height), height - Int(roi.origin.y)))
+      )
+      width = Int(extractRect.width)
+      height = Int(extractRect.height)
+    } else {
+      extractRect = CGRect(x: 0, y: 0, width: width, height: height)
+    }
+
+    // Scale down if exceeds 1080p
+    var scale: Float = 1.0
+    if width > maxRawPixelDimension || height > maxRawPixelDimension {
+      let widthScale = Float(maxRawPixelDimension) / Float(width)
+      let heightScale = Float(maxRawPixelDimension) / Float(height)
+      scale = min(widthScale, heightScale)
+    }
+
+    let outputWidth = Int(Float(width) * scale)
+    let outputHeight = Int(Float(height) * scale)
+
+    guard let baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer) else {
+      return nil
+    }
+
+    let bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer)
+    let srcWidth = CVPixelBufferGetWidth(pixelBuffer)
+
+    // Extract RGBA data
+    var rgbaData = Data(capacity: outputWidth * outputHeight * 4)
+
+    for outY in 0..<outputHeight {
+      let srcY = Int(extractRect.origin.y) + Int(Float(outY) / scale)
+      let rowPtr = baseAddress.advanced(by: srcY * bytesPerRow).assumingMemoryBound(to: UInt8.self)
+
+      for outX in 0..<outputWidth {
+        let srcX = Int(extractRect.origin.x) + Int(Float(outX) / scale)
+        let offset = srcX * 4
+
+        // BGRA -> RGBA conversion
+        let b = rowPtr[offset]
+        let g = rowPtr[offset + 1]
+        let r = rowPtr[offset + 2]
+        let a = rowPtr[offset + 3]
+
+        rgbaData.append(r)
+        rgbaData.append(g)
+        rgbaData.append(b)
+        rgbaData.append(a)
+      }
+    }
+
+    return rgbaData
+  }
+
+  // Analyze raw image data
+  func analyzeImageData(width: Int, height: Int, data: Data) -> [String: Any] {
+    guard let cgImage = createCGImage(width: width, height: height, data: data) else {
+      return [
+        "uniqueColorCount": 0,
+        "topColors": [[String: Int]](),
+        "brightestColors": [[String: Int]]()
+      ]
+    }
+    return analyzeFromCGImage(cgImage)
+  }
+
+  private func createCGImage(width: Int, height: Int, data: Data) -> CGImage? {
+    let bytesPerPixel = 4
+    let bytesPerRow = width * bytesPerPixel
+    let colorSpace = CGColorSpaceCreateDeviceRGB()
+
+    guard let provider = CGDataProvider(data: data as CFData) else { return nil }
+
+    return CGImage(
+      width: width,
+      height: height,
+      bitsPerComponent: 8,
+      bitsPerPixel: 32,
+      bytesPerRow: bytesPerRow,
+      space: colorSpace,
+      bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue),
+      provider: provider,
+      decode: nil,
+      shouldInterpolate: false,
+      intent: .defaultIntent
+    )
+  }
+
+  private func analyzeFromCGImage(_ cgImage: CGImage) -> [String: Any] {
+    let ciImage = CIImage(cgImage: cgImage)
+    guard let histogram = CIFilter(name: "CIAreaHistogram",
+                                   parameters: ["inputImage": ciImage,
+                                                "inputCount": histogramBins,
+                                                "inputExtent": CIVector(cgRect: ciImage.extent),
+                                                "inputScale": 1.0])?.outputImage else {
+      return [
+        "uniqueColorCount": 0,
+        "topColors": [[String: Int]](),
+        "brightestColors": [[String: Int]]()
+      ]
+    }
+
+    let bitmapSize = histogramBins * 4
+    var bitmap = [UInt32](repeating: 0, count: bitmapSize)
+    ciContext.render(histogram,
+                     toBitmap: &bitmap,
+                     rowBytes: bitmapSize * MemoryLayout<UInt32>.size,
+                     bounds: CGRect(x: 0, y: 0, width: histogramBins, height: 1),
+                     format: .RGBA32,
+                     colorSpace: CGColorSpaceCreateDeviceRGB())
+
+    return reduceHistogram(bitmap)
+  }
+
+  private func fullAnalysis(pixelBuffer: CVPixelBuffer, options: AnalysisOptionsNative = AnalysisOptionsNative()) -> [String: Any] {
+    var ciImage = CIImage(cvPixelBuffer: pixelBuffer)
+    let width = CVPixelBufferGetWidth(pixelBuffer)
+    let height = CVPixelBufferGetHeight(pixelBuffer)
+
+    // Apply ROI if configured
+    var roiRect: CGRect?
+    if let roi = options.roi {
+      roiRect = calculateROI(config: roi, width: width, height: height)
+      ciImage = ciImage.cropped(to: roiRect!)
+    }
+
+    guard let histogram = CIFilter(name: "CIAreaHistogram",
+                                   parameters: ["inputImage": ciImage,
+                                                "inputCount": histogramBins,
+                                                "inputExtent": CIVector(cgRect: ciImage.extent),
+                                                "inputScale": 1.0])?.outputImage else {
+      return [
+        "uniqueColorCount": 0,
+        "topColors": [[String: Int]](),
+        "brightestColors": [[String: Int]]()
+      ]
+    }
+
+    let bitmapSize = histogramBins * 4
+    var bitmap = [UInt32](repeating: 0, count: bitmapSize)
+    ciContext.render(histogram,
+                     toBitmap: &bitmap,
+                     rowBytes: bitmapSize * MemoryLayout<UInt32>.size,
+                     bounds: CGRect(x: 0, y: 0, width: histogramBins, height: 1),
+                     format: .RGBA32,
+                     colorSpace: CGColorSpaceCreateDeviceRGB())
+
+    var result = reduceHistogram(bitmap)
+
+    // Add ROI applied flag
+    if options.roi != nil {
+      result["roiApplied"] = true
+    }
+
+    // Add motion detection if enabled
+    if options.enableMotionDetection {
+      let motionResult = calculateMotion(pixelBuffer: pixelBuffer, threshold: options.motionThreshold)
+      result["motion"] = motionResult
+    }
+
+    return result
+  }
+
+  private func reduceHistogram(_ data: [UInt32]) -> [String: Any] {
+    struct Stat { let r: Int; let g: Int; let b: Int; let count: Int; let brightness: Float }
+    var stats: [Stat] = []
+    for i in stride(from: 0, to: data.count, by: 4) {
+      let r = Int(data[i])
+      let g = Int(data[i + 1])
+      let b = Int(data[i + 2])
+      let count = Int(data[i + 3])
+      if count == 0 { continue }
+      let brightness = 0.299 * Float(r) + 0.587 * Float(g) + 0.114 * Float(b)
+      stats.append(Stat(r: r, g: g, b: b, count: count, brightness: brightness))
+    }
+
+    let top = stats.sorted { $0.count > $1.count }.prefix(3).map { ["r": $0.r, "g": $0.g, "b": $0.b] }
+    let bright = stats.sorted { $0.brightness > $1.brightness }.prefix(3).map { ["r": $0.r, "g": $0.g, "b": $0.b] }
+
+    return [
+      "uniqueColorCount": stats.count,
+      "topColors": Array(top),
+      "brightestColors": Array(bright)
+    ]
+  }
+}

package/ios/PixelColorsFrameProcessor.m

@@ -0,0 +1,5 @@
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+#import "CameraVisionPixelColors-Swift.h"
+
+VISION_EXPORT_SWIFT_FRAME_PROCESSOR(PixelColorsFrameProcessor, pixelColors)

package/ios/PixelColorsFrameProcessor.swift

@@ -0,0 +1,50 @@
+import VisionCamera
+import CoreMedia
+
+@objc(PixelColorsFrameProcessor)
+public final class PixelColorsFrameProcessor: FrameProcessorPlugin {
+  public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable : Any]! = [:]) {
+    super.init(proxy: proxy, options: options)
+  }
+
+  public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable : Any]?) -> Any {
+    guard let pixelBuffer = CMSampleBufferGetImageBuffer(frame.buffer) else {
+      return PixelAnalyzerEngine.shared.analyzeSync()
+    }
+
+    // Parse options from arguments
+    let options = parseOptions(from: arguments)
+
+    // Fire & forget GPU pipeline
+    PixelAnalyzerEngine.shared.analyzeAsync(pixelBuffer: pixelBuffer, options: options)
+    // Return latest cached result synchronously
+    return PixelAnalyzerEngine.shared.analyzeSync()
+  }
+
+  private func parseOptions(from arguments: [AnyHashable: Any]?) -> AnalysisOptionsNative {
+    var options = AnalysisOptionsNative()
+
+    guard let args = arguments,
+          let optionsDict = args["options"] as? [String: Any] else {
+      return options
+    }
+
+    if let enableMotionDetection = optionsDict["enableMotionDetection"] as? Bool {
+      options.enableMotionDetection = enableMotionDetection
+    }
+
+    if let motionThreshold = optionsDict["motionThreshold"] as? Double {
+      options.motionThreshold = Float(motionThreshold)
+    }
+
+    if let roiDict = optionsDict["roi"] as? [String: Any],
+       let x = roiDict["x"] as? Double,
+       let y = roiDict["y"] as? Double,
+       let width = roiDict["width"] as? Double,
+       let height = roiDict["height"] as? Double {
+      options.roi = (x: Float(x), y: Float(y), width: Float(width), height: Float(height))
+    }
+
+    return options
+  }
+}

package/lib/commonjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CameraVisionPixelColors = void 0;
+exports.analyzePixelColors = analyzePixelColors;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _reactNativeVisionCamera = require("react-native-vision-camera");
+// Nitro HybridObject for async image analysis
+const CameraVisionPixelColors = exports.CameraVisionPixelColors = _reactNativeNitroModules.NitroModules.createHybridObject('CameraVisionPixelColors');
+
+// Frame Processor plugin for real-time analysis
+const plugin = _reactNativeVisionCamera.VisionCameraProxy.initFrameProcessorPlugin('pixelColors', {});
+function analyzePixelColors(frame, options) {
+  'worklet';
+
+  if (!plugin) {
+    throw new Error('pixelColors frame processor plugin is not available');
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return plugin.call(frame, {
+    options
+  });
+}
+
+// Re-export types
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeVisionCamera","CameraVisionPixelColors","exports","NitroModules","createHybridObject","plugin","VisionCameraProxy","initFrameProcessorPlugin","analyzePixelColors","frame","options","Error","call"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,wBAAA,GAAAD,OAAA;AAWA;AACO,MAAME,uBAAuB,GAAAC,OAAA,CAAAD,uBAAA,GAClCE,qCAAY,CAACC,kBAAkB,CAC7B,yBACF,CAAC;;AAEH;AACA,MAAMC,MAAM,GAAGC,0CAAiB,CAACC,wBAAwB,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;AAErE,SAASC,kBAAkBA,CAChCC,KAAY,EACZC,OAAyB,EACN;EACnB,SAAS;;EACT,IAAI,CAACL,MAAM,EAAE;IACX,MAAM,IAAIM,KAAK,CAAC,qDAAqD,CAAC;EACxE;EACA;EACA,OAAON,MAAM,CAACO,IAAI,CAACH,KAAK,EAAE;IAAEC;EAAQ,CAAQ,CAAC;AAC/C;;AAEA","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/specs/camera-vision-pixel-colors.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=camera-vision-pixel-colors.nitro.js.map

package/lib/commonjs/specs/camera-vision-pixel-colors.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/camera-vision-pixel-colors.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+import { VisionCameraProxy } from 'react-native-vision-camera';
+// Nitro HybridObject for async image analysis
+export const CameraVisionPixelColors = NitroModules.createHybridObject('CameraVisionPixelColors');
+
+// Frame Processor plugin for real-time analysis
+const plugin = VisionCameraProxy.initFrameProcessorPlugin('pixelColors', {});
+export function analyzePixelColors(frame, options) {
+  'worklet';
+
+  if (!plugin) {
+    throw new Error('pixelColors frame processor plugin is not available');
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return plugin.call(frame, {
+    options
+  });
+}
+
+// Re-export types
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","VisionCameraProxy","CameraVisionPixelColors","createHybridObject","plugin","initFrameProcessorPlugin","analyzePixelColors","frame","options","Error","call"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AACzD,SAASC,iBAAiB,QAAoB,4BAA4B;AAW1E;AACA,OAAO,MAAMC,uBAAuB,GAClCF,YAAY,CAACG,kBAAkB,CAC7B,yBACF,CAAC;;AAEH;AACA,MAAMC,MAAM,GAAGH,iBAAiB,CAACI,wBAAwB,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;AAE5E,OAAO,SAASC,kBAAkBA,CAChCC,KAAY,EACZC,OAAyB,EACN;EACnB,SAAS;;EACT,IAAI,CAACJ,MAAM,EAAE;IACX,MAAM,IAAIK,KAAK,CAAC,qDAAqD,CAAC;EACxE;EACA;EACA,OAAOL,MAAM,CAACM,IAAI,CAACH,KAAK,EAAE;IAAEC;EAAQ,CAAQ,CAAC;AAC/C;;AAEA","ignoreList":[]}

package/lib/module/specs/camera-vision-pixel-colors.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=camera-vision-pixel-colors.nitro.js.map

package/lib/module/specs/camera-vision-pixel-colors.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/camera-vision-pixel-colors.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,6 @@
+import { type Frame } from 'react-native-vision-camera';
+import type { CameraVisionPixelColors as CameraVisionPixelColorsSpec, PixelColorsResult, RGBColor, ImageData, ROIConfig, AnalysisOptions, MotionResult } from './specs/camera-vision-pixel-colors.nitro';
+export declare const CameraVisionPixelColors: CameraVisionPixelColorsSpec;
+export declare function analyzePixelColors(frame: Frame, options?: AnalysisOptions): PixelColorsResult;
+export type { PixelColorsResult, RGBColor, ImageData, ROIConfig, AnalysisOptions, MotionResult, };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,KAAK,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,KAAK,EACV,uBAAuB,IAAI,2BAA2B,EACtD,iBAAiB,EACjB,QAAQ,EACR,SAAS,EACT,SAAS,EACT,eAAe,EACf,YAAY,EACb,MAAM,0CAA0C,CAAA;AAGjD,eAAO,MAAM,uBAAuB,6BAGjC,CAAA;AAKH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,eAAe,GACxB,iBAAiB,CAOnB;AAGD,YAAY,EACV,iBAAiB,EACjB,QAAQ,EACR,SAAS,EACT,SAAS,EACT,eAAe,EACf,YAAY,GACb,CAAA"}

package/lib/typescript/src/specs/camera-vision-pixel-colors.nitro.d.ts

@@ -0,0 +1,40 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+export type RGBColor = {
+    r: number;
+    g: number;
+    b: number;
+};
+export type ROIConfig = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type AnalysisOptions = {
+    enableMotionDetection?: boolean;
+    motionThreshold?: number;
+    roi?: ROIConfig;
+};
+export type MotionResult = {
+    score: number;
+    hasMotion: boolean;
+};
+export type PixelColorsResult = {
+    uniqueColorCount: number;
+    topColors: RGBColor[];
+    brightestColors: RGBColor[];
+    motion?: MotionResult;
+    roiApplied?: boolean;
+};
+export type ImageData = {
+    width: number;
+    height: number;
+    data: ArrayBuffer;
+};
+export interface CameraVisionPixelColors extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    analyzeImageAsync(image: ImageData): Promise<PixelColorsResult>;
+}
+//# sourceMappingURL=camera-vision-pixel-colors.nitro.d.ts.map

package/lib/typescript/src/specs/camera-vision-pixel-colors.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-vision-pixel-colors.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/camera-vision-pixel-colors.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,MAAM,QAAQ,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1D,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,GAAG,CAAC,EAAE,SAAS,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,QAAQ,EAAE,CAAA;IACrB,eAAe,EAAE,QAAQ,EAAE,CAAA;IAC3B,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,WAAW,CAAA;CAClB,CAAA;AAED,MAAM,WAAW,uBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;CAChE"}

package/nitro.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": [
+    "cameravisionpixelcolors"
+  ],
+  "ios": {
+    "iosModuleName": "CameraVisionPixelColors"
+  },
+  "android": {
+    "androidNamespace": [
+      "cameravisionpixelcolors"
+    ],
+    "androidCxxLibName": "CameraVisionPixelColors"
+  },
+  "autolinking": {
+    "CameraVisionPixelColors": {
+      "swift": "HybridCameraVisionPixelColors",
+      "kotlin": "HybridCameraVisionPixelColors"
+    }
+  },
+  "ignorePaths": [
+    "**/node_modules",
+    "**/docs"
+  ]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/CameraVisionPixelColors+autolinking.cmake

@@ -0,0 +1,81 @@
+#
+# CameraVisionPixelColors+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/CameraVisionPixelColors+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_CAMERAVISIONPIXELCOLORS_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  CameraVisionPixelColors PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/CameraVisionPixelColorsOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridCameraVisionPixelColorsSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridCameraVisionPixelColorsSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  CameraVisionPixelColors PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        CameraVisionPixelColors
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        CameraVisionPixelColors
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        CameraVisionPixelColors
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()