diff --git a/main.py b/main.py
index 8192797..fe6c129 100644
--- a/main.py
+++ b/main.py
@@ -15,8 +15,9 @@ from networks.geometry.Point3D import Point3D
 
 
 def main():
-    Road([Point3D(3903, 137, -142), Point3D(3948, 111, -148),
-         Point3D(3967, 112, -116), Point3D(4011, 112, -99)], 25)
+    y = 50
+    Road([Point3D(3903, 137+y, -142), Point3D(3948, 111+y, -148),
+         Point3D(3967, 112+y, -116), Point3D(4011, 112+y, -99)], 25)
     # rectangle_house_mountain, rectangle_building, skeleton_highway, skeleton_mountain, road_grid = world_maker()
 
     # editor = Editor(buffering=True)
diff --git a/networks/geometry/Point3D.py b/networks/geometry/Point3D.py
index dcbca41..b71bc9f 100644
--- a/networks/geometry/Point3D.py
+++ b/networks/geometry/Point3D.py
@@ -22,7 +22,7 @@ class Point3D:
         if isinstance(other, Point3D):
             return self.x == other.x and self.y == other.y and self.z == other.z
 
-    def nearest(self, points: List["Point3D"]) -> "Point3D":
+    def nearest(self, points: List["Point3D"], return_index=False) -> "Point3D":
         """Return the nearest point. If multiple nearest point, returns the first in the list.
 
         Args:
@@ -34,6 +34,9 @@ class Point3D:
         >>> Point3D(0, 0, 0).nearest((Point3D(-10, 10, 5), Point3D(10, 10, 1)))
         Point3D(x: 10, y: 10, z: 1)
         """
+        if return_index:
+            return min(
+                enumerate(points), key=lambda pair: self.distance(pair[1]))
         return min(points, key=lambda point: self.distance(point))
 
     def optimized_path(self, points: List["Point3D"]) -> List["Point3D"]:
diff --git a/networks/roads_2/Road.py b/networks/roads_2/Road.py
index 12fecdf..851468e 100644
--- a/networks/roads_2/Road.py
+++ b/networks/roads_2/Road.py
@@ -59,6 +59,8 @@ class Road:
         # Segments
         for i in range(1, len(self.polyline.segments)):
             if len(self.polyline.segments[i].segment()) > 2:
+                self.polyline.segments[i].segment_thick(
+                    self.width, LINE_THICKNESS_MODE.MIDDLE)
                 for k in range(len(self.polyline.segments[i].points_thick_by_line)):
                     kk = k % 7
                     match kk:
@@ -89,8 +91,8 @@ class Road:
                         self.output_block.append(
                             (Point3D.insert_3d([self.polyline.segments[i].gaps[k][m]], 'y', [self.polyline_total_line_output[nearest[0]].y])[0].coordinates, Block("black_concrete")))
 
+        # Circle
         for i in range(1, len(self.polyline.centers)-1):
-            # Circle
             circle, gaps = Circle(self.polyline.centers[i]).circle_thick_by_line(int(
                 (self.polyline.radii[i]-self.width/2))+1, int((self.polyline.radii[i]+self.width/2))+1)
 
@@ -111,31 +113,26 @@ class Road:
                     if gaps[j][k].is_in_triangle(double_point_a, self.polyline.centers[i], double_point_b):
                         circle_list[j].append(gaps[j][k])
 
+            middle_lane_index = round(len(circle_list)/2)
+            middle_line_length = len(circle_list[middle_lane_index])
+            circle_list[middle_lane_index] = circle_list[middle_lane_index][0].optimized_path(
+                circle_list[middle_lane_index])
+            for k in range(len(circle_list[middle_lane_index])):
+                nearest = circle_list[middle_lane_index][k].nearest(
+                    Point3D.to_2d(self.polyline_total_line_output, removed_axis='y'), True)
+                circle_list[middle_lane_index][k] = Point3D.insert_3d([circle_list[middle_lane_index][k]], 'y', [
+                    self.polyline_total_line_output[nearest[0]].y])[0]
+
             for j in range(len(circle_list)):
                 circle_list[j] = circle_list[j][0].optimized_path(
                     circle_list[j])
-                jj = j % 7
-                match jj:
-                    case 0:
-                        blob = 'pink_concrete'
-                    case 1:
-                        blob = 'red_concrete'
-                    case 2:
-                        blob = 'orange_concrete'
-                    case 3:
-                        blob = 'yellow_concrete'
-                    case 4:
-                        blob = 'green_concrete'
-                    case 5:
-                        blob = 'blue_concrete'
-                    case 6:
-                        blob = 'purple_concrete'
+                factor = (middle_line_length)/(len(circle_list[j]))
                 for k in range(len(circle_list[j])):
-                    nearest = circle_list[j][k].nearest(
-                        Point3D.to_2d(self.polyline_total_line_output, removed_axis='y'), True)
+                    print(round(factor * k), factor, k,
+                          len(circle_list[middle_lane_index]))
                     self.output_block.append(
                         (Point3D.insert_3d([circle_list[j][k]], 'y', [
-                            self.polyline_total_line_output[nearest[0]].y])[0].coordinates, Block(blob)))
+                            circle_list[middle_lane_index][int(factor * k)].y])[0].coordinates, Block("stone")))
 
     def _projection_gaussian(self):
         nearest_points_to_reference = []