fix: resolve discrete polygon fallacy and poisson source distribution

Author: Tarawally

projects/arithmetica-lucis/prototype/mobius-caustic-solver/src/main.js

@@ -36,7 +36,7 @@ try {
   // 1. Circular Mirror (approximated by segments)
   // Radius 0.9 (Near Boundary), Centered at Origin.
   // This creates a large Concave Mirror relative to the internal source.
-  const CIRCLE_SEGMENTS = 128; // Sufficient for visual smoothness
+  const CIRCLE_SEGMENTS = 720; // Increased to 720 to avoid Discrete Polygon Fallacy
   const CIRCLE_RADIUS = 0.9;
   for (let i = 0; i < CIRCLE_SEGMENTS; i++) {
     const t0 = (i / CIRCLE_SEGMENTS) * 2 * Math.PI;
@@ -60,11 +60,11 @@ try {
   // 1080 Beams for "Retina" resolution and razor-sharp caustics.
   // ROBUSTNESS: Variable Quality Settings
   const QUALITY_SETTINGS = {
-    HIGH: { beams: 30, depth: 20 },
-    MEDIUM: { beams: 15, depth: 15 },
-    LOW: { beams: 5, depth: 10 },
+    HIGH: { beams: 720, depth: 20 },
+    MEDIUM: { beams: 360, depth: 15 },
+    LOW: { beams: 120, depth: 10 },
   };
-  let currentQuality = "LOW"; // Start conservative for instant load
+  let currentQuality = "MEDIUM"; // Start with reasonable quality
   let NUM_BEAMS = QUALITY_SETTINGS[currentQuality].beams;
   let MAX_DEPTH = QUALITY_SETTINGS[currentQuality].depth;
 
@@ -73,64 +73,48 @@ try {
   // --- INTERACTION STATE ---
   let mousePos = INITIAL_SOURCE_POS.clone(); // Correctly initialize to break symmetryeffect
 
+  // Initialize Solver EARLY so we can use its math helpers in updateScene
+  console.log("Main: Creating Solver");
+  const solver = new Solver(scene);
+  solver.maxDepth = MAX_DEPTH; // Sync initial depth
+
   // --- INTERACTION STATE ---
   console.log("Main: Initializing Interaction State");
 
   function updateScene() {
     scene.sources = [];
 
-    // 1. Generate Uniform Fan at Origin
-    const fan = [];
-    for (let i = 0; i < NUM_BEAMS; i++) {
-      const theta1 = (i / NUM_BEAMS) * 2 * Math.PI;
-      const theta2 = ((i + 1) / NUM_BEAMS) * 2 * Math.PI;
-      fan.push({
-        p1: new Complex(Math.cos(theta1), Math.sin(theta1)),
-        p2: new Complex(Math.cos(theta2), Math.sin(theta2)),
-      });
-    }
+    // FIX: POISSON SOURCE DISTRIBUTION
+    // Instead of transforming a uniform fan from origin (which concentrates rays like a comet),
+    // we generate a uniform fan AT the source position in the Hyperbolic Angle metric.
+    // This ensures isotropic emission.
 
-    // 2. Apply Transform
-    const a = mousePos;
-    // Pre-calculate M coefficients?
-    // M(z) = (z + a)/(1 + a_bar * z)
-    // Using Mobius class? "a, b, c, d"
-    // (1*z + a) / (conj(a)*z + 1)
-    // A=1, B=a, C=conj(a), D=1.
-    const A = new Complex(1, 0);
-    const B = a;
-    const C = new Complex(a.re, -a.im); // conj(a)
-    const D = new Complex(1, 0);
-    const M = new Mobius(A, B, C, D);
+    // We use Solver.projectAngleToBoundary(source, angle) to find the endpoints.
 
-    const transformedOrigin = new Complex(0, 0); // Will become 'a'
-    M.apply(transformedOrigin, new Complex(0, 0));
+    const startAngle = 0;
+    const endAngle = 2 * Math.PI;
+    const step = (endAngle - startAngle) / NUM_BEAMS;
 
-    const temp = new Complex();
-
-    for (const beam of fan) {
-      const tP1 = new Complex();
-      M.apply(tP1, beam.p1);
+    for (let i = 0; i < NUM_BEAMS; i++) {
+      const theta1 = startAngle + i * step;
+      const theta2 = startAngle + (i + 1) * step;
 
-      const tP2 = new Complex();
-      M.apply(tP2, beam.p2);
+      // Use the solver's utility to map local angle -> boundary point
+      const p1 = solver.projectAngleToBoundary(mousePos, theta1);
+      const p2 = solver.projectAngleToBoundary(mousePos, theta2);
 
-      // Push to scene with EXPLICIT origin
       scene.sources.push({
-        origin: transformedOrigin,
-        p1: tP1,
-        p2: tP2,
+        origin: mousePos, // The physical source location
+        p1: p1,
+        p2: p2,
       });
     }
   }
 
   // Initial Update
   updateScene();
 
-  // Initialize Solver
-  console.log("Main: Creating Solver");
-  const solver = new Solver(scene);
-  solver.maxDepth = MAX_DEPTH; // Sync initial depth
+  // (Solver already created above)
 
   console.log("Main: Creating Baseline Verification");
   const baseline = new Baseline();
@@ -157,16 +141,16 @@ try {
 
     // --- BASELINE VERIFICATION ---
     if (SHOW_BASELINE) {
-        // Source object in scene has {origin, p1, p2}.
-        if (scene.sources.length > 0) {
-          const s = scene.sources[0].origin;
-          const particles = baseline.generateParticles(s, 1000); // 1000 dots/frame
-          artist.ctx.fillStyle = "rgba(255, 255, 255, 0.5)";
-          for (const p of particles) {
-             const sc = viewport.diskToScreen(p);
-             artist.ctx.fillRect(sc.x, sc.y, 1, 1);
-          }
+      // Source object in scene has {origin, p1, p2}.
+      if (scene.sources.length > 0) {
+        const s = scene.sources[0].origin;
+        const particles = baseline.generateParticles(s, 1000); // 1000 dots/frame
+        artist.ctx.fillStyle = "rgba(255, 255, 255, 0.5)";
+        for (const p of particles) {
+          const sc = viewport.diskToScreen(p);
+          artist.ctx.fillRect(sc.x, sc.y, 1, 1);
         }
+      }
     }
 
     // Trace and draw each beam