@luxonis/visualizer-protobuf 2.22.0 → 2.23.0

package/dist/pointcloudFromDepth.worker-CNKyMUU-.js

@@ -1,326 +0,0 @@
-import { e as expose } from './comlink-DHMAu6X7.js';
-import { i as i420ToRgbaToPointcloud } from './utils-Cmsz3FxA.js';
-
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/
-/// <reference types="@webgpu/types" />
-function depthToPointCloudBuffer(uint16Array, width, height, fx, fy, cx, cy) {
-  const depthData = Array.from({
-    length: height
-  }, () => new Array(width));
-  for (let v = 0; v < height; v++) {
-    depthData[v] = depthData[v] ?? [];
-    for (let u = 0; u < width; u++) {
-      const d = uint16Array[v * width + u] ?? -1;
-      // biome-ignore lint/style/noNonNullAssertion: <explanation>
-      depthData[v][u] = d > 0 ? d : -1;
-    }
-  }
-  const points = [];
-  // Accumulate the x, y, z values for each pixel.
-  for (let v = 0; v < height; v++) {
-    const row = depthData[v];
-    if (!row) {
-      continue;
-    }
-    for (let u = 0; u < width; u++) {
-      const z = row[u] ?? 0;
-      const x = (cx - u) * z / fx;
-      const y = (cy - v) * z / fy;
-      points.push(x, y, z);
-    }
-  }
-  const pointCount = points.length / 3;
-  const buffer = new ArrayBuffer(pointCount * 16);
-  const view = new DataView(buffer);
-  for (let i = 0; i < pointCount; i++) {
-    const offset = i * 16;
-    view.setFloat32(offset, points[i * 3] ?? 0, true); //X
-    view.setFloat32(offset + 4, points[i * 3 + 1] ?? 0, true); //Y
-    view.setFloat32(offset + 8, points[i * 3 + 2] ?? 0, true); //Z
-    view.setUint8(offset + 12, 0); // R
-    view.setUint8(offset + 13, 0); // G
-    view.setUint8(offset + 14, 0); // B
-    view.setUint8(offset + 15, 255); // A
-  }
-  return new Uint8Array(buffer);
-}
-const shader = `
-@group(0) @binding(1) var<storage, read> intrinsics: array<f32>;
-
-struct PointOutput {
-    x: f32,
-    y: f32,
-    z: f32,
-    color: u32,
-};
-
-@group(0) @binding(0) var<storage, read> depthBuffer: array<u32>;
-@group(0) @binding(2) var<storage, read_write> xyzColorBuffer: array<PointOutput>;
-@group(0) @binding(3) var<storage, read> i420Buffer: array<u32>; // Correct type
-
-@compute @workgroup_size(256, 1, 1)
-fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
-    let i = global_id.x;
-
-    // Read dimensions
-    let depthWidth = intrinsics[5];
-    let depthHeight = intrinsics[6];
-    let numPixels = u32(depthWidth * depthHeight);
-
-    // Bounds check
-    if (i >= numPixels || depthWidth <= 0.0 || depthHeight <= 0.0 ) { return; }
-
-    // Read other intrinsics
-    let fx = intrinsics[0];
-    let fy = intrinsics[1];
-    let cx = intrinsics[2];
-    let cy = intrinsics[3];
-    let depthScale = intrinsics[4]; // Make sure this is correct (e.g., 0.001)
-    let i420Width = intrinsics[7];
-    let i420Height = intrinsics[8];
-
-    let u = f32(i % u32(depthWidth));
-    let v = f32(i / u32(depthWidth));
-
-    // --- Extract u16 depth from u32 buffer ---
-    let depthIndex32 = i / 2u;
-    // Add bounds check for safety, though numPixels check should cover it
-    if (depthIndex32 >= arrayLength(&depthBuffer)) { return; }
-    let packedDepthU32 = depthBuffer[depthIndex32];
-    var rawDepthU32 : u32;
-    if (i % 2u == 0u) {
-      rawDepthU32 = packedDepthU32 & 0xFFFFu; // Lower 16 bits
-    } else {
-      rawDepthU32 = (packedDepthU32 >> 16) & 0xFFFFu; // Upper 16 bits
-    }
-    // --- End depth extraction ---
-
-    // Default point output (black, opaque)
-    var outputPoint: PointOutput;
-    outputPoint.x = 0.0;
-    outputPoint.y = 0.0;
-    outputPoint.z = 0.0;
-    outputPoint.color = 0u | (0u << 8) | (0u << 16) | (255u << 24);
-
-    // Process only valid depth pixels and valid intrinsics
-    if (rawDepthU32 > 0u && fx != 0.0 && fy != 0.0 && depthScale > 0.0) {
-        let z = f32(rawDepthU32) * depthScale;
-        outputPoint.x = (cx- u) * z / fx;
-        outputPoint.y = (cy- v) * z / fy;
-        outputPoint.z = z;
-
-        // --- I420 Color Calculation with u8 extraction from u32 buffer ---
-        if (i420Width > 0.0 && i420Height > 0.0) {
-            let i420WidthU = u32(i420Width);
-            let i420HeightU = u32(i420Height);
-
-            let i420X = min(i420WidthU - 1u, u32( floor(u * (i420Width / depthWidth)) ));
-            let i420Y = min(i420HeightU - 1u, u32( floor(v * (i420Height / depthHeight)) ));
-
-            // Calculate original byte indices
-            let frameSize = i420WidthU * i420HeightU;
-            let uvWidth = (i420WidthU + 1u) / 2u;
-            let uvHeight = (i420HeightU + 1u) / 2u;
-            let uOffset = frameSize;
-            let vOffset = frameSize + uvWidth * uvHeight;
-
-            let yIndex = i420Y * i420WidthU + i420X;
-            let uvX = i420X / 2u;
-            let uvY = i420Y / 2u;
-            let uvIndex = uvY * uvWidth + uvX;
-            let uIndex = uOffset + uvIndex;
-            let vIndex = vOffset + uvIndex;
-
-            // --- Extract Y byte ---
-            let yIndex32 = yIndex / 4u;
-            let yOffsetIn32 = yIndex % 4u;
-            // Bounds check (use original byte length concept for check)
-            let bufferByteLength = arrayLength(&i420Buffer) * 4u; // Conceptual byte length
-            if (yIndex32 < arrayLength(&i420Buffer) && yIndex < bufferByteLength) { // Check index and conceptual byte index
-                let packedY = i420Buffer[yIndex32];
-                let y_byte = (packedY >> (yOffsetIn32 * 8u)) & 0xFFu;
-                let y_f = f32(y_byte);
-
-                // --- Extract U byte ---
-                let uIndex32 = uIndex / 4u;
-                let uOffsetIn32 = uIndex % 4u;
-                 if (uIndex32 < arrayLength(&i420Buffer) && uIndex < bufferByteLength) { // Check index and conceptual byte index
-                    let packedU = i420Buffer[uIndex32];
-                    let u_byte = (packedU >> (uOffsetIn32 * 8u)) & 0xFFu;
-                    let u_f = f32(u_byte) - 128.0;
-
-                    // --- Extract V byte ---
-                    let vIndex32 = vIndex / 4u;
-                    let vOffsetIn32 = vIndex % 4u;
-                     if (vIndex32 < arrayLength(&i420Buffer) && vIndex < bufferByteLength) { // Check index and conceptual byte index
-                        let packedV = i420Buffer[vIndex32];
-                        let v_byte = (packedV >> (vOffsetIn32 * 8u)) & 0xFFu;
-                        let v_f = f32(v_byte) - 128.0;
-
-                        // --- YUV to RGB ---
-                        var r_f = y_f + 1.402 * v_f;
-                        var g_f = y_f - 0.344136 * u_f - 0.714136 * v_f;
-                        var b_f = y_f + 1.772 * u_f;
-
-                        let r = u32(clamp(r_f, 0.0, 255.0));
-                        let g = u32(clamp(g_f, 0.0, 255.0));
-                        let b = u32(clamp(b_f, 0.0, 255.0));
-                        let a = 255u;
-
-                        outputPoint.color = (r & 0xFFu) | ((g & 0xFFu) << 8) | ((b & 0xFFu) << 16) | (a << 24);
-                    } // End V valid
-                } // End U valid
-            } // End Y valid
-        } // End if i420 dimensions valid
-    } // End if rawDepth valid
-
-    xyzColorBuffer[i] = outputPoint;
-}
-`;
-async function depthToPointcloudGPU(depthArray, depthWidth, depthHeight, fx, fy, cx, cy, i420Data, i420Width, i420Height) {
-  const depthScale = 1;
-  if (depthWidth <= 0 || depthHeight <= 0) {
-    throw new Error("Invalid depth dimensions!");
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (!navigator.gpu) {
-    const xyzData = depthToPointCloudBuffer(depthArray, depthWidth, depthHeight, fx, fy, cx, cy);
-    return i420ToRgbaToPointcloud(i420Data, i420Width, i420Height, depthWidth, depthHeight, xyzData);
-  }
-  const adapter = await navigator.gpu.requestAdapter();
-  if (!adapter) {
-    const xyzData = depthToPointCloudBuffer(depthArray, depthWidth, depthHeight, fx, fy, cx, cy);
-    return i420ToRgbaToPointcloud(i420Data, i420Width, i420Height, depthWidth, depthHeight, xyzData);
-  }
-  const device = await adapter.requestDevice();
-  const queue = device.queue;
-  const numPixels = depthWidth * depthHeight;
-  const outputBufferSize = numPixels * 16;
-  const depthBuffer = device.createBuffer({
-    size: depthArray.byteLength,
-    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-    mappedAtCreation: true
-  });
-  new Uint16Array(depthBuffer.getMappedRange()).set(depthArray);
-  depthBuffer.unmap();
-  const intrinsicsData = new Float32Array([fx, fy, cx, cy, depthScale, depthWidth, depthHeight, i420Width, i420Height]);
-  const intrinsicsBufferSize = Math.max(intrinsicsData.byteLength, 40);
-  const intrinsicsBuffer = device.createBuffer({
-    size: intrinsicsBufferSize,
-    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-  });
-  queue.writeBuffer(intrinsicsBuffer, 0, intrinsicsData);
-  const i420BufferSize = i420Data.byteLength;
-  const i420GpuBuffer = device.createBuffer({
-    size: i420BufferSize,
-    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-    mappedAtCreation: true
-  });
-  new Uint8Array(i420GpuBuffer.getMappedRange()).set(i420Data);
-  i420GpuBuffer.unmap();
-  const xyzColorBuffer = device.createBuffer({
-    size: outputBufferSize,
-    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-  });
-  const bindGroupLayout = device.createBindGroupLayout({
-    entries: [{
-      binding: 0,
-      visibility: GPUShaderStage.COMPUTE,
-      buffer: {
-        type: "read-only-storage"
-      }
-    }, {
-      binding: 1,
-      visibility: GPUShaderStage.COMPUTE,
-      buffer: {
-        type: "read-only-storage"
-      }
-    }, {
-      binding: 2,
-      visibility: GPUShaderStage.COMPUTE,
-      buffer: {
-        type: "storage"
-      }
-    }, {
-      binding: 3,
-      visibility: GPUShaderStage.COMPUTE,
-      buffer: {
-        type: "read-only-storage"
-      }
-    }]
-  });
-  const bindGroup = device.createBindGroup({
-    layout: bindGroupLayout,
-    entries: [{
-      binding: 0,
-      resource: {
-        buffer: depthBuffer
-      }
-    }, {
-      binding: 1,
-      resource: {
-        buffer: intrinsicsBuffer
-      }
-    }, {
-      binding: 2,
-      resource: {
-        buffer: xyzColorBuffer
-      }
-    }, {
-      binding: 3,
-      resource: {
-        buffer: i420GpuBuffer
-      }
-    }]
-  });
-  const shaderModule = device.createShaderModule({
-    code: shader
-  });
-  const pipeline = device.createComputePipeline({
-    layout: device.createPipelineLayout({
-      bindGroupLayouts: [bindGroupLayout]
-    }),
-    compute: {
-      module: shaderModule,
-      entryPoint: "main"
-    }
-  });
-  const commandEncoder = device.createCommandEncoder();
-  const passEncoder = commandEncoder.beginComputePass();
-  passEncoder.setPipeline(pipeline);
-  passEncoder.setBindGroup(0, bindGroup);
-  const workgroupSize = 256;
-  const numWorkgroups = Math.ceil(numPixels / workgroupSize);
-  passEncoder.dispatchWorkgroups(numWorkgroups);
-  passEncoder.end();
-  const readbackBuffer = device.createBuffer({
-    size: outputBufferSize,
-    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-  });
-  commandEncoder.copyBufferToBuffer(xyzColorBuffer, 0, readbackBuffer, 0, outputBufferSize);
-  queue.submit([commandEncoder.finish()]);
-  try {
-    await readbackBuffer.mapAsync(GPUMapMode.READ);
-    const mappedRange = readbackBuffer.getMappedRange();
-    const result = new Uint8Array(mappedRange.byteLength);
-    result.set(new Uint8Array(mappedRange));
-    readbackBuffer.unmap();
-    depthBuffer.destroy();
-    intrinsicsBuffer.destroy();
-    i420GpuBuffer.destroy();
-    xyzColorBuffer.destroy();
-    readbackBuffer.destroy();
-    return result;
-  } catch (error) {
-    console.error("Error mapping readback buffer:", error);
-    console.warn("GPU processing failed during readback. Falling back to CPU.");
-    const xyzData = depthToPointCloudBuffer(depthArray, depthWidth, depthHeight, fx, fy, cx, cy);
-    return i420ToRgbaToPointcloud(i420Data, i420Width, i420Height, depthWidth, depthHeight, xyzData);
-  }
-}
-expose({
-  depthToPointcloudGPU
-});