RDG-Networks 0.3.1__py3-none-any.whl → 0.3.4__py3-none-any.whl

{RDG_Networks-0.3.1.dist-info → RDG_Networks-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RDG-Networks
-Version: 0.3.1
+Version: 0.3.4
 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.1.dist-info → RDG_Networks-0.3.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 RDG_networks/Classes.py,sha256=_9X3JPHFAYYlaC8IZ_H9__sfz99G5l9UfPl65lL60_4,7977
-RDG_networks/__init__.py,sha256=Re-b4Ky4fp0QzUB8R8c4VysUMkHEP1VrfXLeOA8W_2w,922
+RDG_networks/__init__.py,sha256=juPsGdSg0t8rIjaELwsQPUKYXVVu1GrdbBI2ncd7lZ0,938
 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
@@ -9,12 +9,11 @@ RDG_networks/get_intersection_segments.py,sha256=mXB5qCy1oOps4Vu1mX6flW6v_4Xxc71
 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=ixi8dBaMi-M_kCdxGfx8V0o_vOTv_anpAgLnPaBwysc,190
-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/generate_line_segments_dynamic_thickness.py,sha256=i10rjKTB9PoFyMaUxVS99YQqegUXfeVfB1qZWryvxRk,25598
 RDG_networks/thickness/sample_in_polygon.py,sha256=nJ-yqfoCCGfC6_EpGL3L1t1LOYdqWZd-7v5bxy6th34,1849
-RDG_Networks-0.3.1.dist-info/LICENSE.txt,sha256=BHUkX2GsdTr30sKmVZ1MLGR1njnx17EX_oUuuSVZZPE,598
-RDG_Networks-0.3.1.dist-info/METADATA,sha256=UD1uvMqUKZzK6p-v0KdyWB_pQUvUcHR4nkuYV3AxAPU,2422
-RDG_Networks-0.3.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-RDG_Networks-0.3.1.dist-info/entry_points.txt,sha256=6AGpOd8ecHGEsoUhRj0j6VvN_Fg0QNCY8h5rInAJom0,542
-RDG_Networks-0.3.1.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
-RDG_Networks-0.3.1.dist-info/RECORD,,
+RDG_Networks-0.3.4.dist-info/LICENSE.txt,sha256=BHUkX2GsdTr30sKmVZ1MLGR1njnx17EX_oUuuSVZZPE,598
+RDG_Networks-0.3.4.dist-info/METADATA,sha256=NrwTO4MslrgfxoBqUxHctABU8Ibht3LxDJZHtdb3k9w,2422
+RDG_Networks-0.3.4.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+RDG_Networks-0.3.4.dist-info/entry_points.txt,sha256=6AGpOd8ecHGEsoUhRj0j6VvN_Fg0QNCY8h5rInAJom0,542
+RDG_Networks-0.3.4.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
+RDG_Networks-0.3.4.dist-info/RECORD,,

RDG_networks/__init__.py

@@ -7,14 +7,14 @@ 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
+from .thickness.generate_line_segments_dynamic_thickness import generate_line_segments_dynamic_thickness
 
 __all__ = ['generate_line_segments', 
            'generate_line_network',
            'get_intersection_segments',
            'generate_line_segments_dynamic',
            'generate_line_segments_static',
-           'generate_line_segments_thickness',
+           'generate_line_segments_dynamic_thickness',
            'draw_segments', 
            'sample_in_polygon',
            'Line', 

RDG_networks/thickness/generate_line_segments_dynamic_thickness.py

@@ -1,8 +1,9 @@
 import math
 import numpy as np
+import random
 from typing import List, Dict, Tuple, Union, Optional
 
-from .Classes import Line, LineSegment
+from .Classes import Line, LineSegment, Polygon
 from .sample_in_polygon import sample_in_polygon, is_inside_polygon
 
 def doLinesIntersect(line1: Line, line2: Line) -> Tuple[bool, Union[Tuple[float, float], None]]:
@@ -40,8 +41,8 @@ def doLinesIntersect(line1: Line, line2: Line) -> Tuple[bool, Union[Tuple[float,
         return False, (None, None)
     
 def doSegmentsIntersect(
-    segment1: 'LineSegment', 
-    segment2: 'LineSegment'
+    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.
@@ -255,7 +256,7 @@ def get_polygons(polygon_id, polygon_arr, neighbor1_1, neighbor1_2, vertex_begin
     return cycle0, vertices0, cycle1, vertices1, cycle2, vertices2
 
 def get_new_segment(
-    line_segments_to_check: List['LineSegment'], 
+    line_segments_to_check: List[LineSegment],
     location: Tuple[float, float], 
     direction: Tuple[float, float], 
     id: Optional[int] = None
@@ -337,7 +338,7 @@ def update_data(
     vertex_end_2: Tuple[float, float], 
     id_1: int, 
     id_2: int
-) -> Tuple[Dict[int, 'LineSegment'], Dict[str, Dict[str, object]], Dict[int, 'Polygon']]:
+) -> 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.
@@ -427,12 +428,12 @@ def update_data(
     return segments_dict, polygon_arr, segment_thickness_dict
     
 def add_line_segment(
-    segments_dict: Dict[int, 'LineSegment'], 
+    segments_dict: Dict[int, LineSegment], 
     polygon_arr: Dict[str, Dict[str, object]], 
-    segment_thickness_dict: Dict[int, 'Polygon'], 
+    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]:
+) -> 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.
 
@@ -520,7 +521,7 @@ 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']]:
+) -> 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.
 

RDG_networks/thickness/functions.py

@@ -1,255 +0,0 @@
-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