@woosh/meep-engine 2.133.5 → 2.134.0

package/src/core/geom/3d/topology/simplify/computeEdgeCollapseCost.js

@@ -14,7 +14,7 @@ const INVALID_FLIP_COST = Number.MAX_VALUE;
  * @param {TopoVertex} victim
  * @param {TopoVertex} target
  * @param {TopoEdge} victim_edge
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @return {number}
  */
 export function computeEdgeCollapseCost(victim, target, victim_edge, vertex_quadratics) {

package/src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.d.ts

@@ -14,19 +14,19 @@ export function edge_collapse_pick_target_vertex(edge: TopoEdge, restricted_vert
 /**
  *
  * @param {TopoEdge} edge
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @param {Set<number>} restricted_vertices
  */
-export function compute_edge_collapse_cost(edge: TopoEdge, quadratics: Map<number, Quadratic3>, restricted_vertices: Set<number>): number;
+export function compute_edge_collapse_cost(edge: TopoEdge, quadratics: Map<number, Quadric3>, restricted_vertices: Set<number>): number;
 /**
  *
  * @param {TopoMesh} mesh
  * @param {TopoEdge}edge
  * @param {TopoVertex} target
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @param {Uint32Heap} heap
  * @param {Set<number>} restricted_vertices
  * @returns {boolean}
  */
-export function decimate_edge_collapse_snap(mesh: TopoMesh, edge: TopoEdge, target: TopoVertex, quadratics: Map<number, Quadratic3>, heap: Uint32Heap, restricted_vertices: Set<number>): boolean;
+export function decimate_edge_collapse_snap(mesh: TopoMesh, edge: TopoEdge, target: TopoVertex, quadratics: Map<number, Quadric3>, heap: Uint32Heap, restricted_vertices: Set<number>): boolean;
 //# sourceMappingURL=decimate_edge_collapse_snap.d.ts.map

package/src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimate_edge_collapse_snap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,kFASC;AAED;;;;;GAKG;AACH,sFAHW,IAAI,MAAM,CAAC,GACT,aAAW,SAAS,CA0ChC;AAqBD;;;;;GAKG;AACH,uEAHW,IAAI,MAAM,aAAY,uBACtB,IAAI,MAAM,CAAC,UAsBrB;AAsBD;;;;;;;;;GASG;AACH,4GALW,IAAI,MAAM,aAAY,yCAEtB,IAAI,MAAM,CAAC,GACT,OAAO,CAmFnB"}
+{"version":3,"file":"decimate_edge_collapse_snap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,kFASC;AAED;;;;;GAKG;AACH,sFAHW,IAAI,MAAM,CAAC,GACT,aAAW,SAAS,CA0ChC;AAqBD;;;;;GAKG;AACH,uEAHW,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,UAsBrB;AAsBD;;;;;;;;;GASG;AACH,4GALW,IAAI,MAAM,WAAU,yCAEpB,IAAI,MAAM,CAAC,GACT,OAAO,CAmFnB"}

package/src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js

@@ -132,7 +132,7 @@ function build_edge_cost_squared_topology(edge) {
 /**
  *
  * @param {TopoEdge} edge
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @param {Set<number>} restricted_vertices
  */
 export function compute_edge_collapse_cost(edge, quadratics, restricted_vertices) {
@@ -160,7 +160,7 @@ export function compute_edge_collapse_cost(edge, quadratics, restricted_vertices
 /**
  *
  * @param {TopoEdge} edge
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @param {Uint32Heap} heap
  * @param {Set<number>} restricted_vertices
  */
@@ -182,7 +182,7 @@ function tm_build_cost(edge, quadratics, heap, restricted_vertices) {
  * @param {TopoMesh} mesh
  * @param {TopoEdge}edge
  * @param {TopoVertex} target
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @param {Uint32Heap} heap
  * @param {Set<number>} restricted_vertices
  * @returns {boolean}

package/src/core/geom/3d/topology/simplify/quadratic/{Quadratic3.d.ts → Quadric3.d.ts}

@@ -1,18 +1,45 @@
 /**
  * Quadric Error Metric
- * Triangular 4x4 matrix, see https://en.wikipedia.org/wiki/Triangular_matrix
+ * Upper-triangular portion of a symmetric 4x4 matrix encoding a quadric form.
+ *
+ * Layout (10 elements):
+ *   [0]=a2 [1]=ab [2]=ac [3]=ad
+ *          [4]=b2 [5]=bc [6]=bd
+ *                 [7]=c2 [8]=cd
+ *                        [9]=d2
  */
-export class Quadratic3 {
-    a2: number;
-    ab: number;
-    ac: number;
-    ad: number;
-    b2: number;
-    bc: number;
-    bd: number;
-    c2: number;
-    cd: number;
-    d2: number;
+export class Quadric3 extends Float64Array {
+    constructor();
+    set a2(arg: any);
+    get a2(): any;
+    0: any;
+    set ab(arg: any);
+    get ab(): any;
+    1: any;
+    set ac(arg: any);
+    get ac(): any;
+    2: any;
+    set ad(arg: any);
+    get ad(): any;
+    3: any;
+    set b2(arg: any);
+    get b2(): any;
+    4: any;
+    set bc(arg: any);
+    get bc(): any;
+    5: any;
+    set bd(arg: any);
+    get bd(): any;
+    6: any;
+    set c2(arg: any);
+    get c2(): any;
+    7: any;
+    set cd(arg: any);
+    get cd(): any;
+    8: any;
+    set d2(arg: any);
+    get d2(): any;
+    9: any;
     /**
      *
      * @param {ArrayLike<number>|number[]|Float32Array} result
@@ -39,12 +66,7 @@ export class Quadratic3 {
      */
     setFromVector4(x: number, y: number, z: number, w: number): void;
     /**
-     *
-     * @param {TopoTriangle} face
-     */
-    setFromFace(face: TopoTriangle): void;
-    /**
-     * Squared distance from the given point to plane encoded by the quadratic
+     * Squared distance from the given point to plane encoded by the quadric
      * @param {number} x
      * @param {number} y
      * @param {number} z
@@ -52,19 +74,17 @@ export class Quadratic3 {
      */
     evaluate(x: number, y: number, z: number): number;
     /**
-     * Find optimal vertex position based on the quadratic
+     * Find the optimal vertex position based on the quadric
      *
-     * Based on Blender's implementation: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
-     *
-     * @param {number[]} out
+     * @param {number[]} out vector3
      * @returns {boolean}
      */
     optimize(out: number[]): boolean;
     /**
      *
-     * @param {Quadratic3} Q
+     * @param {Quadric3} Q
      */
-    add(Q: Quadratic3): void;
+    add(Q: Quadric3): void;
     /**
      *
      * @param {number} v
@@ -72,17 +92,23 @@ export class Quadratic3 {
     multiplyScalar(v: number): void;
     /**
      *
-     * @returns {Quadratic3}
+     * @returns {Quadric3}
      */
-    clone(): Quadratic3;
+    clone(): Quadric3;
     /**
      *
-     * @param {Quadratic3} other
+     * @param {Quadric3} other
      */
-    copy(other: Quadratic3): void;
+    copy(other: Quadric3): void;
     /**
      * Set all matrix values to 0
      */
     clear(): void;
+    /**
+     * Useful for type checking
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isQuadric3: boolean;
 }
-//# sourceMappingURL=Quadratic3.d.ts.map
+//# sourceMappingURL=Quadric3.d.ts.map

package/src/core/geom/3d/topology/simplify/quadratic/Quadric3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Quadric3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/Quadric3.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH;IACI,cAEC;IAMD,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAOf,iBAEC;IAND,cAEC;IAGG,OAAW;IAGf;;;OAGG;IACH,kBAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAMjD;IAED;;;OAGG;IACH,eAFW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAkBjD;IAED;;;;;OAKG;IACH,sBAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,WACvC,MAAM,GACJ,OAAO,CAqCnB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;;OAMG;IACH,YALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CASlB;IAED;;;;;OAKG;IACH,cAHW,MAAM,EAAE,GACN,OAAO,CAkBnB;IAED;;;OAGG;IACH,OAFW,QAAQ,QAalB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAahB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAQpB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAIlB;IAED;;OAEG;IACH,cAEC;IAGL;;;;OAIG;IACH,qBAFU,OAAO,CAEY;CAP5B"}

package/src/core/geom/3d/topology/simplify/quadratic/Quadric3.js

@@ -0,0 +1,307 @@
+import { vec3 } from "gl-matrix";
+import { EPSILON } from "../../../../../math/EPSILON.js";
+import { fabsf } from "../../../../../math/fabsf.js";
+
+const scratch_m3 = new Float32Array(9);
+
+/**
+ * Quadric Error Metric
+ * Upper-triangular portion of a symmetric 4x4 matrix encoding a quadric form.
+ *
+ * Layout (10 elements):
+ *   [0]=a2 [1]=ab [2]=ac [3]=ad
+ *          [4]=b2 [5]=bc [6]=bd
+ *                 [7]=c2 [8]=cd
+ *                        [9]=d2
+ */
+export class Quadric3 extends Float64Array {
+    constructor() {
+        super(10);
+    }
+
+    get a2() {
+        return this[0];
+    }
+
+    set a2(v) {
+        this[0] = v;
+    }
+
+    get ab() {
+        return this[1];
+    }
+
+    set ab(v) {
+        this[1] = v;
+    }
+
+    get ac() {
+        return this[2];
+    }
+
+    set ac(v) {
+        this[2] = v;
+    }
+
+    get ad() {
+        return this[3];
+    }
+
+    set ad(v) {
+        this[3] = v;
+    }
+
+    get b2() {
+        return this[4];
+    }
+
+    set b2(v) {
+        this[4] = v;
+    }
+
+    get bc() {
+        return this[5];
+    }
+
+    set bc(v) {
+        this[5] = v;
+    }
+
+    get bd() {
+        return this[6];
+    }
+
+    set bd(v) {
+        this[6] = v;
+    }
+
+    get c2() {
+        return this[7];
+    }
+
+    set c2(v) {
+        this[7] = v;
+    }
+
+    get cd() {
+        return this[8];
+    }
+
+    set cd(v) {
+        this[8] = v;
+    }
+
+    get d2() {
+        return this[9];
+    }
+
+    set d2(v) {
+        this[9] = v;
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} result
+     */
+    toVector3(result) {
+        result[0] = this[3];
+        result[1] = this[6];
+        result[2] = this[8];
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     */
+    toTensorM3(m3) {
+        const ab = this[1];
+        const ac = this[2];
+        const bc = this[5];
+
+        m3[0] = this[0];
+        m3[1] = ab;
+        m3[2] = ac;
+
+        m3[3] = ab;
+        m3[4] = this[4];
+        m3[5] = bc;
+
+        m3[6] = ac;
+        m3[7] = bc;
+        m3[8] = this[7];
+    }
+
+    /**
+     * Equivalent to taking a tensor followed by matrix inversion
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     * @param {number} epsilon
+     * @returns {boolean} whether operation was successful or not
+     */
+    toTensorM3Inverse(m3, epsilon) {
+        const a2 = this[0];
+        const ab = this[1];
+        const ac = this[2];
+        const b2 = this[4];
+        const bc = this[5];
+        const c2 = this[7];
+
+        const det = a2 * (b2 * c2 - bc * bc) -
+            ab * (ab * c2 - ac * bc) +
+            ac * (ab * bc - ac * b2);
+
+        if (fabsf(det) > epsilon) {
+            // avoid division by zero
+
+            const invdet = 1.0 / det;
+
+            m3[0] = (b2 * c2 - bc * bc) * invdet;
+            m3[3] = (bc * ac - ab * c2) * invdet;
+            m3[6] = (ab * bc - b2 * ac) * invdet;
+
+            m3[1] = (ac * bc - ab * c2) * invdet;
+            m3[4] = (a2 * c2 - ac * ac) * invdet;
+            m3[7] = (ab * ac - a2 * bc) * invdet;
+
+            m3[2] = (ab * bc - ac * b2) * invdet;
+            m3[5] = (ac * ab - a2 * bc) * invdet;
+            m3[8] = (a2 * b2 - ab * ab) * invdet;
+
+            return true;
+        }
+
+        // determinant is zero, matrix is singular, cannot invert
+
+        return false;
+    }
+
+    /**
+     * Set from plane expressed as a 4 component vector
+     * @param {number} x plane normal
+     * @param {number} y plane normal
+     * @param {number} z plane normal
+     * @param {number} w plane offset
+     */
+    setFromVector4(x, y, z, w) {
+        this[0] = x * x;
+        this[1] = x * y;
+        this[2] = x * z;
+        this[3] = x * w;
+
+        this[4] = y * y;
+        this[5] = y * z;
+        this[6] = y * w;
+
+        this[7] = z * z;
+        this[8] = z * w;
+
+        this[9] = w * w;
+    }
+
+    /**
+     * Squared distance from the given point to plane encoded by the quadric
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    evaluate(x, y, z) {
+        // Evaluate vAv + 2bv + c
+
+        return (x * x * this[0]) + (2 * x * y * this[1]) + (2 * x * z * this[2]) + (2 * x * this[3])    // A
+            + (y * y * this[4]) + (2 * y * z * this[5]) + (2 * y * this[6])                             // B
+            + (z * z * this[7]) + (2 * z * this[8])                                                     // C
+            + this[9];                                                                                  // D
+    }
+
+    /**
+     * Find the optimal vertex position based on the quadric
+     *
+     * @param {number[]} out vector3
+     * @returns {boolean}
+     */
+    optimize(out) {
+
+        // Based on Blender's implementation: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
+
+        if (this.toTensorM3Inverse(scratch_m3, EPSILON)) {
+
+            this.toVector3(out);
+
+            vec3.transformMat3(out, out, scratch_m3);
+            vec3.negate(out, out);
+
+            return true;
+        }
+
+        return false;
+
+    }
+
+    /**
+     *
+     * @param {Quadric3} Q
+     */
+    add(Q) {
+        this[0] += Q[0];
+        this[1] += Q[1];
+        this[2] += Q[2];
+        this[3] += Q[3];
+        this[4] += Q[4];
+        this[5] += Q[5];
+        this[6] += Q[6];
+        this[7] += Q[7];
+        this[8] += Q[8];
+        this[9] += Q[9];
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    multiplyScalar(v) {
+        this[0] *= v;
+        this[1] *= v;
+        this[2] *= v;
+        this[3] *= v;
+        this[4] *= v;
+        this[5] *= v;
+        this[6] *= v;
+        this[7] *= v;
+        this[8] *= v;
+        this[9] *= v;
+    }
+
+    /**
+     *
+     * @returns {Quadric3}
+     */
+    clone() {
+        const r = new Quadric3();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {Quadric3} other
+     */
+    copy(other) {
+        this.set(other);
+    }
+
+    /**
+     * Set all matrix values to 0
+     */
+    clear() {
+        this.fill(0);
+    }
+}
+
+/**
+ * Useful for type checking
+ * @readonly
+ * @type {boolean}
+ */
+Quadric3.prototype.isQuadric3 = true;

package/src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.d.ts

@@ -1,25 +1,25 @@
 /**
  *
- * @param {Map<number, Quadratic3>} destination
- * @param {Map<number, Quadratic3>} source
+ * @param {Map<number, Quadric3>} destination
+ * @param {Map<number, Quadric3>} source
  * @param {TopoMesh} mesh
  */
-export function deep_copy_vertex_quadratics(destination: Map<number, Quadratic3>, source: Map<number, Quadratic3>, mesh: TopoMesh): void;
+export function deep_copy_vertex_quadratics(destination: Map<number, Quadric3>, source: Map<number, Quadric3>, mesh: TopoMesh): void;
 /**
  *
  * @param {TopoMesh} mesh
  * @param {TopoEdge[]} border_set
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {number} [weight]
  */
-export function apply_border_penalties_to_vertex_quadrics(mesh: TopoMesh, border_set: TopoEdge[], vertex_quadratics: Map<number, Quadratic3>, weight?: number): void;
+export function apply_border_penalties_to_vertex_quadrics(mesh: TopoMesh, border_set: TopoEdge[], vertex_quadratics: Map<number, Quadric3>, weight?: number): void;
 /**
  *
  * @param {TopoMesh} mesh
- * @param {Map<number, Quadratic3>} quadratics VertexID -> Quadratic map
+ * @param {Map<number, Quadric3>} quadratics VertexID -> Quadratic map
  * @param {boolean} [use_triangle_area]
  * @param {boolean} [use_border_constraints]
  */
 export function build_vertex_quadratics({ mesh, quadratics, use_triangle_area, use_border_constraints }: TopoMesh): void;
-import { Quadratic3 } from "./Quadratic3.js";
+import { Quadric3 } from "./Quadric3.js";
 //# sourceMappingURL=build_vertex_quadratics.d.ts.map

package/src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_vertex_quadratics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,yDAJW,IAAI,MAAM,EAAE,UAAU,CAAC,UACvB,IAAI,MAAM,EAAE,UAAU,CAAC,wBAgBjC;AA8CD;;;;;;GAMG;AACH,sFAJW,UAAU,qBACV,IAAI,MAAM,EAAE,UAAU,CAAC,WACvB,MAAM,QAQhB;AAED;;;;;;GAMG;AACH,yHAwDC;2BAtJ0B,iBAAiB"}
+{"version":3,"file":"build_vertex_quadratics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,yDAJW,IAAI,MAAM,EAAE,QAAQ,CAAC,UACrB,IAAI,MAAM,EAAE,QAAQ,CAAC,wBAgB/B;AA8CD;;;;;;GAMG;AACH,sFAJW,UAAU,qBACV,IAAI,MAAM,EAAE,QAAQ,CAAC,WACrB,MAAM,QAQhB;AA2BD;;;;;;GAMG;AACH,yHAwDC;yBA1KwB,eAAe"}

package/src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js

@@ -1,14 +1,15 @@
-import { Quadratic3 } from "./Quadratic3.js";
-import { tm_face_area } from "../../tm_face_area.js";
-import { assert } from "../../../../../assert.js";
-import { tm_face_normal } from "../../tm_face_normal.js";
 import { vec3 } from "gl-matrix";
+import { assert } from "../../../../../assert.js";
+import { v3_dot } from "../../../../vec3/v3_dot.js";
 import { query_edge_is_boundary } from "../../query/query_edge_is_boundary.js";
+import { tm_face_area } from "../../tm_face_area.js";
+import { tm_face_normal } from "../../tm_face_normal.js";
+import { Quadric3 } from "./Quadric3.js";
 
 /**
  *
- * @param {Map<number, Quadratic3>} destination
- * @param {Map<number, Quadratic3>} source
+ * @param {Map<number, Quadric3>} destination
+ * @param {Map<number, Quadric3>} source
  * @param {TopoMesh} mesh
  */
 export function deep_copy_vertex_quadratics(destination, source, mesh) {
@@ -31,7 +32,7 @@ export function deep_copy_vertex_quadratics(destination, source, mesh) {
  * @see "Boundary and Texture Preserving Mesh Simplification Algorithm for Virtual Reality" by Kanchan Bahirat et.al. University of Texas/Dallas
  * @param {TopoEdge} edge
  * @param {number} weight
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  */
 function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics) {
     const v0 = edge.v0;
@@ -57,7 +58,7 @@ function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics
 
     const d = -vec3.dot(abc, v0);
 
-    const constraint = new Quadratic3();
+    const constraint = new Quadric3();
     constraint.setFromVector4(abc[0], abc[1], abc[2], d);
     constraint.multiplyScalar(vec3.length(edge_vector) * weight);
     // constraint.multiplyScalar(weight);
@@ -74,7 +75,7 @@ function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics
  *
  * @param {TopoMesh} mesh
  * @param {TopoEdge[]} border_set
- * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number, Quadric3>} vertex_quadratics
  * @param {number} [weight]
  */
 export function apply_border_penalties_to_vertex_quadrics(mesh, border_set, vertex_quadratics, weight = 10) {
@@ -85,10 +86,35 @@ export function apply_border_penalties_to_vertex_quadrics(mesh, border_set, vert
     }
 }
 
+/**
+ *
+ * @param {Quadric3} quadric
+ * @param {TopoTriangle} face
+ */
+function quadric_set_from_face(quadric, face){
+    const v0 = face.vertices[0];
+
+    // compute triangle's plane
+    face.computeNormal();
+
+    // compute plane offset
+    const normal_x = face.normal[0];
+    const normal_y = face.normal[1];
+    const normal_z = face.normal[2];
+
+    const plane_constant = -v3_dot(
+        normal_x, normal_y, normal_z,
+
+        v0.x, v0.y, v0.z
+    );
+
+    quadric.setFromVector4(normal_x, normal_y, normal_z, plane_constant);
+}
+
 /**
  *
  * @param {TopoMesh} mesh
- * @param {Map<number, Quadratic3>} quadratics VertexID -> Quadratic map
+ * @param {Map<number, Quadric3>} quadratics VertexID -> Quadratic map
  * @param {boolean} [use_triangle_area]
  * @param {boolean} [use_border_constraints]
  */
@@ -108,19 +134,19 @@ export function build_vertex_quadratics({
     for (i = 0; i < mesh_vertex_count; i++) {
         const mesh_vertex = mesh_vertices[i];
 
-        const vertex_quadratic = new Quadratic3();
+        const vertex_quadratic = new Quadric3();
 
         quadratics.set(mesh_vertex.index, vertex_quadratic);
     }
 
     // compute values for quadratics
-    const q = new Quadratic3();
+    const q = new Quadric3();
 
     const faces = mesh.getFaces();
 
     for (face of faces) {
 
-        q.setFromFace(face);
+        quadric_set_from_face(q,face);
 
         if (use_triangle_area) {
             const triangle_area = tm_face_area(face);

package/src/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.d.ts

@@ -3,8 +3,8 @@
  * @param {TopoVertex} v0
  * @param {TopoVertex} v1
  * @param {TopoVertex} target where to collapse v0 and v1 to
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @returns {number}
  */
-export function compute_edge_collapse_cost_quadratic(v0: TopoVertex, v1: TopoVertex, target: TopoVertex, quadratics: Map<number, Quadratic3>): number;
+export function compute_edge_collapse_cost_quadratic(v0: TopoVertex, v1: TopoVertex, target: TopoVertex, quadratics: Map<number, Quadric3>): number;
 //# sourceMappingURL=compute_edge_collapse_cost_quadratic.d.ts.map

package/src/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_edge_collapse_cost_quadratic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qHAHW,IAAI,MAAM,aAAY,GACpB,MAAM,CAqBlB"}
+{"version":3,"file":"compute_edge_collapse_cost_quadratic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qHAHW,IAAI,MAAM,WAAU,GAClB,MAAM,CAqBlB"}

package/src/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.js

@@ -3,7 +3,7 @@
  * @param {TopoVertex} v0
  * @param {TopoVertex} v1
  * @param {TopoVertex} target where to collapse v0 and v1 to
- * @param {Map<number,Quadratic3>} quadratics
+ * @param {Map<number,Quadric3>} quadratics
  * @returns {number}
  */
 export function compute_edge_collapse_cost_quadratic(