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

package/android/src/main/java/com/cameravisionpixelcolors/PixelAnalyzerEngine.kt

@@ -0,0 +1,256 @@
+package com.cameravisionpixelcolors
+
+import android.graphics.Bitmap
+import android.graphics.Rect
+import java.nio.ByteBuffer
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+
+data class AnalysisOptions(
+  val enableMotionDetection: Boolean = false,
+  val motionThreshold: Float = 0.1f,
+  val roi: ROIConfig? = null
+)
+
+data class ROIConfig(
+  val x: Float,
+  val y: Float,
+  val width: Float,
+  val height: Float
+)
+
+object PixelAnalyzerEngine {
+  private const val BUCKETS = 32 * 32 * 32
+  private const val MAX_RAW_PIXEL_DIMENSION = 1920
+  private val executor = Executors.newSingleThreadExecutor()
+  private val cachedResult = AtomicReference<Map<String, Any>>(mapOf(
+    "uniqueColorCount" to 0,
+    "topColors" to emptyList<Map<String, Int>>(),
+    "brightestColors" to emptyList<Map<String, Int>>()
+  ))
+
+  private val histogram = IntArray(BUCKETS)
+  private val brightnessSum = IntArray(BUCKETS)
+
+  // Motion detection state
+  private var previousGrayscale: IntArray? = null
+  private var previousWidth: Int = 0
+  private var previousHeight: Int = 0
+
+  fun analyzeAsync(bitmap: Bitmap, options: AnalysisOptions = AnalysisOptions()) {
+    executor.execute {
+      analyze(bitmap, options)
+    }
+  }
+
+  fun analyzeSync(): Map<String, Any> {
+    return cachedResult.get()
+  }
+
+  // Calculate ROI in pixel coordinates
+  private fun calculateROI(config: ROIConfig, width: Int, height: Int): Rect {
+    val x = (config.x * width).toInt()
+    val y = (config.y * height).toInt()
+    val w = max(1, (config.width * width).toInt())
+    val h = max(1, (config.height * height).toInt())
+    return Rect(x, y, min(x + w, width), min(y + h, height))
+  }
+
+  // Calculate motion score between current and previous frame
+  private fun calculateMotion(bitmap: Bitmap, threshold: Float): Map<String, Any> {
+    val width = bitmap.width
+    val height = bitmap.height
+    val totalPixels = width * height
+    val pixels = IntArray(totalPixels)
+    bitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+
+    // Convert to grayscale
+    val currentGrayscale = IntArray(totalPixels) { i ->
+      val px = pixels[i]
+      val r = (px shr 16) and 0xFF
+      val g = (px shr 8) and 0xFF
+      val b = px and 0xFF
+      ((0.299 * r + 0.587 * g + 0.114 * b).toInt())
+    }
+
+    val prev = previousGrayscale
+    if (prev == null || previousWidth != width || previousHeight != height) {
+      // First frame - save and return zero motion
+      previousGrayscale = currentGrayscale
+      previousWidth = width
+      previousHeight = height
+      return mapOf("score" to 0.0, "hasMotion" to false)
+    }
+
+    // Count pixels exceeding threshold
+    val thresholdValue = (threshold * 255).toInt()
+    var changedCount = 0
+    for (i in 0 until totalPixels) {
+      if (abs(currentGrayscale[i] - prev[i]) > thresholdValue) {
+        changedCount++
+      }
+    }
+
+    val score = changedCount.toDouble() / totalPixels
+
+    // Swap buffers
+    previousGrayscale = currentGrayscale
+    previousWidth = width
+    previousHeight = height
+
+    return mapOf("score" to score, "hasMotion" to (score > threshold))
+  }
+
+  // Extract raw RGBA pixels with optional scaling
+  private fun extractRawPixels(bitmap: Bitmap, roi: Rect?): ByteBuffer? {
+    var workBitmap = bitmap
+
+    // Apply ROI if provided
+    if (roi != null) {
+      workBitmap = Bitmap.createBitmap(
+        bitmap,
+        roi.left,
+        roi.top,
+        roi.width(),
+        roi.height()
+      )
+    }
+
+    var width = workBitmap.width
+    var height = workBitmap.height
+
+    // Scale down if exceeds 1080p
+    if (width > MAX_RAW_PIXEL_DIMENSION || height > MAX_RAW_PIXEL_DIMENSION) {
+      val scale = min(
+        MAX_RAW_PIXEL_DIMENSION.toFloat() / width,
+        MAX_RAW_PIXEL_DIMENSION.toFloat() / height
+      )
+      val newWidth = (width * scale).toInt()
+      val newHeight = (height * scale).toInt()
+      workBitmap = Bitmap.createScaledBitmap(workBitmap, newWidth, newHeight, true)
+      width = newWidth
+      height = newHeight
+    }
+
+    // Extract RGBA data
+    val pixels = IntArray(width * height)
+    workBitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+
+    val buffer = ByteBuffer.allocateDirect(width * height * 4)
+    for (px in pixels) {
+      // ARGB -> RGBA conversion
+      val a = (px shr 24) and 0xFF
+      val r = (px shr 16) and 0xFF
+      val g = (px shr 8) and 0xFF
+      val b = px and 0xFF
+      buffer.put(r.toByte())
+      buffer.put(g.toByte())
+      buffer.put(b.toByte())
+      buffer.put(a.toByte())
+    }
+    buffer.rewind()
+
+    return buffer
+  }
+
+  fun analyzeImageData(width: Int, height: Int, data: ByteArray): Map<String, Any> {
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    bitmap.copyPixelsFromBuffer(ByteBuffer.wrap(data))
+    return analyzeImmediate(bitmap)
+  }
+
+  private fun analyzeImmediate(bitmap: Bitmap, options: AnalysisOptions = AnalysisOptions()): Map<String, Any> {
+    var workBitmap = bitmap
+    var roiRect: Rect? = null
+
+    // Apply ROI if configured
+    if (options.roi != null) {
+      roiRect = calculateROI(options.roi, bitmap.width, bitmap.height)
+      workBitmap = Bitmap.createBitmap(
+        bitmap,
+        roiRect.left,
+        roiRect.top,
+        roiRect.width(),
+        roiRect.height()
+      )
+    }
+
+    val width = workBitmap.width
+    val height = workBitmap.height
+    val size = width * height
+    val pixels = IntArray(size)
+    workBitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+
+    val localHistogram = IntArray(BUCKETS)
+    val localBrightnessSum = IntArray(BUCKETS)
+
+    for (px in pixels) {
+      val r = (px shr 16) and 0xFF
+      val g = (px shr 8) and 0xFF
+      val b = px and 0xFF
+      val rq = r shr 3
+      val gq = g shr 3
+      val bq = b shr 3
+      val idx = (rq shl 10) or (gq shl 5) or bq
+      localHistogram[idx]++
+      val brightness = (2126 * r + 7152 * g + 722 * b) / 10000
+      localBrightnessSum[idx] += brightness
+    }
+
+    val topColors = ArrayList<Pair<Int, Int>>(3)
+    val topBright = ArrayList<Pair<Int, Int>>(3)
+    var uniqueCount = 0
+    for (i in 0 until BUCKETS) {
+      val count = localHistogram[i]
+      if (count == 0) continue
+      uniqueCount++
+      insertTop(topColors, i, count)
+      val avgBrightness = localBrightnessSum[i] / max(count, 1)
+      insertTop(topBright, i, avgBrightness)
+    }
+
+    fun decode(idx: Int): Map<String, Int> {
+      return mapOf(
+        "r" to ((idx shr 10) and 31 shl 3),
+        "g" to ((idx shr 5) and 31 shl 3),
+        "b" to ((idx and 31) shl 3)
+      )
+    }
+
+    val result = mutableMapOf<String, Any>(
+      "uniqueColorCount" to uniqueCount,
+      "topColors" to topColors.map { decode(it.first) },
+      "brightestColors" to topBright.map { decode(it.first) }
+    )
+
+    // Add ROI applied flag
+    if (options.roi != null) {
+      result["roiApplied"] = true
+    }
+
+    // Add motion detection if enabled
+    if (options.enableMotionDetection) {
+      val motionResult = calculateMotion(bitmap, options.motionThreshold)
+      result["motion"] = motionResult
+    }
+
+    return result
+  }
+
+  private fun analyze(bitmap: Bitmap, options: AnalysisOptions = AnalysisOptions()) {
+    val result = analyzeImmediate(bitmap, options)
+    cachedResult.set(result)
+  }
+
+  private fun insertTop(list: MutableList<Pair<Int, Int>>, idx: Int, value: Int) {
+    var i = 0
+    while (i < list.size && value <= list[i].second) i++
+    if (i < 3) {
+      list.add(i, idx to value)
+      if (list.size > 3) list.removeAt(3)
+    }
+  }
+}

package/android/src/main/java/com/cameravisionpixelcolors/PixelColorsFrameProcessor.kt

@@ -0,0 +1,40 @@
+package com.cameravisionpixelcolors
+
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+
+class PixelColorsFrameProcessor(proxy: VisionCameraProxy, options: Map<String, Any>?) : FrameProcessorPlugin() {
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
+    val image = frame.image ?: return emptyMap<String, Any>()
+    val bitmap = YuvToBitmapConverter.convert(image)
+
+    // Parse options from arguments
+    val analysisOptions = parseOptions(arguments)
+
+    PixelAnalyzerEngine.analyzeAsync(bitmap, analysisOptions)
+    return PixelAnalyzerEngine.analyzeSync()
+  }
+
+  private fun parseOptions(arguments: Map<String, Any>?): AnalysisOptions {
+    val optionsMap = arguments?.get("options") as? Map<*, *> ?: return AnalysisOptions()
+
+    val enableMotionDetection = optionsMap["enableMotionDetection"] as? Boolean ?: false
+    val motionThreshold = (optionsMap["motionThreshold"] as? Number)?.toFloat() ?: 0.1f
+
+    val roiMap = optionsMap["roi"] as? Map<*, *>
+    val roi = if (roiMap != null) {
+      val x = (roiMap["x"] as? Number)?.toFloat() ?: 0f
+      val y = (roiMap["y"] as? Number)?.toFloat() ?: 0f
+      val width = (roiMap["width"] as? Number)?.toFloat() ?: 1f
+      val height = (roiMap["height"] as? Number)?.toFloat() ?: 1f
+      ROIConfig(x, y, width, height)
+    } else null
+
+    return AnalysisOptions(
+      enableMotionDetection = enableMotionDetection,
+      motionThreshold = motionThreshold,
+      roi = roi
+    )
+  }
+}

package/android/src/main/java/com/cameravisionpixelcolors/YuvToBitmapConverter.kt

@@ -0,0 +1,33 @@
+package com.cameravisionpixelcolors
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.ImageFormat
+import android.graphics.Rect
+import android.graphics.YuvImage
+import android.media.Image
+import java.io.ByteArrayOutputStream
+
+object YuvToBitmapConverter {
+    fun convert(image: Image): Bitmap {
+        val yBuffer = image.planes[0].buffer
+        val uBuffer = image.planes[1].buffer
+        val vBuffer = image.planes[2].buffer
+
+        val ySize = yBuffer.remaining()
+        val uSize = uBuffer.remaining()
+        val vSize = vBuffer.remaining()
+
+        val nv21 = ByteArray(ySize + uSize + vSize)
+
+        yBuffer.get(nv21, 0, ySize)
+        vBuffer.get(nv21, ySize, vSize)
+        uBuffer.get(nv21, ySize + vSize, uSize)
+
+        val yuvImage = YuvImage(nv21, ImageFormat.NV21, image.width, image.height, null)
+        val out = ByteArrayOutputStream()
+        yuvImage.compressToJpeg(Rect(0, 0, image.width, image.height), 90, out)
+        val imageBytes = out.toByteArray()
+        return BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
+    }
+}

package/android/src/main/java/com/margelo/nitro/cameravisionpixelcolors/HybridCameraVisionPixelColors.kt

@@ -0,0 +1,50 @@
+package com.margelo.nitro.cameravisionpixelcolors
+
+import com.cameravisionpixelcolors.PixelAnalyzerEngine
+import com.margelo.nitro.core.Promise
+import java.util.concurrent.Executors
+
+class HybridCameraVisionPixelColors: HybridCameraVisionPixelColorsSpec() {
+    private val executor = Executors.newSingleThreadExecutor()
+
+    override fun analyzeImageAsync(image: ImageData): Promise<PixelColorsResult> {
+        return Promise.async {
+            val width = image.width.toInt()
+            val height = image.height.toInt()
+            val data = ByteArray(image.data.size.toInt())
+            image.data.getBuffer(false).get(data)
+
+            val result = PixelAnalyzerEngine.analyzeImageData(width, height, data)
+
+            val uniqueColorCount = result["uniqueColorCount"] as? Int ?: 0
+            @Suppress("UNCHECKED_CAST")
+            val topColorsMap = result["topColors"] as? List<Map<String, Int>> ?: emptyList()
+            @Suppress("UNCHECKED_CAST")
+            val brightestColorsMap = result["brightestColors"] as? List<Map<String, Int>> ?: emptyList()
+
+            val topColors = topColorsMap.map { map ->
+                RGBColor(
+                    r = (map["r"] ?: 0).toDouble(),
+                    g = (map["g"] ?: 0).toDouble(),
+                    b = (map["b"] ?: 0).toDouble()
+                )
+            }.toTypedArray()
+
+            val brightestColors = brightestColorsMap.map { map ->
+                RGBColor(
+                    r = (map["r"] ?: 0).toDouble(),
+                    g = (map["g"] ?: 0).toDouble(),
+                    b = (map["b"] ?: 0).toDouble()
+                )
+            }.toTypedArray()
+
+            PixelColorsResult(
+                uniqueColorCount = uniqueColorCount.toDouble(),
+                topColors = topColors,
+                brightestColors = brightestColors,
+                motion = null,
+                roiApplied = null
+            )
+        }
+    }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/withPixelColors');

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  camera-vision-pixel-colors
+//
+//  Created by Yevhen Lahodiuk on 1/17/2026
+//
+
+#pragma once

package/ios/HybridCameraVisionPixelColors.swift

@@ -0,0 +1,53 @@
+//
+//  HybridCameraVisionPixelColors.swift
+//  CameraVisionPixelColors
+//
+
+import Foundation
+import NitroModules
+
+class HybridCameraVisionPixelColors: HybridCameraVisionPixelColorsSpec {
+  func analyzeImageAsync(image: ImageData) throws -> Promise<PixelColorsResult> {
+    return Promise { resolve, reject in
+      DispatchQueue.global(qos: .userInitiated).async {
+        let width = Int(image.width)
+        let height = Int(image.height)
+        let data = Data(image.data)
+
+        let result = PixelAnalyzerEngine.shared.analyzeImageData(
+          width: width,
+          height: height,
+          data: data
+        )
+
+        let uniqueColorCount = result["uniqueColorCount"] as? Int ?? 0
+        let topColorsDict = result["topColors"] as? [[String: Int]] ?? []
+        let brightestColorsDict = result["brightestColors"] as? [[String: Int]] ?? []
+
+        let topColors = topColorsDict.map { dict in
+          RGBColor(
+            r: Double(dict["r"] ?? 0),
+            g: Double(dict["g"] ?? 0),
+            b: Double(dict["b"] ?? 0)
+          )
+        }
+
+        let brightestColors = brightestColorsDict.map { dict in
+          RGBColor(
+            r: Double(dict["r"] ?? 0),
+            g: Double(dict["g"] ?? 0),
+            b: Double(dict["b"] ?? 0)
+          )
+        }
+
+        let pixelColorsResult = PixelColorsResult(
+          uniqueColorCount: Double(uniqueColorCount),
+          topColors: topColors,
+          brightestColors: brightestColors
+        )
+
+        resolve(pixelColorsResult)
+      }
+    }
+  }
+}