@woosh/meep-engine 2.37.18 → 2.38.0

package/core/geom/3d/topology/simplify/prototypeMeshSimplification.js

@@ -0,0 +1,502 @@
+import {
+    AmbientLight,
+    CanvasTexture,
+    CubeTextureLoader,
+    DirectionalLight,
+    FrontSide,
+    Group,
+    Mesh,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    PerspectiveCamera,
+    PlaneBufferGeometry,
+    PointLight,
+    RepeatWrapping,
+    Scene,
+    SphereBufferGeometry,
+    SphereGeometry,
+    sRGBEncoding,
+    TextureLoader,
+    VSMShadowMap,
+    WebGLRenderer
+} from "three";
+import { mergeVertices } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import Stats from "three/examples/jsm/libs/stats.module.js";
+import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
+import { topoMeshToBufferGeometry } from "../topoMeshToBufferGeometry.js";
+import { TopoMesh } from "../struct/TopoMesh.js";
+import {
+    deinterleaveBufferGeometry
+} from "../../../../../engine/graphics/geometry/buffered/deinterleaveBufferGeometry.js";
+import Vector3 from "../../../Vector3.js";
+import { simplifyTopoMesh2 } from "./simplifyTopoMesh2.js";
+import { scaleGeometryToBox } from "../../../../../engine/graphics/geometry/scaleGeometryToBox.js";
+import { computeTopoMeshBoundiningBox } from "../bounds/computeTopoMeshBoundiningBox.js";
+import { AABB3 } from "../../../../bvh2/aabb3/AABB3.js";
+import { Color } from "../../../../color/Color.js";
+import { clamp } from "../../../../math/clamp.js";
+
+
+/**
+ *
+ * @param {string} text
+ * @returns {CanvasTexture}
+ */
+function makeTextLabelTexture(text) {
+    const canvas = document.createElement('canvas');
+    canvas.width = 64;
+    canvas.height = 64;
+
+    const ctx = canvas.getContext('2d');
+    ctx.font = '42px Tahoma';
+    ctx.fillStyle = 'transparent';
+    ctx.fillRect(0, 0, 64, 64);
+    ctx.strokeStyle = `white`;
+    ctx.fillStyle = 'black';
+
+    const label_x = 34 - text.length * 12;
+    const label_y = 48;
+
+    ctx.strokeText(text, label_x, label_y);
+    ctx.fillText(text, label_x, label_y);
+
+    return new CanvasTexture(canvas);
+}
+
+/**
+ *
+ * @param {string|number} text
+ * @param {number} scale
+ * @param {boolean} depth_test
+ * @returns {THREE.Object3D}
+ */
+function makeTextLabelMesh({ text, scale = 1, depth_test = false }) {
+    const g_text = new PlaneBufferGeometry(1, 1);
+
+    const mesh = new Mesh(g_text, new MeshBasicMaterial({
+        map: makeTextLabelTexture(text.toString()),
+        transparent: true,
+        depthTest: depth_test
+    }));
+
+    mesh.scale.setScalar(scale);
+
+    return mesh;
+}
+
+const background = new TextureLoader().load('data/textures/utility/checkers_white_grey_256x256.png');
+background.repeat.set(50, 30);
+background.wrapS = RepeatWrapping;
+background.wrapT = RepeatWrapping;
+
+let container, stats;
+
+let camera, scene, renderer;
+let directionalLight;
+let pointLight;
+
+let windowHalfX = window.innerWidth / 2;
+let windowHalfY = window.innerHeight / 2;
+
+function init() {
+
+    container = document.createElement("div");
+    document.body.appendChild(container);
+
+    document.body.style.margin = 0;
+
+    camera = new PerspectiveCamera(45, window.innerWidth / window.innerHeight, 1, 1000000);
+    camera.position.z = 4000;
+
+    //
+
+
+    scene = new Scene();
+
+    window.scene = scene;
+
+    // LIGHTS
+
+    const ambient = new AmbientLight(0xffffff, 0.2);
+    scene.add(ambient);
+
+    pointLight = new PointLight(0x6666ff, 0.5);
+    pointLight.position.y = 1000;
+    scene.add(pointLight);
+
+    // light representation
+
+    const sphere = new SphereGeometry(100, 16, 8);
+
+    const mesh = new Mesh(sphere, new MeshBasicMaterial({ color: 0xffffff }));
+    mesh.scale.set(0.5, 0.5, 0.5);
+    pointLight.add(mesh);
+
+    // add directional light
+    directionalLight = new DirectionalLight(0xFFAAAA, 0.8);
+    directionalLight.position.set(-500, 1000, 300);
+    directionalLight.castShadow = true;
+    const shadow_camera = directionalLight.shadow.camera;
+    // small bias to prevent shadow acne
+    directionalLight.shadow.bias = -0.0001;
+    // directionalLight.shadow.mapSize.set(4096, 4096);
+    directionalLight.shadow.mapSize.set(1024, 1024);
+    directionalLight.shadow.autoUpdate = true;
+
+    window.light = directionalLight;
+    // directionalLight.shadow.autoUpdate = true;
+
+    shadow_camera.near = 0.1;
+    shadow_camera.far = 2000;
+
+    const shadow_camera_size = 15;
+
+    shadow_camera.left = -shadow_camera_size / 2;
+    shadow_camera.right = shadow_camera_size / 2;
+
+    shadow_camera.bottom = -shadow_camera_size / 2;
+    shadow_camera.top = shadow_camera_size / 2;
+
+    shadow_camera.updateProjectionMatrix();
+
+
+    scene.add(directionalLight);
+    // material samples
+
+    const cubeMaterial1 = new MeshStandardMaterial({
+        wireframe: false,
+        side: FrontSide,
+        color: 0xffffff
+    });
+
+    //
+
+    renderer = new WebGLRenderer({
+        antialias: true,
+        preserveDrawingBuffer: true,
+        stencil: false
+    });
+
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = VSMShadowMap;
+    // renderer.shadowMap.type = BasicShadowMap;
+    renderer.sortObjects = false;
+
+    renderer.setPixelRatio(window.devicePixelRatio);
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    container.appendChild(renderer.domElement);
+
+    stats = new Stats();
+    container.appendChild(stats.dom);
+
+
+    window.addEventListener("resize", onWindowResize);
+
+// envmap
+    const genCubeUrls = function (prefix, postfix) {
+
+        return [
+            prefix + "posx" + postfix, prefix + "negx" + postfix,
+            prefix + "posy" + postfix, prefix + "negy" + postfix,
+            prefix + "posz" + postfix, prefix + "negz" + postfix
+        ];
+
+    };
+
+    const urls = genCubeUrls("data/textures/cubemaps/hip_miramar/32/", ".png");
+
+    new CubeTextureLoader().load(urls, function (cubeTexture) {
+
+        cubeTexture.encoding = sRGBEncoding;
+
+        // scene.background = new Color(0.1, 0.1, 0.1);
+        // scene.background = new ThreeColor(1, 0.3, 0.3);
+        // scene.background = new Color(0.3, 1, 0.3);
+
+        scene.background = background;
+        scene.environment = cubeTexture;
+
+
+        // const lightProbe = new LightProbe();
+        //
+        // lightProbe.copy(LightProbeGenerator.fromCubeTexture(cubeTexture));
+        // lightProbe.intensity = 1.2;
+
+        // scene.add(lightProbe);
+    });
+
+    onWindowResize();
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     * @param {string|number} [color]
+     * @param {boolean} wireframe
+     * @returns {Group}
+     */
+    function build_preview_object({
+                                      geometry,
+                                      color = 0xFFFFFF,
+                                      wireframe = true
+                                  }) {
+
+        const source = new Group();
+
+        const source_solid = new Mesh(geometry, new MeshStandardMaterial({ color: color }));
+        source.add(source_solid);
+
+        if (wireframe) {
+            const c = new Color();
+            c.parse(color);
+
+            const hsv = c.getHSV();
+            hsv.v = clamp(hsv.v - 0.3, 0.2, 0.8);
+            hsv.s = clamp(hsv.s - 0.2, 0, 1);
+            hsv.h = (hsv.h + 0.333) % 1;
+
+            c.setHSV(hsv.h, hsv.s, hsv.v);
+
+            const source_wire = new Mesh(geometry, new MeshStandardMaterial({
+                color: c.toUint(),
+                wireframe: true,
+                depthTest: true,
+                polygonOffset: true,
+                polygonOffsetFactor: 1
+            }));
+            source.add(source_wire);
+        }
+
+
+        return source;
+    }
+
+
+    /**
+     *
+     * @param {number} steps
+     * @param {THREE.BufferGeometry} geo
+     * @param {Vector3} offset
+     * @param {Vector3} spacing
+     * @param {boolean} label_vertices
+     * @param {boolean} label_steps
+     */
+    function breakdown_simplification({
+                                          steps,
+                                          geo,
+                                          offset,
+                                          spacing,
+                                          label_vertices = true,
+                                          label_steps = true
+                                      }) {
+
+        const topology = new TopoMesh();
+        const faces_array = geo.getIndex().array;
+        topology.build(geo.getAttribute('position').array, faces_array);
+
+        for (let i = 0; i < steps; i++) {
+            if (i === 11) debugger;
+            simplifyTopoMesh2(topology, 1);
+
+            const simplified_bg = topoMeshToBufferGeometry(topology);
+            simplified_bg.computeVertexNormals();
+
+            const proxy = build_preview_object({ geometry: simplified_bg, color: 'rgb(255,90,90)' });
+
+            if (label_steps) {
+                const label_step = makeTextLabelMesh({ text: i, scale: 500 });
+
+                label_step.position.y += 700;
+
+                proxy.add(label_step);
+            }
+
+            if (label_vertices) {
+                topology.vertices.forEach(v => {
+                    const l = makeTextLabelMesh({ text: v.index, scale: 70 });
+
+                    l.position.set(v.x, v.y, v.z + 0.1);
+
+                    proxy.add(l);
+                });
+            }
+
+            proxy.position.x = offset.x + spacing.x * i;
+            proxy.position.y = offset.y + spacing.y * i;
+            proxy.position.z = offset.z + spacing.z * i;
+
+            scene.add(proxy);
+        }
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} input_geometry
+     * @param {number} [percent]
+     * @returns {Group}
+     */
+    function simplify_percent(input_geometry, percent = 0.5) {
+
+       const geo = mergeVertices(input_geometry);
+
+        const mesh = new TopoMesh();
+        const faces_array = geo.getIndex().array;
+        const position_attribute = geo.getAttribute('position');
+        const position_array = position_attribute.array;
+
+        console.time('topo build');
+        mesh.build(position_array, faces_array);
+        console.timeEnd('topo build');
+
+        console.log(`source topo: ${mesh}`);
+
+        const initial_face_count = mesh.getFaces().size;
+
+        const numFacesToRemove = Math.floor(initial_face_count * (1 - percent));
+        // const numFacesToRemove = Math.floor(faces_array.length / 3) - 12;
+
+        const mesh_bounds = new AABB3();
+        computeTopoMeshBoundiningBox(mesh_bounds, mesh)
+
+
+        // const weld_removed_vertex_count = weld_duplicate_vertices(mesh, mesh_bounds);
+        // console.warn(`Vertices removed via weld: ${weld_removed_vertex_count} (=${Math.round(weld_removed_vertex_count * 10000 / position_attribute.count) / 100}%)`);
+
+        console.time('simplification');
+        // console.profile('simplification');
+
+
+        // expandConnectivityByLocality(mesh, mesh_bounds);
+        simplifyTopoMesh2(mesh, numFacesToRemove);
+        // console.profileEnd('simplification');
+        console.timeEnd('simplification');
+
+        console.time('topo -> buffer geo');
+        const simplified_bg = topoMeshToBufferGeometry(mesh);
+        console.timeEnd('topo -> buffer geo');
+
+        simplified_bg.computeVertexNormals();
+
+        const proxy = build_preview_object({ geometry: simplified_bg, color: 0xFF0000, wireframe: true });
+
+
+        console.log(`Simplified to ${mesh.getFaces().size} (=${Math.floor(mesh.getFaces().size * 10000 / initial_face_count) / 100})%`)
+
+        return proxy;
+    }
+
+    function process_geo(geometry, percent = 0.05) {
+        const source_geometry = deinterleaveBufferGeometry(geometry);
+        source_geometry.computeVertexNormals();
+
+        source_geometry.computeBoundingBox();
+
+        //
+        const scale = new Vector3();
+        scaleGeometryToBox(source_geometry, new Vector3(700, 700, 700), scale);
+
+        const source = build_preview_object({ geometry: source_geometry, color: 0xFFFFFF, wireframe: true });
+        source.scale.copy(scale);
+
+        const SPACING = 1000;
+
+        // breakdown_simplification({
+        //     steps: 20,
+        //     geo: source_geometry,
+        //     offset: new Vector3(-SPACING * 0.5, 0, 0),
+        //     spacing: new Vector3(-SPACING, 0, 0),
+        //     label_vertices: true
+        // });
+        //
+        const proxy = simplify_percent(source_geometry, percent);
+        proxy.scale.copy(scale);
+        scene.add(proxy);
+        proxy.position.x -= SPACING * 0.5;
+
+        source.position.x += SPACING * 0.5;
+
+        scene.add(source);
+    }
+
+    function make_lucy() {
+        load_ply("data/models/stanford/Lucy100k.ply");
+    }
+
+    function make_bunny() {
+        load_ply("data/models/stanford/bun_zipper.ply");
+    }
+
+    function make_car() {
+        load_ply("data/models/stanford/big_porsche.ply");
+    }
+
+    function make_dragon_1m() {
+        load_ply("data/models/stanford/dragon_recon/dragon_vrip.ply");
+    }
+
+    function load_ply(url) {
+
+        new PLYLoader().load(url, async geometry => {
+            process_geo(geometry);
+        });
+    }
+
+    function make_square() {
+        process_geo(new PlaneBufferGeometry(700, 700, 40, 40));
+    }
+
+    function make_sphere() {
+        process_geo(new SphereBufferGeometry(350, 20, 20), 0.5);
+    }
+
+    // make_square();
+    // make_sphere();
+    // make_lucy();
+    // make_car();
+    // make_dragon_1m();
+    // make_bunny();
+    load_ply("moicon/isiflow_Oct_15_21/0/floor_01.ply");
+}
+
+
+function onWindowResize() {
+
+    const w = window.innerWidth;
+    const h = window.innerHeight;
+
+    windowHalfX = w / 2;
+    windowHalfY = h / 2;
+
+    camera.aspect = w / h;
+    camera.updateProjectionMatrix();
+
+    renderer.setSize(w, h);
+
+    background.repeat.set(w / 20, h / 20);
+}
+
+function animate() {
+    requestAnimationFrame(animate);
+
+    render();
+    stats.update();
+}
+
+function render() {
+    if (orbitControls !== undefined) {
+        orbitControls.update();
+    }
+
+    const timer = -0.0002 * Date.now();
+
+    pointLight.position.x = 10000 * Math.cos(timer);
+    pointLight.position.z = 10000 * Math.sin(timer);
+
+    renderer.render(scene, camera);
+}
+
+
+init();
+const orbitControls = new OrbitControls(camera, container);
+animate();
+

package/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -2,7 +2,14 @@ import { v3_dot } from "../../../../v3_dot.js";
 import { fabsf } from "../../../../../math/fabsf.js";
 import { EPSILON } from "../../../../../math/MathUtils.js";
 import { vec3 } from "gl-matrix";
+import { compute_triangle_normal } from "../../struct/TopoTriangle.js";
 
+const scratch_v3 = new Float32Array(3);
+
+/**
+ * Quadric Error Metric
+ * Triangular 4x4 matrix, see https://en.wikipedia.org/wiki/Triangular_matrix
+ */
 export class Quadratic3 {
     constructor() {
         // Row 0
@@ -120,15 +127,16 @@ export class Quadratic3 {
      * @param {TopoTriangle} face
      */
     setFromFace(face) {
+        const v0 = face.vertices[0];
+
         // compute triangle's plane
-        const face_normal = face.normal;
+        compute_triangle_normal(scratch_v3, v0, face.vertices[1], face.vertices[2]);
 
         // compute plane offset
-        const v0 = face.vertices[0];
 
-        const normal_x = face_normal[0];
-        const normal_y = face_normal[1];
-        const normal_z = face_normal[2];
+        const normal_x = scratch_v3[0];
+        const normal_y = scratch_v3[1];
+        const normal_z = scratch_v3[2];
 
         const plane_constant = -v3_dot(
             normal_x, normal_y, normal_z,
@@ -207,6 +215,30 @@ export class Quadratic3 {
         this.d2 += Q.d2;
     }
 
+    /**
+     *
+     * @param {number} v
+     */
+    multiplyScalar(v) {
+        // R0
+        this.a2 *= v;
+        this.ab *= v;
+        this.ac *= v;
+        this.ad *= v;
+
+        // R1
+        this.b2 *= v;
+        this.bc *= v;
+        this.bd *= v;
+
+        // R2
+        this.c2 *= v;
+        this.cd *= v;
+
+        // R3
+        this.d2 *= v;
+    }
+
     /**
      *
      * @returns {Quadratic3}

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

@@ -1,4 +1,9 @@
 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 { query_edge_is_boundary } from "../../query/query_edge_is_boundary.js";
 
 /**
  *
@@ -21,12 +26,78 @@ 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
+ */
+function apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics) {
+    const v0 = edge.v0;
+    const v1 = edge.v1;
+
+    const edge_vector = [];
+    vec3.sub(edge_vector, v0, v1);
+
+    // Edge must have exactly 1 triangle attached
+    const edge_faces = edge.faces;
+
+    assert.equal(edge_faces.length, 1, 'must have exactly 1 face');
+
+    const tri = edge_faces[0];
+
+    const normal = [];
+    tm_face_normal(normal, tri);
+
+    const abc = [];
+
+    vec3.cross(abc, edge_vector, normal);
+    vec3.normalize(abc, abc);
+
+    const d = -vec3.dot(abc, v0);
+
+    const constraint = new Quadratic3();
+    constraint.setFromVector4(abc[0], abc[1], abc[2], d);
+    constraint.multiplyScalar(vec3.length(edge_vector) * weight);
+    // constraint.multiplyScalar(weight);
+
+    // apply constraint
+    const v0_quadratic = vertex_quadratics.get(v0.index);
+    const v1_quadratic = vertex_quadratics.get(v1.index);
+
+    v0_quadratic.add(constraint);
+    v1_quadratic.add(constraint);
+}
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoEdge[]} border_set
+ * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {number} [weight]
+ */
+export function apply_border_penalties_to_vertex_quadrics(mesh, border_set, vertex_quadratics, weight = 10) {
+    const edge_count = border_set.length;
+    for (let i = 0; i < edge_count; i++) {
+        const edge = border_set[i];
+        apply_border_penalty_to_vertex_quadrics(edge, weight, vertex_quadratics);
+    }
+}
+
 /**
  *
  * @param {TopoMesh} mesh
  * @param {Map<number, Quadratic3>} quadratics VertexID -> Quadratic map
+ * @param {boolean} [use_triangle_area]
+ * @param {boolean} [use_border_constraints]
  */
-export function build_vertex_quadratics(mesh, quadratics) {
+export function build_vertex_quadratics({
+                                            mesh,
+                                            quadratics,
+                                            use_triangle_area = false,
+                                            use_border_constraints = true
+                                        }) {
     // initialize vertex quadratics
     const mesh_vertices = mesh.vertices;
     const mesh_vertex_count = mesh_vertices.length;
@@ -51,6 +122,12 @@ export function build_vertex_quadratics(mesh, quadratics) {
 
         q.setFromFace(face);
 
+        if (use_triangle_area) {
+            const triangle_area = tm_face_area(face);
+
+            q.multiplyScalar(triangle_area);
+        }
+
         const face_vertices = face.vertices;
         const face_vertex_count = face_vertices.length;
 
@@ -63,4 +140,12 @@ export function build_vertex_quadratics(mesh, quadratics) {
             face_vertex_quadratic.add(q);
         }
     }
+
+    if (use_border_constraints) {
+        for (let edge of mesh.getEdges()) {
+            if (query_edge_is_boundary(edge)) {
+                apply_border_penalty_to_vertex_quadrics(edge, 10, quadratics);
+            }
+        }
+    }
 }

package/core/geom/3d/topology/simplify/simplifyTopoMesh.js

@@ -1,11 +1,11 @@
-import FastBinaryHeap from "../../../../../engine/navigation/grid/FastBinaryHeap.js";
+import FastBinaryHeap from "../../../../collection/heap/FastBinaryHeap.js";
 import { array_copy_unique } from "../../../../collection/array/array_copy_unique.js";
 import { EdgeCollapseCandidate } from "./EdgeCollapseCandidate.js";
 import { build_vertex_quadratics } from "./quadratic/build_vertex_quadratics.js";
 import { collapse_degenerate_edge } from "./collapse_degenerate_edge.js";
 import { collapse_all_degenerate_edges } from "./collapse_all_degenerate_edges.js";
 import { build_edge_collapse_candidates } from "./build_edge_collapse_candidates.js";
-import { update_topo_face_normals } from "../update_topo_face_normals.js";
+
 
 const scratch_array_1 = [];
 const scratch_array_2 = [];
@@ -212,7 +212,7 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
 
     if (num_faces_to_remove <= 0 || face_count <= 0) {
         // we're already at the target
-        return ;
+        return;
     }
 
 
@@ -234,7 +234,7 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
      */
     const vertex_quadratics = new Map();
 
-    build_vertex_quadratics(mesh, vertex_quadratics);
+    build_vertex_quadratics({ mesh: mesh, quadratics: vertex_quadratics });
 
     // compute collapse cost of each vertex/edge pair
     build_edge_collapse_candidates(