From c419dca58f8e5df8d5913afd5e9aaffc759f965a Mon Sep 17 00:00:00 2001
From: TreetopFlyer <seth111@gmail.com>
Date: Wed, 7 Jul 2021 12:09:52 -0400
Subject: [PATCH] constraints working

---
 index.html | 123 +++++++++++++++++++++++++++++++++++------------------
 scene.js   |   2 +-
 2 files changed, 82 insertions(+), 43 deletions(-)

diff --git a/index.html b/index.html
index 8fdc073..0e8d88d 100644
--- a/index.html
+++ b/index.html
@@ -23,10 +23,9 @@
 <script type="module">
     import { Scene, THREE } from './scene.js';
 
-    let average = (inArray, inCenterInd, ...inPointsInd) =>
+    let average = (inCenter, inArray, ...inPointsInd) =>
     {
         let output = [0, 0, 0];
-        let centerInd = inCenterInd*3;
 
         for(let i=0; i<inPointsInd.length; i++)
         {
@@ -36,67 +35,105 @@
             output[2] += inArray[pointInd+2];
         }
         
-        let scalar = inPointsInd.length;
-        output[0] /= scalar;
-        output[1] /= scalar;
-        output[2] /= scalar;
+        let reducer = inPointsInd.length;
+        output[0] /= reducer;
+        output[1] /= reducer;
+        output[2] /= reducer;
 
-        let limit = (inPoint, inCenter) => 
+        let limit = (inCenter, inPoint) => 
         {
-            let limit = inCenter-0.5;
-            if(inPoint < limit)
-            {
-                return limit;
-            }
+            var limit;
+            
+            limit = inCenter-0.5;
+            if(inPoint < limit){ return limit; }
+
             limit = inCenter+0.5;
-            if(inPoint > limit)
-            {
-                return limit;
-            }
+            if(inPoint > limit){ return limit; }
+
             return inPoint;
         }
-        output[0] = limit(output[0], inArray[centerInd+0]);
-        output[1] = limit(output[1], inArray[centerInd+1]);
-        output[2] = limit(output[2], inArray[centerInd+2]);
+
+        var limited = [];
+        limited[0] = limit(inCenter[0], output[0]);
+        limited[1] = limit(inCenter[1], output[1]);
+        limited[2] = limit(inCenter[2], output[2]);
+
+        //console.log(`<${output[0].toFixed(2)}, ${output[1].toFixed(2)}> limited to <${limited[0].toFixed(2)}, ${limited[1].toFixed(2)}> by <${inCenter[0].toFixed(2)}, ${inCenter[1].toFixed(2)}>`)
+
+        output[0] = limited[0];
+        output[1] = limited[1];
+        output[2] = limited[2];
+
 
         return output;
     };
-    let smooth = (inArray) =>
+    let smooth = (inArray, inTimes) =>
     {
-        let output = [inArray[0], inArray[1], inArray[2] ];
-        for(let i=1; i < (inArray.length/3)-1; i++)
+        let output = [...inArray];
+        let count = output.length/3;
+        for(let t=0; t<inTimes; t++)
         {
-            output.push( ...average(inArray, i, i-1, i, i+1) );
+            for(let i=0; i<count; i++)
+            {
+                var av;
+                var center = [inArray[i*3 + 0], inArray[i*3 + 1], inArray[i*3 + 2]]
+                if(i==0)
+                {
+                    av = average(center, output,  count-1, i, i+1);
+                }
+                else
+                {
+                    if(i==count-1)
+                    {
+                        av = average(center, output, i-1, i, 0);
+                    }
+                    else
+                    {
+                        av = average(center, output, i-1, i, i+1);
+                    }
+                }
+                output[i*3+0] = av[0]; 
+                output[i*3+1] = av[1]; 
+                output[i*3+2] = av[2]; 
+            }
         }
-        output.push(inArray[inArray.length-3], inArray[inArray.length-2], inArray[inArray.length-1]);
         return output;
     }
-    let path = (inPoints, inColor) =>
+    let path = (inPoints, inSmoothing, inColor) =>
     {
         const geometry = new THREE.BufferGeometry();
-        geometry.setAttribute('position', new THREE.Float32BufferAttribute( inPoints, 3 ));
-        const material = new THREE.LineBasicMaterial( { color: inColor, linewidth: 3 } );
-        return new THREE.Line( geometry, material );
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute( smooth(inPoints, inSmoothing), 3 ));
+        const materialLine = new THREE.LineBasicMaterial( { color: inColor, linewidth: 3 } );
+        const materialPoint = new THREE.PointsMaterial( { color:inColor, size: 0.05 } );
+        const output = new THREE.Group();
+        
+        output.add( new THREE.Line( geometry, materialLine ) );
+        output.add( new THREE.Points( geometry, materialPoint ) );
+        return output;
     }
 
     const points =
     [
+         4,  0,  0,
+         3,  0,  0,
+         2,  0,  0,
+         1,  0,  0,
+        //
          0,  0,  0,
          0,  1,  0,
          1,  1,  0,
          2,  1,  0,
-         2,  0,  0,
-         3,  0,  0,
-         4,  0,  0,
-         4,  1,  0
+         2,  2,  0,
+         3,  2,  0,
+         4,  2,  0,
+         4,  3,  0,
+         //
+         5,  3,  0,
+         5,  2,  0,
+         5,  1,  0,
+         5,  0,  0,
     ];
 
-    console.log( smooth(points) );
-
-    let path0 = path(points, 0xFF0000);
-    let path1 = path(smooth(points), 0x009900);
-    let path2 = path(smooth(smooth(points)), 0x00AA00);
-    let path3 = path(smooth(smooth(smooth(points))), 0x00FF00);
 
 
     Scene(
@@ -104,10 +141,12 @@
         DOM:"canvas",
         Init(inScene)
         {
-            inScene.add( path0 );
-            inScene.add( path1 );
-            inScene.add( path2 );
-            inScene.add( path3 );
+            inScene.add(path(points, 0, 0xFF0000));
+            inScene.add(path(points, 1, 0x003300));
+            inScene.add(path(points, 3, 0x005500));
+            inScene.add(path(points, 5, 0x007700));
+            inScene.add(path(points, 7, 0x009900));
+            inScene.add(path(points, 100, 0x00bb00));
         },
         Update(scene, delta)
         {
diff --git a/scene.js b/scene.js
index e6ee68e..157c958 100644
--- a/scene.js
+++ b/scene.js
@@ -43,7 +43,7 @@ export function Scene(inSettings)
     };
     
     scene.add(light);
-    scene.add(new T.GridHelper(10, 10));
+    //scene.add(new T.GridHelper(10, 10));
     light.position.set(-1, 2, 4);
     camera.position.set(0, 0, 2);
     controls.update();