@vib3code/sdk 2.0.1

package/src/geometry/generators/Tetrahedron.js

@@ -0,0 +1,225 @@
+/**
+ * 4D Tetrahedron (5-cell / Pentatope) Generator
+ *
+ * The 5-cell is the 4D analog of a tetrahedron.
+ * - 5 vertices
+ * - 10 edges
+ * - 10 triangular faces
+ * - 5 tetrahedral cells
+ *
+ * Also generates simpler 4D-embedded 3D tetrahedron variants.
+ */
+
+import { Vec4 } from '../../math/Vec4.js';
+
+/**
+ * Generate 5-cell (pentatope) vertices
+ * Regular 5-cell inscribed in unit 4-sphere
+ * All vertices equidistant from each other (edge length = size * sqrt(2))
+ * @param {number} size - Scale factor (default 1)
+ * @returns {Vec4[]} Array of 5 vertices
+ */
+export function generatePentatopeVertices(size = 1) {
+    // Standard regular 5-cell coordinates
+    // These form a regular 4-simplex with all edges equal length
+    // Vertices are on the 3-sphere of radius size
+
+    const s = size;
+    const sqrt5 = Math.sqrt(5);
+    const sqrt10 = Math.sqrt(10);
+
+    // Coordinates that give equal distances between all vertex pairs
+    // Based on the 4-simplex inscribed in unit sphere
+    return [
+        new Vec4(s, s, s, -s / sqrt5),
+        new Vec4(s, -s, -s, -s / sqrt5),
+        new Vec4(-s, s, -s, -s / sqrt5),
+        new Vec4(-s, -s, s, -s / sqrt5),
+        new Vec4(0, 0, 0, s * sqrt5 - s / sqrt5)
+    ].map(v => {
+        // Normalize to put all on sphere of radius 'size'
+        const len = v.length();
+        return new Vec4(v.x * size / len, v.y * size / len, v.z * size / len, v.w * size / len);
+    });
+}
+
+/**
+ * Generate simple 4D tetrahedron (3D tetrahedron embedded in 4D at w=0)
+ * @param {number} size - Scale factor
+ * @returns {Vec4[]} Array of 4 vertices
+ */
+export function generateTetrahedronVertices(size = 1) {
+    // Regular tetrahedron centered at origin, embedded at w=0
+    const a = size / Math.sqrt(2);
+
+    return [
+        new Vec4(a, a, a, 0),
+        new Vec4(a, -a, -a, 0),
+        new Vec4(-a, a, -a, 0),
+        new Vec4(-a, -a, a, 0)
+    ];
+}
+
+/**
+ * Generate 5-cell edges
+ * All pairs of vertices are connected in a 5-cell
+ * @returns {number[][]} Array of [i, j] index pairs
+ */
+export function generatePentatopeEdges() {
+    const edges = [];
+    for (let i = 0; i < 5; i++) {
+        for (let j = i + 1; j < 5; j++) {
+            edges.push([i, j]);
+        }
+    }
+    return edges;
+}
+
+/**
+ * Generate tetrahedron edges
+ * @returns {number[][]} Array of [i, j] index pairs
+ */
+export function generateTetrahedronEdges() {
+    return [
+        [0, 1], [0, 2], [0, 3],
+        [1, 2], [1, 3], [2, 3]
+    ];
+}
+
+/**
+ * Generate 5-cell faces (triangles)
+ * @returns {number[][]} Array of [a, b, c] vertex indices
+ */
+export function generatePentatopeFaces() {
+    const faces = [];
+    for (let i = 0; i < 5; i++) {
+        for (let j = i + 1; j < 5; j++) {
+            for (let k = j + 1; k < 5; k++) {
+                faces.push([i, j, k]);
+            }
+        }
+    }
+    return faces;
+}
+
+/**
+ * Generate tetrahedron faces
+ * @returns {number[][]} Array of [a, b, c] vertex indices
+ */
+export function generateTetrahedronFaces() {
+    return [
+        [0, 1, 2],
+        [0, 1, 3],
+        [0, 2, 3],
+        [1, 2, 3]
+    ];
+}
+
+/**
+ * Generate complete 5-cell geometry
+ * @param {number} size - Scale factor
+ * @returns {object} Geometry object
+ */
+export function generatePentatope(size = 1) {
+    return {
+        name: 'pentatope',
+        vertices: generatePentatopeVertices(size),
+        edges: generatePentatopeEdges(),
+        faces: generatePentatopeFaces(),
+        cells: 5,
+        vertexCount: 5,
+        edgeCount: 10,
+        faceCount: 10
+    };
+}
+
+/**
+ * Generate complete tetrahedron geometry (4D embedded)
+ * @param {number} size - Scale factor
+ * @returns {object} Geometry object
+ */
+export function generateTetrahedron(size = 1) {
+    return {
+        name: 'tetrahedron',
+        vertices: generateTetrahedronVertices(size),
+        edges: generateTetrahedronEdges(),
+        faces: generateTetrahedronFaces(),
+        cells: 1,
+        vertexCount: 4,
+        edgeCount: 6,
+        faceCount: 4
+    };
+}
+
+/**
+ * Generate tetrahedron lattice in 4D
+ * Creates a grid of tetrahedra along W axis
+ * @param {number} size - Individual tetrahedron size
+ * @param {number} count - Number of layers along W
+ * @param {number} wSpacing - Spacing between layers
+ * @returns {object} Combined geometry
+ */
+export function generateTetrahedronLattice(size = 0.5, count = 4, wSpacing = 0.8) {
+    const vertices = [];
+    const edges = [];
+
+    for (let layer = 0; layer < count; layer++) {
+        const baseVerts = generateTetrahedronVertices(size);
+        const wOffset = (layer - (count - 1) / 2) * wSpacing;
+        const vertexOffset = vertices.length;
+
+        // Add vertices with W offset
+        for (const v of baseVerts) {
+            vertices.push(new Vec4(v.x, v.y, v.z, wOffset));
+        }
+
+        // Add intra-layer edges
+        for (const [i, j] of generateTetrahedronEdges()) {
+            edges.push([vertexOffset + i, vertexOffset + j]);
+        }
+
+        // Connect to previous layer
+        if (layer > 0) {
+            const prevOffset = vertexOffset - 4;
+            for (let i = 0; i < 4; i++) {
+                edges.push([prevOffset + i, vertexOffset + i]);
+            }
+        }
+    }
+
+    return {
+        name: 'tetrahedron_lattice',
+        vertices,
+        edges,
+        faces: [],
+        cells: count,
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0
+    };
+}
+
+// 5-cell aliases and exports (5-cell is the common name for pentatope)
+export const generate5CellVertices = generatePentatopeVertices;
+export const generate5CellEdges = generatePentatopeEdges;
+export const generate5CellFaces = generatePentatopeFaces;
+
+/**
+ * Generate complete 5-cell geometry (alias with correct name)
+ * @param {number} size - Scale factor
+ * @returns {object} Geometry object
+ */
+export function generate5Cell(size = 1) {
+    return {
+        name: '5cell',
+        vertices: generatePentatopeVertices(size),
+        edges: generatePentatopeEdges(),
+        faces: generatePentatopeFaces(),
+        cells: 5,
+        vertexCount: 5,
+        edgeCount: 10,
+        faceCount: 10
+    };
+}
+
+export default generateTetrahedron;

package/src/geometry/generators/Torus.js

@@ -0,0 +1,304 @@
+/**
+ * 4D Torus Generators
+ *
+ * In 4D, there are several types of tori:
+ * - Clifford Torus: flat torus embedded in 3-sphere
+ * - Duocylinder: product of two circles S¹ × S¹
+ * - 3-Torus: S¹ × S¹ × S¹
+ */
+
+import { Vec4 } from '../../math/Vec4.js';
+
+/**
+ * Generate Clifford Torus vertices
+ * The Clifford torus is a flat torus embedded in the 3-sphere.
+ * Parameterized by two angles: x = cos(θ), y = sin(θ), z = cos(φ), w = sin(φ)
+ *
+ * @param {number} radius - Overall radius
+ * @param {number} segments - Points per angle dimension
+ * @returns {Vec4[]} Array of vertices
+ */
+export function generateCliffordTorusVertices(radius = 1, segments = 16) {
+    const vertices = [];
+    const scale = radius / Math.sqrt(2);
+
+    for (let i = 0; i < segments; i++) {
+        const theta = (i / segments) * Math.PI * 2;
+        const cosTheta = Math.cos(theta);
+        const sinTheta = Math.sin(theta);
+
+        for (let j = 0; j < segments; j++) {
+            const phi = (j / segments) * Math.PI * 2;
+            const cosPhi = Math.cos(phi);
+            const sinPhi = Math.sin(phi);
+
+            vertices.push(new Vec4(
+                scale * cosTheta,
+                scale * sinTheta,
+                scale * cosPhi,
+                scale * sinPhi
+            ));
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate Clifford Torus edges
+ * @param {number} segments - Points per dimension
+ * @returns {number[][]} Edge pairs
+ */
+export function generateCliffordTorusEdges(segments = 16) {
+    const edges = [];
+
+    for (let i = 0; i < segments; i++) {
+        for (let j = 0; j < segments; j++) {
+            const idx = i * segments + j;
+            const nextI = ((i + 1) % segments) * segments + j;
+            const nextJ = i * segments + ((j + 1) % segments);
+
+            edges.push([idx, nextI]);
+            edges.push([idx, nextJ]);
+        }
+    }
+
+    return edges;
+}
+
+/**
+ * Generate standard 3D torus embedded in 4D
+ * @param {number} majorRadius - Distance from center to tube center
+ * @param {number} minorRadius - Tube radius
+ * @param {number} majorSegments - Segments around major circle
+ * @param {number} minorSegments - Segments around minor circle
+ * @param {number} wOffset - W coordinate (default 0)
+ * @returns {Vec4[]} Vertices
+ */
+export function generateTorusVertices(majorRadius = 1, minorRadius = 0.4, majorSegments = 16, minorSegments = 8, wOffset = 0) {
+    const vertices = [];
+
+    for (let i = 0; i < majorSegments; i++) {
+        const theta = (i / majorSegments) * Math.PI * 2;
+        const cosTheta = Math.cos(theta);
+        const sinTheta = Math.sin(theta);
+
+        for (let j = 0; j < minorSegments; j++) {
+            const phi = (j / minorSegments) * Math.PI * 2;
+            const cosPhi = Math.cos(phi);
+            const sinPhi = Math.sin(phi);
+
+            const x = (majorRadius + minorRadius * cosPhi) * cosTheta;
+            const y = (majorRadius + minorRadius * cosPhi) * sinTheta;
+            const z = minorRadius * sinPhi;
+
+            vertices.push(new Vec4(x, y, z, wOffset));
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate torus edges
+ * @param {number} majorSegments
+ * @param {number} minorSegments
+ * @returns {number[][]} Edge pairs
+ */
+export function generateTorusEdges(majorSegments = 16, minorSegments = 8) {
+    const edges = [];
+
+    for (let i = 0; i < majorSegments; i++) {
+        for (let j = 0; j < minorSegments; j++) {
+            const idx = i * minorSegments + j;
+            const nextI = ((i + 1) % majorSegments) * minorSegments + j;
+            const nextJ = i * minorSegments + ((j + 1) % minorSegments);
+
+            edges.push([idx, nextI]);
+            edges.push([idx, nextJ]);
+        }
+    }
+
+    return edges;
+}
+
+/**
+ * Generate 4D torus extending in W dimension
+ * Creates a torus that also loops in W
+ * @param {number} radius - Base radius
+ * @param {number} segments - Segments per dimension
+ * @returns {object} Geometry
+ */
+export function generateTorus4D(radius = 1, segments = 12) {
+    const vertices = [];
+    const edges = [];
+
+    const r1 = radius;
+    const r2 = radius * 0.4;
+    const r3 = radius * 0.2;
+
+    for (let i = 0; i < segments; i++) {
+        const theta = (i / segments) * Math.PI * 2;
+        const ct = Math.cos(theta);
+        const st = Math.sin(theta);
+
+        for (let j = 0; j < segments; j++) {
+            const phi = (j / segments) * Math.PI * 2;
+            const cp = Math.cos(phi);
+            const sp = Math.sin(phi);
+
+            for (let k = 0; k < segments / 2; k++) {
+                const psi = (k / (segments / 2)) * Math.PI * 2;
+                const cps = Math.cos(psi);
+                const sps = Math.sin(psi);
+
+                const x = (r1 + r2 * cp + r3 * cps) * ct;
+                const y = (r1 + r2 * cp + r3 * cps) * st;
+                const z = r2 * sp;
+                const w = r3 * sps;
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+    }
+
+    // Generate edges connecting neighbors
+    const halfSeg = segments / 2;
+    for (let i = 0; i < segments; i++) {
+        for (let j = 0; j < segments; j++) {
+            for (let k = 0; k < halfSeg; k++) {
+                const idx = i * segments * halfSeg + j * halfSeg + k;
+                const nextI = ((i + 1) % segments) * segments * halfSeg + j * halfSeg + k;
+                const nextJ = i * segments * halfSeg + ((j + 1) % segments) * halfSeg + k;
+                const nextK = i * segments * halfSeg + j * halfSeg + ((k + 1) % halfSeg);
+
+                edges.push([idx, nextI]);
+                edges.push([idx, nextJ]);
+                edges.push([idx, nextK]);
+            }
+        }
+    }
+
+    return {
+        name: 'torus4d',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0
+    };
+}
+
+/**
+ * Generate complete torus geometry (Clifford Torus)
+ * @param {number} radius - Radius
+ * @param {number} density - Vertex density
+ * @returns {object} Geometry
+ */
+export function generateTorus(radius = 1, density = 16) {
+    const vertices = generateCliffordTorusVertices(radius, density);
+    const edges = generateCliffordTorusEdges(density);
+
+    return {
+        name: 'clifford_torus',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0
+    };
+}
+
+/**
+ * Generate Clifford Torus (alias with common parameter signature)
+ * @param {number} radius - Overall radius
+ * @param {number} tubeRadius - Tube thickness (used for scaling)
+ * @param {number} segments - Points per angle dimension
+ * @returns {object} Geometry object
+ */
+export function generateCliffordTorus(radius = 1, tubeRadius = 0.3, segments = 16) {
+    const vertices = generateCliffordTorusVertices(radius, segments);
+    const edges = generateCliffordTorusEdges(segments);
+
+    return {
+        name: 'clifford_torus',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0,
+        radius,
+        tubeRadius
+    };
+}
+
+/**
+ * Generate 4D torus with 3 radii
+ * @param {number} r1 - Primary radius
+ * @param {number} r2 - Secondary radius
+ * @param {number} r3 - Tertiary radius (W dimension)
+ * @param {number} segments - Points per dimension
+ * @returns {object} Geometry object
+ */
+export function generate4DTorus(r1 = 1, r2 = 0.3, r3 = 0.1, segments = 12) {
+    const vertices = [];
+    const edges = [];
+
+    const halfSeg = Math.max(2, Math.floor(segments / 2));
+
+    for (let i = 0; i < segments; i++) {
+        const theta = (i / segments) * Math.PI * 2;
+        const ct = Math.cos(theta);
+        const st = Math.sin(theta);
+
+        for (let j = 0; j < segments; j++) {
+            const phi = (j / segments) * Math.PI * 2;
+            const cp = Math.cos(phi);
+            const sp = Math.sin(phi);
+
+            for (let k = 0; k < halfSeg; k++) {
+                const psi = (k / halfSeg) * Math.PI * 2;
+                const cps = Math.cos(psi);
+                const sps = Math.sin(psi);
+
+                const x = (r1 + r2 * cp + r3 * cps) * ct;
+                const y = (r1 + r2 * cp + r3 * cps) * st;
+                const z = r2 * sp;
+                const w = r3 * sps;
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+    }
+
+    // Generate edges connecting neighbors
+    for (let i = 0; i < segments; i++) {
+        for (let j = 0; j < segments; j++) {
+            for (let k = 0; k < halfSeg; k++) {
+                const idx = i * segments * halfSeg + j * halfSeg + k;
+                const nextI = ((i + 1) % segments) * segments * halfSeg + j * halfSeg + k;
+                const nextJ = i * segments * halfSeg + ((j + 1) % segments) * halfSeg + k;
+                const nextK = i * segments * halfSeg + j * halfSeg + ((k + 1) % halfSeg);
+
+                edges.push([idx, nextI]);
+                edges.push([idx, nextJ]);
+                edges.push([idx, nextK]);
+            }
+        }
+    }
+
+    return {
+        name: '4d_torus',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0
+    };
+}
+
+export default generateTorus;