RDG-Networks 0.3.2__tar.gz → 0.3.5__tar.gz

{rdg_networks-0.3.2 → rdg_networks-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RDG-Networks
-Version: 0.3.2
+Version: 0.3.5
 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.2 → rdg_networks-0.3.5}/RDG_Networks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RDG-Networks
-Version: 0.3.2
+Version: 0.3.5
 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.2 → rdg_networks-0.3.5}/RDG_Networks.egg-info/SOURCES.txt

@@ -16,8 +16,9 @@ RDG_networks/generate_line_segments_dynamic.py
 RDG_networks/generate_line_segments_static.py
 RDG_networks/get_intersection_segments.py
 RDG_networks/sample_in_polygon.py
+RDG_networks/save_to_stl.py
 RDG_networks/thickness/Classes.py
 RDG_networks/thickness/__init__.py
-RDG_networks/thickness/functions.py
-RDG_networks/thickness/generate_line_segments_dynamic_thickness.py
+RDG_networks/thickness/generate_line_segments_thickness_orientation.py
+RDG_networks/thickness/ggenerate_line_segments_thickness.py
 RDG_networks/thickness/sample_in_polygon.py

{rdg_networks-0.3.2 → rdg_networks-0.3.5}/RDG_Networks.egg-info/entry_points.txt

@@ -3,6 +3,8 @@ 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_dynamic_orientation = RDG_networks.generate_line_segments_dynamic_orientation:main
 generate_line_segments_static = RDG_networks.generate_line_segments_static:main
+generate_line_segments_thickness = RDG_networks.thickness.generate_line_segments_thickness:main
 get_intersection_segments = RDG_networks.get_intersection_segments:main
+save_to_stl = RDG_networks.save_to_stl:main

{rdg_networks-0.3.2 → rdg_networks-0.3.5}/RDG_networks/__init__.py

@@ -7,17 +7,21 @@ 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_dynamic_thickness
+from .thickness.generate_line_segments_thickness import generate_line_segments_thickness
+from .thickness.generate_line_segments_thickness_orientation import generate_line_segments_thickness_orientation
+from .save_to_stl import save_to_stl
 
 __all__ = ['generate_line_segments', 
-           'generate_line_network',
-           'get_intersection_segments',
+           'generate_line_segments_thickness',
+           'generate_line_segments_thickness_orientation',
            'generate_line_segments_dynamic',
            'generate_line_segments_static',
-           'generate_line_segments_dynamic_thickness',
+           'generate_line_network',
+           'get_intersection_segments',
            'draw_segments', 
            'sample_in_polygon',
            'Line', 
            'LineSegment', 
-           'Polygon'
+           'Polygon',
+           'save_to_stl'
            ]

rdg_networks-0.3.5/RDG_networks/save_to_stl.py

@@ -0,0 +1,105 @@
+import numpy as np
+import json
+import pandas as pd
+import networkx as nx
+import random
+import matplotlib.pyplot as plt
+import numpy as np
+import math
+import pickle
+
+import numpy as np
+from stl import mesh
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+
+# Function to convert 2D polygon to 3D mesh by adding thickness
+def polygon_to_3d_mesh(polygon, thickness=1.0):
+    # Get the exterior coordinates of the 2D polygon
+    exterior_coords = list(polygon.exterior.coords)
+    
+    # Create vertices for the top and bottom of the 3D shape
+    top_vertices = [(x, y, thickness) for x, y in exterior_coords]
+    bottom_vertices = [(x, y, 0) for x, y in exterior_coords]
+    
+    # Vertices array: two sets of vertices (top and bottom)
+    vertices = np.array(top_vertices + bottom_vertices)
+    n = len(exterior_coords)
+    
+    # Create faces (triangles) connecting the top and bottom surfaces
+    faces = []
+    
+    # Create side walls
+    for i in range(n):
+        next_i = (i + 1) % n
+        faces.append([i, next_i, n + next_i])   # Top to bottom
+        faces.append([i, n + next_i, n + i])    # Bottom to top
+    
+    # Create top and bottom surfaces
+    for i in range(1, n - 1):
+        faces.append([0, i+1, i ])            # Top face
+        faces.append([n, n + i, n + i+1])     # Bottom face
+
+    # Convert faces to NumPy array
+    faces = np.array(faces)
+    
+    # Create mesh object
+    polygon_mesh = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+    
+    for i, face in enumerate(faces):
+        for j in range(3):
+            polygon_mesh.vectors[i][j] = vertices[face[j], :]
+    
+    return polygon_mesh
+
+def merge_3d_meshes(mesh_list):
+    # List to hold the vertices and faces of the merged mesh
+    vertices = []
+    faces = []
+    
+    # Variable to track the current offset for the face indices
+    vertex_offset = 0
+    
+    # Iterate over each mesh and extract its vertices and faces
+    for m in mesh_list:
+        # Extract the vertices and faces of the current mesh
+        current_vertices = m.vectors.reshape(-1, 3)  # Each face is a set of 3 vertices
+        current_faces = np.arange(len(current_vertices)).reshape(-1, 3)
+        
+        # Append the vertices, and adjust the face indices by the current offset
+        vertices.append(current_vertices)
+        faces.append(current_faces + vertex_offset)
+        
+        # Update the vertex offset for the next mesh
+        vertex_offset += len(current_vertices)
+    
+    # Concatenate all the vertices and faces into a single array
+    vertices = np.vstack(vertices)
+    faces = np.vstack(faces)
+    
+    # Create a new merged mesh
+    merged_mesh = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+    
+    # Fill the new mesh with the vertices and faces
+    for i, face in enumerate(faces):
+        for j in range(3):
+            merged_mesh.vectors[i][j] = vertices[face[j], :]
+    
+    return merged_mesh
+
+def save_to_stl(seg_thick_dict, thickness, name):
+    mesh_list = []
+    for k,v in seg_thick_dict.items():
+        p = [] 
+        for j in v.vertices:
+            try: 
+                p.append((float(j[0]), float(j[1])))
+            except:
+                None
+        
+        mesh_list.append(polygon_to_3d_mesh(Polygon(p), thickness=thickness))
+
+    merged_mesh = merge_3d_meshes(mesh_list)
+
+    # Save the merged mesh as an STL file   
+    merged_mesh.save(name)

rdg_networks-0.3.5/RDG_networks/thickness/__init__.py

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

rdg_networks-0.3.5/RDG_networks/thickness/generate_line_segments_thickness_orientation.py

@@ -0,0 +1,180 @@
+import numpy as np
+from typing import List, Dict, Tuple, Union, Optional
+from shapely.geometry import Polygon as Polygon_Shapely, LineString
+import matplotlib.pyplot as plt
+from concurrent.futures import ProcessPoolExecutor
+
+from .Classes import Line, LineSegment, Polygon
+from .generate_line_segments_dynamic_thickness import generate_line_segments_dynamic_thickness
+
+def rot(point, center, rotation_matrix):
+    """
+    Rotates a point around the center using the given rotation matrix.
+    point: numpy array representing the point to rotate
+    center: numpy array representing the center of rotation
+    rotation_matrix: 2x2 numpy array representing the rotation matrix
+    """
+    translated_point = point - center
+    rotated_point = np.dot(rotation_matrix, translated_point)
+    final_point = rotated_point + center
+
+    return final_point
+
+def unit_vector(v):
+    """ Returns the unit vector of the vector. """
+    return v / np.linalg.norm(v)
+
+def angle_between(v1, v2):
+    """ Returns the angle in radians between vectors 'v1' and 'v2'."""
+    v1_u = unit_vector(v1)
+    v2_u = unit_vector(v2)
+    return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))
+
+def get_alignment_mean(line_vector_arr, director):
+    """Get the mean alignment."""
+    S_all = []
+    for item in line_vector_arr:
+        line_vector = item['line_vector']
+        area = item['area']
+        P2 = 0.5*(3*(np.cos(angle_between(line_vector, director)))**2-1)
+        S_all.append(P2*area)
+
+    return float(np.mean(S_all))
+
+def compute_alignment_for_angle(angle, segment_thickness_dict, director, box_size):
+    """Helper function to compute alignment for a given angle."""
+    rotation_matrix = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]])
+    center = np.array([box_size / 2, box_size / 2])
+    line_vector_arr = []
+
+    # Get all line vectors and areas
+    for segment in segment_thickness_dict.values():
+        m_pts = np.array([segment.middle_segment.start, segment.middle_segment.end])
+        (start_rotated, end_rotated) = rot(m_pts, center, rotation_matrix)
+        line_vector = np.array(end_rotated) - np.array(start_rotated)
+        line_vector_arr.append({'line_vector': line_vector, 'area': segment.area()})
+
+    # Calculate the alignment for this angle
+    alignment = get_alignment_mean(line_vector_arr, director)
+    return angle, alignment
+
+def get_max_alignment_angle(segment_thickness_dict, director, box_size, grid_points=360):
+    """Get the angle with the maximum alignment."""
+    # Define the angles we will test
+    angles = np.linspace(0, 2 * np.pi, grid_points)
+
+    with ProcessPoolExecutor() as executor:
+        # Submit tasks for each angle in parallel, passing necessary arguments
+        results = list(executor.map(
+            compute_alignment_for_angle,
+            angles,
+            [segment_thickness_dict] * len(angles),
+            [director] * len(angles),               
+            [box_size] * len(angles)                 
+        ))
+
+    # Find the angle with the maximum alignment
+    max_angle, _ = max(results, key=lambda x: x[1])
+
+    return max_angle
+
+def orientate_network(segment_thickness_dict, config, rotate_angle, box_size):
+    # Rotate the orginal network
+    rotation_matrix = np.array([[np.cos(rotate_angle), -np.sin(rotate_angle)],[np.sin(rotate_angle), np.cos(rotate_angle)]])
+    center = np.array([box_size/2,box_size/2])
+
+    config_angles = [ item['angle'] for item in config]
+    orientated_config = []
+
+    # Get all oriented lines
+    for i, v in enumerate(segment_thickness_dict.values()):
+        angle_rotated = config_angles[i] - rotate_angle
+        n_p_0 = rot(np.array(v.middle_segment.start), center, rotation_matrix)
+        n_p_1 = rot(np.array(v.middle_segment.end), center, rotation_matrix)
+
+        # Find the intersection between the rotated line and the square
+        polygon_box = Polygon_Shapely([(0, 0), (box_size, 0), (box_size, box_size), (0, box_size)])
+        line_middle_point = LineString([(n_p_0[0], n_p_0[1]), (n_p_1[0], n_p_1[1])])
+
+        # Calculate the intersection between the box and the line
+        intersection = polygon_box.intersection(line_middle_point)
+
+        # Check if the line intersects the polygon
+        if intersection.is_empty:
+            continue
+        else:
+            length = intersection.length
+            midpoint = intersection.interpolate(length/2)
+
+            x = midpoint.xy[0][0]
+            y = midpoint.xy[1][0]
+
+            orientated_config.append({ 'location': (x,y), 'angle': angle_rotated, 'thickness': config[i]['thickness'] })
+
+    return orientated_config 
+
+def generate_line_segments_thickness_orientation(
+    size: int, 
+    thickness_arr: List[float], 
+    orientation: List[int],
+    angles: List[float],
+    config: List[List[float]] = None, 
+    epsilon: float = 0,
+    box_size: float = 1,
+    grid_points: int = 360
+    ) -> List[Tuple[Dict[str, LineSegment], Dict[str, Dict[str, object]], Dict[int, Polygon], np.ndarray]]:
+    """
+    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'.
+                List[float]: list of angles in radians.
+        orientation (List[int]): the orientation of the model.
+        config (List[List[float]]): A list of configurations for the nucleation points and angles.
+        epsilon (float): the minimum distance between two line.
+        box_size (float): the size of the system.
+
+    Returns:
+        - an array of dictionaries for each orientation containing:
+        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.
+            - Array of the nucleation points and angles [x,y,theta].
+    """
+    # Size of the box
+    box_size_0 = box_size*np.sqrt(2)
+
+    # Initial structure
+    data_dict = generate_line_segments_dynamic_thickness(size = size,
+                                                        thickness_arr =  thickness_arr,
+                                                        epsilon= epsilon,
+                                                        config = config,
+                                                        angles = angles,
+                                                        box_size= box_size_0)
+    
+    segment_thickness_dict = data_dict['segment_thickness_dict']
+    generated_config = data_dict['generated_config']
+
+    # Calculate alignment with the y axis
+    director = (0,1)
+    max_angle = get_max_alignment_angle(segment_thickness_dict, director, box_size, grid_points)
+    
+    # Regenerate network for each orientation
+    output = []
+    for o in orientation:
+        rotate_angle = o-max_angle
+        orientated_config = orientate_network(segment_thickness_dict, generated_config, rotate_angle, box_size)
+
+        data_dict_new = generate_line_segments_dynamic_thickness(size=size,
+                                                                thickness_arr=thickness_arr,
+                                                                epsilon=epsilon,
+                                                                config=orientated_config,
+                                                                angles=angles,
+                                                                box_size=box_size)
+
+        output.append({'orientation': o, 'data_dict': data_dict_new})
+    
+    return output

rdg_networks-0.3.2/RDG_networks/thickness/generate_line_segments_dynamic_thickness.py → rdg_networks-0.3.5/RDG_networks/thickness/ggenerate_line_segments_thickness.py

@@ -1,17 +1,20 @@
 import math
 import numpy as np
+import random
 from typing import List, Dict, Tuple, Union, Optional
+from shapely.geometry import Polygon as Polygon_Shapely, LineString
 
-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]]:
+def doLinesIntersect(line1: Line, line2: Line, box_size = 1) -> 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.
+    - box_size (float): The size of the bounding box. Defaults to 1.
 
     Returns:
     - intersect (bool): True if the lines intersect, False otherwise.
@@ -34,14 +37,16 @@ def doLinesIntersect(line1: Line, line2: Line) -> Tuple[bool, Union[Tuple[float,
     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:
+
+    if -1e-6 < intersect_x < box_size + 1e-6 and -1e-6 < intersect_y < box_size + 1e-6:
         return True, (intersect_x, intersect_y)
     else:
         return False, (None, None)
     
 def doSegmentsIntersect(
-    segment1: 'LineSegment', 
-    segment2: 'LineSegment'
+    segment1: LineSegment, 
+    segment2: LineSegment,
+    box_size = 1
 ) -> Tuple[bool, Tuple[Optional[float], Optional[float]]]:
     """
     Determines if two line segments intersect and returns the intersection point if they do.
@@ -62,7 +67,7 @@ def doSegmentsIntersect(
     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)
+    intersect, (intersect_x, intersect_y) = doLinesIntersect(line1, line2, box_size)
     
     # If no intersection, return False
     if not intersect:
@@ -137,6 +142,8 @@ def pick_item_with_probability(
 def get_location_and_direction(
     polygon_arr: Dict[str, Dict[str, object]], 
     thickness: float, 
+    nucleation_point: Tuple[float, float] = None,
+    min_distance: float = 0,
     max_attempts: int = 1000, 
     angles: Union[str, List[float]] = 'uniform'
 ) -> Union[Tuple[str, Dict[str, object], Tuple[float, float], np.ndarray, np.ndarray], bool]:
@@ -154,6 +161,10 @@ def get_location_and_direction(
             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'.
+        nucleation_point (Tuple[float, float], optional): 
+            predified nucleation point for the segment. Defaults to None.
+        min_distance (float, optional): 
+            the minimum distance between two lines. Defaults to 0.
 
     Returns:
         Union[Tuple[str, Dict[str, object], Tuple[float, float], np.ndarray, np.ndarray], bool]:
@@ -163,17 +174,20 @@ def get_location_and_direction(
                 - 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`).
+                - The nucleation point [x,y] of the segment
+                - The angle of the segment.
             - 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)])
+        angle_new = random.uniform(-np.pi, np.pi)
+        direction = (np.cos(angle_new), np.sin(angle_new))
         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
+        angle_new = random.choice(angles)
+        direction = (np.cos(angle_new), np.sin(angle_new))
+        direction = np.array(direction) / np.linalg.norm(direction)
     
     # Try to find a valid location and direction up to max_attempts
     attempt = 0
@@ -181,7 +195,11 @@ def get_location_and_direction(
         polygon_id, polygon = pick_item_with_probability(polygon_arr)
         
         # Sample a location within the polygon
-        location_new = sample_in_polygon(polygon['vertices'])
+        #check if nucleation point is given
+        if nucleation_point:
+            location_new = nucleation_point
+        else:
+            location_new = sample_in_polygon(polygon['vertices'])
         
         # Compute the perpendicular vector to the direction
         perpendicular = np.array([direction[1], -direction[0]])
@@ -192,12 +210,12 @@ def get_location_and_direction(
             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
+        p1 = np.array(location_new) + (thickness/2 + min_distance) * perpendicular 
+        p2 = np.array(location_new) - (thickness/2 + min_distance) * 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
+            return polygon_id, polygon, location_new, direction, perpendicular, angle_new
         
         attempt += 1
     
@@ -255,11 +273,12 @@ 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
-) -> 'LineSegment':
+    id: Optional[int] = None,
+    box_size: float = 1
+) -> 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.
@@ -269,18 +288,20 @@ def get_new_segment(
         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.
+        box_size(optional[Int]]): The size of the box. Defaults to 1.
 
     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]]] = []
+    s_temp = LineSegment(start=np.array(location) - 10*np.sqrt(2)*box_size * np.array(direction), end=np.array(location) + 10*np.sqrt(2)*box_size * np.array(direction))
+
+    intersection_points = []
 
     # Check for intersections with existing line segments
     for segment in line_segments_to_check:
-        intersect, (intersect_x, intersect_y) = doSegmentsIntersect(s_temp, segment)
+        intersect, (intersect_x, intersect_y) = doSegmentsIntersect(s_temp, segment, box_size)
 
         if intersect:
             segment_length = math.sqrt(
@@ -317,10 +338,10 @@ def get_new_segment(
     return segment_new
     
 def update_data(
-    segments_dict: Dict[int, 'LineSegment'], 
+    segments_dict: Dict[int, LineSegment], 
     polygon_arr: Dict[str, Dict[str, object]], 
     polygon_id: str, 
-    segment_thickness_dict: Dict[int, 'Polygon'], 
+    segment_thickness_dict: Dict[int, Polygon], 
     vertices0: List[Tuple[float, float]], 
     vertices1: List[Tuple[float, float]], 
     vertices2: List[Tuple[float, float]], 
@@ -337,7 +358,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 +448,16 @@ 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'], 
-    thickness: float = 0, 
-    angles: str = 'uniform'
-) -> Union[Tuple[Dict[int, 'LineSegment'], Dict[str, Dict[str, object]], Dict[int, 'Polygon']], bool]:
+    segment_thickness_dict: Dict[int, Polygon], 
+    angles: str = 'uniform',
+    thickness: float = 0,
+    nucleation_point: Tuple[float, float] = None,
+    min_distance: float = 0,
+    box_size: float = 1,
+    max_attempts: int = 1000
+) -> Union[Tuple[Dict[int, LineSegment], Dict[str, Dict[str, object]], Dict[int, Polygon], List[float], float], bool]:
     """
     Adds a new line segment to the segments and polygon data structures, with a given thickness and angle distribution.
 
@@ -442,26 +467,31 @@ def add_line_segment(
         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'.
+        nucleation_point (Tuple[float, float]): A predefined nucleation point for the new segment. Defaults to None.
+        min_distance (float): The minimum distance between two lines. Defaults to 0.
+        box_size (float): The size of the box. Defaults to 1.
+        max_attempts (int): The maximum number of attempts to find a valid location and direction. Defaults to 1000.
 
     Returns:
-        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]], List[float], float, 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.
+            -nucleation point in a list [x,y] and the angle of the segment in radians.
     """
     
     # 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)
+    loc = get_location_and_direction(polygon_arr, thickness, nucleation_point, min_distance, max_attempts=max_attempts, angles=angles)
     if loc:
-        polygon_id, polygon, location_new, direction_new, perpendicular = loc
+        polygon_id, polygon, location_new, direction_new, perpendicular, angle_new = 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)
+    middle_segment = get_new_segment(line_segments_to_check, location=location_new, direction=direction_new, box_size=box_size)
+    s1 = get_new_segment(line_segments_to_check, location=np.array(location_new) + thickness * perpendicular / 2, direction=direction_new,box_size=box_size)
+    s2 = get_new_segment(line_segments_to_check, location=np.array(location_new) - thickness * perpendicular / 2, direction=direction_new, box_size=box_size)
     
     # Extract neighbor information and segment vertices
     neighbor1_1, neighbor1_2 = list(s1.neighbors.keys())
@@ -514,13 +544,16 @@ def add_line_segment(
     # 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
+    return segments_dict, polygon_arr, segment_thickness_dict, location_new, angle_new
 
-def generate_line_segments_dynamic_thickness(
+def generate_line_segments_thickness(
     size: int, 
     thickness_arr: List[float], 
-    angles: str = 'uniform'
-) -> Tuple[Dict[str, 'LineSegment'], Dict[str, Dict[str, object]], Dict[int, 'Polygon']]:
+    angles: str = 'uniform',
+    config: List[List[float]] = None, 
+    epsilon: float = 0,
+    box_size: float = 1 
+    ) -> Tuple[Dict[str, LineSegment], Dict[str, Dict[str, object]], Dict[int, Polygon], np.ndarray]:
     """
     Generates a specified number of line segments and updates the polygon and segment thickness dictionaries.
 
@@ -528,26 +561,31 @@ def generate_line_segments_dynamic_thickness(
         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'.
+                List[float]: list of angles in radians.
+        config (List[List[float]]): A list of configurations for the nucleation points and angles.
+        epsilon (float): the minimum distance between two line.
+        box_size (float): the size of the box.
 
     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.
+            - Array of the nucleation points and angles [x,y,theta].
     """
     
     # 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)})
+        LineSegment((box_size, 0), (0, 0), id='b1', neighbors_initial={'b2': (0, 0), 'b4': (box_size, 0)}, neighbors={'b2': (0, 0), 'b4': (box_size, 0)}),
+        LineSegment((0, box_size), (0, 0), id='b2', neighbors_initial={'b1': (0, 0), 'b3': (0, box_size)}, neighbors={'b1': (0, 0), 'b3': (0, box_size)}),
+        LineSegment((0, box_size), (box_size, box_size), id='b3', neighbors_initial={'b2': (0, box_size), 'b4': (box_size, box_size)}, neighbors={'b2': (0, box_size), 'b4': (box_size, box_size)}),
+        LineSegment((box_size, box_size), (box_size, 0), id='b4', neighbors_initial={'b1': (box_size, 0), 'b3': (box_size, box_size)}, neighbors={'b1': (box_size, 0), 'b3': (box_size, box_size)})
     ]
     
     polygon_arr = {
         'p1': {
-            'vertices': [(0, 0), (0, 1), (1, 1), (1, 0)], 
-            'area': 1, 
+            'vertices': [(0, 0), (0, box_size), (box_size, box_size), (box_size, 0)], 
+            'area': box_size**2, 
             'faces': ['b1', 'b2', 'b3', 'b4']
         }
     }
@@ -555,18 +593,47 @@ def generate_line_segments_dynamic_thickness(
     segments = borders
     segments_dict = {segment.id: segment for segment in segments}
     segment_thickness_dict = {}
+    generated_config = []
 
-    # Generate new line segments based on the given size and thickness array
+    if config is not None and size > len(config):
+        print("The size of the configuration is smaller than the size of the segments. Generated a network of the same size as the configuration.")
+        size = len(config)
+
+    jammed = False
     for i in range(size):
-        output = add_line_segment(segments_dict, polygon_arr, segment_thickness_dict, thickness=thickness_arr[i], angles=angles)
+        if config:
+            nucleation_point = config[i]['location']
+            angles = [config[i]['angle']]
+        else:
+            nucleation_point = None
+            if angles != 'uniform':
+                angles=[angles[i]]
+
+        output = add_line_segment(segments_dict, 
+                                    polygon_arr, 
+                                    segment_thickness_dict, 
+                                    thickness=thickness_arr[i], 
+                                    min_distance = epsilon,
+                                    nucleation_point = nucleation_point, 
+                                    angles=angles,
+                                    box_size=box_size)
         if output:
-            segments_dict, polygon_arr, segment_thickness_dict = output
+            segments_dict, polygon_arr, segment_thickness_dict, location, angle = output
+            # generated_config += [[n_pts[0], n_pts[1], ang]]
+            generated_config.append({ 'location': location, 'angle': angle, 'thickness': thickness_arr[i] })
+
         else: 
-            print(f"Stopped at iteration {i}, could not find a valid segment position.")
-            break
+            print(f"Stopped at iteration {len(segment_thickness_dict)}, could not find a valid segment position.")
+            jammed = True
         
         # 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
+    data_dict = {'segments_dict': segments_dict, 
+                 'polygon_arr': polygon_arr, 
+                 'segment_thickness_dict': segment_thickness_dict, 
+                 'jammed': jammed,
+                 'generated_config': generated_config}
+    
+    return data_dict

{rdg_networks-0.3.2 → rdg_networks-0.3.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='RDG-Networks',
-    version='0.3.2',
+    version='0.3.5',
     author='Niek Mooij',
     author_email='mooij.niek@gmail.com',
     description='Most of the code from the RDG Networks project',
@@ -24,12 +24,14 @@ setup(
     entry_points={
         'console_scripts': [
             'generate_line_segments=RDG_networks.generate_line_segments:main',
-            'generate_line_network=RDG_networks.generate_line_network:main',
-            'get_intersection_segments=RDG_networks.get_intersection_segments:main',
+            'generate_line_segments_thickness=RDG_networks.thickness.generate_line_segments_thickness:main',
+            'generate_line_segments_dynamic_orientation=RDG_networks.generate_line_segments_dynamic_orientation:main',
             'generate_line_segments_dynamic=RDG_networks.generate_line_segments_dynamic:main',
             'generate_line_segments_static=RDG_networks.generate_line_segments_static:main',
-            'generate_line_segments_dynamic_thickness=RDG_networks.thickness.generate_line_segments_dynamic_thickness:main',
-            'draw_segments=RDG_networks.draw_segments:main'
+            'generate_line_network=RDG_networks.generate_line_network:main',
+            'get_intersection_segments=RDG_networks.get_intersection_segments:main',
+            'draw_segments=RDG_networks.draw_segments:main',
+            'save_to_stl=RDG_networks.save_to_stl:main'
         ],
     },
 )

rdg_networks-0.3.2/RDG_networks/thickness/__init__.py

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

rdg_networks-0.3.2/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