From 705b610d68a845df5fc994b7ebd7dff776285287 Mon Sep 17 00:00:00 2001
From: gdamms <damguillotin@gmail.com>
Date: Mon, 30 Jan 2023 10:23:34 +0100
Subject: [PATCH] des dessins + geoly

---
 src/fvi.py | 65 +++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 54 insertions(+), 11 deletions(-)

diff --git a/src/fvi.py b/src/fvi.py
index 8ff1d6d..4b7cf87 100644
--- a/src/fvi.py
+++ b/src/fvi.py
@@ -94,19 +94,42 @@ def fast_voxel_intersect(start_, end_, origin_, step_, shape_) -> tuple[list, li
 
 if __name__ == "__main__":
     import matplotlib.pyplot as plt
+    from perlin_noise import PerlinNoise
 
     def update_figure():
         positions, voxels, voxels_idx = fast_voxel_intersect(start, end, origin, step, shape)
 
         plt.clf()
 
+        # Plot black background based on levelset
+        for i in range(shape[0]):
+            for j in range(shape[1]):
+                if V[i, j] > 0.5:
+                    continue
+                plt.fill(
+                    [
+                        origin[0] + i * step[0],
+                        origin[0] + (i + 1) * step[0],
+                        origin[0] + (i + 1) * step[0],
+                        origin[0] + i * step[0],
+                    ],
+                    [
+                        origin[1] + j * step[1],
+                        origin[1] + j * step[1],
+                        origin[1] + (j + 1) * step[1],
+                        origin[1] + (j + 1) * step[1],
+                    ],
+                    color="#000",
+                    alpha=0.8,
+                )
+
         # Plot hitted voxels
         for voxel in voxels:
             plt.fill(
                 [voxel[0], voxel[0] + step[0], voxel[0] + step[0], voxel[0]],
                 [voxel[1], voxel[1], voxel[1] + step[1], voxel[1] + step[1]],
                 color="#e25",
-                alpha=0.5,
+                alpha=0.3,
             )
 
         for voxel_id in voxels_idx:
@@ -124,7 +147,7 @@ if __name__ == "__main__":
                     origin[1] + (voxel_id[1] + 1) * step[1],
                 ],
                 color="#2e3",
-                alpha=0.5,
+                alpha=0.3,
             )
 
         # Plot line segment
@@ -133,37 +156,57 @@ if __name__ == "__main__":
         # Plot intersection points
         for pos in positions:
             plt.plot(pos[0], pos[1], 'bo')
-        
+
         # Plot start and end points
         plt.plot(start[0], start[1], 'go')
         plt.plot(end[0], end[1], 'ro')
 
         # Plot voxel grid
-        plt.axis("equal")
         plt.xlim((-10, 10))
         plt.ylim((-10, 10))
         plt.xticks(origin[0] + step[0] * np.arange(shape[0] + 1))
         plt.yticks(origin[1] + step[1] * np.arange(shape[1] + 1))
         plt.grid()
+        ax = plt.gca()
+        ax.set_aspect('equal', adjustable='box')
         plt.draw()
 
     def onkey(event):
         global start, end
         if event.key == " ":
-            start = np.random.rand(2) * 20 - 10
-            end = np.random.rand(2) * 20 - 10
+            start = random_start()
+            end = random_end()
             update_figure()
+        elif event.key == "enter":
+            plt.savefig("fvi.png", dpi=300, bbox_inches="tight", pad_inches=0, transparent=True)
+
+    def random_start():
+        x = (np.random.randint(0, shape[0]) + 0.5) * step[0] + origin[0]
+        y = (np.random.randint(0, shape[1]) + 0.5) * step[1] + origin[1]
+        return (x, y)
+
+    def random_end():
+        teta = np.random.rand() * 2 * np.pi
+        x = np.cos(teta) * 10
+        y = np.sin(teta) * 10
+        return (x, y)
+
 
     # Define voxel grid
     origin = np.array([-5., -5.])
-    step = np.array([1.4, 1.4])
+    step = np.array([1.0, 1.0])
     shape = (10, 10)
 
+    # Define levelset
+    noise = PerlinNoise(octaves=6, seed=1)
+    X, Y = np.mgrid[:shape[0], :shape[1]]
+    V = [[2 * noise([x/shape[0], y/shape[1]]) + np.sqrt((x-shape[0]/2)**2 + (y-shape[1]/2)**2) for y in range(shape[1])] for x in range(shape[0])]
+    V = np.array(V)
+    V = (V - V.min()) / (V.max() - V.min())
+
     # Define segment
-    # start = np.random.rand(2) * 20 - 10
-    # end = np.random.rand(2) * 20 - 10
-    start = np.array([2.5, -3.5])
-    end = np.array([7.0, 3.0])
+    start = random_start()
+    end = random_end()
 
     # Plot
     fig = plt.figure()