@srsergio/taptapp-ar 1.0.32 → 1.0.33

package/src/compiler/matching/matching.js

@@ -18,6 +18,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
   const qlen = querypoints.length;
   const kmax = keyframe.max;
   const kmin = keyframe.min;
+  const descSize = 2; // Protocol V6: 64-bit LSH (2 x 32-bit)
 
   for (let j = 0; j < qlen; j++) {
     const querypoint = querypoints[j];
@@ -48,8 +49,8 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     for (let k = 0; k < keypointIndexes.length; k++) {
       const idx = keypointIndexes[k];
 
-      // Use offsets to avoid subarray allocation
-      const d = hammingCompute({ v1: cDesc, v1Offset: idx * 84, v2: qDesc });
+      // Use offsets based on detected descriptor size
+      const d = hammingCompute({ v1: cDesc, v1Offset: idx * descSize, v2: qDesc });
 
       if (d < bestD1) {
         bestD2 = bestD1;
@@ -60,19 +61,18 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
       }
     }
 
-    if (
-      bestIndex !== -1 &&
-      (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD)
-    ) {
-      matches.push({
-        querypoint,
-        keypoint: {
-          x: col.x[bestIndex],
-          y: col.y[bestIndex],
-          angle: col.a[bestIndex],
-          scale: col.s ? col.s[bestIndex] : keyframe.s
-        }
-      });
+    if (bestIndex !== -1) {
+      if (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD) {
+        matches.push({
+          querypoint,
+          keypoint: {
+            x: col.x[bestIndex],
+            y: col.y[bestIndex],
+            angle: col.a[bestIndex],
+            scale: col.s ? col.s[bestIndex] : keyframe.s
+          }
+        });
+      }
     }
   }
 
@@ -94,7 +94,9 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     keyframe: { width: keyframe.w, height: keyframe.h },
   });
 
-  if (H === null) return { debugExtra };
+  if (H === null) {
+    return { debugExtra };
+  }
 
   const inlierMatches = _findInlierMatches({
     H,
@@ -141,7 +143,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
 
       if (d2 > dThreshold2) continue;
 
-      const d = hammingCompute({ v1: cd, v1Offset: k * 84, v2: qDesc });
+      const d = hammingCompute({ v1: cd, v1Offset: k * descSize, v2: qDesc });
 
       if (d < bestD1) {
         bestD2 = bestD1;
@@ -200,6 +202,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
 };
 
 const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop }) => {
+  const descSize = 2;
   const isLeaf = node[0] === 1;
   const childrenOrIndices = node[2];
 
@@ -221,7 +224,7 @@ const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop
 
     const d = hammingCompute({
       v1: descriptors,
-      v1Offset: cIdx * 84,
+      v1Offset: cIdx * descSize,
       v2: qDesc,
     });
     distances[i] = d;

package/src/compiler/node-worker.js

@@ -52,7 +52,7 @@ parentPort.on('message', async (msg) => {
             const keyframes = [];
             for (let i = 0; i < imageList.length; i++) {
                 const image = imageList[i];
-                const detector = new DetectorLite(image.width, image.height);
+                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
 
                 // Detectar features usando JS puro (sin TensorFlow)
                 const { featurePoints: ps } = detector.detect(image.data);

package/src/compiler/offline-compiler.js

@@ -27,7 +27,7 @@ const isNode = typeof process !== "undefined" &&
   process.versions != null &&
   process.versions.node != null;
 
-const CURRENT_VERSION = 3; // Protocol v3: High-performance Columnar Binary Format
+const CURRENT_VERSION = 6; // Protocol v6: Moonshot - LSH 64-bit
 
 /**
  * Compilador offline optimizado sin TensorFlow
@@ -37,9 +37,9 @@ export class OfflineCompiler {
     this.data = null;
     this.workerPool = null;
 
-    // Workers solo en Node.js (no en browser)
+    // Workers only in Node.js (no en browser)
     if (isNode) {
-      this._initNodeWorkers();
+      // Lazy init workers only when needed
     } else {
       console.log("🌐 OfflineCompiler: Browser mode (no workers)");
     }
@@ -68,7 +68,6 @@ export class OfflineCompiler {
       const numWorkers = Math.min(os.cpus().length, 4);
 
       this.workerPool = new WorkerPool(workerPath, numWorkers, Worker);
-      console.log(`🚀 OfflineCompiler: Node.js mode with ${numWorkers} workers`);
     } catch (e) {
       console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
     }
@@ -142,6 +141,7 @@ export class OfflineCompiler {
     let currentPercent = 0;
 
     // Use workers if available
+    if (isNode) await this._initNodeWorkers();
     if (this.workerPool) {
       const progressMap = new Float32Array(targetImages.length);
 
@@ -172,7 +172,7 @@ export class OfflineCompiler {
       const keyframes = [];
 
       for (const image of imageList) {
-        const detector = new DetectorLite(image.width, image.height);
+        const detector = new DetectorLite(image.width, image.height, { useLSH: true });
         const { featurePoints: ps } = detector.detect(image.data);
 
         const maximaPoints = ps.filter((p) => p.maxima);
@@ -260,8 +260,9 @@ export class OfflineCompiler {
     const dataList = this.data.map((item) => {
       const matchingData = item.matchingData.map((kf) => this._packKeyframe(kf));
 
-      const trackingData = item.trackingData.map((td) => {
+      const trackingData = [item.trackingData[0]].map((td) => {
         const count = td.points.length;
+        // Step 1: Packed Coords - Normalize width/height to 16-bit
         const px = new Float32Array(count);
         const py = new Float32Array(count);
         for (let i = 0; i < count; i++) {
@@ -294,30 +295,71 @@ export class OfflineCompiler {
     });
   }
 
+  _getMorton(x, y) {
+    // Interleave bits of x and y
+    let x_int = x | 0;
+    let y_int = y | 0;
+
+    x_int = (x_int | (x_int << 8)) & 0x00FF00FF;
+    x_int = (x_int | (x_int << 4)) & 0x0F0F0F0F;
+    x_int = (x_int | (x_int << 2)) & 0x33333333;
+    x_int = (x_int | (x_int << 1)) & 0x55555555;
+
+    y_int = (y_int | (y_int << 8)) & 0x00FF00FF;
+    y_int = (y_int | (y_int << 4)) & 0x0F0F0F0F;
+    y_int = (y_int | (y_int << 2)) & 0x33333333;
+    y_int = (y_int | (y_int << 1)) & 0x55555555;
+
+    return x_int | (y_int << 1);
+  }
+
   _packKeyframe(kf) {
+    // Step 2.1: Morton Sorting - Sort points spatially to improve Delta-Descriptor XOR
+    const sortPoints = (points) => {
+      return [...points].sort((a, b) => {
+        return this._getMorton(a.x, a.y) - this._getMorton(b.x, b.y);
+      });
+    };
+
+    const sortedMaxima = sortPoints(kf.maximaPoints);
+    const sortedMinima = sortPoints(kf.minimaPoints);
+
+    // Rebuild clusters with sorted indices
+    const sortedMaximaCluster = hierarchicalClusteringBuild({ points: sortedMaxima });
+    const sortedMinimaCluster = hierarchicalClusteringBuild({ points: sortedMinima });
+
     return {
       w: kf.width,
       h: kf.height,
       s: kf.scale,
-      max: this._columnarize(kf.maximaPoints, kf.maximaPointsCluster),
-      min: this._columnarize(kf.minimaPoints, kf.minimaPointsCluster),
+      max: this._columnarize(sortedMaxima, sortedMaximaCluster, kf.width, kf.height),
+      min: this._columnarize(sortedMinima, sortedMinimaCluster, kf.width, kf.height),
     };
   }
 
-  _columnarize(points, tree) {
+  _columnarize(points, tree, width, height) {
     const count = points.length;
-    const x = new Float32Array(count);
-    const y = new Float32Array(count);
-    const angle = new Float32Array(count);
-    const scale = new Float32Array(count);
-    const descriptors = new Uint8Array(count * 84); // 84 bytes per point (FREAK)
+    // Step 1: Packed Coords - Normalize to 16-bit
+    const x = new Uint16Array(count);
+    const y = new Uint16Array(count);
+    // Step 1.1: Angle Quantization - Int16
+    const angle = new Int16Array(count);
+    // Step 1.2: Scale Indexing - Uint8
+    const scale = new Uint8Array(count);
+
+    // Step 3: LSH 64-bit Descriptors - Uint32Array (2 elements per point)
+    const descriptors = new Uint32Array(count * 2);
 
     for (let i = 0; i < count; i++) {
-      x[i] = points[i].x;
-      y[i] = points[i].y;
-      angle[i] = points[i].angle;
-      scale[i] = points[i].scale;
-      descriptors.set(points[i].descriptors, i * 84);
+      x[i] = Math.round((points[i].x / width) * 65535);
+      y[i] = Math.round((points[i].y / height) * 65535);
+      angle[i] = Math.round((points[i].angle / Math.PI) * 32767);
+      scale[i] = Math.round(Math.log2(points[i].scale || 1));
+
+      if (points[i].descriptors && points[i].descriptors.length >= 2) {
+        descriptors[i * 2] = points[i].descriptors[0];
+        descriptors[(i * 2) + 1] = points[i].descriptors[1];
+      }
     }
 
     return {
@@ -340,35 +382,84 @@ export class OfflineCompiler {
   importData(buffer) {
     const content = msgpack.decode(new Uint8Array(buffer));
 
-    if (!content.v || content.v !== CURRENT_VERSION) {
-      console.error("Incompatible .mind version. Required: " + CURRENT_VERSION);
+    const version = content.v || 0;
+    if (version !== CURRENT_VERSION && version !== 5) {
+      console.error(`Incompatible .mind version: ${version}. This engine only supports Protocol V5/V6.`);
       return [];
     }
+    const descSize = version >= 6 ? 2 : 4;
 
-    // Restore Float32Arrays from Uint8Arrays returned by msgpack
+    // Restore TypedArrays from Uint8Arrays returned by msgpack
     const dataList = content.dataList;
     for (let i = 0; i < dataList.length; i++) {
       const item = dataList[i];
+
+      // Unpack Tracking Data
+      for (const td of item.trackingData) {
+        let px = td.px;
+        let py = td.py;
+
+        if (px instanceof Uint8Array) {
+          px = new Float32Array(px.buffer.slice(px.byteOffset, px.byteOffset + px.byteLength));
+        }
+        if (py instanceof Uint8Array) {
+          py = new Float32Array(py.buffer.slice(py.byteOffset, py.byteOffset + py.byteLength));
+        }
+        td.px = px;
+        td.py = py;
+      }
+
+      // Unpack Matching Data
       for (const kf of item.matchingData) {
         for (const col of [kf.max, kf.min]) {
-          if (col.x instanceof Uint8Array) {
-            col.x = new Float32Array(col.x.buffer.slice(col.x.byteOffset, col.x.byteOffset + col.x.byteLength));
+          let xRaw = col.x;
+          let yRaw = col.y;
+
+          if (xRaw instanceof Uint8Array) {
+            xRaw = new Uint16Array(xRaw.buffer.slice(xRaw.byteOffset, xRaw.byteOffset + xRaw.byteLength));
           }
-          if (col.y instanceof Uint8Array) {
-            col.y = new Float32Array(col.y.buffer.slice(col.y.byteOffset, col.y.byteOffset + col.y.byteLength));
+          if (yRaw instanceof Uint8Array) {
+            yRaw = new Uint16Array(yRaw.buffer.slice(yRaw.byteOffset, yRaw.byteOffset + yRaw.byteLength));
           }
+
+          // Rescale for compatibility with Matcher
+          const count = xRaw.length;
+          const x = new Float32Array(count);
+          const y = new Float32Array(count);
+          for (let k = 0; k < count; k++) {
+            x[k] = (xRaw[k] / 65535) * kf.w;
+            y[k] = (yRaw[k] / 65535) * kf.h;
+          }
+          col.x = x;
+          col.y = y;
+
           if (col.a instanceof Uint8Array) {
-            col.a = new Float32Array(col.a.buffer.slice(col.a.byteOffset, col.a.byteOffset + col.a.byteLength));
+            const aRaw = new Int16Array(col.a.buffer.slice(col.a.byteOffset, col.a.byteOffset + col.a.byteLength));
+            const a = new Float32Array(count);
+            for (let k = 0; k < count; k++) {
+              a[k] = (aRaw[k] / 32767) * Math.PI;
+            }
+            col.a = a;
           }
           if (col.s instanceof Uint8Array) {
-            col.s = new Float32Array(col.s.buffer.slice(col.s.byteOffset, col.s.byteOffset + col.s.byteLength));
+            const sRaw = col.s;
+            const s = new Float32Array(count);
+            for (let k = 0; k < count; k++) {
+              s[k] = Math.pow(2, sRaw[k]);
+            }
+            col.s = s;
+          }
+
+          // Restore LSH descriptors (Uint32Array)
+          if (col.d instanceof Uint8Array) {
+            col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
           }
         }
       }
     }
 
     this.data = dataList;
-    return this.data;
+    return { version, dataList };
   }
 
   _unpackKeyframe(kf) {
@@ -376,23 +467,25 @@ export class OfflineCompiler {
       width: kf.w,
       height: kf.h,
       scale: kf.s,
-      maximaPoints: this._decolumnarize(kf.max),
-      minimaPoints: this._decolumnarize(kf.min),
+      maximaPoints: this._decolumnarize(kf.max, kf.w, kf.h),
+      minimaPoints: this._decolumnarize(kf.min, kf.w, kf.h),
       maximaPointsCluster: { rootNode: this._expandTree(kf.max.t) },
       minimaPointsCluster: { rootNode: this._expandTree(kf.min.t) },
     };
   }
 
-  _decolumnarize(col) {
+  _decolumnarize(col, width, height) {
     const points = [];
     const count = col.x.length;
+    const descSize = col.d.length / count;
+
     for (let i = 0; i < count; i++) {
       points.push({
-        x: col.x[i],
-        y: col.y[i],
+        x: (col.x[i] / 65535) * width,
+        y: (col.y[i] / 65535) * height,
         angle: col.a[i],
         scale: col.s ? col.s[i] : 1.0,
-        descriptors: col.d.slice(i * 84, (i + 1) * 84),
+        descriptors: col.d.slice(i * descSize, (i + 1) * descSize),
       });
     }
     return points;

package/src/compiler/simple-ar.js

@@ -1,5 +1,6 @@
 import { Controller } from "./controller.js";
 import { OneEuroFilter } from "../libs/one-euro-filter.js";
+import { projectToScreen } from "./utils/projection.js";
 
 /**
  * 🍦 SimpleAR - Dead-simple vanilla AR for image overlays
@@ -157,11 +158,11 @@ class SimpleAR {
                 this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 0.1, beta: 0.01 });
             }
 
-            // Flatten mVT for filtering (3x4 matrix = 12 values)
+            // Flatten modelViewTransform for filtering (3x4 matrix = 12 values)
             const flatMVT = [
-                mVT[0][0], mVT[0][1], mVT[0][2], mVT[0][3],
-                mVT[1][0], mVT[1][1], mVT[1][2], mVT[1][3],
-                mVT[2][0], mVT[2][1], mVT[2][2], mVT[2][3]
+                modelViewTransform[0][0], modelViewTransform[0][1], modelViewTransform[0][2], modelViewTransform[0][3],
+                modelViewTransform[1][0], modelViewTransform[1][1], modelViewTransform[1][2], modelViewTransform[1][3],
+                modelViewTransform[2][0], modelViewTransform[2][1], modelViewTransform[2][2], modelViewTransform[2][3]
             ];
             const smoothedFlat = this.filters[targetIndex].filter(Date.now(), flatMVT);
             const smoothedMVT = [
@@ -202,8 +203,8 @@ class SimpleAR {
 
         // 3. Project 3 points to determine position, scale, and rotation
         // Points in Marker Space: Center, Right-Edge, and Down-Edge
-        const pMid = this._projectToScreen(markerW / 2, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
-        const pRight = this._projectToScreen(markerW / 2 + 100, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
+        const pMid = projectToScreen(markerW / 2, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
+        const pRight = projectToScreen(markerW / 2 + 100, markerH / 2, 0, mVT, proj, videoW, videoH, containerRect, needsRotation);
 
         // 4. Calculate Screen Position
         const screenX = pMid.sx;
@@ -252,41 +253,7 @@ class SimpleAR {
         `;
     }
 
-    /**
-     * Projects a 3D marker-space point all the way to 2D screen CSS pixels
-     */
-    _projectToScreen(x, y, z, mVT, proj, videoW, videoH, containerRect, needsRotation) {
-        // Marker -> Camera Space
-        const tx = mVT[0][0] * x + mVT[0][1] * y + mVT[0][2] * z + mVT[0][3];
-        const ty = mVT[1][0] * x + mVT[1][1] * y + mVT[1][2] * z + mVT[1][3];
-        const tz = mVT[2][0] * x + mVT[2][1] * y + mVT[2][2] * z + mVT[2][3];
-
-        // Camera -> Buffer Pixels (e.g. 1280x720)
-        const bx = (proj[0][0] * tx / tz) + proj[0][2];
-        const by = (proj[1][1] * ty / tz) + proj[1][2];
-
-        // Buffer -> Screen CSS Pixels
-        const vW = needsRotation ? videoH : videoW;
-        const vH = needsRotation ? videoW : videoH;
-        const perspectiveScale = Math.max(containerRect.width / vW, containerRect.height / vH);
-
-        const displayW = vW * perspectiveScale;
-        const displayH = vH * perspectiveScale;
-        const offsetX = (containerRect.width - displayW) / 2;
-        const offsetY = (containerRect.height - displayH) / 2;
-
-        let sx, sy;
-        if (needsRotation) {
-            // Mapping: Camera +X (Right) -> Screen +Y (Down), Camera +Y (Down) -> Screen -X (Left)
-            sx = offsetX + (displayW / 2) - (by - proj[1][2]) * perspectiveScale;
-            sy = offsetY + (displayH / 2) + (bx - proj[0][2]) * perspectiveScale;
-        } else {
-            sx = offsetX + (displayW / 2) + (bx - proj[0][2]) * perspectiveScale;
-            sy = offsetY + (displayH / 2) + (by - proj[1][2]) * perspectiveScale;
-        }
-
-        return { sx, sy };
-    }
+    // Unified projection logic moved to ./utils/projection.js
 }
 
 export { SimpleAR };

package/src/compiler/tracker/tracker.js

@@ -4,7 +4,7 @@ const AR2_DEFAULT_TS = 6;
 const AR2_DEFAULT_TS_GAP = 1;
 const AR2_SEARCH_SIZE = 10;
 const AR2_SEARCH_GAP = 1;
-const AR2_SIM_THRESH = 0.8;
+const AR2_SIM_THRESH = 0.6;
 
 const TRACKING_KEYFRAME = 0; // 0: 128px (optimized)
 

package/src/compiler/utils/lsh-binarizer.js

@@ -0,0 +1,43 @@
+/**
+ * LSH Binarizer for FREAK descriptors.
+ * 
+ * This utility implements Locality Sensitive Hashing (LSH) for binary descriptors.
+ * It uses simple Bit-Sampling to reduce the 672 bits (84 bytes) of a FREAK 
+ * descriptor into a 64-bit (8-byte) fingerprint.
+ * 
+ * Bit-sampling is chosen for maximum speed and zero memory overhead, 
+ * which fits the Moonshot goal of an ultra-lightweight bundle.
+ */
+
+// For 64-bit LSH, we use a uniform sampling across the 672-bit descriptor.
+const SAMPLING_INDICES = new Int32Array(64);
+for (let i = 0; i < 64; i++) {
+    SAMPLING_INDICES[i] = Math.floor(i * (672 / 64));
+}
+
+/**
+ * Converts an 84-byte FREAK descriptor into a Uint32Array of 2 elements (64 bits).
+ * @param {Uint8Array} descriptor - The 84-byte FREAK descriptor.
+ * @returns {Uint32Array} Array of two 32-bit integers.
+ */
+export function binarizeFREAK64(descriptor) {
+    const result = new Uint32Array(2);
+
+    for (let i = 0; i < 64; i++) {
+        const bitIndex = SAMPLING_INDICES[i];
+        const byteIdx = bitIndex >> 3;
+        const bitIdx = 7 - (bitIndex & 7);
+
+        if ((descriptor[byteIdx] >> bitIdx) & 1) {
+            const uintIdx = i >> 5; // i / 32
+            const uintBitIdx = i & 31; // i % 32
+            result[uintIdx] |= (1 << uintBitIdx);
+        }
+    }
+
+    return result;
+}
+
+// Backward compatibility or for other uses
+export const binarizeFREAK128 = binarizeFREAK64;
+export const binarizeFREAK32 = binarizeFREAK64;

package/src/compiler/utils/projection.js

@@ -0,0 +1,58 @@
+/**
+ * 📐 AR Projection Utilities
+ * Common logic for projecting 3D marker-space points to 2D screen CSS pixels.
+ */
+
+/**
+ * Projects a 3D marker-space point (x, y, z) into 2D screen coordinates.
+ * 
+ * @param {number} x - Marker X coordinate
+ * @param {number} y - Marker Y coordinate
+ * @param {number} z - Marker Z coordinate (height from surface)
+ * @param {number[][]} mVT - ModelViewTransform matrix (3x4)
+ * @param {number[][]} proj - Projection matrix (3x3)
+ * @param {number} videoW - Internal video width
+ * @param {number} videoH - Internal video height
+ * @param {Object} containerRect - {width, height} of the display container
+ * @param {boolean} needsRotation - Whether the feed needs 90deg rotation (e.g. portrait mobile)
+ * @returns {{sx: number, sy: number}} Screen coordinates [X, Y]
+ */
+export function projectToScreen(x, y, z, mVT, proj, videoW, videoH, containerRect, needsRotation = false) {
+    // 1. Marker Space -> Camera Space (3D)
+    const tx = mVT[0][0] * x + mVT[0][1] * y + mVT[0][2] * z + mVT[0][3];
+    const ty = mVT[1][0] * x + mVT[1][1] * y + mVT[1][2] * z + mVT[1][3];
+    const tz = mVT[2][0] * x + mVT[2][1] * y + mVT[2][2] * z + mVT[2][3];
+
+    // 2. Camera Space -> Buffer Pixels (2D)
+    // Using intrinsic projection from controller
+    const bx = (proj[0][0] * tx / tz) + proj[0][2];
+    const by = (proj[1][1] * ty / tz) + proj[1][2];
+
+    // 3. Buffer Pixels -> Screen CSS Pixels
+    const vW = needsRotation ? videoH : videoW;
+    const vH = needsRotation ? videoW : videoH;
+
+    // Calculate how the video is scaled to cover (object-fit: cover) the container
+    const perspectiveScale = Math.max(containerRect.width / vW, containerRect.height / vH);
+
+    const displayW = vW * perspectiveScale;
+    const displayH = vH * perspectiveScale;
+
+    // Centering offsets
+    const offsetX = (containerRect.width - displayW) / 2;
+    const offsetY = (containerRect.height - displayH) / 2;
+
+    let sx, sy;
+    if (needsRotation) {
+        // Rotation Mapping: 
+        // Camera +X (Right) -> Screen +Y (Down)
+        // Camera +Y (Down)  -> Screen -X (Left)
+        sx = offsetX + (displayW / 2) - (by - proj[1][2]) * perspectiveScale;
+        sy = offsetY + (displayH / 2) + (bx - proj[0][2]) * perspectiveScale;
+    } else {
+        sx = offsetX + (displayW / 2) + (bx - proj[0][2]) * perspectiveScale;
+        sy = offsetY + (displayH / 2) + (by - proj[1][2]) * perspectiveScale;
+    }
+
+    return { sx, sy };
+}