RDG-Networks 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

{RDG_Networks-0.2.5.dist-info → RDG_Networks-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RDG-Networks
-Version: 0.2.5
+Version: 0.3.0
 Summary: Most of the code from the RDG Networks project
 Home-page: https://github.com/NiekMooij/RDG_networks
 Author: Niek Mooij

RDG_Networks-0.3.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+RDG_networks/Classes.py,sha256=_9X3JPHFAYYlaC8IZ_H9__sfz99G5l9UfPl65lL60_4,7977
+RDG_networks/__init__.py,sha256=Re-b4Ky4fp0QzUB8R8c4VysUMkHEP1VrfXLeOA8W_2w,922
+RDG_networks/draw_segments.py,sha256=U53N5GXmQHWKdM1Q1faP_EGKjc6enOu2mcsunzSFpP0,984
+RDG_networks/generate_line_network.py,sha256=lJ4rhObim3WcEQoebomewRQKWNJC5phFyFYRW7qjXIg,1127
+RDG_networks/generate_line_segments.py,sha256=QV8_k7q6TD5c7Hcb2Ms_apEdWYw4XdLr7rdJgh49v4Q,9004
+RDG_networks/generate_line_segments_dynamic.py,sha256=GoIhGXYbcvjqR5BJCnkvAGp8QBpzsE1ZSbl2k9XAOGI,7531
+RDG_networks/generate_line_segments_static.py,sha256=7KvHZi3krv-tAGydJR_gbMMmHKZ5azzrKcQe3fuWzCE,9265
+RDG_networks/get_intersection_segments.py,sha256=mXB5qCy1oOps4Vu1mX6flW6v_4Xxc71YK41yOWjJX8o,2797
+RDG_networks/sample_in_polygon.py,sha256=qpPpW-Da1vK8ZkVWMJ0zBsE8IgyMB619gCdybSkzKSQ,1605
+RDG_networks/thickness/Classes.py,sha256=kgWNP5NCc11dTVAfujk30r_MsY2Xf4dAOmoalLRHa5E,8063
+RDG_networks/thickness/__init__.py,sha256=6wL6ViEJvbybgfeKJM9jQJhzdxavdi5nsGtcv94Oh8I,182
+RDG_networks/thickness/functions.py,sha256=cEUd858EZtf7ZUjq-MS1dctlWHPBxQzAY-B2Vko4DzU,11596
+RDG_networks/thickness/generate_line_segments_dynamic_thickness.py,sha256=M8jOad-Jg_J14Y263k9RTNoLd0VblOTKTumqwOlCM_I,25598
+RDG_networks/thickness/sample_in_polygon.py,sha256=nJ-yqfoCCGfC6_EpGL3L1t1LOYdqWZd-7v5bxy6th34,1849
+RDG_Networks-0.3.0.dist-info/LICENSE.txt,sha256=BHUkX2GsdTr30sKmVZ1MLGR1njnx17EX_oUuuSVZZPE,598
+RDG_Networks-0.3.0.dist-info/METADATA,sha256=9-zzX1WxWlxkDIzUGhXiQskWzIUx40WfFTpCo8CmqBU,2422
+RDG_Networks-0.3.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+RDG_Networks-0.3.0.dist-info/entry_points.txt,sha256=6AGpOd8ecHGEsoUhRj0j6VvN_Fg0QNCY8h5rInAJom0,542
+RDG_Networks-0.3.0.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
+RDG_Networks-0.3.0.dist-info/RECORD,,

{RDG_Networks-0.2.5.dist-info → RDG_Networks-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{RDG_Networks-0.2.5.dist-info → RDG_Networks-0.3.0.dist-info}/entry_points.txt

@@ -3,4 +3,6 @@ draw_segments = RDG_networks.draw_segments:main
 generate_line_network = RDG_networks.generate_line_network:main
 generate_line_segments = RDG_networks.generate_line_segments:main
 generate_line_segments_dynamic = RDG_networks.generate_line_segments_dynamic:main
+generate_line_segments_dynamic_thickness = RDG_networks.thickness.generate_line_segments_dynamic_thickness:main
+generate_line_segments_static = RDG_networks.generate_line_segments_static:main
 get_intersection_segments = RDG_networks.get_intersection_segments:main

RDG_networks/__init__.py

@@ -5,12 +5,16 @@ from .generate_line_segments import generate_line_segments
 from .generate_line_network import generate_line_network
 from .get_intersection_segments import get_intersection_segments
 from .generate_line_segments_dynamic import generate_line_segments_dynamic
+from .generate_line_segments_static import generate_line_segments_static
 from .draw_segments import draw_segments
+from .thickness.generate_line_segments_dynamic_thickness import generate_line_segments_thickness
 
 __all__ = ['generate_line_segments', 
            'generate_line_network',
            'get_intersection_segments',
            'generate_line_segments_dynamic',
+           'generate_line_segments_static',
+           'generate_line_segments_thickness',
            'draw_segments', 
            'sample_in_polygon',
            'Line', 

RDG_networks/thickness/Classes.py

@@ -0,0 +1,213 @@
+import copy
+import matplotlib.axes._axes as axes
+from matplotlib.patches import Polygon as polgon
+import numpy as np
+from typing import List, Tuple, Union, Optional
+
+class Line:
+    """
+    Represents a line segment by its location and direction.
+
+    Attributes:
+    - location (Tuple[float, float]): The starting point of the line.
+    - direction (Tuple[float, float]): The direction vector of the line.
+    - id (Optional[Union[str, int]]): Identifier for the line segment.
+    """
+    
+    def __init__(self, location: Tuple[float, float], direction: Tuple[float, float], id: Optional[Union[str, int]] = None, neighbors_initial={}, neighbors={}):
+        self.location = location
+        self.direction = direction
+        self.id = id
+        self.neighbors_initial = neighbors_initial
+        self.neighbors = neighbors
+        
+
+    def draw(self, ax: axes.Axes, color: str = 'black', alpha: float = 1.0, label: bool = False, linewidth=1):
+        """
+        Draw the line segment on a given axes.
+
+        Args:
+        - ax (axes.Axes): Matplotlib axes on which to draw the line segment.
+        - color (str): Color of the line segment (default is 'black').
+        - alpha (float): Alpha (transparency) value (default is 1.0).
+        """
+        
+        x1, y1 = np.array(self.location[0]) - np.array(self.direction) / np.linalg.norm(self.direction) * 100
+        x2, y2 = np.array(self.location[1]) - np.array(self.direction) / np.linalg.norm(self.direction) * 100
+        ax.plot([x1, x2], [y1, y2], color=color, alpha=alpha, linewidth=linewidth)
+        
+        if label:
+            ax.text((x1+x2)/2, (y1+y2)/2, self.id, fontsize=12)
+            
+        ax.set(xlim=(0, 1), ylim=(0, 1))
+
+class LineSegment:
+    """
+    Represents a line segment defined by its start and end points.
+
+    Attributes:
+    - start (Tuple[float, float]): Starting point of the line segment.
+    - end (Tuple[float, float]): Ending point of the line segment.
+    - id (Optional[Union[str, int]]): Identifier for the line segment.
+    """
+    
+    def __init__(self, start: Tuple[float, float], end: Tuple[float, float], id: Optional[Union[str, int]] = None, neighbors_initial={}, neighbors={}):
+        self.start = start
+        self.end = end
+        self.id = id
+        self.neighbors_initial = neighbors_initial
+        self.neighbors = neighbors
+        
+    def length(self) -> float:
+        return np.linalg.norm(np.array(self.start) - np.array(self.end))
+
+    def draw(self, ax: axes.Axes, color: str = 'black', alpha: float = 1.0, label: bool = False, linewidth=1):
+        """
+        Draw the line segment on a given axes.
+
+        Args:
+        - ax (axes.Axes): Matplotlib axes on which to draw the line segment.
+        - color (str): Color of the line segment (default is 'black').
+        - alpha (float): Alpha (transparency) value (default is 1.0).
+        """
+        
+        x1, y1 = self.start
+        x2, y2 = self.end
+        ax.plot([x1, x2], [y1, y2], color=color, alpha=alpha, linewidth=linewidth)
+        
+        if label:
+            ax.text((x1+x2)/2, (y1+y2)/2, self.id, fontsize=12)
+            
+    def copy(self):
+        """
+        Create a copy of the LineSegment object.
+
+        Returns:
+        - LineSegment: A new LineSegment object with the same attributes.
+        """
+        return copy.deepcopy(self)
+    
+class Polygon:
+    """
+    Represents a polygon defined by a list of vertices.
+
+    Args:
+        vertices (List[Tuple[float, float]]): A list of (x, y) coordinates representing the vertices of the polygon.
+    """
+
+    def __init__(self, vertices: List[tuple], middle_segment=None):
+        """
+        Initializes a Polygon instance with the provided vertices.
+
+        Args:
+            vertices (List[Tuple[float, float]]): A list of (x, y) coordinates representing the vertices of the polygon.
+        """
+        self.vertices = vertices
+        self.middle_line = middle_segment
+
+    def area(self) -> float:
+        """
+        Calculates the area of the polygon.
+
+        Returns:
+            float: The area of the polygon.
+
+        Raises:
+            ValueError: If the polygon has less than 3 vertices.
+        """
+        if len(self.vertices) < 3:
+            raise ValueError("A polygon must have at least 3 vertices.")
+
+        area = 0.0
+
+        for i in range(len(self.vertices)):
+            x1, y1 = self.vertices[i]
+            x2, y2 = self.vertices[(i + 1) % len(self.vertices)]
+            area += (x1 * y2) - (x2 * y1)
+
+        area = abs(area) / 2.0
+
+        return area
+
+    def sort_vertices(self) -> List[Tuple[float, float]]:
+        """
+        Sorts the vertices of the polygon based on their polar angles with respect to a reference point.
+
+        Returns:
+            List[Tuple[float, float]]: The sorted list of vertices.
+        """
+        def polar_angle(point: Tuple[float, float], reference_point: Tuple[float, float]) -> float:
+            """
+            Calculates the polar angle of a point with respect to a reference point.
+
+            Args:
+                point (Tuple[float, float]): The coordinates (x, y) of the point for which to calculate the polar angle.
+                reference_point (Tuple[float, float]): The coordinates (x, y) of the reference point.
+
+            Returns:
+                float: The polar angle in radians.
+            """
+            dx = point[0] - reference_point[0]
+            dy = point[1] - reference_point[1]
+            return np.arctan2(dy, dx)
+
+        reference_point = min(self.vertices, key=lambda point: point[1])
+        return sorted(self.vertices, key=lambda point: polar_angle(point, reference_point))
+
+    def draw(self, ax: axes.Axes, color='purple', alpha=0.8):
+        """
+        Draws a filled polygon with the given vertices on the specified Matplotlib axes.
+
+        Args:
+            ax (matplotlib.axes.Axes): The Matplotlib axes on which to draw the polygon.
+
+        Note:
+            This method sorts the vertices based on their polar angles with respect to a reference point
+            (vertex with the lowest y-coordinate) before drawing the filled polygon.
+        """
+        sorted_vertices = self.sort_vertices()
+        polygon = polgon(sorted_vertices, closed=True, alpha=alpha, facecolor=color, edgecolor='black')
+        ax.add_patch(polygon)
+        
+    def perimeter(self):
+        perimeter = 0
+        for i in range(len(self.vertices)):
+            x1, y1 = self.vertices[i]
+            x2, y2 = self.vertices[(i + 1) % len(self.vertices)]
+            perimeter += np.sqrt((x1-x2)**2 + (y1-y2)**2)
+        return perimeter
+        
+class Cycle:
+    def __init__(self, vertices, id=None):
+        self.vertices = vertices
+        self.id = id
+        
+    def sort_vertices(self) -> List[Tuple[float, float]]:
+        """
+        Sorts the vertices of the polygon based on their polar angles with respect to a reference point.
+
+        Returns:
+            List[Tuple[float, float]]: The sorted list of vertices.
+        """
+        def polar_angle(point: Tuple[float, float], reference_point: Tuple[float, float]) -> float:
+            """
+            Calculates the polar angle of a point with respect to a reference point.
+
+            Args:
+                point (Tuple[float, float]): The coordinates (x, y) of the point for which to calculate the polar angle.
+                reference_point (Tuple[float, float]): The coordinates (x, y) of the reference point.
+
+            Returns:
+                float: The polar angle in radians.
+            """
+            dx = point[0] - reference_point[0]
+            dy = point[1] - reference_point[1]
+            return np.arctan2(dy, dx)
+
+        reference_point = min(self.vertices, key=lambda point: point[1])
+        return sorted(self.vertices, key=lambda point: polar_angle(point, reference_point))
+
+    def draw(self, ax: axes.Axes, color='purple', alpha=0.8):
+        sorted_vertices = self.sort_vertices()
+        polygon = polgon(sorted_vertices, closed=False, alpha=alpha, color=color)
+        ax.add_patch(polygon)

RDG_networks/thickness/__init__.py

@@ -0,0 +1,7 @@
+# __init__.py
+
+from .generate_line_segments_dynamic_thickness import generate_line_segments_thickness
+
+__all__ = [
+           'generate_line_segments_dynamic_thickness',
+           ]

RDG_networks/thickness/functions.py

@@ -0,0 +1,255 @@
+import numpy as np
+import random
+from typing import List, Dict, Tuple, Union, Optional
+
+from .Classes import Line, LineSegment
+from .sample_in_polygon import sample_in_polygon, is_inside_polygon
+
+def doLinesIntersect(line1: Line, line2: Line) -> Tuple[bool, Union[Tuple[float, float], None]]:
+    """
+    Check if two lines intersect and return the intersection point.
+
+    Args:
+    - line1 (Line): The first line segment.
+    - line2 (Line): The second line segment.
+
+    Returns:
+    - intersect (bool): True if the lines intersect, False otherwise.
+    - intersection_point (tuple or None): The intersection point (x, y) if lines intersect, None otherwise.
+    """
+    x1, y1 = line1.location
+    v1, w1 = line1.direction
+
+    x2, y2 = line2.location
+    v2, w2 = line2.direction
+
+    determinant = v1 * w2 - v2 * w1
+
+    if determinant == 0:
+        return False, (None, None)
+
+    t1 = ((x2 - x1) * w2 - (y2 - y1) * v2) / determinant
+    t2 = ((x2 - x1) * w1 - (y2 - y1) * v1) / determinant
+
+    intersect_x = x1 + v1 * t1
+    intersect_y = y2 + w2 * t2
+
+    if -1e-6 < intersect_x < 1 + 1e-6 and -1e-6 < intersect_y < 1 + 1e-6:
+        return True, (intersect_x, intersect_y)
+    else:
+        return False, (None, None)
+    
+def doSegmentsIntersect(
+    segment1: 'LineSegment', 
+    segment2: 'LineSegment'
+) -> Tuple[bool, Tuple[Optional[float], Optional[float]]]:
+    """
+    Determines if two line segments intersect and returns the intersection point if they do.
+
+    Args:
+        segment1 (LineSegment): The first line segment.
+        segment2 (LineSegment): The second line segment.
+
+    Returns:
+        Tuple[bool, Tuple[Optional[float], Optional[float]]]:
+            - A boolean indicating whether the segments intersect.
+            - A tuple of the x and y coordinates of the intersection point if they intersect,
+              otherwise (None, None).
+    """
+    
+    # Create line equations based on the segments' start and end points
+    line1 = Line(location=segment1.start, direction=np.array(segment1.end) - np.array(segment1.start))
+    line2 = Line(location=segment2.start, direction=np.array(segment2.end) - np.array(segment2.start))
+    
+    # Check if the infinite extensions of the two lines intersect
+    intersect, (intersect_x, intersect_y) = doLinesIntersect(line1, line2)
+    
+    # If no intersection, return False
+    if not intersect:
+        return False, (None, None)
+    
+    # Check if the intersection point is within the bounds of both segments in the x-direction
+    xcheck = (
+        (segment1.end[0] <= intersect_x <= segment1.start[0]
+        or segment1.start[0] <= intersect_x <= segment1.end[0]
+        or abs(intersect_x - segment1.end[0]) < 1e-6
+        or abs(intersect_x - segment1.start[0]) < 1e-6)
+        and
+        (segment2.end[0] <= intersect_x <= segment2.start[0]
+        or segment2.start[0] <= intersect_x <= segment2.end[0]
+        or abs(intersect_x - segment2.end[0]) < 1e-6
+        or abs(intersect_x - segment2.start[0]) < 1e-6)
+    )
+    
+    # Check if the intersection point is within the bounds of both segments in the y-direction
+    ycheck = (
+        (segment1.end[1] <= intersect_y <= segment1.start[1]
+        or segment1.start[1] <= intersect_y <= segment1.end[1]
+        or abs(intersect_y - segment1.end[1]) < 1e-6
+        or abs(intersect_y - segment1.start[1]) < 1e-6)
+        and
+        (segment2.end[1] <= intersect_y <= segment2.start[1]
+        or segment2.start[1] <= intersect_y <= segment2.end[1]
+        or abs(intersect_y - segment2.end[1]) < 1e-6
+        or abs(intersect_y - segment2.start[1]) < 1e-6)
+    )
+    
+    # If the intersection point lies within the bounds of both segments, return True with the intersection point
+    if xcheck and ycheck:
+        return True, (intersect_x, intersect_y)
+    
+    # Otherwise, return False and no intersection point
+    return False, (None, None)
+
+def pick_item_with_probability(
+    polygon_arr: Dict[str, Dict[str, object]]
+) -> Tuple[str, Dict[str, object]]:
+    """
+    Randomly selects an item from the polygon array with a probability proportional to the area of the polygons.
+
+    Args:
+        polygon_arr (Dict[str, Dict[str, object]]): 
+            A dictionary where keys are polygon identifiers (e.g., 'p1', 'p2') and values are dictionaries containing polygon properties, 
+            including an 'area' key that stores the area of the polygon.
+
+    Returns:
+        Tuple[str, Dict[str, object]]: 
+            - The identifier of the selected polygon.
+            - The corresponding polygon data (dictionary) containing its properties.
+    """
+    
+    # Calculate the total weight (sum of areas of all polygons)
+    max_weight = sum(pol['area'] for pol in polygon_arr.values())
+    
+    # Generate a random threshold between 0 and the total weight
+    threshold = random.uniform(0, max_weight)
+    cumulative_weight = 0
+    
+    # Iterate through the polygons, accumulating weights
+    for item, pol in polygon_arr.items():
+        weight = pol['area']
+        cumulative_weight += weight
+        
+        # Return the polygon when the cumulative weight surpasses the threshold
+        if cumulative_weight >= threshold:
+            return item, pol
+
+def get_location_and_direction(
+    polygon_arr: Dict[str, Dict[str, object]], 
+    thickness: float, 
+    max_attempts: int = 1000, 
+    angles: Union[str, List[float]] = 'uniform'
+) -> Union[Tuple[str, Dict[str, object], Tuple[float, float], np.ndarray, np.ndarray], bool]:
+    """
+    Attempts to find a valid location and direction within a polygon for placing a new segment. The direction can either be randomly 
+    chosen (uniformly) or from a specified list of angles. It ensures that the segment lies within the polygon's bounds given the 
+    specified thickness.
+
+    Args:
+        polygon_arr (Dict[str, Dict[str, object]]): 
+            A dictionary where the keys are polygon identifiers and the values are dictionaries containing polygon properties, including 'vertices'.
+        thickness (float): 
+            The thickness of the segment that needs to fit inside the polygon.
+        max_attempts (int, optional): 
+            The maximum number of attempts to find a valid location and direction. Defaults to 1000.
+        angles (Union[str, List[float]], optional): 
+            A string ('uniform' for random directions) or a list of angles (in radians) to choose the direction from. Defaults to 'uniform'.
+
+    Returns:
+        Union[Tuple[str, Dict[str, object], Tuple[float, float], np.ndarray, np.ndarray], bool]:
+            - If a valid location and direction are found, returns a tuple containing:
+                - The polygon ID (`str`).
+                - The polygon data (`Dict[str, object]`).
+                - The new location as a tuple of floats (`Tuple[float, float]`).
+                - The direction vector as a numpy array (`np.ndarray`).
+                - The perpendicular vector to the direction as a numpy array (`np.ndarray`).
+            - Returns `False` if no valid location and direction are found after the maximum attempts.
+    """
+    
+    # Generate a new direction based on the angles parameter
+    if angles == 'uniform':
+        direction = np.array([random.uniform(-1, 1), random.uniform(-1, 1)])
+        direction = direction / np.linalg.norm(direction)  # Normalize the direction vector
+    else:
+        directions = [ (np.cos(angle), np.sin(angle)) for angle in angles ]
+        direction = random.choice(directions)
+        direction = np.array(direction) / np.linalg.norm(direction)  # Normalize the chosen direction
+    
+    # Try to find a valid location and direction up to max_attempts
+    attempt = 0
+    while attempt < max_attempts:
+        polygon_id, polygon = pick_item_with_probability(polygon_arr)
+        
+        # Sample a location within the polygon
+        location_new = sample_in_polygon(polygon['vertices'])
+        
+        # Compute the perpendicular vector to the direction
+        perpendicular = np.array([direction[1], -direction[0]])
+        perpendicular = perpendicular / np.linalg.norm(perpendicular)
+        
+        # Ensure the perpendicular vector is oriented consistently (y-component is non-negative)
+        if perpendicular[1] < 0:
+            perpendicular = -perpendicular
+        
+        # Compute the positions for the segment with thickness, shifted by half-thickness along the perpendicular direction
+        p1 = np.array(location_new) + thickness / 2 * perpendicular
+        p2 = np.array(location_new) - thickness / 2 * perpendicular
+        
+        # Check if both endpoints of the segment are inside the polygon
+        if is_inside_polygon(polygon['vertices'], p1) and is_inside_polygon(polygon['vertices'], p2):
+            return polygon_id, polygon, location_new, direction, perpendicular
+        
+        attempt += 1
+    
+    # If no valid location and direction is found, return False
+    return False
+
+def get_polygons(polygon_id, polygon_arr, neighbor1_1, neighbor1_2, vertex_begin_1, vertex_end_1, neighbor2_1, neighbor2_2, vertex_begin_2, vertex_end_2, segment_new_id_1, segment_new_id_2):
+    # Extract vertices and cycle (faces) of the original polygon
+    vertices = polygon_arr[polygon_id]['vertices']
+    cycle = polygon_arr[polygon_id]['faces']
+    
+    # Get first cycle and vertices
+    index_start_1, index_end_1 = (cycle.index(neighbor1_1), cycle.index(neighbor1_2))
+    if index_start_1 < index_end_1:
+        cycle1 = [segment_new_id_1] + cycle[index_start_1:index_end_1+1]
+        vertices1 = [vertex_begin_1] + vertices[index_start_1:index_end_1] + [vertex_end_1]
+    else:
+        cycle1 = [segment_new_id_1] + cycle[index_start_1:] + cycle[:index_end_1+1]
+        vertices1 = [vertex_begin_1] + vertices[index_start_1:] + vertices[:index_end_1] + [vertex_end_1]
+        
+    # Get second cycle and vertices
+    index_start_2, index_end_2 = (cycle.index(neighbor2_2), cycle.index(neighbor2_1))
+    if index_start_2 < index_end_2:
+        cycle2 = [segment_new_id_2] + cycle[index_start_2:index_end_2+1]
+        vertices2 = [vertex_end_2] + vertices[index_start_2:index_end_2] + [vertex_begin_2]
+    else:
+        cycle2 = [segment_new_id_2] + cycle[index_start_2:] + cycle[:index_end_2+1]
+        vertices2 = [vertex_end_2] + vertices[index_start_2:] + vertices[:index_end_2] + [vertex_begin_2]
+    
+    # Get middle cycle and vertices
+    cycle0 = [neighbor1_1, segment_new_id_1, neighbor1_2]
+    vertices0 = [vertex_begin_1, vertex_end_1]
+    
+    index_start_0, index_end_0 = (cycle.index(neighbor1_2), cycle.index(neighbor2_2))
+    if index_start_0 < index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:index_end_0] 
+        
+    elif index_start_0 > index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:] + cycle[:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:] + vertices[:index_end_0]
+        
+    cycle0 = cycle0 + [segment_new_id_2]
+    vertices0 = vertices0 + [vertex_end_2] + [vertex_begin_2]
+    
+    index_start_0, index_end_0 = (cycle.index(neighbor2_1), cycle.index(neighbor1_1))
+    if index_start_0 < index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:index_end_0] 
+        
+    elif index_start_0 > index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:] + cycle[:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:] + vertices[:index_end_0]
+    
+    return cycle0, vertices0, cycle1, vertices1, cycle2, vertices2

RDG_networks/thickness/generate_line_segments_dynamic_thickness.py

@@ -0,0 +1,572 @@
+import math
+import numpy as np
+from typing import List, Dict, Tuple, Union, Optional
+
+from .Classes import Line, LineSegment
+from .sample_in_polygon import sample_in_polygon, is_inside_polygon
+
+def doLinesIntersect(line1: Line, line2: Line) -> Tuple[bool, Union[Tuple[float, float], None]]:
+    """
+    Check if two lines intersect and return the intersection point.
+
+    Args:
+    - line1 (Line): The first line segment.
+    - line2 (Line): The second line segment.
+
+    Returns:
+    - intersect (bool): True if the lines intersect, False otherwise.
+    - intersection_point (tuple or None): The intersection point (x, y) if lines intersect, None otherwise.
+    """
+    x1, y1 = line1.location
+    v1, w1 = line1.direction
+
+    x2, y2 = line2.location
+    v2, w2 = line2.direction
+
+    determinant = v1 * w2 - v2 * w1
+
+    if determinant == 0:
+        return False, (None, None)
+
+    t1 = ((x2 - x1) * w2 - (y2 - y1) * v2) / determinant
+    t2 = ((x2 - x1) * w1 - (y2 - y1) * v1) / determinant
+
+    intersect_x = x1 + v1 * t1
+    intersect_y = y2 + w2 * t2
+
+    if -1e-6 < intersect_x < 1 + 1e-6 and -1e-6 < intersect_y < 1 + 1e-6:
+        return True, (intersect_x, intersect_y)
+    else:
+        return False, (None, None)
+    
+def doSegmentsIntersect(
+    segment1: 'LineSegment', 
+    segment2: 'LineSegment'
+) -> Tuple[bool, Tuple[Optional[float], Optional[float]]]:
+    """
+    Determines if two line segments intersect and returns the intersection point if they do.
+
+    Args:
+        segment1 (LineSegment): The first line segment.
+        segment2 (LineSegment): The second line segment.
+
+    Returns:
+        Tuple[bool, Tuple[Optional[float], Optional[float]]]:
+            - A boolean indicating whether the segments intersect.
+            - A tuple of the x and y coordinates of the intersection point if they intersect,
+              otherwise (None, None).
+    """
+    
+    # Create line equations based on the segments' start and end points
+    line1 = Line(location=segment1.start, direction=np.array(segment1.end) - np.array(segment1.start))
+    line2 = Line(location=segment2.start, direction=np.array(segment2.end) - np.array(segment2.start))
+    
+    # Check if the infinite extensions of the two lines intersect
+    intersect, (intersect_x, intersect_y) = doLinesIntersect(line1, line2)
+    
+    # If no intersection, return False
+    if not intersect:
+        return False, (None, None)
+    
+    # Check if the intersection point is within the bounds of both segments in the x-direction
+    xcheck = (
+        (segment1.end[0] <= intersect_x <= segment1.start[0]
+        or segment1.start[0] <= intersect_x <= segment1.end[0]
+        or abs(intersect_x - segment1.end[0]) < 1e-6
+        or abs(intersect_x - segment1.start[0]) < 1e-6)
+        and
+        (segment2.end[0] <= intersect_x <= segment2.start[0]
+        or segment2.start[0] <= intersect_x <= segment2.end[0]
+        or abs(intersect_x - segment2.end[0]) < 1e-6
+        or abs(intersect_x - segment2.start[0]) < 1e-6)
+    )
+    
+    # Check if the intersection point is within the bounds of both segments in the y-direction
+    ycheck = (
+        (segment1.end[1] <= intersect_y <= segment1.start[1]
+        or segment1.start[1] <= intersect_y <= segment1.end[1]
+        or abs(intersect_y - segment1.end[1]) < 1e-6
+        or abs(intersect_y - segment1.start[1]) < 1e-6)
+        and
+        (segment2.end[1] <= intersect_y <= segment2.start[1]
+        or segment2.start[1] <= intersect_y <= segment2.end[1]
+        or abs(intersect_y - segment2.end[1]) < 1e-6
+        or abs(intersect_y - segment2.start[1]) < 1e-6)
+    )
+    
+    # If the intersection point lies within the bounds of both segments, return True with the intersection point
+    if xcheck and ycheck:
+        return True, (intersect_x, intersect_y)
+    
+    # Otherwise, return False and no intersection point
+    return False, (None, None)
+
+def pick_item_with_probability(
+    polygon_arr: Dict[str, Dict[str, object]]
+) -> Tuple[str, Dict[str, object]]:
+    """
+    Randomly selects an item from the polygon array with a probability proportional to the area of the polygons.
+
+    Args:
+        polygon_arr (Dict[str, Dict[str, object]]): 
+            A dictionary where keys are polygon identifiers (e.g., 'p1', 'p2') and values are dictionaries containing polygon properties, 
+            including an 'area' key that stores the area of the polygon.
+
+    Returns:
+        Tuple[str, Dict[str, object]]: 
+            - The identifier of the selected polygon.
+            - The corresponding polygon data (dictionary) containing its properties.
+    """
+    
+    # Calculate the total weight (sum of areas of all polygons)
+    max_weight = sum(pol['area'] for pol in polygon_arr.values())
+    
+    # Generate a random threshold between 0 and the total weight
+    threshold = random.uniform(0, max_weight)
+    cumulative_weight = 0
+    
+    # Iterate through the polygons, accumulating weights
+    for item, pol in polygon_arr.items():
+        weight = pol['area']
+        cumulative_weight += weight
+        
+        # Return the polygon when the cumulative weight surpasses the threshold
+        if cumulative_weight >= threshold:
+            return item, pol
+
+def get_location_and_direction(
+    polygon_arr: Dict[str, Dict[str, object]], 
+    thickness: float, 
+    max_attempts: int = 1000, 
+    angles: Union[str, List[float]] = 'uniform'
+) -> Union[Tuple[str, Dict[str, object], Tuple[float, float], np.ndarray, np.ndarray], bool]:
+    """
+    Attempts to find a valid location and direction within a polygon for placing a new segment. The direction can either be randomly 
+    chosen (uniformly) or from a specified list of angles. It ensures that the segment lies within the polygon's bounds given the 
+    specified thickness.
+
+    Args:
+        polygon_arr (Dict[str, Dict[str, object]]): 
+            A dictionary where the keys are polygon identifiers and the values are dictionaries containing polygon properties, including 'vertices'.
+        thickness (float): 
+            The thickness of the segment that needs to fit inside the polygon.
+        max_attempts (int, optional): 
+            The maximum number of attempts to find a valid location and direction. Defaults to 1000.
+        angles (Union[str, List[float]], optional): 
+            A string ('uniform' for random directions) or a list of angles (in radians) to choose the direction from. Defaults to 'uniform'.
+
+    Returns:
+        Union[Tuple[str, Dict[str, object], Tuple[float, float], np.ndarray, np.ndarray], bool]:
+            - If a valid location and direction are found, returns a tuple containing:
+                - The polygon ID (`str`).
+                - The polygon data (`Dict[str, object]`).
+                - The new location as a tuple of floats (`Tuple[float, float]`).
+                - The direction vector as a numpy array (`np.ndarray`).
+                - The perpendicular vector to the direction as a numpy array (`np.ndarray`).
+            - Returns `False` if no valid location and direction are found after the maximum attempts.
+    """
+    
+    # Generate a new direction based on the angles parameter
+    if angles == 'uniform':
+        direction = np.array([random.uniform(-1, 1), random.uniform(-1, 1)])
+        direction = direction / np.linalg.norm(direction)  # Normalize the direction vector
+    else:
+        directions = [ (np.cos(angle), np.sin(angle)) for angle in angles ]
+        direction = random.choice(directions)
+        direction = np.array(direction) / np.linalg.norm(direction)  # Normalize the chosen direction
+    
+    # Try to find a valid location and direction up to max_attempts
+    attempt = 0
+    while attempt < max_attempts:
+        polygon_id, polygon = pick_item_with_probability(polygon_arr)
+        
+        # Sample a location within the polygon
+        location_new = sample_in_polygon(polygon['vertices'])
+        
+        # Compute the perpendicular vector to the direction
+        perpendicular = np.array([direction[1], -direction[0]])
+        perpendicular = perpendicular / np.linalg.norm(perpendicular)
+        
+        # Ensure the perpendicular vector is oriented consistently (y-component is non-negative)
+        if perpendicular[1] < 0:
+            perpendicular = -perpendicular
+        
+        # Compute the positions for the segment with thickness, shifted by half-thickness along the perpendicular direction
+        p1 = np.array(location_new) + thickness / 2 * perpendicular
+        p2 = np.array(location_new) - thickness / 2 * perpendicular
+        
+        # Check if both endpoints of the segment are inside the polygon
+        if is_inside_polygon(polygon['vertices'], p1) and is_inside_polygon(polygon['vertices'], p2):
+            return polygon_id, polygon, location_new, direction, perpendicular
+        
+        attempt += 1
+    
+    # If no valid location and direction is found, return False
+    return False
+
+def get_polygons(polygon_id, polygon_arr, neighbor1_1, neighbor1_2, vertex_begin_1, vertex_end_1, neighbor2_1, neighbor2_2, vertex_begin_2, vertex_end_2, segment_new_id_1, segment_new_id_2):
+    # Extract vertices and cycle (faces) of the original polygon
+    vertices = polygon_arr[polygon_id]['vertices']
+    cycle = polygon_arr[polygon_id]['faces']
+    
+    # Get first cycle and vertices
+    index_start_1, index_end_1 = (cycle.index(neighbor1_1), cycle.index(neighbor1_2))
+    if index_start_1 < index_end_1:
+        cycle1 = [segment_new_id_1] + cycle[index_start_1:index_end_1+1]
+        vertices1 = [vertex_begin_1] + vertices[index_start_1:index_end_1] + [vertex_end_1]
+    else:
+        cycle1 = [segment_new_id_1] + cycle[index_start_1:] + cycle[:index_end_1+1]
+        vertices1 = [vertex_begin_1] + vertices[index_start_1:] + vertices[:index_end_1] + [vertex_end_1]
+        
+    # Get second cycle and vertices
+    index_start_2, index_end_2 = (cycle.index(neighbor2_2), cycle.index(neighbor2_1))
+    if index_start_2 < index_end_2:
+        cycle2 = [segment_new_id_2] + cycle[index_start_2:index_end_2+1]
+        vertices2 = [vertex_end_2] + vertices[index_start_2:index_end_2] + [vertex_begin_2]
+    else:
+        cycle2 = [segment_new_id_2] + cycle[index_start_2:] + cycle[:index_end_2+1]
+        vertices2 = [vertex_end_2] + vertices[index_start_2:] + vertices[:index_end_2] + [vertex_begin_2]
+    
+    # Get middle cycle and vertices
+    cycle0 = [neighbor1_1, segment_new_id_1, neighbor1_2]
+    vertices0 = [vertex_begin_1, vertex_end_1]
+    
+    index_start_0, index_end_0 = (cycle.index(neighbor1_2), cycle.index(neighbor2_2))
+    if index_start_0 < index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:index_end_0] 
+        
+    elif index_start_0 > index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:] + cycle[:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:] + vertices[:index_end_0]
+        
+    cycle0 = cycle0 + [segment_new_id_2]
+    vertices0 = vertices0 + [vertex_end_2] + [vertex_begin_2]
+    
+    index_start_0, index_end_0 = (cycle.index(neighbor2_1), cycle.index(neighbor1_1))
+    if index_start_0 < index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:index_end_0] 
+        
+    elif index_start_0 > index_end_0:
+        cycle0 = cycle0 + cycle[index_start_0:] + cycle[:index_end_0+1]
+        vertices0 = vertices0 + vertices[index_start_0:] + vertices[:index_end_0]
+    
+    return cycle0, vertices0, cycle1, vertices1, cycle2, vertices2
+
+def get_new_segment(
+    line_segments_to_check: List['LineSegment'], 
+    location: Tuple[float, float], 
+    direction: Tuple[float, float], 
+    id: Optional[int] = None
+) -> 'LineSegment':
+    """
+    Creates a new line segment by extending a given location in a specified direction and 
+    determines its neighbors by checking intersections with other line segments.
+
+    Args:
+        line_segments_to_check (List[LineSegment]): List of existing line segments to check for intersections.
+        location (Tuple[float, float]): The starting point (x, y) for the new line segment.
+        direction (Tuple[float, float]): The direction vector in which to extend the line segment.
+        id (Optional[int]): Optional ID for the new line segment. If not provided, defaults to None.
+
+    Returns:
+        LineSegment: A new line segment object with its neighbors based on intersections.
+    """
+    
+    # Create a temporary line segment extending from the location in both directions
+    s_temp = LineSegment(start=np.array(location) - 10 * np.array(direction), end=np.array(location) + 10 * np.array(direction))
+    intersection_points: List[Dict[str, Tuple[float, float]]] = []
+
+    # Check for intersections with existing line segments
+    for segment in line_segments_to_check:
+        intersect, (intersect_x, intersect_y) = doSegmentsIntersect(s_temp, segment)
+
+        if intersect:
+            segment_length = math.sqrt(
+                (location[0] - intersect_x) ** 2
+                + (location[1] - intersect_y) ** 2
+            )
+            intersection_points.append(
+                {"id": segment.id, "point": (intersect_x, intersect_y), "segment_length": segment_length}
+            )
+
+    # Divide intersections into ones behind and in front of the new line
+    intersections_b = [intersection for intersection in intersection_points if intersection["point"][0] < location[0]]
+    intersections_f = [intersection for intersection in intersection_points if intersection["point"][0] > location[0]]
+
+    if not intersections_b or not intersections_f:
+        intersections_b = [intersection for intersection in intersection_points if intersection["point"][1] < location[1]]
+        intersections_f = [intersection for intersection in intersection_points if intersection["point"][1] > location[1]]
+
+    # Determine the closest intersections for segment start and end
+    s_start = min(intersections_b, key=lambda x: x["segment_length"])
+    s_end = min(intersections_f, key=lambda x: x["segment_length"])
+    start, end = s_start['point'], s_end['point']
+    start_id, end_id = s_start['id'], s_end['id']
+
+    # Ensure the start comes before the end
+    if start[0] > end[0]:
+        start, end = end, start
+        start_id, end_id = end_id, start_id
+
+    # Create a new line segment and assign neighbors
+    neighbors_initial = {start_id: start, end_id: end}
+    segment_new = LineSegment(start=start, end=end, id=id, neighbors_initial=neighbors_initial, neighbors=neighbors_initial)
+    
+    return segment_new
+    
+def update_data(
+    segments_dict: Dict[int, 'LineSegment'], 
+    polygon_arr: Dict[str, Dict[str, object]], 
+    polygon_id: str, 
+    segment_thickness_dict: Dict[int, 'Polygon'], 
+    vertices0: List[Tuple[float, float]], 
+    vertices1: List[Tuple[float, float]], 
+    vertices2: List[Tuple[float, float]], 
+    cycle0: List[int], 
+    cycle1: List[int], 
+    cycle2: List[int], 
+    neighbor1_1: int, 
+    neighbor1_2: int, 
+    neighbor2_1: int, 
+    neighbor2_2: int, 
+    vertex_begin_1: Tuple[float, float], 
+    vertex_end_1: Tuple[float, float], 
+    vertex_begin_2: Tuple[float, float], 
+    vertex_end_2: Tuple[float, float], 
+    id_1: int, 
+    id_2: int
+) -> Tuple[Dict[int, 'LineSegment'], Dict[str, Dict[str, object]], Dict[int, 'Polygon']]:
+    """
+    Updates the segments, polygons, and segment thickness dictionaries by adding new data derived
+    from provided vertices and neighbor information.
+
+    Args:
+        segments_dict (Dict[int, LineSegment]): A dictionary of segments with segment ID as the key.
+        polygon_arr (Dict[str, Dict[str, object]]): A dictionary of polygons with polygon ID as the key.
+        polygon_id (str): The ID of the polygon being updated.
+        segment_thickness_dict (Dict[int, Polygon]): A dictionary mapping thickness information to polygon objects.
+        vertices0 (List[Tuple[float, float]]): Vertices of the base polygon.
+        vertices1 (List[Tuple[float, float]]): Vertices of the first new polygon.
+        vertices2 (List[Tuple[float, float]]): Vertices of the second new polygon.
+        cycle0 (List[int]): List of face indices for the base polygon.
+        cycle1 (List[int]): List of face indices for the first new polygon.
+        cycle2 (List[int]): List of face indices for the second new polygon.
+        neighbor1_1 (int): ID of the first neighbor of the first segment.
+        neighbor1_2 (int): ID of the second neighbor of the first segment.
+        neighbor2_1 (int): ID of the first neighbor of the second segment.
+        neighbor2_2 (int): ID of the second neighbor of the second segment.
+        vertex_begin_1 (Tuple[float, float]): Starting vertex of the first segment.
+        vertex_end_1 (Tuple[float, float]): Ending vertex of the first segment.
+        vertex_begin_2 (Tuple[float, float]): Starting vertex of the second segment.
+        vertex_end_2 (Tuple[float, float]): Ending vertex of the second segment.
+        id_1 (int): ID of the first new segment.
+        id_2 (int): ID of the second new segment.
+
+    Returns:
+        Tuple[Dict[int, LineSegment], Dict[str, Dict[str, object]], Dict[int, Polygon]]:
+            - Updated dictionary of line segments.
+            - Updated dictionary of polygons.
+            - Updated dictionary of segment thickness.
+    """
+    
+    # Update polygon_arr (a dictionary of polygons)
+    polygon_new_1 = {
+        f'p{len(polygon_arr) + 1}': {
+            'vertices': vertices1, 
+            'area': Polygon(vertices=vertices1).area(), 
+            'faces': cycle1
+        }
+    }
+    polygon_new_2 = {
+        polygon_id: {
+            'vertices': vertices2, 
+            'area': Polygon(vertices=vertices2).area(), 
+            'faces': cycle2
+        }
+    }
+    polygon_arr.update(polygon_new_1)
+    polygon_arr.update(polygon_new_2)
+    
+    # Update the segments_dict for the first segment
+    neighbors_initial_1 = {
+        neighbor1_1: vertex_begin_1,
+        neighbor1_2: vertex_end_1
+    }
+    segment_new_1 = LineSegment(
+        start=vertex_begin_1, 
+        end=vertex_end_1, 
+        id=id_1, 
+        neighbors_initial=neighbors_initial_1, 
+        neighbors=neighbors_initial_1
+    )
+    segments_dict[segment_new_1.id] = segment_new_1
+    segments_dict[neighbor1_1].neighbors[id_1] = vertex_begin_1
+    segments_dict[neighbor1_2].neighbors[id_1] = vertex_end_1
+    
+    # Update the segments_dict for the second segment
+    neighbors_initial_2 = {
+        neighbor2_1: vertex_begin_2,
+        neighbor2_2: vertex_end_2
+    }
+    segment_new_2 = LineSegment(
+        start=vertex_begin_2, 
+        end=vertex_end_2, 
+        id=id_2, 
+        neighbors_initial=neighbors_initial_2, 
+        neighbors=neighbors_initial_2
+    )
+    segments_dict[segment_new_2.id] = segment_new_2
+    segments_dict[neighbor2_1].neighbors[id_2] = vertex_begin_2
+    segments_dict[neighbor2_2].neighbors[id_2] = vertex_end_2
+    
+    # Update the segment_thickness_dict with the base polygon
+    segment_thickness_dict[len(segment_thickness_dict) + 1] = Polygon(vertices=vertices0)
+    
+    return segments_dict, polygon_arr, segment_thickness_dict
+    
+def add_line_segment(
+    segments_dict: Dict[int, 'LineSegment'], 
+    polygon_arr: Dict[str, Dict[str, object]], 
+    segment_thickness_dict: Dict[int, 'Polygon'], 
+    thickness: float = 0, 
+    angles: str = 'uniform'
+) -> Union[Tuple[Dict[int, 'LineSegment'], Dict[str, Dict[str, object]], Dict[int, 'Polygon']], bool]:
+    """
+    Adds a new line segment to the segments and polygon data structures, with a given thickness and angle distribution.
+
+    Args:
+        segments_dict (Dict[int, LineSegment]): A dictionary containing the current line segments.
+        polygon_arr (Dict[str, Dict[str, object]]): A dictionary containing the current polygons and their properties.
+        segment_thickness_dict (Dict[int, Polygon]): A dictionary storing the thickness information mapped to polygons.
+        thickness (float): The thickness of the new segment to be added. Defaults to 0.
+        angles (str): The angle distribution method. Defaults to 'uniform'.
+
+    Returns:
+        Union[Tuple[Dict[int, LineSegment], Dict[str, Dict[str, object]], Dict[int, Polygon]], bool]:
+            - A tuple containing the updated segments dictionary, polygon dictionary, and thickness dictionary, 
+              or False if no valid location for the new segment is found.
+    """
+    
+    # Get a valid location and direction, or return False if none is found
+    loc = get_location_and_direction(polygon_arr, thickness, max_attempts=1000, angles=angles)
+    if loc:
+        polygon_id, polygon, location_new, direction_new, perpendicular = loc
+    else:
+        print('No valid location found')
+        return False
+        
+    # Get the borders of the new segment with the given thickness
+    line_segments_to_check = [segments_dict[segment] for segment in polygon['faces']]
+    middle_segment = get_new_segment(line_segments_to_check, location=location_new, direction=direction_new)
+    s1 = get_new_segment(line_segments_to_check, location=np.array(location_new) + thickness * perpendicular / 2, direction=direction_new)
+    s2 = get_new_segment(line_segments_to_check, location=np.array(location_new) - thickness * perpendicular / 2, direction=direction_new)
+    
+    # Extract neighbor information and segment vertices
+    neighbor1_1, neighbor1_2 = list(s1.neighbors.keys())
+    vertex_begin_1, vertex_end_1 = list(s1.neighbors.values())
+    neighbor2_1, neighbor2_2 = list(s2.neighbors.keys())
+    vertex_begin_2, vertex_end_2 = list(s2.neighbors.values())
+    id_1 = str(int((len(segments_dict.keys()) - 2) / 2)) + '_1'
+    id_2 = str(int((len(segments_dict.keys()) - 2) / 2)) + '_2'
+    
+    # Get the resulting polygons after splitting
+    cycle0, vertices0, cycle1, vertices1, cycle2, vertices2 = get_polygons(
+        polygon_id,
+        polygon_arr, 
+        neighbor1_1, 
+        neighbor1_2, 
+        vertex_begin_1, 
+        vertex_end_1, 
+        neighbor2_1, 
+        neighbor2_2,
+        vertex_begin_2=vertex_begin_2,
+        vertex_end_2=vertex_end_2,
+        segment_new_id_1=id_1, 
+        segment_new_id_2=id_2
+    )
+    
+    # Update all relevant data structures
+    segments_dict, polygon_arr, segment_thickness_dict = update_data(
+        segments_dict, 
+        polygon_arr, 
+        polygon_id, 
+        segment_thickness_dict, 
+        vertices0, 
+        vertices1, 
+        vertices2, 
+        cycle0, 
+        cycle1, 
+        cycle2, 
+        neighbor1_1, 
+        neighbor1_2, 
+        neighbor2_1, 
+        neighbor2_2, 
+        vertex_begin_1, 
+        vertex_end_1, 
+        vertex_begin_2, 
+        vertex_end_2, 
+        id_1, 
+        id_2
+    )
+    
+    # Associate the middle segment with the newly created thickness entry
+    segment_thickness_dict[list(segment_thickness_dict.keys())[-1]].middle_segment = middle_segment
+    
+    return segments_dict, polygon_arr, segment_thickness_dict
+
+def generate_line_segments_dynamic_thickness(
+    size: int, 
+    thickness_arr: List[float], 
+    angles: str = 'uniform'
+) -> Tuple[Dict[str, 'LineSegment'], Dict[str, Dict[str, object]], Dict[int, 'Polygon']]:
+    """
+    Generates a specified number of line segments and updates the polygon and segment thickness dictionaries.
+
+    Args:
+        size (int): The number of line segments to generate.
+        thickness_arr (List[float]): A list containing the thickness values for each segment to be generated.
+        angles (str): The angle distribution method for generating segments. Defaults to 'uniform'.
+
+    Returns:
+        Tuple[Dict[str, LineSegment], Dict[str, Dict[str, object]], Dict[int, Polygon]]:
+            - Updated dictionary of line segments.
+            - Updated dictionary of polygons.
+            - Updated dictionary of segment thicknesses.
+    """
+    
+    # Initialize border segments for a square and its polygon representation
+    borders = [
+        LineSegment((1, 0), (0, 0), id='b1', neighbors_initial={'b2': (0, 0), 'b4': (1, 0)}, neighbors={'b2': (0, 0), 'b4': (1, 0)}),
+        LineSegment((0, 1), (0, 0), id='b2', neighbors_initial={'b1': (0, 0), 'b3': (0, 1)}, neighbors={'b1': (0, 0), 'b3': (0, 1)}),
+        LineSegment((0, 1), (1, 1), id='b3', neighbors_initial={'b2': (0, 1), 'b4': (1, 1)}, neighbors={'b2': (0, 1), 'b4': (1, 1)}),
+        LineSegment((1, 1), (1, 0), id='b4', neighbors_initial={'b1': (1, 0), 'b3': (1, 1)}, neighbors={'b1': (1, 0), 'b3': (1, 1)})
+    ]
+    
+    polygon_arr = {
+        'p1': {
+            'vertices': [(0, 0), (0, 1), (1, 1), (1, 0)], 
+            'area': 1, 
+            'faces': ['b1', 'b2', 'b3', 'b4']
+        }
+    }
+
+    segments = borders
+    segments_dict = {segment.id: segment for segment in segments}
+    segment_thickness_dict = {}
+
+    # Generate new line segments based on the given size and thickness array
+    for i in range(size):
+        output = add_line_segment(segments_dict, polygon_arr, segment_thickness_dict, thickness=thickness_arr[i], angles=angles)
+        if output:
+            segments_dict, polygon_arr, segment_thickness_dict = output
+        else: 
+            print(f"Stopped at iteration {i}, could not find a valid segment position.")
+            break
+        
+        # Uncomment the following line if you want progress feedback
+        percentage = np.round(i / size * 100, 3)
+        print(f'generate_segments: {percentage}% done', end='\r')
+    
+    return segments_dict, polygon_arr, segment_thickness_dict

RDG_networks/thickness/sample_in_polygon.py

@@ -0,0 +1,54 @@
+import numpy as np
+from shapely.geometry import Polygon, Point
+
+def sort_vertices(vertices):
+    """
+    Sorts the vertices of the polygon based on their polar angles with respect to a reference point.
+
+    Returns:
+        List[Tuple[float, float]]: The sorted list of vertices.
+    """
+    def polar_angle(point, reference_point) -> float:
+        """
+        Calculates the polar angle of a point with respect to a reference point.
+
+        Args:
+            point (Tuple[float, float]): The coordinates (x, y) of the point for which to calculate the polar angle.
+            reference_point (Tuple[float, float]): The coordinates (x, y) of the reference point.
+
+        Returns:
+            float: The polar angle in radians.
+        """
+        dx = point[0] - reference_point[0]
+        dy = point[1] - reference_point[1]
+        return np.arctan2(dy, dx)
+
+    reference_point = min(vertices, key=lambda point: point[1])
+    return sorted(vertices, key=lambda point: polar_angle(point, reference_point))
+
+def sample_in_polygon(vertices):
+    
+    vertices = sort_vertices(vertices)
+    
+    # Create a Shapely polygon from the given vertices
+    polygon = Polygon(vertices)
+    
+    # Find the bounding box of the polygon
+    min_x, min_y, max_x, max_y = polygon.bounds
+        
+    # Generate random points within the bounding box
+    while True:
+        random_point = Point(np.random.uniform(min_x, max_x), np.random.uniform(min_y, max_y))
+        
+        # Check if the random point is inside the polygon
+        if polygon.contains(random_point):
+            return random_point.x, random_point.y
+        
+def is_inside_polygon(vertices, point):
+    vertices = sort_vertices(vertices)
+    polygon = Polygon(vertices)
+    point = Point(point[0], point[1])
+    if polygon.contains(point):
+        return True
+    else:
+        return False

RDG_Networks-0.2.5.dist-info/RECORD

@@ -1,15 +0,0 @@
-RDG_networks/Classes.py,sha256=_9X3JPHFAYYlaC8IZ_H9__sfz99G5l9UfPl65lL60_4,7977
-RDG_networks/__init__.py,sha256=aCfGs87cJn0Tp5GqTpFXPOEfJPpR4Tnnz819Kk_0t84,661
-RDG_networks/draw_segments.py,sha256=U53N5GXmQHWKdM1Q1faP_EGKjc6enOu2mcsunzSFpP0,984
-RDG_networks/generate_line_network.py,sha256=lJ4rhObim3WcEQoebomewRQKWNJC5phFyFYRW7qjXIg,1127
-RDG_networks/generate_line_segments.py,sha256=QV8_k7q6TD5c7Hcb2Ms_apEdWYw4XdLr7rdJgh49v4Q,9004
-RDG_networks/generate_line_segments_dynamic.py,sha256=GoIhGXYbcvjqR5BJCnkvAGp8QBpzsE1ZSbl2k9XAOGI,7531
-RDG_networks/generate_line_segments_static.py,sha256=7KvHZi3krv-tAGydJR_gbMMmHKZ5azzrKcQe3fuWzCE,9265
-RDG_networks/get_intersection_segments.py,sha256=mXB5qCy1oOps4Vu1mX6flW6v_4Xxc71YK41yOWjJX8o,2797
-RDG_networks/sample_in_polygon.py,sha256=qpPpW-Da1vK8ZkVWMJ0zBsE8IgyMB619gCdybSkzKSQ,1605
-RDG_Networks-0.2.5.dist-info/LICENSE.txt,sha256=BHUkX2GsdTr30sKmVZ1MLGR1njnx17EX_oUuuSVZZPE,598
-RDG_Networks-0.2.5.dist-info/METADATA,sha256=df8uZ3On7aPNlvd59IvUkC2a0IvXktdRO6aaYLa4q0M,2422
-RDG_Networks-0.2.5.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-RDG_Networks-0.2.5.dist-info/entry_points.txt,sha256=Htsh9jRabMCGHwXayUwZoSy-9IFGFrMB1X9hgyyr3_8,350
-RDG_Networks-0.2.5.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
-RDG_Networks-0.2.5.dist-info/RECORD,,