RDG-Networks 0.3.6__tar.gz → 0.3.8__tar.gz

{rdg_networks-0.3.6 → rdg_networks-0.3.8}/PKG-INFO

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

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

@@ -20,6 +20,6 @@ RDG_networks/save_to_stl.py
 RDG_networks/thickness/Classes.py
 RDG_networks/thickness/__init__.py
 RDG_networks/thickness/generate_line_segments_thickness.py
-RDG_networks/thickness/generate_line_segments_thickness_orientation backup.py
-RDG_networks/thickness/generate_line_segments_thickness_orientation.py
+RDG_networks/thickness/generate_line_segments_thickness_static.py
+RDG_networks/thickness/orientate_network.py
 RDG_networks/thickness/sample_in_polygon.py

{rdg_networks-0.3.6 → rdg_networks-0.3.8}/RDG_Networks.egg-info/entry_points.txt

@@ -6,9 +6,10 @@ generate_line_segments = RDG_networks.generate_line_segments: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_thickness = RDG_networks.thickness.generate_line_segments_thickness:main
-generate_line_segments_thickness_orientation = RDG_networks.thickness.generate_line_segments_dynamic_orientation:main
+generate_line_segments_thickness_static = RDG_networks.generate_line_segments_thickness_static:main
 get_alignment_mean = RDG_networks.thickness.get_alignment_mean:main
 get_intersection_segments = RDG_networks.get_intersection_segments:main
+orientate_network = RDG_networks.thickness.orientate_network:main
 rotate_network = RDG_networks.thickness.rotate_network:main
 save_to_stl = RDG_networks.save_to_stl:main
 translate_network = RDG_networks.thickness.translate_network:main

{rdg_networks-0.3.6 → rdg_networks-0.3.8}/RDG_networks/__init__.py

@@ -8,22 +8,24 @@ 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_thickness import generate_line_segments_thickness
-from .thickness.generate_line_segments_thickness_orientation import generate_line_segments_thickness_orientation
-from .thickness.generate_line_segments_thickness_orientation import translate_network
-from .thickness.generate_line_segments_thickness_orientation import clip_network
-from .thickness.generate_line_segments_thickness_orientation import rotate_network
-from .thickness.generate_line_segments_thickness_orientation import get_alignment_mean
+from .thickness.orientate_network import orientate_network
+from .thickness.generate_line_segments_thickness_static import generate_line_segments_thickness_static
+from .thickness.orientate_network import translate_network
+from .thickness.orientate_network import clip_network
+from .thickness.orientate_network import rotate_network
+from .thickness.orientate_network import get_alignment_mean
 from .save_to_stl import save_to_stl
 
 __all__ = ['generate_line_segments', 
            'generate_line_segments_thickness',
-           'generate_line_segments_thickness_orientation',
+           'orientate_network',
            'translate_network',
            'clip_network',
            'rotate_network',
            'get_alignment_mean',
-           'generate_line_segments_dynamic',
            'generate_line_segments_static',
+           'generate_line_segments_thickness_static',
+           'generate_line_segments_dynamic',
            'generate_line_network',
            'get_intersection_segments',
            'draw_segments', 

{rdg_networks-0.3.6 → rdg_networks-0.3.8}/RDG_networks/save_to_stl.py

@@ -87,7 +87,7 @@ def merge_3d_meshes(mesh_list):
     
     return merged_mesh
 
-def save_to_stl(seg_thick_dict, thickness, name):
+def save_to_stl(seg_thick_dict, thickness, name, frame_thickness = None):
     mesh_list = []
     for k,v in seg_thick_dict.items():
         p = [] 
@@ -98,6 +98,18 @@ def save_to_stl(seg_thick_dict, thickness, name):
                 None
         
         mesh_list.append(polygon_to_3d_mesh(Polygon(p), thickness=thickness))
+    
+    if frame_thickness != None:
+        t = frame_thickness
+        bottom = Polygon([ (0,0-t), (0,0),(1,0),(1,0-t)])
+        top = Polygon([(0,1),(0,1+t), (1,1+t), (1,1)])
+        right = Polygon([(1,0-t), (1,1+t), (1+t,1+t), (1+t,0-t)])
+        left = Polygon([(0-t,0-t),(0-t,1+t), (0,1+t), (0,0-t)])
+
+        f = [bottom,top,  right, left]
+
+        for f_ in f:            
+            mesh_list.append(polygon_to_3d_mesh(f_, thickness=thickness))
 
     merged_mesh = merge_3d_meshes(mesh_list)
 

rdg_networks-0.3.8/RDG_networks/thickness/__init__.py

@@ -0,0 +1,19 @@
+# __init__.py
+
+from .generate_line_segments_thickness import generate_line_segments_thickness
+from .orientate_network import orientate_network
+from .generate_line_segments_thickness_static import generate_line_segments_thickness_static
+from .orientate_network import translate_network
+from .orientate_network import clip_network
+from .orientate_network import rotate_network
+from .orientate_network import get_alignment_mean
+
+__all__ = [
+           'generate_line_segments_thickness',
+           'orientate_network',
+           'generate_line_segments_thickness_static',
+           'translate_network',
+           'clip_network',
+           'rotate_network',
+           'get_alignment_mean'
+           ]

{rdg_networks-0.3.6 → rdg_networks-0.3.8}/RDG_networks/thickness/generate_line_segments_thickness.py

@@ -142,10 +142,10 @@ def pick_item_with_probability(
 def get_location_and_direction(
     polygon_arr: Dict[str, Dict[str, object]], 
     thickness: float, 
+    angle: float,
     nucleation_point: Tuple[float, float] = None,
     min_distance: float = 0,
-    max_attempts: int = 1000, 
-    angles: Union[str, List[float]] = 'uniform'
+    max_attempts: int = 1000
 ) -> 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 
@@ -159,8 +159,8 @@ def get_location_and_direction(
             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'.
+        angle (float): 
+            A float indicating the angle of the new segment.
         nucleation_point (Tuple[float, float], optional): 
             predified nucleation point for the segment. Defaults to None.
         min_distance (float, optional): 
@@ -178,16 +178,8 @@ def get_location_and_direction(
                 - 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':
-        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:
-        angle_new = random.choice(angles)
-        direction = (np.cos(angle_new), np.sin(angle_new))
-        direction = np.array(direction) / np.linalg.norm(direction)
+    direction = (np.cos(angle), np.sin(angle))
+    direction = np.array(direction) / np.linalg.norm(direction)
     
     # Try to find a valid location and direction up to max_attempts
     attempt = 0
@@ -215,7 +207,7 @@ def get_location_and_direction(
         
         # 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, angle_new
+            return polygon_id, polygon, location_new, direction, perpendicular, angle
         
         attempt += 1
     
@@ -451,7 +443,7 @@ def add_line_segment(
     segments_dict: Dict[int, LineSegment], 
     polygon_arr: Dict[str, Dict[str, object]], 
     segment_thickness_dict: Dict[int, Polygon], 
-    angles: str = 'uniform',
+    angle: float,
     thickness: float = 0,
     nucleation_point: Tuple[float, float] = None,
     min_distance: float = 0,
@@ -480,7 +472,7 @@ def add_line_segment(
     """
     
     # Get a valid location and direction, or return False if none is found
-    loc = get_location_and_direction(polygon_arr, thickness, nucleation_point, min_distance, max_attempts=max_attempts, angles=angles)
+    loc = get_location_and_direction(polygon_arr, angle=angle, thickness=thickness, nucleation_point=nucleation_point, min_distance=min_distance, max_attempts=max_attempts)
     if loc:
         polygon_id, polygon, location_new, direction_new, perpendicular, angle_new = loc
     else:
@@ -560,8 +552,7 @@ def generate_line_segments_thickness(
     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.
+        angles (str): Angle used in the generation of the segments.
         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.
@@ -606,8 +597,8 @@ def generate_line_segments_thickness(
             angles = [config[i]['angle']]
         else:
             nucleation_point = None
-            if angles != 'uniform':
-                angles=[angles[i]]
+            # if angles != 'uniform':
+            #     angles=[angles[i]]
 
         output = add_line_segment(segments_dict, 
                                     polygon_arr, 
@@ -615,7 +606,7 @@ def generate_line_segments_thickness(
                                     thickness=thickness_arr[i], 
                                     min_distance = epsilon,
                                     nucleation_point = nucleation_point, 
-                                    angles=angles,
+                                    angle=angles[i],
                                     box_size=box_size)
         if output:
             segments_dict, polygon_arr, segment_thickness_dict, location, angle = output

rdg_networks-0.3.8/RDG_networks/thickness/generate_line_segments_thickness_static.py

@@ -0,0 +1,240 @@
+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, Polygon
+
+def minDistance_line_point(A, B, E):
+    # vector AB
+    AB = np.array(B) - np.array(A)
+    EB = np.array(B) - np.array(E)
+    AE = np.array(E) - np.array(A)
+  
+    # Calculating the dot product
+    AB_BE = np.dot(AB, EB)
+    AB_AE = np.dot(AB, AE)
+     
+    # Case 1
+    if (AB_BE > 0):
+        # Finding the magnitude
+        y = E[1] - B[1]
+        x = E[0] - B[0]
+        reqAns = np.sqrt(x * x + y * y)
+
+    # Case 2
+    elif (AB_AE < 0):
+        y = E[1] - A[1]
+        x = E[0] - A[0]
+        reqAns = np.sqrt(x * x + y * y)
+ 
+    # Case 3
+    else:
+        reqAns = np.linalg.outer(AB, AE) / np.linalg.norm(AB)
+     
+    return reqAns
+
+def doLinesIntersect(line1, line2):
+    """
+    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[0]
+    v1, w1 = (np.cos(line1[1]), np.sin(line1[1]))
+
+    x2, y2 = line2[0]
+    v2, w2 = (np.cos(line2[1]), np.sin(line2[1]))
+
+    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 seeds(number_of_lines, radius = 0.015, number_of_trials = 10000):
+    Line = {}
+    line_id = 0
+    
+    nucleation_points = [(0,0), (1,0), (1,1), (0,1)]
+    angle = [0,np.pi/2, np.pi, 3*np.pi/2]
+    
+    Line = {'b1':[ (0,0), 0], 'b2':[ (1,0), np.pi/2], 'b3':[ (1,1), np.pi], 'b4':[ (0,1), 3*np.pi/2] }
+    
+    for i in range(number_of_lines):
+        new_points =  (random.uniform(0,1), random.uniform(0,1))
+    
+        line_new_point = []
+        for j in range(len(nucleation_points)):
+            start = (np.cos(angle[i])*10+nucleation_points[i][0], np.sin(angle[i])*10+nucleation_points[i][1])
+            end = (-np.cos(angle[i])*10+nucleation_points[i][0], -np.sin(angle[i])*10+nucleation_points[i][1])
+            line_new_point += [minDistance_line_point(start, end, new_points)]
+            
+        trial = 0
+        while  sum(np.array(line_new_point) < radius) != 0 or np.sum( np.sqrt(np.sum((np.array(nucleation_points) - np.array(new_points))**2, axis = 1)) < radius) != 0:
+            new_points =  (random.uniform(0,1), random.uniform(0,1))
+    
+            line_new_point = []
+            for j in range(len(nucleation_points)):
+                start = (np.cos(angle[i])*10+nucleation_points[i][0], np.sin(angle[i])*10+nucleation_points[i][1])
+                end = (-np.cos(angle[i])*10+nucleation_points[i][0], -np.sin(angle[i])*10+nucleation_points[i][1])
+                line_new_point += [minDistance_line_point(start, end, new_points)]
+            
+            trial += 1
+    
+            if trial > number_of_trials:
+                break
+    
+        if trial <= number_of_trials:
+            nucleation_points += [new_points]
+            angles = [0, np.pi/4, np.pi/2, 3*np.pi/4]
+            angle_new = random.uniform(0, 2*np.pi)
+            angle += [angle_new]
+            Line[line_id] = [ new_points ,angle_new]
+            line_id += 1
+        else:
+            print('jammed')
+            break
+
+    return Line
+
+def all_intersection(Line):
+    intersections_dict = {}
+
+    for k,v in Line.items():
+        #intersections_dict[k] = {}
+        intersections_dict[k] = {'back':{}, 'front':{}}
+    
+        for kk,vv in Line.items():
+            intersect, (intersect_x, intersect_y) = doLinesIntersect(v ,vv)
+
+            if intersect:
+                segment_length = np.sqrt( (v[0][0] - intersect_x)**2 + (v[0][1] - intersect_y)**2)
+            
+                if intersect_x < v[0][0]:
+                    intersections_dict[k]['back'][kk] =  [(intersect_x, intersect_y), segment_length] 
+                else:
+                    if intersect_x == v[0][0] and intersect_y < v[0][1]:
+                        intersections_dict[k]['back'][kk] =  [(intersect_x, intersect_y), segment_length] 
+                    else:
+                        intersections_dict[k]['front'][kk] =  [(intersect_x, intersect_y), segment_length] 
+        intersections_dict[k]['back'] = dict(sorted(intersections_dict[k]['back'].items(), key=lambda e:e[1], reverse = True))
+        intersections_dict[k]['front'] = dict(sorted(intersections_dict[k]['front'].items(), key=lambda e:e[1]))
+
+    return intersections_dict
+
+def transform_to_standard_lines(segments):
+    data = []
+    for s in segments:
+        start = (s[3], s[4])
+        end = (s[5], s[6])
+        line = LineSegment(start=start, end=end, id=s[0], neighbors_initial=[s[1], s[2]], neighbors=None)
+        data.append(line)
+        
+    return data
+
+def static_line_graph_generation(seed_loc, intersections_dict):
+    borders = ['b1', 'b2', 'b3', 'b4']
+    segments = []
+    edges = []
+            
+    for k,v in seed_loc.items():
+        if k not in borders:
+            #front
+            for kk_f, vv_f in intersections_dict[k]['front'].items():
+                try:
+                    d_k_kk = intersections_dict[kk_f]['back'][k][1]
+                    front_coordinate = intersections_dict[kk_f]['back'][k][0]
+                    front_id = kk_f
+                    where = 'back'
+                except:
+                    d_k_kk = intersections_dict[kk_f]['front'][k][1]
+                    front_coordinate = intersections_dict[kk_f]['front'][k][0]
+                    front_id = kk_f
+                    where = 'front'
+    
+                if vv_f[1] > d_k_kk:
+                    #check kk neighbors 
+                    boolean = []
+                    for kkk, vvv in intersections_dict[kk_f][where].items():
+                        if vvv[1] < d_k_kk:
+                            try:
+                                d_kk_kkk = intersections_dict[kkk]['back'][kk_f][1]
+                            except:
+                                d_kk_kkk = intersections_dict[kkk]['front'][kk_f][1]
+    
+                            if d_kk_kkk > vvv[1]:
+                                boolean += [0]
+                            else:
+                                boolean += [1]
+    
+                    #print(k,kk, boolean)
+                     
+                    if sum(boolean) == 0:
+                        #print(k, kk, front_coordinate)
+                        break
+                        
+            #back
+            for kk_b, vv_b in intersections_dict[k]['back'].items():
+                try:
+                    d_k_kk = intersections_dict[kk_b]['back'][k][1]
+                    back_coordinate = intersections_dict[kk_b]['back'][k][0]
+                    back_id = kk_b
+                    where = 'back'
+                except:
+                    d_k_kk = intersections_dict[kk_b]['front'][k][1]
+                    back_coordinate = intersections_dict[kk_b]['front'][k][0]
+                    back_id = kk_b
+                    where = 'front'
+    
+                if vv_b[1] > d_k_kk:
+                    boolean = []
+                    for kkk, vvv in intersections_dict[kk_b][where].items():
+                        if vvv[1] < d_k_kk:
+                            try:
+                                d_kk_kkk = intersections_dict[kkk]['back'][kk_b][1]
+                            except:
+                                d_kk_kkk = intersections_dict[kkk]['front'][kk_b][1]
+    
+                            if d_kk_kkk > vvv[1]:
+                                boolean += [0]
+                            else:
+                                boolean += [1]
+
+                    if sum(boolean) == 0:
+                        break
+    
+        try:
+            if k!= kk_f and k!= kk_b and kk_f != kk_b and (k, kk_f) not in edges and (kk_f, k) not in edges and (k, kk_b) not in edges and (kk_b, k) not in edges:                           
+                segments+= [[k, kk_f, kk_b, front_coordinate[0], front_coordinate[1], back_coordinate[0], back_coordinate[1]]]
+                edges += [(k,kk_f)]
+                edges += [(k,kk_b)]
+        except:
+            None
+        
+    return segments
+
+def generate_line_segments_thickness_static(size, seed_loc=None):
+    if seed_loc is None:
+        seed_loc = seeds(size, 0.0)
+    segments = static_line_graph_generation(seed_loc, all_intersection(seed_loc))
+    segments = transform_to_standard_lines(segments)
+    
+    return segments

rdg_networks-0.3.6/RDG_networks/thickness/generate_line_segments_thickness_orientation.py → rdg_networks-0.3.8/RDG_networks/thickness/orientate_network.py

@@ -1,8 +1,8 @@
 import numpy as np
+import math
 from typing import List, Dict, Tuple
 from shapely.geometry import Polygon as Polygon_Shapely
 from shapely.geometry import LineString, box
-from concurrent.futures import ProcessPoolExecutor
 from .Classes import LineSegment, Polygon
 
 def rotate(point, center, rotation_matrix):
@@ -13,7 +13,9 @@ def rotate(point, center, rotation_matrix):
     rotation_matrix: 2x2 numpy array representing the rotation matrix
     """
     translated_point = point - center
-    rotated_point = np.dot(rotation_matrix, translated_point)
+
+    # rotated_point = np.dot(rotation_matrix, translated_point)
+    rotated_point = rotation_matrix@translated_point
     final_point = rotated_point + center
 
     return final_point
@@ -30,16 +32,22 @@ def angle_between(v1, v2):
 
 def get_alignment_mean(line_vector_arr, director):
     """Get the mean alignment."""
-    S_all = []
+    S_all = 0
+    total_mass = 0
     for item in line_vector_arr:
         line_vector = item['line_vector']
+        vector_diff = np.array(line_vector[1]) - np.array(line_vector[0])
+
         area = item['area']
-        P2 = 0.5*(3*(np.cos(angle_between(line_vector, director)))**2-1)
-        S_all.append(P2*area)
+        align = math.cos(angle_between(vector_diff, director))**2
+        S_all += align*area
+        total_mass += area
 
-    return float(np.mean(S_all))
+    output = S_all / total_mass
 
-def compute_alignment_for_angle(
+    return output
+
+def compute_alignment(
     angle: float, 
     segment_thickness_dict: dict[str, Polygon],
     director: np.ndarray, 
@@ -69,7 +77,7 @@ def compute_alignment_for_angle(
     tuple[float, float]
         A tuple where the first element is the input angle and the second element is the computed alignment value.
     """
-    box_center = (np.array(box_measurements[0]) + np.array(box_measurements[2])) / 2
+    box_center = np.array((box_measurements[0]) + np.array(box_measurements[2])) / 2
 
     # Rotate network
     segment_thickness_dict_new = rotate_network(segment_thickness_dict, rotate_angle=angle, box_center=box_center)
@@ -79,13 +87,38 @@ def compute_alignment_for_angle(
 
     line_vectors = [
         {'line_vector': [seg.middle_segment.start, seg.middle_segment.end], 'area': seg.area()}
-        for seg in segment_thickness_dict_new.values()
+        for seg in segment_thickness_dict_new.values() if seg.middle_segment is not None
     ]
 
     alignment = get_alignment_mean(line_vectors, director)
-
+    
     return angle, alignment
 
+def get_max_alignment(
+    segment_thickness_dict: dict, 
+    director: np.ndarray, 
+    box_measurements: list[float], 
+    grid_points: int = 360
+) -> float:
+    """Find the angle with the maximum alignment using parallel processing."""
+    # Create a list of angles to evaluate
+    angles = np.linspace(0, np.pi, grid_points)
+
+    results = []
+    for a in angles:
+        result = compute_alignment(a, segment_thickness_dict, director, box_measurements)
+        results.append(result)
+
+    # Find the angle with the maximum alignment
+    max_alignment = 0
+    max_angle = None
+    for angle, alignment in results:
+        if alignment > max_alignment:
+            max_alignment = alignment
+            max_angle = angle
+
+    return max_angle
+
 def rotate_network(
     segment_thickness_dict: dict[str, Polygon],
     rotate_angle: float, 
@@ -256,74 +289,12 @@ def translate_network(
 
     return segment_thickness_dict_new
 
-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(
-    segment_thickness_dict: dict,
-    angle: float, 
-    box_center,
-    director: np.ndarray, 
-) -> tuple[float, float]:
-    """Compute the alignment for a given angle."""
-    
-    # Rotate the segment network for the given angle
-    segment_thickness_dict_rotated = rotate_network(segment_thickness_dict, rotate_angle=angle, box_center=box_center)
-    
-    # Create line vectors from the rotated segments
-    line_vectors = [] 
-    for s in segment_thickness_dict_rotated.values():
-        line_vectors.append({'line_vector': np.array([s.middle_segment.start, s.middle_segment.end]), 'area': s.area()})
-
-    # Compute the alignment for the current angle
-    alignment = get_alignment_mean(line_vectors, director)
-    return angle, alignment
-
-def get_max_alignment_angle(
-    segment_thickness_dict: dict, 
-    director: np.ndarray, 
-    box_measurements: list[float], 
-    grid_points: int = 360
-) -> float:
-    """Find the angle with the maximum alignment using parallel processing."""
-    
-    # Create a list of angles to evaluate
-    angles = np.linspace(0, 2 * np.pi, grid_points)
-
-    # Use ProcessPoolExecutor for parallel computation of alignment
-    with ProcessPoolExecutor() as executor:
-        # Submit tasks to the pool for each angle
-        results = list(executor.map(
-            compute_alignment_for_angle, 
-            [segment_thickness_dict] * len(angles),  # Same segment dictionary for all angles
-            angles,                                 # Different angles
-            [box_measurements] * len(angles),       # Same box measurements for all angles
-            [director] * len(angles)                # Same director for all angles
-        ))
-
-    # Find the angle with the maximum alignment
-    max_alignment = 0
-    max_angle = 0
-    for angle, alignment in results:
-        if alignment > max_alignment:
-            max_alignment = alignment
-            max_angle = angle
-
-    return max_angle
-
-def generate_line_segments_thickness_orientation(
+def orientate_network(
     data_dict: Dict[str, dict], 
     orientation: List[int], 
     grid_points: int = 360, 
-    box_measurements: List[Tuple[float, float]] = [(0, 0), (0, 1), (1, 1), (1, 0)]
+    box_measurements: List[Tuple[float, float]] = [(0, 0), (0, 1), (1, 1), (1, 0)],
+    director: np.ndarray = np.array([0, 1])
 ) -> List[Dict[str, dict]]:
     """
     Generates a set of networks of line segments with different thicknesses and orientations, and clips them to fit 
@@ -354,36 +325,33 @@ def generate_line_segments_thickness_orientation(
     
     # Extract the segment thickness dictionary from the input data
     segment_thickness_dict = data_dict['segment_thickness_dict']
-
-    # Define the director vector along the y-axis
-    director = np.array([0, 1])
     
     # Find the angle that aligns the network most with the y-axis
-    max_angle = get_max_alignment_angle(segment_thickness_dict, director, box_measurements, grid_points)
-
+    max_angle = get_max_alignment(segment_thickness_dict, director, box_measurements, grid_points)
+    
     # Store the initial unmodified configuration
     output = [{'orientation': 'original', 'data_dict': data_dict}]
     
     # Loop through each given orientation, rotate, clip, and translate the network
     for o in orientation:
         # Compute the rotation angle for the current orientation relative to max alignment
-        rotate_angle = o - max_angle
+        rotate_angle = -max_angle + o
         
         # Rotate the network by the computed angle
-        segment_thickness_dict_new = rotate_network(segment_thickness_dict, rotate_angle=rotate_angle, box_center=box_center)
+        segment_thickness_dict_rotated = rotate_network(segment_thickness_dict, rotate_angle=rotate_angle, box_center=box_center)
 
         # Clip the rotated network to fit within the bounding box
-        segment_thickness_dict_new = clip_network(segment_thickness_dict_new, box_measurements=box_measurements)
+        segment_thickness_dict_clipped = clip_network(segment_thickness_dict_rotated, box_measurements=box_measurements)
 
         # Translate the clipped network to start at the origin (0,0)
         translation_vector = -np.array(box_measurements[0])
-        segment_thickness_dict_new = translate_network(segment_thickness_dict_new, translation_vector)
+        segment_thickness_dict_translated = translate_network(segment_thickness_dict_clipped, translation_vector)
     
         # Prepare a new data dictionary with the transformed segment information
         data_dict_new = {
             'segments_dict': None,
             'polygon_arr': None,
-            'segment_thickness_dict': segment_thickness_dict_new,
+            'segment_thickness_dict': segment_thickness_dict_translated,
             'jammed': None,
             'generated_config': None
         }

{rdg_networks-0.3.6 → rdg_networks-0.3.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='RDG-Networks',
-    version='0.3.6',
+    version='0.3.8',
     author='Niek Mooij',
     author_email='mooij.niek@gmail.com',
     description='Most of the code from the RDG Networks project',
@@ -26,7 +26,7 @@ setup(
             'generate_line_segments=RDG_networks.generate_line_segments:main',
             'generate_line_segments_thickness=RDG_networks.thickness.generate_line_segments_thickness:main',
             
-            'generate_line_segments_thickness_orientation=RDG_networks.thickness.generate_line_segments_dynamic_orientation:main',
+            'orientate_network=RDG_networks.thickness.orientate_network:main',
 
             'translate_network=RDG_networks.thickness.translate_network:main',
             'clip_network=RDG_networks.thickness.clip_network:main',
@@ -38,6 +38,7 @@ setup(
             '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_thickness_static=RDG_networks.generate_line_segments_thickness_static:main',
 
             'generate_line_network=RDG_networks.generate_line_network:main',
 

rdg_networks-0.3.6/RDG_networks/thickness/__init__.py

@@ -1,17 +0,0 @@
-# __init__.py
-
-from .generate_line_segments_thickness import generate_line_segments_thickness
-from .generate_line_segments_thickness_orientation import generate_line_segments_thickness_orientation
-from .generate_line_segments_thickness_orientation import translate_network
-from .generate_line_segments_thickness_orientation import clip_network
-from .generate_line_segments_thickness_orientation import rotate_network
-from .generate_line_segments_thickness_orientation import get_alignment_mean
-
-__all__ = [
-           'generate_line_segments_thickness',
-           'generate_line_segments_thickness_orientation',
-           'translate_network',
-           'clip_network',
-           'rotate_network',
-           'get_alignment_mean'
-           ]

rdg_networks-0.3.6/RDG_networks/thickness/generate_line_segments_thickness_orientation backup.py

@@ -1,202 +0,0 @@
-import numpy as np
-from typing import List, Dict, Tuple, Union, Optional
-from shapely.geometry import Polygon as Polygon_Shapely, LineString
-from shapely.geometry import Point
-import matplotlib.pyplot as plt
-from concurrent.futures import ProcessPoolExecutor
-
-from .Classes import Line, LineSegment, Polygon
-from .generate_line_segments_thickness import generate_line_segments_thickness
-
-def rotate(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: float, 
-    segment_thickness_dict: dict, 
-    director: np.ndarray, 
-    box_size: float
-) -> tuple[float, float]:
-    """Compute the 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_vectors = [
-        {'line_vector': np.diff(rotate(np.array([seg.middle_segment.start, seg.middle_segment.end]), center, rotation_matrix), axis=0)[0], 
-         'area': seg.area()}
-        for seg in segment_thickness_dict.values()
-    ]
-
-    alignment = get_alignment_mean(line_vectors, director)
-    return angle, alignment
-
-
-def get_max_alignment_angle(
-    segment_thickness_dict: dict, 
-    director: np.ndarray, 
-    box_size: float, 
-    grid_points: int = 360
-) -> float:
-    """Find the angle with the maximum alignment."""
-    angles = np.linspace(0, 2 * np.pi, grid_points)
-
-    with ProcessPoolExecutor() as executor:
-        results = executor.map(
-            compute_alignment_for_angle, 
-            angles, 
-            [segment_thickness_dict] * grid_points, 
-            [director] * grid_points, 
-            [box_size] * grid_points
-        )
-
-    return max(results, key=lambda x: x[1])[0]
-
-def orientate_network(
-    segment_thickness_dict: dict, 
-    config: list[dict], 
-    rotate_angle: float, 
-    box_size: float
-) -> list[dict]:
-    """
-    Rotates and clips a network of line segments within a bounding box.
-
-    Parameters:
-        segment_thickness_dict (dict): Segment data with start and end points.
-        config (list[dict]): Segment configuration with angle and thickness.
-        rotate_angle (float): Rotation angle in radians.    
-        box_size (float): Size of the bounding box.
-
-    Returns:
-        list[dict]: New segment positions, angles, and thicknesses.
-    """
-    center = np.array([box_size / 2, box_size / 2])
-    rotation_matrix = np.array([[np.cos(rotate_angle), -np.sin(rotate_angle)], [np.sin(rotate_angle), np.cos(rotate_angle)]])
-    box = Polygon_Shapely([(0, 0), (box_size, 0), (box_size, box_size), (0, box_size)])
-
-    segment_thickness_dict_new = {}
-    # orientated_config = []
-    for i, segment in enumerate(segment_thickness_dict.values()):
-        for vertex in segment.vertices:
-            angle_rotated = config[i]['angle'] - rotate_angle
-            start_rotated = rotate(np.array(v.middle_segment.start), center, rotation_matrix)
-            end_rotated = rotate(np.array(v.middle_segment.end), center, rotation_matrix)
-
-        # Find the intersection between the rotated line and the square
-        line_middle_point = LineString([start_rotated, end_rotated])
-
-        # Calculate the intersection between the box and the line
-        intersection = box.intersection(line_middle_point)
-
-        # Check if the line intersects the polygon
-        if intersection.is_empty:
-            continue
-        else:
-            length = intersection.length
-            # midpoint = intersection.interpolate(1/2, normalized=True)
-            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
-
-    return segment_thickness_dict_new
-
-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.
-        grid_points (int): the number of points to test for the alignment.
-
-    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_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 = [{'orientation': 'original', 'data_dict': data_dict}]
-    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_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