@vib3code/sdk 2.0.1

package/src/geometry/generators/KleinBottle.js

@@ -0,0 +1,197 @@
+/**
+ * Klein Bottle Generator
+ *
+ * The Klein bottle is a non-orientable surface that cannot exist
+ * in 3D without self-intersection, but can be properly embedded in 4D.
+ *
+ * In 4D, it's a closed surface with no boundary and no inside/outside.
+ */
+
+import { Vec4 } from '../../math/Vec4.js';
+
+/**
+ * Generate Klein Bottle vertices using 4D embedding
+ * The "figure-8" immersion extended to 4D to remove self-intersection
+ *
+ * @param {number} radius - Overall scale
+ * @param {number} uSegments - Segments around length
+ * @param {number} vSegments - Segments around circumference
+ * @returns {Vec4[]} Array of vertices
+ */
+export function generateKleinBottleVertices(radius = 1, uSegments = 32, vSegments = 16) {
+    const vertices = [];
+    const r = radius;
+
+    for (let i = 0; i <= uSegments; i++) {
+        const u = (i / uSegments) * Math.PI * 2;
+        const cosU = Math.cos(u);
+        const sinU = Math.sin(u);
+        const cos2U = Math.cos(2 * u);
+        const sin2U = Math.sin(2 * u);
+
+        for (let j = 0; j <= vSegments; j++) {
+            const v = (j / vSegments) * Math.PI * 2;
+            const cosV = Math.cos(v);
+            const sinV = Math.sin(v);
+
+            // Klein bottle parametric equations in 4D
+            // This is the "figure-8" Klein bottle lifted to 4D
+            const x = r * (cosU * (cosU * cosV + 1) - sinU * sin2U * cosV / 2);
+            const y = r * (sinU * (cosU * cosV + 1) + cosU * sin2U * cosV / 2);
+            const z = r * sinV * (1 + cos2U / 2);
+            const w = r * sinV * sin2U / 2;
+
+            vertices.push(new Vec4(x, y, z, w));
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate Klein Bottle using "bottle" parameterization
+ * @param {number} scale - Overall scale
+ * @param {number} segments - Resolution
+ * @returns {Vec4[]} Vertices
+ */
+export function generateKleinBottleBottle(scale = 1, segments = 24) {
+    const vertices = [];
+    const a = scale * 2;
+    const b = scale;
+
+    for (let i = 0; i <= segments; i++) {
+        const u = (i / segments) * Math.PI * 2;
+
+        for (let j = 0; j <= segments; j++) {
+            const v = (j / segments) * Math.PI * 2;
+
+            let x, y, z, w;
+
+            if (u < Math.PI) {
+                // First half: bottle body
+                x = (a + b * Math.cos(u)) * Math.cos(v);
+                y = (a + b * Math.cos(u)) * Math.sin(v);
+                z = b * Math.sin(u);
+                w = b * Math.sin(u) * Math.sin(v / 2);
+            } else {
+                // Second half: handle that passes through
+                const uShift = u - Math.PI;
+                x = a * Math.cos(v) + b * Math.cos(uShift) * Math.cos(v);
+                y = a * Math.sin(v) + b * Math.cos(uShift) * Math.sin(v);
+                z = -b * Math.sin(uShift);
+                w = -b * Math.sin(uShift) * Math.cos(v / 2);
+            }
+
+            vertices.push(new Vec4(x, y, z, w));
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate Klein Bottle edges
+ * @param {number} uSegments
+ * @param {number} vSegments
+ * @returns {number[][]} Edge pairs
+ */
+export function generateKleinBottleEdges(uSegments = 32, vSegments = 16) {
+    const edges = [];
+
+    for (let i = 0; i < uSegments; i++) {
+        for (let j = 0; j < vSegments; j++) {
+            const idx = i * (vSegments + 1) + j;
+            const nextU = (i + 1) * (vSegments + 1) + j;
+            const nextV = i * (vSegments + 1) + j + 1;
+
+            edges.push([idx, nextU]);
+            edges.push([idx, nextV]);
+        }
+    }
+
+    // Close the surface by connecting last to first
+    // Note: Klein bottle has twisted identification
+    for (let j = 0; j < vSegments; j++) {
+        const lastU = uSegments * (vSegments + 1) + j;
+        // Connect to reversed v on first u
+        const firstU = (vSegments - j);
+        edges.push([lastU, firstU]);
+    }
+
+    return edges;
+}
+
+/**
+ * Generate Möbius strip (related to Klein bottle)
+ * A Möbius strip is a one-sided surface that can be embedded in 4D
+ * @param {number} radius - Major radius
+ * @param {number} width - Strip width
+ * @param {number} segments - Resolution
+ * @returns {object} Geometry
+ */
+export function generateMobiusStrip(radius = 1, width = 0.3, segments = 32) {
+    const vertices = [];
+    const edges = [];
+
+    for (let i = 0; i <= segments; i++) {
+        const u = (i / segments) * Math.PI * 2;
+        const halfU = u / 2;
+
+        for (let j = 0; j <= 4; j++) {
+            const v = (j / 4) * 2 - 1; // -1 to 1
+
+            const x = (radius + width * v * Math.cos(halfU)) * Math.cos(u);
+            const y = (radius + width * v * Math.cos(halfU)) * Math.sin(u);
+            const z = width * v * Math.sin(halfU);
+            const w = width * v * Math.sin(halfU) * 0.5; // Lift to 4D
+
+            vertices.push(new Vec4(x, y, z, w));
+        }
+    }
+
+    // Generate grid edges
+    for (let i = 0; i < segments; i++) {
+        for (let j = 0; j < 4; j++) {
+            const idx = i * 5 + j;
+            edges.push([idx, idx + 1]);      // Along width
+            edges.push([idx, idx + 5]);      // Along length
+        }
+        edges.push([i * 5 + 4, (i + 1) * 5 + 4]); // Last row
+    }
+
+    return {
+        name: 'mobius_strip',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0
+    };
+}
+
+/**
+ * Generate complete Klein Bottle geometry
+ * @param {number} scale - Overall scale
+ * @param {number} density - Vertex density
+ * @returns {object} Geometry
+ */
+export function generateKleinBottle(scale = 1, density = 24) {
+    const uSeg = density;
+    const vSeg = Math.floor(density / 2);
+    const vertices = generateKleinBottleVertices(scale, uSeg, vSeg);
+    const edges = generateKleinBottleEdges(uSeg, vSeg);
+
+    return {
+        name: 'klein_bottle',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0,
+        nonOrientable: true
+    };
+}
+
+export default generateKleinBottle;

package/src/geometry/generators/Sphere.js

@@ -0,0 +1,192 @@
+/**
+ * 4D Hypersphere Generator
+ *
+ * Generates points on a 4D hypersphere using various sampling methods.
+ * The 3-sphere (hypersphere) is the set of points equidistant from origin in 4D.
+ */
+
+import { Vec4 } from '../../math/Vec4.js';
+
+/**
+ * Generate hypersphere vertices using spherical coordinates
+ * Uses 3 angles (θ, φ, ψ) to parameterize the 3-sphere
+ *
+ * @param {number} radius - Sphere radius
+ * @param {number} segments - Points per dimension
+ * @returns {Vec4[]} Array of vertices on hypersphere
+ */
+export function generateHypersphereVertices(radius = 1, segments = 8) {
+    const vertices = [];
+
+    for (let i = 0; i <= segments; i++) {
+        const theta = (i / segments) * Math.PI;
+        const sinTheta = Math.sin(theta);
+        const cosTheta = Math.cos(theta);
+
+        for (let j = 0; j <= segments; j++) {
+            const phi = (j / segments) * Math.PI;
+            const sinPhi = Math.sin(phi);
+            const cosPhi = Math.cos(phi);
+
+            for (let k = 0; k <= segments * 2; k++) {
+                const psi = (k / (segments * 2)) * Math.PI * 2;
+                const sinPsi = Math.sin(psi);
+                const cosPsi = Math.cos(psi);
+
+                // Hyperspherical coordinates
+                const x = radius * sinTheta * sinPhi * cosPsi;
+                const y = radius * sinTheta * sinPhi * sinPsi;
+                const z = radius * sinTheta * cosPhi;
+                const w = radius * cosTheta;
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate hypersphere using Fibonacci lattice (more uniform distribution)
+ * @param {number} radius - Sphere radius
+ * @param {number} count - Number of points
+ * @returns {Vec4[]} Array of uniformly distributed vertices
+ */
+export function generateHypersphereFibonacci(radius = 1, count = 200) {
+    const vertices = [];
+    const phi = (1 + Math.sqrt(5)) / 2; // Golden ratio
+
+    for (let i = 0; i < count; i++) {
+        // Use 4D Fibonacci-like sequence
+        const t1 = i / phi;
+        const t2 = i / (phi * phi);
+        const t3 = i / (phi * phi * phi);
+
+        // Convert to angles
+        const theta = Math.acos(1 - 2 * (i + 0.5) / count);
+        const phi1 = 2 * Math.PI * (t1 % 1);
+        const phi2 = 2 * Math.PI * (t2 % 1);
+
+        // Map to 4D sphere
+        const sinTheta = Math.sin(theta);
+        const cosTheta = Math.cos(theta);
+        const sinPhi1 = Math.sin(phi1);
+        const cosPhi1 = Math.cos(phi1);
+        const sinPhi2 = Math.sin(phi2);
+        const cosPhi2 = Math.cos(phi2);
+
+        const x = radius * sinTheta * cosPhi1;
+        const y = radius * sinTheta * sinPhi1 * cosPhi2;
+        const z = radius * sinTheta * sinPhi1 * sinPhi2;
+        const w = radius * cosTheta;
+
+        vertices.push(new Vec4(x, y, z, w));
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate hypersphere edges connecting nearby vertices
+ * @param {Vec4[]} vertices - Vertices to connect
+ * @param {number} threshold - Distance threshold for connection
+ * @returns {number[][]} Edge pairs
+ */
+export function generateHypersphereEdges(vertices, threshold = 0.5) {
+    const edges = [];
+
+    for (let i = 0; i < vertices.length; i++) {
+        for (let j = i + 1; j < vertices.length; j++) {
+            const dist = vertices[i].distanceTo(vertices[j]);
+            if (dist < threshold) {
+                edges.push([i, j]);
+            }
+        }
+    }
+
+    return edges;
+}
+
+/**
+ * Generate latitude circles on hypersphere
+ * @param {number} radius - Sphere radius
+ * @param {number} latitudes - Number of latitude circles
+ * @param {number} pointsPerCircle - Points per circle
+ * @returns {object} Geometry with latitude circles
+ */
+export function generateHypersphereLatitudes(radius = 1, latitudes = 8, pointsPerCircle = 16) {
+    const vertices = [];
+    const edges = [];
+
+    // Generate latitude circles at different W values
+    for (let lat = 0; lat <= latitudes; lat++) {
+        const w = radius * Math.cos((lat / latitudes) * Math.PI);
+        const circleRadius = Math.sqrt(radius * radius - w * w);
+
+        if (circleRadius < 0.001) {
+            // Just a point at poles
+            vertices.push(new Vec4(0, 0, 0, w));
+            continue;
+        }
+
+        const startIdx = vertices.length;
+
+        // Generate circle at this latitude
+        for (let i = 0; i < pointsPerCircle; i++) {
+            const angle1 = (i / pointsPerCircle) * Math.PI * 2;
+
+            // Inner loop for the 3D circle at this W slice
+            for (let j = 0; j < pointsPerCircle / 2; j++) {
+                const angle2 = (j / (pointsPerCircle / 2)) * Math.PI * 2;
+
+                const x = circleRadius * Math.cos(angle1) * Math.cos(angle2);
+                const y = circleRadius * Math.cos(angle1) * Math.sin(angle2);
+                const z = circleRadius * Math.sin(angle1);
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+
+        // Connect points in this latitude
+        const endIdx = vertices.length;
+        for (let i = startIdx; i < endIdx - 1; i++) {
+            edges.push([i, i + 1]);
+        }
+        if (endIdx > startIdx + 1) {
+            edges.push([endIdx - 1, startIdx]);
+        }
+    }
+
+    return {
+        name: 'hypersphere_latitudes',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length
+    };
+}
+
+/**
+ * Generate complete hypersphere geometry
+ * @param {number} radius - Sphere radius
+ * @param {number} density - Vertex density
+ * @returns {object} Geometry object
+ */
+export function generateSphere(radius = 1, density = 8) {
+    const vertices = generateHypersphereFibonacci(radius, density * density * 4);
+    const edges = generateHypersphereEdges(vertices, radius * 0.4);
+
+    return {
+        name: 'hypersphere',
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0
+    };
+}
+
+export default generateSphere;

package/src/geometry/generators/Tesseract.js

@@ -0,0 +1,160 @@
+/**
+ * Tesseract (Hypercube) Generator
+ *
+ * The tesseract is the 4D analog of a cube.
+ * - 16 vertices (2^4)
+ * - 32 edges
+ * - 24 square faces
+ * - 8 cubic cells
+ *
+ * Vertices are at all combinations of (±1, ±1, ±1, ±1)
+ */
+
+import { Vec4 } from '../../math/Vec4.js';
+
+/**
+ * Generate tesseract vertices
+ * @param {number} size - Half-edge length (default 1)
+ * @returns {Vec4[]} Array of 16 vertices
+ */
+export function generateTesseractVertices(size = 1) {
+    const vertices = [];
+
+    // Generate all 16 vertices at (±size, ±size, ±size, ±size)
+    for (let i = 0; i < 16; i++) {
+        const x = (i & 1) ? size : -size;
+        const y = (i & 2) ? size : -size;
+        const z = (i & 4) ? size : -size;
+        const w = (i & 8) ? size : -size;
+        vertices.push(new Vec4(x, y, z, w));
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate tesseract edges
+ * Two vertices are connected if they differ in exactly one coordinate
+ * @returns {number[][]} Array of [i, j] index pairs
+ */
+export function generateTesseractEdges() {
+    const edges = [];
+
+    for (let i = 0; i < 16; i++) {
+        for (let j = i + 1; j < 16; j++) {
+            // Count differing bits (Hamming distance)
+            const diff = i ^ j;
+            // If exactly one bit differs, they're connected
+            if (diff && !(diff & (diff - 1))) {
+                edges.push([i, j]);
+            }
+        }
+    }
+
+    return edges;
+}
+
+/**
+ * Generate tesseract faces (squares)
+ * Each face is defined by fixing 2 coordinates and varying 2
+ * @returns {number[][]} Array of [a, b, c, d] vertex indices (counterclockwise)
+ */
+export function generateTesseractFaces() {
+    const faces = [];
+
+    // For each pair of dimensions, and each combination of fixed values
+    for (let dim1 = 0; dim1 < 4; dim1++) {
+        for (let dim2 = dim1 + 1; dim2 < 4; dim2++) {
+            // Fixed dimensions
+            const fixedDims = [];
+            for (let d = 0; d < 4; d++) {
+                if (d !== dim1 && d !== dim2) fixedDims.push(d);
+            }
+
+            // For each combination of fixed dimension values
+            for (let fixed0 = 0; fixed0 < 2; fixed0++) {
+                for (let fixed1 = 0; fixed1 < 2; fixed1++) {
+                    // Build the 4 vertices of this face
+                    const faceVertices = [];
+                    for (let v1 = 0; v1 < 2; v1++) {
+                        for (let v2 = 0; v2 < 2; v2++) {
+                            let idx = 0;
+                            // Set varying dimensions
+                            if (v1) idx |= (1 << dim1);
+                            if (v2) idx |= (1 << dim2);
+                            // Set fixed dimensions
+                            if (fixed0) idx |= (1 << fixedDims[0]);
+                            if (fixed1) idx |= (1 << fixedDims[1]);
+                            faceVertices.push(idx);
+                        }
+                    }
+                    // Reorder for counterclockwise winding
+                    faces.push([faceVertices[0], faceVertices[1], faceVertices[3], faceVertices[2]]);
+                }
+            }
+        }
+    }
+
+    return faces;
+}
+
+/**
+ * Generate complete tesseract geometry
+ * @param {number} size - Half-edge length
+ * @returns {object} { vertices, edges, faces, cells }
+ */
+export function generateTesseract(size = 1) {
+    return {
+        name: 'tesseract',
+        vertices: generateTesseractVertices(size),
+        edges: generateTesseractEdges(),
+        faces: generateTesseractFaces(),
+        cells: 8,
+        vertexCount: 16,
+        edgeCount: 32,
+        faceCount: 24
+    };
+}
+
+/**
+ * Generate tesseract with subdivided edges for smoother rendering
+ * @param {number} size - Half-edge length
+ * @param {number} subdivisions - Points per edge (default 1 = no subdivision)
+ * @returns {object} Geometry with subdivided edges
+ */
+export function generateTesseractSubdivided(size = 1, subdivisions = 1) {
+    const baseGeom = generateTesseract(size);
+    const vertices = [...baseGeom.vertices];
+    const edges = [];
+
+    if (subdivisions <= 1) {
+        return baseGeom;
+    }
+
+    // For each edge, add intermediate points
+    for (const [i, j] of baseGeom.edges) {
+        const v1 = baseGeom.vertices[i];
+        const v2 = baseGeom.vertices[j];
+
+        let prevIdx = i;
+        for (let s = 1; s < subdivisions; s++) {
+            const t = s / subdivisions;
+            const intermediate = v1.lerp(v2, t);
+            const newIdx = vertices.length;
+            vertices.push(intermediate);
+            edges.push([prevIdx, newIdx]);
+            prevIdx = newIdx;
+        }
+        edges.push([prevIdx, j]);
+    }
+
+    return {
+        ...baseGeom,
+        vertices,
+        edges,
+        vertexCount: vertices.length,
+        edgeCount: edges.length
+    };
+}
+
+export default generateTesseract;