Geometry

import * as tf from "@polydera/trueform";

// UV sphere
const sphere = tf.sphereMesh(1.0, 20, 20);  // radius, stacks, segments

// Cylinder along z-axis
const cyl = tf.cylinderMesh(1.0, 2.0, 20);  // radius, height, segments

// Axis-aligned box
const box = tf.boxMesh(2, 1, 3);

// Subdivided box for deformation/simulation
const boxSub = tf.boxMesh(2, 1, 3, 4, 2, 6);  // + widthTicks, heightTicks, depthTicks

// Flat plane in XY
const plane = tf.planeMesh(10, 5);

// Subdivided plane
const planeSub = tf.planeMesh(10, 5, 20, 10);  // + widthTicks, heightTicks

// Double-precision mesh — pass { dtype: "float64" } as a trailing option
const sphere64 = tf.sphereMesh(1.0, 20, 20, { dtype: "float64" });

// From intersection curves
const curves = tf.intersectionCurves(mesh0, mesh1);
const tubes = tf.tubeMesh(curves, 0.01, 12);  // curves, radius, radialSegments

// From boundary paths
const boundary = tf.boundaryPaths(mesh);
const tubes = tf.tubeMesh(boundary, 0.005);

const edges = tf.sharpEdges(mesh, 30);  // 30°, returns NDArrayInt32 [N, 2]

const box = tf.boxMesh(2, 3, 4);
const a = tf.area(box);  // 52.0

const box = tf.boxMesh(2, 3, 4);
tf.volume(box);        // 24.0
tf.signedVolume(box);  // 24.0

tf.meanEdgeLength(mesh);
tf.minEdgeLength(mesh);
tf.maxEdgeLength(mesh);

const { quality, minAngle, maxAngle, aspectRatio } = tf.faceQuality(mesh);

const { edges, angles } = tf.dihedralAngles(mesh);
// edges  : NDArrayInt32 [N, 2] — vertex index pairs, one per undirected edge
// angles : NDArrayFloat32 | NDArrayFloat64 [N] — radians, aligned with edges

const mesh = tf.mesh(faces, points);

// Face normals — one unit normal per face
const n = mesh.normals;       // NDArrayFloat32 [F, 3]

// Vertex normals — area-weighted average of adjacent face normals
const pn = mesh.pointNormals; // NDArrayFloat32 [V, 3]

const normals = await tf.async.computeNormals(mesh);
const pointNormals = await tf.async.computePointNormals(mesh);

// Curvature values only
const { k0, k1 } = tf.principalCurvatures(mesh);
// k0: NDArrayFloat32 [V] — maximum principal curvature
// k1: NDArrayFloat32 [V] — minimum principal curvature

// With principal directions
const { k0, k1, d0, d1 } = tf.principalDirections(mesh);
// d0: NDArrayFloat32 [V, 3] — direction of max curvature
// d1: NDArrayFloat32 [V, 3] — direction of min curvature

// Custom k-ring size (default k=2)
const curv = tf.principalCurvatures(mesh, 3);

// Derived measures
const gaussian = k0.mul(k1);         // Gaussian curvature
const mean = k0.add(k1).mul(0.5);    // Mean curvature

const si = tf.shapeIndex(mesh);       // NDArrayFloat32 [V]
const si3 = tf.shapeIndex(mesh, 3);   // custom k-ring

// Orient mesh to have outward-facing normals
const oriented = tf.positivelyOriented(mesh);

// Skip consistency step if mesh is already consistently oriented
const oriented2 = tf.positivelyOriented(mesh, true);

// Triangulate a polygon
const poly = tf.polygon(new Float32Array([
  0,0,0, 1,0,0, 1,1,0, 0.5,1.5,0, 0,1,0
]));
const triMesh = tf.triangulate(poly);

// Triangulate a quad mesh
const quadMesh = { faces: quadFaces, points: pts };
const triMesh2 = tf.triangulate(quadMesh);

// Triangulate a dynamic (variable n-gon) mesh
const dynMesh = { faces: offsetBlockedFaces, points: pts };
const triMesh3 = tf.triangulate(dynMesh);

// Pass a Mesh directly — returned as-is if already triangulated
const same = tf.triangulate(existingTriMesh);

// 100 iterations, lambda=0.5 (default)
const smoothed = tf.laplacianSmoothed(mesh, 100);

// Custom lambda
const smoothed2 = tf.laplacianSmoothed(mesh, 100, 0.3);

// 50 iterations
const smoothed = tf.taubinSmoothed(mesh, 50);

// Custom parameters
const smoothed2 = tf.taubinSmoothed(mesh, 50, 0.5, 0.1);

// Typical pipeline: OBB → ICP
const T_coarse = tf.fitObbAlignment(source, target);
source.transformation = T_coarse;

const T_fine = tf.fitIcpAlignment(source, target, { maxIterations: 50 });

// Compose for total transformation
// T_fine is a delta from source's current world position

const T = tf.fitRigidAlignment(source, target);  // NDArrayFloat32 [4, 4]

const T = tf.fitObbAlignment(source, target);

// Custom sample size for orientation disambiguation
const T2 = tf.fitObbAlignment(source, target, { sampleSize: 200 });

source.transformation = T_init;

const T = tf.fitIcpAlignment(source, target, {
  maxIterations: 50,
  nSamples: 1000,
});

const error = tf.chamferError(source, target);

// With outlier rejection
const error2 = tf.chamferError(source, target, { outlierProportion: 0.05 });

// Symmetric chamfer distance
const sym = (tf.chamferError(a, b) + tf.chamferError(b, a)) / 2;

const a = await tf.async.area(mesh);
const { k0, k1 } = await tf.async.principalCurvatures(mesh);
const T = await tf.async.fitIcpAlignment(source, target, { maxIterations: 50 });
const tubes = await tf.async.tubeMesh(curves, 0.01);