Reversed splines, show tags in spline names

.pylintrc

@@ -25,4 +25,5 @@ disable=raw-checker-failed,
         too-many-statements,
         attribute-defined-outside-init,
         unused-argument,
-        consider-using-from-import
+        consider-using-from-import,
+        line-too-long

README.md

@@ -615,6 +615,7 @@ You can also apply some advanced settings to the map generation process.<br>
 ### Splines Advanced settings
 
 - Splines density - number of points, which will be added (interpolate) between each pair of existing points. The higher the value, the denser the spline will be. It can smooth the splines, but high values can in opposite make the splines look unnatural.
+- Add reversed splines - if enabled, the tool will add the reversed copies of the splines. It can be useful if you want to have the splines on both directions. By default, it's set to False.
 
 ### Satellite Advanced settings
 

maps4fs/generator/component/i3d.py

@@ -149,13 +149,13 @@ def _add_splines(self) -> None:
             return
 
         node_id = SPLINES_NODE_ID_STARTING_VALUE
-        for road_id, road in enumerate(roads_polylines, start=1):
-            # Add to scene node
-            # <Shape name="spline01_CSV" translation="0 0 0" nodeId="11" shapeId="11"/>
+        for road_id, road_info in enumerate(roads_polylines, start=1):
+            points = road_info.get("points")
+            tags = road_info.get("tags")
 
             try:
                 fitted_road = self.fit_object_into_bounds(
-                    linestring_points=road, angle=self.rotation
+                    linestring_points=points, angle=self.rotation
                 )
             except ValueError as e:
                 self.logger.debug(
@@ -168,52 +168,58 @@ def _add_splines(self) -> None:
             fitted_road = self.interpolate_points(
                 fitted_road, num_points=self.map.spline_settings.spline_density
             )
+            fitted_roads = [(fitted_road, "original")]
 
-            spline_name = f"spline{road_id}"
+            if self.map.spline_settings.add_reversed_splines:
+                reversed_fitted_road = fitted_road[::-1]
+                fitted_roads.append((reversed_fitted_road, "reversed"))
 
-            data = {
-                "name": spline_name,
-                "translation": "0 0 0",
-                "nodeId": str(node_id),
-                "shapeId": str(node_id),
-            }
+            for fitted_road, direction in fitted_roads:
+                spline_name = f"spline_{road_id}_{direction}_{tags}"
 
-            scene_node.append(self.create_element("Shape", data))
+                data = {
+                    "name": spline_name,
+                    "translation": "0 0 0",
+                    "nodeId": str(node_id),
+                    "shapeId": str(node_id),
+                }
 
-            road_ccs = [self.top_left_coordinates_to_center(point) for point in fitted_road]
+                scene_node.append(self.create_element("Shape", data))
 
-            data = {
-                "name": spline_name,
-                "shapeId": str(node_id),
-                "degree": "3",
-                "form": "open",
-            }
-            nurbs_curve_node = self.create_element("NurbsCurve", data)
+                road_ccs = [self.top_left_coordinates_to_center(point) for point in fitted_road]
 
-            for point_ccs, point in zip(road_ccs, fitted_road):
-                cx, cy = point_ccs
-                x, y = point
+                data = {
+                    "name": spline_name,
+                    "shapeId": str(node_id),
+                    "degree": "3",
+                    "form": "open",
+                }
+                nurbs_curve_node = self.create_element("NurbsCurve", data)
 
-                x = max(0, min(int(x), dem_x_size - 1))
-                y = max(0, min(int(y), dem_y_size - 1))
+                for point_ccs, point in zip(road_ccs, fitted_road):
+                    cx, cy = point_ccs
+                    x, y = point
 
-                z = not_resized_dem[y, x]
-                z *= self.get_z_scaling_factor()
+                    x = max(0, min(int(x), dem_x_size - 1))
+                    y = max(0, min(int(y), dem_y_size - 1))
 
-                nurbs_curve_node.append(self.create_element("cv", {"c": f"{cx}, {z}, {cy}"}))
+                    z = not_resized_dem[y, x]
+                    z *= self.get_z_scaling_factor()
 
-            shapes_node.append(nurbs_curve_node)
+                    nurbs_curve_node.append(self.create_element("cv", {"c": f"{cx}, {z}, {cy}"}))
 
-            user_attribute_node = self.get_user_attribute_node(
-                node_id,
-                attributes=[
-                    ("maxSpeedScale", "integer", "1"),
-                    ("speedLimit", "integer", "100"),
-                ],
-            )
+                shapes_node.append(nurbs_curve_node)
 
-            user_attributes_node.append(user_attribute_node)
-            node_id += 1
+                user_attribute_node = self.get_user_attribute_node(
+                    node_id,
+                    attributes=[
+                        ("maxSpeedScale", "integer", "1"),
+                        ("speedLimit", "integer", "100"),
+                    ],
+                )
+
+                user_attributes_node.append(user_attribute_node)
+                node_id += 1
 
         tree.write(splines_i3d_path)  # type: ignore
         self.logger.debug("Splines I3D file saved to: %s.", splines_i3d_path)

maps4fs/generator/component/texture.py

@@ -402,7 +402,11 @@ def _add_roads(self, layer: Layer, info_layer_data: dict[str, list[list[int]]])
             for linestring in self.objects_generator(
                 layer.tags, layer.width, layer.info_layer, yield_linestrings=True
             ):
-                info_layer_data[f"{layer.info_layer}_polylines"].append(linestring)  # type: ignore
+                linestring_entry = {
+                    "points": linestring,
+                    "tags": str(layer.tags),
+                }
+                info_layer_data[f"{layer.info_layer}_polylines"].append(linestring_entry)  # type: ignore
 
     def dissolve(self) -> None:
         """Dissolves textures of the layers with tags into sublayers for them to look more

maps4fs/generator/settings.py

@@ -212,6 +212,7 @@ class SplineSettings(SettingsModel):
     """
 
     spline_density: int = 2
+    add_reversed_splines: bool = False
 
 
 class SatelliteSettings(SettingsModel):

webui/templates.py

@@ -308,6 +308,10 @@ class Settings:
         "more smooth. Be careful with high values, because it may make your spline too complex.  \n"
         "ℹ️ **Units:** number of additional points between each pair of existing points."
     )
+    ADD_REVERSED_SPLINES = (
+        "If add reversed splines is enabled, the splines will be generated in both directions. "
+        "Otherwise, only one direction will be generated (as in the OSM data)."
+    )
 
     # Satellite Settings