RDG-Networks 0.1.8__py3-none-any.whl → 0.2.0__py3-none-any.whl

{RDG_Networks-0.1.8.dist-info → RDG_Networks-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RDG-Networks
-Version: 0.1.8
+Version: 0.2.0
 Summary: Most of the code from the RDG Networks project
 Home-page: https://github.com/NiekMooij/RDG_networks
 Author: Niek Mooij
@@ -36,6 +36,7 @@ This Python package provides code regarding the RDG networks project.
 - **generate_line_segments:** Function that determines the linesegments of a RDG network.
 - **generate_line_network:** Function that makes the underlying network of the linesegments.
 - **get_intersection_segments:** Function that determines the intersection segments of a RDG network.
+- **generate_line_segments_dynamic:** Function that determines the segments of a dynamic RDG network (with increasing linelengths in time).
 - **draw_segments:** Function that draws the segments.
 
 

{RDG_Networks-0.1.8.dist-info → RDG_Networks-0.2.0.dist-info}/RECORD

@@ -1,13 +1,14 @@
 RDG_networks/Classes.py,sha256=_9X3JPHFAYYlaC8IZ_H9__sfz99G5l9UfPl65lL60_4,7977
-RDG_networks/__init__.py,sha256=lbEZ5NwKERxQ4oLXTxWoe8q8f6c_iSx4ZQXDwgx_OP4,759
+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=6WaGHnJ-sDmDdyfqh1I-_x5UJCi_1cU2frlPTJYMPoo,7180
 RDG_networks/get_intersection_segments.py,sha256=mXB5qCy1oOps4Vu1mX6flW6v_4Xxc71YK41yOWjJX8o,2797
 RDG_networks/sample_in_polygon.py,sha256=qpPpW-Da1vK8ZkVWMJ0zBsE8IgyMB619gCdybSkzKSQ,1605
-RDG_Networks-0.1.8.dist-info/LICENSE.txt,sha256=Zlv8517YKFuHaaqksoTKeIiQBl9DGxhUdb_0kJg0NOE,1066
-RDG_Networks-0.1.8.dist-info/METADATA,sha256=7oAfTrYytPyZIzFIQu5PhIvvJ_hn0G_BNqw8uAXC1uU,1756
-RDG_Networks-0.1.8.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-RDG_Networks-0.1.8.dist-info/entry_points.txt,sha256=4LC5qJH7VKpjuuhDR3HpJulO4qy9K5UlAUOGBg6ctxA,268
-RDG_Networks-0.1.8.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
-RDG_Networks-0.1.8.dist-info/RECORD,,
+RDG_Networks-0.2.0.dist-info/LICENSE.txt,sha256=Zlv8517YKFuHaaqksoTKeIiQBl9DGxhUdb_0kJg0NOE,1066
+RDG_Networks-0.2.0.dist-info/METADATA,sha256=KJ84ROI4GhdhdpYIQdPFIWMKNeHOMh1C_lkVxcHccb0,1896
+RDG_Networks-0.2.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+RDG_Networks-0.2.0.dist-info/entry_points.txt,sha256=Htsh9jRabMCGHwXayUwZoSy-9IFGFrMB1X9hgyyr3_8,350
+RDG_Networks-0.2.0.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
+RDG_Networks-0.2.0.dist-info/RECORD,,

{RDG_Networks-0.1.8.dist-info → RDG_Networks-0.2.0.dist-info}/entry_points.txt

@@ -2,4 +2,5 @@
 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
 get_intersection_segments = RDG_networks.get_intersection_segments:main

RDG_networks/__init__.py

@@ -1,16 +1,16 @@
 # __init__.py
 
-# Import important classes, functions, or variables that you want to make available when the package is imported.
 from .Classes import Line, LineSegment, Polygon
 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 .draw_segments import draw_segments
 
-# Define the __all__ variable to specify what should be imported when using "from my_package import *".
 __all__ = ['generate_line_segments', 
            'generate_line_network',
            'get_intersection_segments',
+           'generate_line_segments_dynamic',
            'draw_segments', 
            'sample_in_polygon',
            'Line', 

RDG_networks/generate_line_segments_dynamic.py

@@ -0,0 +1,197 @@
+import numpy as np
+import random
+from shapely.geometry import LineString
+from typing import List, Dict, Any, Tuple
+
+from .Classes import LineSegment
+
+def grow_lines(lines: List[Dict[str, Any]], epsilon: float) -> List[Dict[str, Any]]:
+    """
+    Grows lines based on their current status.
+
+    Args:
+        lines (List[Dict[str, Any]]): A list of dictionaries representing lines, each containing keys
+            'growth_status', 'end', and 'angle'.
+        epsilon (float): The amount by which to grow the lines.
+
+    Returns:
+        List[Dict[str, Any]]: A list of dictionaries representing the updated lines after growth.
+    """
+    for index, line in enumerate(lines):
+        if line['growth_status']:
+            # Update the end point of the line based on epsilon and angle
+            lines[index]['end'] = (
+                line['end'][0] + epsilon * np.cos(line['angle']),
+                line['end'][1] + epsilon * np.sin(line['angle'])
+            )
+    
+    return lines
+
+def add_new_line(lines: List[Dict[str, Any]], line_id: str, t_total: float, angles='uniform') -> List[Dict[str, Any]]:
+    """
+    Adds a new line and its mirror line to the list of lines.
+
+    Args:
+        lines (List[Dict[str, Any]]): A list of dictionaries representing existing lines.
+        line_id (str): The identifier for the new line.
+        t_total (float): The total time elapsed.
+        angles (str) or List: The allowed anfles in the system.
+
+    Returns:
+        List[Dict[str, Any]]: The updated list of lines after adding the new line and its mirror line.
+    """
+    np_x = random.uniform(0, 1)
+    np_y = random.uniform(0, 1)
+    
+    if angles == 'uniform':
+        angle = random.uniform(-np.pi, np.pi)
+        
+    else: 
+        angle = random.choice(angles)
+
+    # Create the first line
+    line_new_1 = {
+        'id': f'{line_id}_1',
+        'introduction_time': t_total,
+        'neighbors_initial': [],
+        'start': (np_x, np_y),
+        'end': (np_x, np_y),
+        'angle': angle,
+        'growth_status': True
+    }
+
+    # Create the mirror line
+    line_new_2 = line_new_1.copy()
+    line_new_2['id'] = f'{line_id}_2'
+    line_new_2['angle'] = angle + np.pi
+
+    # Add both lines to the list
+    lines.extend([line_new_1, line_new_2])
+    
+    return lines
+
+def update_for_border_intersections(lines: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Update lines that intersect with the border.
+
+    Args:
+        lines (List[Dict[str, Any]]): A list of dictionaries representing lines.
+
+    Returns:
+        List[Dict[str, Any]]: The updated list of lines after handling border intersections.
+    """
+    for index, line in enumerate(lines):
+        if lines[index]['growth_status'] == True and (line['end'][0] < 0 or line['end'][0] > 1 or line['end'][1] < 0 or line['end'][1] > 1):
+            # If line has intersected with the border, update its properties
+            lines[index]['neighbors_initial'] = lines[index]['neighbors_initial'] + ['border']
+            lines[index]['growth_status'] = False
+            
+    return lines
+
+def check_and_update_when_intersect(lines: List[Dict[str, Any]], epsilon: float) -> List[Dict[str, Any]]:
+    """
+    Check for intersections between lines and update their properties accordingly.
+
+    Args:
+        lines (List[Dict[str, Any]]): A list of dictionaries representing lines.
+        epsilon (float): The growth rate of the lines.
+
+    Returns:
+        List[Dict[str, Any]]: The updated list of lines after handling intersections.
+    """
+    for index1, j1 in enumerate(lines):
+        for index2, j2 in enumerate(lines):
+            if j1['id'][:-2] == j2['id'][:-2] or index2 < index1:
+                continue
+                
+            line1 = LineString([j1['start'], j1['end']])
+            line2 = LineString([j2['start'], j2['end']])
+
+            intersection_pt = line1.intersection(line2)
+
+            if not intersection_pt.is_empty:
+                d1 = np.linalg.norm(np.array(j1['start']) - np.array([intersection_pt.x, intersection_pt.y]))
+                d2 = np.linalg.norm(np.array(j2['start']) - np.array([intersection_pt.x, intersection_pt.y]))
+                
+                arrival_1 = j1['introduction_time'] + d1 / epsilon
+                arrival_2 = j2['introduction_time'] + d2 / epsilon
+
+                if arrival_1 > arrival_2:
+                    lines[index1]['end'] = (intersection_pt.x, intersection_pt.y)
+                    lines[index1]['neighbors_initial'] = lines[index1]['neighbors_initial'] + [j2['id'][:-2]]
+                    lines[index1]['growth_status'] = False
+
+                else:                        
+                    lines[index2]['end'] = (intersection_pt.x, intersection_pt.y)
+                    lines[index2]['neighbors_initial'] = lines[index2]['neighbors_initial'] + [j1['id'][:-2]]
+                    lines[index2]['growth_status'] = False
+                    
+    return lines
+
+def transform_to_standard_lines(lines: List[Dict[str, Any]]) -> List[LineSegment]:
+    """
+    Transform a list of lines into a list of standard line segments.
+
+    Args:
+        lines (List[Dict[str, Any]]): A list of dictionaries representing lines.
+
+    Returns:
+        List[LineSegment]: A list of LineSegment objects representing standard line segments.
+    """
+    segments = []
+    for index in range(0, len(lines), 2):
+        s1 = lines[index]
+        s2 = lines[index + 1]
+        
+        id = s1['id'][:-2]
+        start = s1['end']
+        end = s2['end']
+        
+        neighbors = [s1['neighbors_initial'], s2['neighbors_initial']]
+        
+        line_segment = LineSegment(start=start, end=end, id=id, neighbors_initial=neighbors)
+        segments.append(line_segment)
+        
+    return segments
+
+def generate_line_segments_dynamic(size: int, dt: float, epsilon: float, time: float) -> List[LineSegment]:
+    """
+    Generate line segments dynamically based on growth and intersection conditions.
+
+    Args:
+        size (int): The desired number of line segments.
+        dt (float): Time increment.
+        epsilon (float): Growth rate of the lines.
+        time (float): Interval at which new lines are added.
+
+    Returns:
+        List[LineSegment]: A list of LineSegment objects representing standard line segments.
+    """
+    lines = []
+    line_id, t, t_total = 1, 0, 0
+
+    # Stop loop whenever we have enough lines and all lines have stopped growing
+    while len(lines) / 2 < size or np.any([item['growth_status'] for item in lines]):
+
+        t += dt
+        t_total += dt
+        
+        if t > time and len(lines) / 2 < size:
+            
+            if time == 0:
+                number_of_lines_to_add = size
+            else:
+                number_of_lines_to_add = int(t - (t % time))
+            for _ in range(number_of_lines_to_add):
+                lines = add_new_line(lines, line_id, t_total)
+                line_id += 1
+            
+                t = 0
+
+        lines = grow_lines(lines, epsilon)
+        lines = update_for_border_intersections(lines)
+        lines = check_and_update_when_intersect(lines, epsilon)
+
+    lines = transform_to_standard_lines(lines)
+        
+    return lines