@srsergio/taptapp-ar 1.1.1 → 1.1.3

package/dist/core/utils/cumsum.js

@@ -1,37 +1 @@
-// fast 2D submatrix sum using cumulative sum algorithm
-class Cumsum {
-    constructor(data, width, height) {
-        this.width = width;
-        this.height = height;
-        this.cumsum = new Int32Array(width * height);
-        this.cumsum[0] = data[0];
-        for (let i = 1; i < width; i++) {
-            this.cumsum[i] = this.cumsum[i - 1] + data[i];
-        }
-        for (let j = 1; j < height; j++) {
-            this.cumsum[j * width] = this.cumsum[(j - 1) * width] + data[j * width];
-        }
-        for (let j = 1; j < height; j++) {
-            for (let i = 1; i < width; i++) {
-                const pos = j * width + i;
-                this.cumsum[pos] =
-                    data[pos] +
-                        this.cumsum[(j - 1) * width + i] +
-                        this.cumsum[j * width + i - 1] -
-                        this.cumsum[(j - 1) * width + i - 1];
-            }
-        }
-    }
-    query(x1, y1, x2, y2) {
-        const { width } = this;
-        let ret = this.cumsum[y2 * width + x2];
-        if (y1 > 0)
-            ret -= this.cumsum[(y1 - 1) * width + x2];
-        if (x1 > 0)
-            ret -= this.cumsum[y2 * width + x1 - 1];
-        if (x1 > 0 && y1 > 0)
-            ret += this.cumsum[(y1 - 1) * width + x1 - 1];
-        return ret;
-    }
-}
-export { Cumsum };
+class s{constructor(s,t,u){this.width=t,this.height=u,this.cumsum=new Int32Array(t*u),this.cumsum[0]=s[0];for(let u=1;u<t;u++)this.cumsum[u]=this.cumsum[u-1]+s[u];for(let m=1;m<u;m++)this.cumsum[m*t]=this.cumsum[(m-1)*t]+s[m*t];for(let m=1;m<u;m++)for(let u=1;u<t;u++){const h=m*t+u;this.cumsum[h]=s[h]+this.cumsum[(m-1)*t+u]+this.cumsum[m*t+u-1]-this.cumsum[(m-1)*t+u-1]}}query(s,t,u,m){const{width:h}=this;let i=this.cumsum[m*h+u];return t>0&&(i-=this.cumsum[(t-1)*h+u]),s>0&&(i-=this.cumsum[m*h+s-1]),s>0&&t>0&&(i+=this.cumsum[(t-1)*h+s-1]),i}}export{s as Cumsum};

package/dist/core/utils/delaunay.js

@@ -1,125 +1 @@
-/**
- * 🚀 Moonshot: Simple incremental Delaunay Triangulation (Bowyer-Watson)
- *
- * Used to create a topological mesh covering the image target features.
- */
-export function triangulate(points) {
-    if (points.length < 3)
-        return [];
-    // 1. Create a super-triangle that contains all points
-    // Find min/max bounds
-    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-    for (const p of points) {
-        if (p.x < minX)
-            minX = p.x;
-        if (p.x > maxX)
-            maxX = p.x;
-        if (p.y < minY)
-            minY = p.y;
-        if (p.y > maxY)
-            maxY = p.y;
-    }
-    const dx = maxX - minX;
-    const dy = maxY - minY;
-    const deltaMax = Math.max(dx, dy);
-    const midX = (minX + maxX) / 2;
-    const midY = (minY + maxY) / 2;
-    // A triangle large enough to cover all points
-    const p1 = { x: midX - 20 * deltaMax, y: midY - deltaMax };
-    const p2 = { x: midX, y: midY + 20 * deltaMax };
-    const p3 = { x: midX + 20 * deltaMax, y: midY - deltaMax };
-    let triangles = [
-        { p1, p2, p3, indices: [-1, -2, -3] }
-    ];
-    // 2. Add points one by one
-    for (let i = 0; i < points.length; i++) {
-        const p = points[i];
-        const badTriangles = [];
-        for (const t of triangles) {
-            if (isInCircumcircle(p, t)) {
-                badTriangles.push(t);
-            }
-        }
-        const polygon = [];
-        for (const t of badTriangles) {
-            const edges = [
-                { a: t.p1, b: t.p2, i1: t.indices[0], i2: t.indices[1] },
-                { a: t.p2, b: t.p3, i1: t.indices[1], i2: t.indices[2] },
-                { a: t.p3, b: t.p1, i1: t.indices[2], i2: t.indices[0] }
-            ];
-            for (const edge of edges) {
-                let isShared = false;
-                for (const t2 of badTriangles) {
-                    if (t === t2)
-                        continue;
-                    if (isSameEdge(edge, t2)) {
-                        isShared = true;
-                        break;
-                    }
-                }
-                if (!isShared) {
-                    polygon.push(edge);
-                }
-            }
-        }
-        // Remove bad triangles
-        triangles = triangles.filter(t => !badTriangles.includes(t));
-        // Add new triangles from polygon edges to point p
-        for (const edge of polygon) {
-            triangles.push({
-                p1: edge.a,
-                p2: edge.b,
-                p3: p,
-                indices: [edge.i1, edge.i2, i]
-            });
-        }
-    }
-    // 3. Remove triangles that share vertices with the super-triangle
-    return triangles.filter(t => {
-        return t.indices[0] >= 0 && t.indices[1] >= 0 && t.indices[2] >= 0;
-    }).map(t => t.indices);
-}
-function isInCircumcircle(p, t) {
-    const x1 = t.p1.x, y1 = t.p1.y;
-    const x2 = t.p2.x, y2 = t.p2.y;
-    const x3 = t.p3.x, y3 = t.p3.y;
-    const D = 2 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2));
-    const centerX = ((x1 * x1 + y1 * y1) * (y2 - y3) + (x2 * x2 + y2 * y2) * (y3 - y1) + (x3 * x3 + y3 * y3) * (y1 - y2)) / D;
-    const centerY = ((x1 * x1 + y1 * y1) * (x3 - x2) + (x2 * x2 + y2 * y2) * (x1 - x3) + (x3 * x3 + y3 * y3) * (x2 - x1)) / D;
-    const radiusSq = (x1 - centerX) * (x1 - centerX) + (y1 - centerY) * (y1 - centerY);
-    const distSq = (p.x - centerX) * (p.x - centerX) + (p.y - centerY) * (p.y - centerY);
-    return distSq <= radiusSq;
-}
-function isSameEdge(edge, triangle) {
-    const tEdges = [
-        [triangle.indices[0], triangle.indices[1]],
-        [triangle.indices[1], triangle.indices[2]],
-        [triangle.indices[2], triangle.indices[0]]
-    ];
-    for (const te of tEdges) {
-        if ((edge.i1 === te[0] && edge.i2 === te[1]) || (edge.i1 === te[1] && edge.i2 === te[0])) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Extract edges from triangles for Mass-Spring logic
- */
-export function getEdges(triangles) {
-    const edgeSet = new Set();
-    const edges = [];
-    for (const t of triangles) {
-        const pairs = [[t[0], t[1]], [t[1], t[2]], [t[2], t[0]]];
-        for (const pair of pairs) {
-            const low = Math.min(pair[0], pair[1]);
-            const high = Math.max(pair[0], pair[1]);
-            const key = `${low}-${high}`;
-            if (!edgeSet.has(key)) {
-                edgeSet.add(key);
-                edges.push([low, high]);
-            }
-        }
-    }
-    return edges;
-}
+export function triangulate(t){if(t.length<3)return[];let o=1/0,s=1/0,c=-1/0,e=-1/0;for(const i of t)i.x<o&&(o=i.x),i.x>c&&(c=i.x),i.y<s&&(s=i.y),i.y>e&&(e=i.y);const f=c-o,r=e-s,p=Math.max(f,r),d=(o+c)/2,u=(s+e)/2;let x=[{p1:{x:d-20*p,y:u-p},p2:{x:d,y:u+20*p},p3:{x:d+20*p,y:u-p},indices:[-1,-2,-3]}];for(let o=0;o<t.length;o++){const s=t[o],c=[];for(const n of x)i(s,n)&&c.push(n);const e=[];for(const i of c){const t=[{a:i.p1,b:i.p2,i1:i.indices[0],i2:i.indices[1]},{a:i.p2,b:i.p3,i1:i.indices[1],i2:i.indices[2]},{a:i.p3,b:i.p1,i1:i.indices[2],i2:i.indices[0]}];for(const o of t){let t=!1;for(const s of c)if(i!==s&&n(o,s)){t=!0;break}t||e.push(o)}}x=x.filter(i=>!c.includes(i));for(const i of e)x.push({p1:i.a,p2:i.b,p3:s,indices:[i.i1,i.i2,o]})}return x.filter(i=>i.indices[0]>=0&&i.indices[1]>=0&&i.indices[2]>=0).map(i=>i.indices)}function i(i,n){const t=n.p1.x,o=n.p1.y,s=n.p2.x,c=n.p2.y,e=n.p3.x,f=n.p3.y,r=2*(t*(c-f)+s*(f-o)+e*(o-c)),p=((t*t+o*o)*(c-f)+(s*s+c*c)*(f-o)+(e*e+f*f)*(o-c))/r,d=((t*t+o*o)*(e-s)+(s*s+c*c)*(t-e)+(e*e+f*f)*(s-t))/r,u=(t-p)*(t-p)+(o-d)*(o-d);return(i.x-p)*(i.x-p)+(i.y-d)*(i.y-d)<=u}function n(i,n){const t=[[n.indices[0],n.indices[1]],[n.indices[1],n.indices[2]],[n.indices[2],n.indices[0]]];for(const n of t)if(i.i1===n[0]&&i.i2===n[1]||i.i1===n[1]&&i.i2===n[0])return!0;return!1}export function getEdges(i){const n=new Set,t=[];for(const o of i){const i=[[o[0],o[1]],[o[1],o[2]],[o[2],o[0]]];for(const o of i){const i=Math.min(o[0],o[1]),s=Math.max(o[0],o[1]),c=`${i}-${s}`;n.has(c)||(n.add(c),t.push([i,s]))}}return t}

package/dist/core/utils/geometry.js

@@ -1,101 +1 @@
-// check which side point C on the line from A to B
-const linePointSide = (A, B, C) => {
-    return (B[0] - A[0]) * (C[1] - A[1]) - (B[1] - A[1]) * (C[0] - A[0]);
-};
-// srcPoints, dstPoints: array of four elements [x, y]
-const checkFourPointsConsistent = (x1, x2, x3, x4, x1p, x2p, x3p, x4p) => {
-    if (linePointSide(x1, x2, x3) > 0 !== linePointSide(x1p, x2p, x3p) > 0)
-        return false;
-    if (linePointSide(x2, x3, x4) > 0 !== linePointSide(x2p, x3p, x4p) > 0)
-        return false;
-    if (linePointSide(x3, x4, x1) > 0 !== linePointSide(x3p, x4p, x1p) > 0)
-        return false;
-    if (linePointSide(x4, x1, x2) > 0 !== linePointSide(x4p, x1p, x2p) > 0)
-        return false;
-    return true;
-};
-const checkThreePointsConsistent = (x1, x2, x3, x1p, x2p, x3p) => {
-    if (linePointSide(x1, x2, x3) > 0 !== linePointSide(x1p, x2p, x3p) > 0)
-        return false;
-    return true;
-};
-const determinant = (A) => {
-    const C1 = A[4] * A[8] - A[5] * A[7];
-    const C2 = A[3] * A[8] - A[5] * A[6];
-    const C3 = A[3] * A[7] - A[4] * A[6];
-    return A[0] * C1 - A[1] * C2 + A[2] * C3;
-};
-const matrixInverse33 = (A, threshold) => {
-    const det = determinant(A);
-    if (Math.abs(det) <= threshold)
-        return null;
-    const oneOver = 1.0 / det;
-    const B = [
-        (A[4] * A[8] - A[5] * A[7]) * oneOver,
-        (A[2] * A[7] - A[1] * A[8]) * oneOver,
-        (A[1] * A[5] - A[2] * A[4]) * oneOver,
-        (A[5] * A[6] - A[3] * A[8]) * oneOver,
-        (A[0] * A[8] - A[2] * A[6]) * oneOver,
-        (A[2] * A[3] - A[0] * A[5]) * oneOver,
-        (A[3] * A[7] - A[4] * A[6]) * oneOver,
-        (A[1] * A[6] - A[0] * A[7]) * oneOver,
-        (A[0] * A[4] - A[1] * A[3]) * oneOver,
-    ];
-    return B;
-};
-const matrixMul33 = (A, B) => {
-    const C = [];
-    C[0] = A[0] * B[0] + A[1] * B[3] + A[2] * B[6];
-    C[1] = A[0] * B[1] + A[1] * B[4] + A[2] * B[7];
-    C[2] = A[0] * B[2] + A[1] * B[5] + A[2] * B[8];
-    C[3] = A[3] * B[0] + A[4] * B[3] + A[5] * B[6];
-    C[4] = A[3] * B[1] + A[4] * B[4] + A[5] * B[7];
-    C[5] = A[3] * B[2] + A[4] * B[5] + A[5] * B[8];
-    C[6] = A[6] * B[0] + A[7] * B[3] + A[8] * B[6];
-    C[7] = A[6] * B[1] + A[7] * B[4] + A[8] * B[7];
-    C[8] = A[6] * B[2] + A[7] * B[5] + A[8] * B[8];
-    return C;
-};
-const multiplyPointHomographyInhomogenous = (x, H) => {
-    const w = H[6] * x[0] + H[7] * x[1] + H[8];
-    const xp = [];
-    xp[0] = (H[0] * x[0] + H[1] * x[1] + H[2]) / w;
-    xp[1] = (H[3] * x[0] + H[4] * x[1] + H[5]) / w;
-    return xp;
-};
-const smallestTriangleArea = (x1, x2, x3, x4) => {
-    const v12 = _vector(x2, x1);
-    const v13 = _vector(x3, x1);
-    const v14 = _vector(x4, x1);
-    const v32 = _vector(x2, x3);
-    const v34 = _vector(x4, x3);
-    const a1 = _areaOfTriangle(v12, v13);
-    const a2 = _areaOfTriangle(v13, v14);
-    const a3 = _areaOfTriangle(v12, v14);
-    const a4 = _areaOfTriangle(v32, v34);
-    return Math.min(Math.min(Math.min(a1, a2), a3), a4);
-};
-// check if four points form a convex quadrilaternal.
-// all four combinations should have same sign
-const quadrilateralConvex = (x1, x2, x3, x4) => {
-    const first = linePointSide(x1, x2, x3) <= 0;
-    if (linePointSide(x2, x3, x4) <= 0 !== first)
-        return false;
-    if (linePointSide(x3, x4, x1) <= 0 !== first)
-        return false;
-    if (linePointSide(x4, x1, x2) <= 0 !== first)
-        return false;
-    //if (linePointSide(x1, x2, x3) <= 0) return false;
-    //if (linePointSide(x2, x3, x4) <= 0) return false;
-    //if (linePointSide(x3, x4, x1) <= 0) return false;
-    //if (linePointSide(x4, x1, x2) <= 0) return false;
-    return true;
-};
-const _vector = (a, b) => {
-    return [a[0] - b[0], a[1] - b[1]];
-};
-const _areaOfTriangle = (u, v) => {
-    const a = u[0] * v[1] - u[1] * v[0];
-    return Math.abs(a) * 0.5;
-};
-export { matrixInverse33, matrixMul33, quadrilateralConvex, smallestTriangleArea, multiplyPointHomographyInhomogenous, checkThreePointsConsistent, checkFourPointsConsistent, determinant, };
+const t=(t,n,r)=>(n[0]-t[0])*(r[1]-t[1])-(n[1]-t[1])*(r[0]-t[0]),n=(n,r,s,o,c,e,u,a)=>t(n,r,s)>0==t(c,e,u)>0&&t(r,s,o)>0==t(e,u,a)>0&&t(s,o,n)>0==t(u,a,c)>0&&t(o,n,r)>0==t(a,c,e)>0,r=(n,r,s,o,c,e)=>t(n,r,s)>0==t(o,c,e)>0,s=t=>{const n=t[4]*t[8]-t[5]*t[7],r=t[3]*t[8]-t[5]*t[6],s=t[3]*t[7]-t[4]*t[6];return t[0]*n-t[1]*r+t[2]*s},o=(t,n)=>{const r=s(t);if(Math.abs(r)<=n)return null;const o=1/r;return[(t[4]*t[8]-t[5]*t[7])*o,(t[2]*t[7]-t[1]*t[8])*o,(t[1]*t[5]-t[2]*t[4])*o,(t[5]*t[6]-t[3]*t[8])*o,(t[0]*t[8]-t[2]*t[6])*o,(t[2]*t[3]-t[0]*t[5])*o,(t[3]*t[7]-t[4]*t[6])*o,(t[1]*t[6]-t[0]*t[7])*o,(t[0]*t[4]-t[1]*t[3])*o]},c=(t,n)=>{const r=[];return r[0]=t[0]*n[0]+t[1]*n[3]+t[2]*n[6],r[1]=t[0]*n[1]+t[1]*n[4]+t[2]*n[7],r[2]=t[0]*n[2]+t[1]*n[5]+t[2]*n[8],r[3]=t[3]*n[0]+t[4]*n[3]+t[5]*n[6],r[4]=t[3]*n[1]+t[4]*n[4]+t[5]*n[7],r[5]=t[3]*n[2]+t[4]*n[5]+t[5]*n[8],r[6]=t[6]*n[0]+t[7]*n[3]+t[8]*n[6],r[7]=t[6]*n[1]+t[7]*n[4]+t[8]*n[7],r[8]=t[6]*n[2]+t[7]*n[5]+t[8]*n[8],r},e=(t,n)=>{const r=n[6]*t[0]+n[7]*t[1]+n[8],s=[];return s[0]=(n[0]*t[0]+n[1]*t[1]+n[2])/r,s[1]=(n[3]*t[0]+n[4]*t[1]+n[5])/r,s},u=(t,n,r,s)=>{const o=h(n,t),c=h(r,t),e=h(s,t),u=h(n,r),a=h(s,r),i=M(o,c),m=M(c,e),b=M(o,e),l=M(u,a);return Math.min(Math.min(Math.min(i,m),b),l)},a=(n,r,s,o)=>{const c=t(n,r,s)<=0;return t(r,s,o)<=0===c&&t(s,o,n)<=0===c&&t(o,n,r)<=0===c},h=(t,n)=>[t[0]-n[0],t[1]-n[1]],M=(t,n)=>{const r=t[0]*n[1]-t[1]*n[0];return.5*Math.abs(r)};export{o as matrixInverse33,c as matrixMul33,a as quadrilateralConvex,u as smallestTriangleArea,e as multiplyPointHomographyInhomogenous,r as checkThreePointsConsistent,n as checkFourPointsConsistent,s as determinant};

package/dist/core/utils/gpu-compute.js

@@ -1,231 +1 @@
-/**
- * @fileoverview GPU Compute Layer for AR Compiler
- *
- * Provides optimized image processing with GPU acceleration when available.
- * - In browser: Uses GPU.js with WebGL
- * - In Node.js: Uses pure JavaScript (GPU.js requires headless-gl which may not compile)
- *
- * All methods have pure JS fallbacks that work universally.
- */
-// This module now uses pure JavaScript for all operations to ensure 
-// zero-dependency builds and universal compatibility (Node.js & Browser).
-// The pure JS implementations are highly optimized for performance.
-/**
- * No-op initialization for compatibility
- */
-const tryInitGPU = () => {
-    return null;
-};
-// ============================================================================
-// PURE JAVASCRIPT IMPLEMENTATIONS (Always work)
-// ============================================================================
-/**
- * Pure JS: Compute edge gradients
- */
-const computeGradientsJS = (imageData, width, height) => {
-    const dValue = new Float32Array(width * height);
-    for (let j = 1; j < height - 1; j++) {
-        const rowOffset = j * width;
-        const prevRowOffset = (j - 1) * width;
-        const nextRowOffset = (j + 1) * width;
-        for (let i = 1; i < width - 1; i++) {
-            const pos = rowOffset + i;
-            const dx = (imageData[prevRowOffset + i + 1] - imageData[prevRowOffset + i - 1] +
-                imageData[rowOffset + i + 1] - imageData[rowOffset + i - 1] +
-                imageData[nextRowOffset + i + 1] - imageData[nextRowOffset + i - 1]) / 768;
-            const dy = (imageData[nextRowOffset + i - 1] - imageData[prevRowOffset + i - 1] +
-                imageData[nextRowOffset + i] - imageData[prevRowOffset + i] +
-                imageData[nextRowOffset + i + 1] - imageData[prevRowOffset + i + 1]) / 768;
-            dValue[pos] = Math.sqrt((dx * dx + dy * dy) / 2);
-        }
-    }
-    return dValue;
-};
-/**
- * Pure JS: Find local maxima
- */
-const findLocalMaximaJS = (gradients, width, height) => {
-    const isCandidate = new Uint8Array(width * height);
-    for (let j = 1; j < height - 1; j++) {
-        const rowOffset = j * width;
-        for (let i = 1; i < width - 1; i++) {
-            const pos = rowOffset + i;
-            const val = gradients[pos];
-            if (val > 0 &&
-                val >= gradients[pos - 1] && val >= gradients[pos + 1] &&
-                val >= gradients[pos - width] && val >= gradients[pos + width]) {
-                isCandidate[pos] = 1;
-            }
-        }
-    }
-    return isCandidate;
-};
-/**
- * Pure JS: Gaussian blur (5x5 binomial)
- */
-const gaussianBlurJS = (data, width, height) => {
-    const output = new Float32Array(width * height);
-    const temp = new Float32Array(width * height);
-    const k0 = 1 / 16, k1 = 4 / 16, k2 = 6 / 16;
-    const w1 = width - 1;
-    const h1 = height - 1;
-    // Horizontal pass
-    for (let y = 0; y < height; y++) {
-        const rowOffset = y * width;
-        for (let x = 0; x < width; x++) {
-            const x0 = x < 2 ? 0 : x - 2;
-            const x1 = x < 1 ? 0 : x - 1;
-            const x3 = x > w1 - 1 ? w1 : x + 1;
-            const x4 = x > w1 - 2 ? w1 : x + 2;
-            temp[rowOffset + x] =
-                data[rowOffset + x0] * k0 +
-                    data[rowOffset + x1] * k1 +
-                    data[rowOffset + x] * k2 +
-                    data[rowOffset + x3] * k1 +
-                    data[rowOffset + x4] * k0;
-        }
-    }
-    // Vertical pass
-    for (let y = 0; y < height; y++) {
-        const y0 = (y < 2 ? 0 : y - 2) * width;
-        const y1 = (y < 1 ? 0 : y - 1) * width;
-        const y2 = y * width;
-        const y3 = (y > h1 - 1 ? h1 : y + 1) * width;
-        const y4 = (y > h1 - 2 ? h1 : y + 2) * width;
-        for (let x = 0; x < width; x++) {
-            output[y2 + x] =
-                temp[y0 + x] * k0 +
-                    temp[y1 + x] * k1 +
-                    temp[y2 + x] * k2 +
-                    temp[y3 + x] * k1 +
-                    temp[y4 + x] * k0;
-        }
-    }
-    return output;
-};
-/**
- * Pure JS: Downsample by factor of 2
- */
-const downsampleJS = (data, width, height) => {
-    const newWidth = Math.floor(width / 2);
-    const newHeight = Math.floor(height / 2);
-    const output = new Float32Array(newWidth * newHeight);
-    for (let y = 0; y < newHeight; y++) {
-        const sy = y * 2;
-        for (let x = 0; x < newWidth; x++) {
-            const sx = x * 2;
-            const pos = sy * width + sx;
-            output[y * newWidth + x] =
-                (data[pos] + data[pos + 1] + data[pos + width] + data[pos + width + 1]) / 4;
-        }
-    }
-    return { data: output, width: newWidth, height: newHeight };
-};
-// ============================================================================
-// GPU COMPUTE CLASS
-// ============================================================================
-/**
- * GPU Compute class - provides optimized image processing
- */
-export class GPUCompute {
-    constructor() {
-        this.gpu = null;
-        this.kernelCache = new Map();
-        this.initialized = false;
-    }
-    /**
-     * Initialize (tries GPU in browser, uses JS in Node)
-     */
-    init() {
-        if (this.initialized)
-            return;
-        this.gpu = tryInitGPU();
-        this.initialized = true;
-    }
-    /**
-     * Compute edge gradients
-     */
-    computeGradients(imageData, width, height) {
-        this.init();
-        // Always use JS implementation for reliability
-        return computeGradientsJS(imageData, width, height);
-    }
-    /**
-     * Find local maxima
-     */
-    findLocalMaxima(gradients, width, height) {
-        this.init();
-        return findLocalMaximaJS(gradients, width, height);
-    }
-    /**
-     * Combined edge detection
-     */
-    edgeDetection(imageData, width, height) {
-        const dValue = this.computeGradients(imageData, width, height);
-        const isCandidate = this.findLocalMaxima(dValue, width, height);
-        return { dValue, isCandidate };
-    }
-    /**
-     * Gaussian blur
-     */
-    gaussianBlur(imageData, width, height) {
-        this.init();
-        return gaussianBlurJS(imageData, width, height);
-    }
-    /**
-     * Downsample by factor of 2
-     */
-    downsample(imageData, width, height) {
-        this.init();
-        return downsampleJS(imageData, width, height);
-    }
-    /**
-     * Build Gaussian pyramid
-     */
-    buildPyramid(imageData, width, height, numLevels = 5) {
-        this.init();
-        const pyramid = [];
-        let currentData = imageData instanceof Float32Array ? imageData : Float32Array.from(imageData);
-        let currentWidth = width;
-        let currentHeight = height;
-        for (let level = 0; level < numLevels; level++) {
-            const blurred = this.gaussianBlur(currentData, currentWidth, currentHeight);
-            pyramid.push({
-                data: blurred,
-                width: currentWidth,
-                height: currentHeight,
-                scale: Math.pow(2, level),
-            });
-            if (currentWidth > 8 && currentHeight > 8) {
-                const downsampled = this.downsample(blurred, currentWidth, currentHeight);
-                currentData = downsampled.data;
-                currentWidth = downsampled.width;
-                currentHeight = downsampled.height;
-            }
-            else {
-                break;
-            }
-        }
-        return pyramid;
-    }
-    /**
-     * Check if GPU is available
-     */
-    isGPUAvailable() {
-        this.init();
-        return this.gpu !== null;
-    }
-    /**
-     * Cleanup resources
-     */
-    destroy() {
-        this.kernelCache.clear();
-        if (this.gpu && this.gpu.destroy) {
-            this.gpu.destroy();
-        }
-        this.gpu = null;
-        this.initialized = false;
-    }
-}
-// Singleton instance
-export const gpuCompute = new GPUCompute();
+export class GPUCompute{constructor(){this.gpu=null,this.kernelCache=new Map,this.initialized=!1}init(){this.initialized||(this.gpu=null,this.initialized=!0)}computeGradients(t,i,e){return this.init(),((t,i,e)=>{const n=new Float32Array(i*e);for(let r=1;r<e-1;r++){const e=r*i,s=(r-1)*i,o=(r+1)*i;for(let r=1;r<i-1;r++){const i=e+r,a=(t[s+r+1]-t[s+r-1]+t[e+r+1]-t[e+r-1]+t[o+r+1]-t[o+r-1])/768,l=(t[o+r-1]-t[s+r-1]+t[o+r]-t[s+r]+t[o+r+1]-t[s+r+1])/768;n[i]=Math.sqrt((a*a+l*l)/2)}}return n})(t,i,e)}findLocalMaxima(t,i,e){return this.init(),((t,i,e)=>{const n=new Uint8Array(i*e);for(let r=1;r<e-1;r++){const e=r*i;for(let r=1;r<i-1;r++){const s=e+r,o=t[s];o>0&&o>=t[s-1]&&o>=t[s+1]&&o>=t[s-i]&&o>=t[s+i]&&(n[s]=1)}}return n})(t,i,e)}edgeDetection(t,i,e){const n=this.computeGradients(t,i,e);return{dValue:n,isCandidate:this.findLocalMaxima(n,i,e)}}gaussianBlur(t,i,e){return this.init(),((t,i,e)=>{const n=new Float32Array(i*e),r=new Float32Array(i*e),s=1/16,o=.25,a=6/16,l=i-1,h=e-1;for(let n=0;n<e;n++){const e=n*i;for(let n=0;n<i;n++){const i=n<2?0:n-2,h=n<1?0:n-1,u=n>l-1?l:n+1,c=n>l-2?l:n+2;r[e+n]=t[e+i]*s+t[e+h]*o+t[e+n]*a+t[e+u]*o+t[e+c]*s}}for(let t=0;t<e;t++){const e=(t<2?0:t-2)*i,l=(t<1?0:t-1)*i,u=t*i,c=(t>h-1?h:t+1)*i,d=(t>h-2?h:t+2)*i;for(let t=0;t<i;t++)n[u+t]=r[e+t]*s+r[l+t]*o+r[u+t]*a+r[c+t]*o+r[d+t]*s}return n})(t,i,e)}downsample(t,i,e){return this.init(),((t,i,e)=>{const n=Math.floor(i/2),r=Math.floor(e/2),s=new Float32Array(n*r);for(let e=0;e<r;e++){const r=2*e;for(let o=0;o<n;o++){const a=r*i+2*o;s[e*n+o]=(t[a]+t[a+1]+t[a+i]+t[a+i+1])/4}}return{data:s,width:n,height:r}})(t,i,e)}buildPyramid(t,i,e,n=5){this.init();const r=[];let s=t instanceof Float32Array?t:Float32Array.from(t),o=i,a=e;for(let t=0;t<n;t++){const i=this.gaussianBlur(s,o,a);if(r.push({data:i,width:o,height:a,scale:Math.pow(2,t)}),!(o>8&&a>8))break;{const t=this.downsample(i,o,a);s=t.data,o=t.width,a=t.height}}return r}isGPUAvailable(){return this.init(),null!==this.gpu}destroy(){this.kernelCache.clear(),this.gpu&&this.gpu.destroy&&this.gpu.destroy(),this.gpu=null,this.initialized=!1}}export const gpuCompute=new GPUCompute;

package/dist/core/utils/homography.js

@@ -1,138 +1 @@
-import { Matrix, inverse } from "ml-matrix";
-const solveHomography = (srcPoints, dstPoints) => {
-    const { normPoints: normSrcPoints, param: srcParam } = _normalizePoints(srcPoints);
-    const { normPoints: normDstPoints, param: dstParam } = _normalizePoints(dstPoints);
-    const num = normDstPoints.length;
-    const AData = [];
-    const BData = [];
-    for (let j = 0; j < num; j++) {
-        const row1 = [
-            normSrcPoints[j][0],
-            normSrcPoints[j][1],
-            1,
-            0,
-            0,
-            0,
-            -(normSrcPoints[j][0] * normDstPoints[j][0]),
-            -(normSrcPoints[j][1] * normDstPoints[j][0]),
-        ];
-        const row2 = [
-            0,
-            0,
-            0,
-            normSrcPoints[j][0],
-            normSrcPoints[j][1],
-            1,
-            -(normSrcPoints[j][0] * normDstPoints[j][1]),
-            -(normSrcPoints[j][1] * normDstPoints[j][1]),
-        ];
-        AData.push(row1);
-        AData.push(row2);
-        BData.push([normDstPoints[j][0]]);
-        BData.push([normDstPoints[j][1]]);
-    }
-    try {
-        const A = new Matrix(AData);
-        const B = new Matrix(BData);
-        const AT = A.transpose();
-        const ATA = AT.mmul(A);
-        const ATB = AT.mmul(B);
-        const ATAInv = inverse(ATA);
-        const C = ATAInv.mmul(ATB).to1DArray();
-        const H = _denormalizeHomography(C, srcParam, dstParam);
-        return H;
-    }
-    catch (e) {
-        return null;
-    }
-};
-// centroid at origin and avg distance from origin is sqrt(2)
-const _normalizePoints = (coords) => {
-    //return {normalizedCoords: coords, param: {meanX: 0, meanY: 0, s: 1}}; // skip normalization
-    let sumX = 0;
-    let sumY = 0;
-    for (let i = 0; i < coords.length; i++) {
-        sumX += coords[i][0];
-        sumY += coords[i][1];
-    }
-    let meanX = sumX / coords.length;
-    let meanY = sumY / coords.length;
-    let sumDiff = 0;
-    for (let i = 0; i < coords.length; i++) {
-        const diffX = coords[i][0] - meanX;
-        const diffY = coords[i][1] - meanY;
-        sumDiff += Math.sqrt(diffX * diffX + diffY * diffY);
-    }
-    let s = (Math.sqrt(2) * coords.length) / sumDiff;
-    const normPoints = [];
-    for (let i = 0; i < coords.length; i++) {
-        normPoints.push([(coords[i][0] - meanX) * s, (coords[i][1] - meanY) * s]);
-    }
-    return { normPoints, param: { meanX, meanY, s } };
-};
-// Denormalize homography
-// where T is the normalization matrix, i.e.
-//
-//     [1  0  -meanX]
-// T = [0  1  -meanY]
-//     [0  0     1/s]
-//
-//          [1  0  s*meanX]
-// inv(T) = [0  1  s*meanY]
-// 	    [0  0        s]
-//
-// H = inv(Tdst) * Hn * Tsrc
-//
-// @param {
-//   nH: normH,
-//   srcParam: param of src transform,
-//   dstParam: param of dst transform
-// }
-const _denormalizeHomography = (nH, srcParam, dstParam) => {
-    /*
-    Matrix version
-    const normH = new Matrix([
-      [nH[0], nH[1], nH[2]],
-      [nH[3], nH[4], nH[5]],
-      [nH[6], nH[7], 1],
-    ]);
-    const Tsrc = new Matrix([
-      [1, 0, -srcParam.meanX],
-      [0, 1, -srcParam.meanY],
-      [0, 0,    1/srcParam.s],
-    ]);
-  
-    const invTdst = new Matrix([
-      [1, 0, dstParam.s * dstParam.meanX],
-      [0, 1, dstParam.s * dstParam.meanY],
-      [0, 0, dstParam.s],
-    ]);
-    const H = invTdst.mmul(normH).mmul(Tsrc);
-    */
-    // plain implementation of the above using Matrix
-    const sMeanX = dstParam.s * dstParam.meanX;
-    const sMeanY = dstParam.s * dstParam.meanY;
-    const H = [
-        nH[0] + sMeanX * nH[6],
-        nH[1] + sMeanX * nH[7],
-        (nH[0] + sMeanX * nH[6]) * -srcParam.meanX +
-            (nH[1] + sMeanX * nH[7]) * -srcParam.meanY +
-            (nH[2] + sMeanX) / srcParam.s,
-        nH[3] + sMeanY * nH[6],
-        nH[4] + sMeanY * nH[7],
-        (nH[3] + sMeanY * nH[6]) * -srcParam.meanX +
-            (nH[4] + sMeanY * nH[7]) * -srcParam.meanY +
-            (nH[5] + sMeanY) / srcParam.s,
-        dstParam.s * nH[6],
-        dstParam.s * nH[7],
-        dstParam.s * nH[6] * -srcParam.meanX +
-            dstParam.s * nH[7] * -srcParam.meanY +
-            dstParam.s / srcParam.s,
-    ];
-    // make H[8] === 1;
-    for (let i = 0; i < 9; i++) {
-        H[i] = H[i] / H[8];
-    }
-    return H;
-};
-export { solveHomography };
+import{Matrix as t,inverse as n}from"ml-matrix";const e=(e,m)=>{const{normPoints:o,param:a}=s(e),{normPoints:l,param:h}=s(m),u=l.length,p=[],c=[];for(let t=0;t<u;t++){const n=[o[t][0],o[t][1],1,0,0,0,-o[t][0]*l[t][0],-o[t][1]*l[t][0]],e=[0,0,0,o[t][0],o[t][1],1,-o[t][0]*l[t][1],-o[t][1]*l[t][1]];p.push(n),p.push(e),c.push([l[t][0]]),c.push([l[t][1]])}try{const e=new t(p),s=new t(c),m=e.transpose(),o=m.mmul(e),l=m.mmul(s),u=n(o).mmul(l).to1DArray();return r(u,a,h)}catch(t){return null}},s=t=>{let n=0,e=0;for(let s=0;s<t.length;s++)n+=t[s][0],e+=t[s][1];let s=n/t.length,r=e/t.length,m=0;for(let n=0;n<t.length;n++){const e=t[n][0]-s,o=t[n][1]-r;m+=Math.sqrt(e*e+o*o)}let o=Math.sqrt(2)*t.length/m;const a=[];for(let n=0;n<t.length;n++)a.push([(t[n][0]-s)*o,(t[n][1]-r)*o]);return{normPoints:a,param:{meanX:s,meanY:r,s:o}}},r=(t,n,e)=>{const s=e.s*e.meanX,r=e.s*e.meanY,m=[t[0]+s*t[6],t[1]+s*t[7],(t[0]+s*t[6])*-n.meanX+(t[1]+s*t[7])*-n.meanY+(t[2]+s)/n.s,t[3]+r*t[6],t[4]+r*t[7],(t[3]+r*t[6])*-n.meanX+(t[4]+r*t[7])*-n.meanY+(t[5]+r)/n.s,e.s*t[6],e.s*t[7],e.s*t[6]*-n.meanX+e.s*t[7]*-n.meanY+e.s/n.s];for(let t=0;t<9;t++)m[t]=m[t]/m[8];return m};export{e as solveHomography};