RDG-Networks 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

{RDG_Networks-0.3.5.dist-info → RDG_Networks-0.3.6.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
 RDG_networks/Classes.py,sha256=_9X3JPHFAYYlaC8IZ_H9__sfz99G5l9UfPl65lL60_4,7977
-RDG_networks/__init__.py,sha256=PnXsJcqHJ-TlwMBEV4v46jP5VE654UYeU094yP0rdh8,1149
+RDG_networks/__init__.py,sha256=SmpD26lMaZ3wPz2Hs2Z-24AJiEU5DbNldhQt1fZxI0U,1607
 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
@@ -8,14 +8,15 @@ RDG_networks/generate_line_segments_static.py,sha256=7KvHZi3krv-tAGydJR_gbMMmHKZ
 RDG_networks/get_intersection_segments.py,sha256=mXB5qCy1oOps4Vu1mX6flW6v_4Xxc71YK41yOWjJX8o,2797
 RDG_networks/sample_in_polygon.py,sha256=qpPpW-Da1vK8ZkVWMJ0zBsE8IgyMB619gCdybSkzKSQ,1605
 RDG_networks/save_to_stl.py,sha256=xHwuoG39cbemggoIjT44DlsMlhjlV3uxTWo6gcHEePA,3414
-RDG_networks/thickness/Classes.py,sha256=kgWNP5NCc11dTVAfujk30r_MsY2Xf4dAOmoalLRHa5E,8063
-RDG_networks/thickness/__init__.py,sha256=iKwquAaxqyCZ6qi1YSkgm2oIEuu_FjhHsqJmwUNScyc,327
-RDG_networks/thickness/generate_line_segments_thickness_orientation.py,sha256=7sEZX8ISTBm5Fy-jqKsvRpZkteaRxfTVPNTB3lNEUYk,7797
-RDG_networks/thickness/ggenerate_line_segments_thickness.py,sha256=Eho-HAFVJdYSv1xqNSE2pCR--ncLrv1ZWahTkOlCI0A,29091
+RDG_networks/thickness/Classes.py,sha256=gVe_q5Rh_1DBiJoZ8H0FyJ4xG-IAcespjUpUirxFfAA,8125
+RDG_networks/thickness/__init__.py,sha256=87hNJsP1c-4y5QqZVM0bDcVn2cWoNd23Da3_Dvy7Fno,745
+RDG_networks/thickness/generate_line_segments_thickness.py,sha256=4SJn2_ScMKNSbHWFCSQCInCWRTo08AUiobAFxasFEKI,29190
+RDG_networks/thickness/generate_line_segments_thickness_orientation backup.py,sha256=5gcStrs4SNLp17tFb9XsN4TLWpOaeu0cHteEedISs5E,8204
+RDG_networks/thickness/generate_line_segments_thickness_orientation.py,sha256=oTEwQkXRBuoHvEdIGU30p21e2QHW1UlmApzRO1s5c64,16821
 RDG_networks/thickness/sample_in_polygon.py,sha256=nJ-yqfoCCGfC6_EpGL3L1t1LOYdqWZd-7v5bxy6th34,1849
-RDG_Networks-0.3.5.dist-info/LICENSE.txt,sha256=BHUkX2GsdTr30sKmVZ1MLGR1njnx17EX_oUuuSVZZPE,598
-RDG_Networks-0.3.5.dist-info/METADATA,sha256=dxEztE7a_LbwlRI-Os1SbdRPRIc7gg1-kTDVPOIZv2M,2422
-RDG_Networks-0.3.5.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-RDG_Networks-0.3.5.dist-info/entry_points.txt,sha256=f6AkERofpy7bp4KBUJo3y_ey6lZtvXxBVAMtPZZHqiI,676
-RDG_Networks-0.3.5.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
-RDG_Networks-0.3.5.dist-info/RECORD,,
+RDG_Networks-0.3.6.dist-info/LICENSE.txt,sha256=BHUkX2GsdTr30sKmVZ1MLGR1njnx17EX_oUuuSVZZPE,598
+RDG_Networks-0.3.6.dist-info/METADATA,sha256=wGZdZ1ZiKAB4gHxXv3WosChSNoaZ2FFKjbfAIog92Dw,2422
+RDG_Networks-0.3.6.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+RDG_Networks-0.3.6.dist-info/entry_points.txt,sha256=g8LC0VSpouLfaeL08Wqn31Pm3K74h4DfkD39C9Fr120,938
+RDG_Networks-0.3.6.dist-info/top_level.txt,sha256=4gUUYafD5Al9V8ZSiViVGYHpRMMCsCBcGgCNodk9Syg,13
+RDG_Networks-0.3.6.dist-info/RECORD,,

{RDG_Networks-0.3.5.dist-info → RDG_Networks-0.3.6.dist-info}/entry_points.txt

@@ -1,10 +1,14 @@
 [console_scripts]
+clip_network = RDG_networks.thickness.clip_network:main
 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_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
+generate_line_segments_thickness_orientation = RDG_networks.thickness.generate_line_segments_dynamic_orientation:main
+get_alignment_mean = RDG_networks.thickness.get_alignment_mean:main
 get_intersection_segments = RDG_networks.get_intersection_segments: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/__init__.py

@@ -9,11 +9,19 @@ 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 .save_to_stl import save_to_stl
 
 __all__ = ['generate_line_segments', 
            'generate_line_segments_thickness',
            'generate_line_segments_thickness_orientation',
+           'translate_network',
+           'clip_network',
+           'rotate_network',
+           'get_alignment_mean',
            'generate_line_segments_dynamic',
            'generate_line_segments_static',
            'generate_line_network',

RDG_networks/thickness/Classes.py

@@ -103,7 +103,7 @@ class Polygon:
             vertices (List[Tuple[float, float]]): A list of (x, y) coordinates representing the vertices of the polygon.
         """
         self.vertices = vertices
-        self.middle_line = middle_segment
+        self.middle_segment = middle_segment
 
     def area(self) -> float:
         """
@@ -151,7 +151,8 @@ class Polygon:
             dy = point[1] - reference_point[1]
             return np.arctan2(dy, dx)
 
-        reference_point = min(self.vertices, key=lambda point: point[1])
+        # reference_point = min(self.vertices, key=lambda point: point[1])
+        reference_point = np.mean(self.vertices, axis=0)
         return sorted(self.vertices, key=lambda point: polar_angle(point, reference_point))
 
     def draw(self, ax: axes.Axes, color='purple', alpha=0.8):

RDG_networks/thickness/__init__.py

@@ -2,8 +2,16 @@
 
 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'
+           'generate_line_segments_thickness_orientation',
+           'translate_network',
+           'clip_network',
+           'rotate_network',
+           'get_alignment_mean'
            ]

RDG_networks/thickness/{ggenerate_line_segments_thickness.py → generate_line_segments_thickness.py}

@@ -196,7 +196,7 @@ def get_location_and_direction(
         
         # Sample a location within the polygon
         #check if nucleation point is given
-        if nucleation_point:
+        if nucleation_point is not None:
             location_new = nucleation_point
         else:
             location_new = sample_in_polygon(polygon['vertices'])
@@ -619,13 +619,16 @@ def generate_line_segments_thickness(
                                     box_size=box_size)
         if 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 {len(segment_thickness_dict)}, could not find a valid segment position.")
-            jammed = True
-        
+        else:
+            if config:
+                print('Configuration not possible. Point is skipped.')
+            else:    
+                print(f"Stopped at iteration {len(segment_thickness_dict)}, could not find a valid segment position.")
+                jammed = True
+                break
+            
         # Uncomment the following line if you want progress feedback
         percentage = np.round(i / size * 100, 3)
         print(f'generate_segments: {percentage}% done', end='\r')

RDG_networks/thickness/generate_line_segments_thickness_orientation backup.py

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

RDG_networks/thickness/generate_line_segments_thickness_orientation.py

@@ -1,13 +1,11 @@
 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 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
 
-from .Classes import Line, LineSegment, Polygon
-from .generate_line_segments_dynamic_thickness import generate_line_segments_dynamic_thickness
-
-def rot(point, center, rotation_matrix):
+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
@@ -41,140 +39,356 @@ def get_alignment_mean(line_vector_arr, director):
 
     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)
+def compute_alignment_for_angle(
+    angle: float, 
+    segment_thickness_dict: dict[str, Polygon],
+    director: np.ndarray, 
+    box_measurements: list[list[float]]
+) -> tuple[float, float]:
+    """
+    Computes the alignment of a network of segments for a given rotation angle.
+
+    This function rotates a network of segments based on the specified angle, clips the network to fit within the 
+    specified bounding box, and then calculates the alignment of the network relative to a director vector.
+
+    Parameters:
+    -----------
+    angle : float
+        The angle (in radians or degrees, depending on your implementation) by which to rotate the network of segments.
+    segment_thickness_dict : dict[str, object]
+        A dictionary where the keys are segment IDs (as strings) and the values are objects representing segments 
+        (should include properties like `middle_segment` and `area()`).
+    director : np.ndarray
+        A numpy array representing the director vector, typically a unit vector used for calculating the alignment.
+    box_measurements : list[list[float]]
+        A list containing the measurements of the bounding box. It typically contains four corner points as 
+        sublists, with each sublist representing [x, y] coordinates of a corner.
+
+    Returns:
+    --------
+    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
+
+    # Rotate network
+    segment_thickness_dict_new = rotate_network(segment_thickness_dict, rotate_angle=angle, box_center=box_center)
+
+    # Clip network
+    segment_thickness_dict_new = clip_network(segment_thickness_dict_new, box_measurements=box_measurements)
+
+    line_vectors = [
+        {'line_vector': [seg.middle_segment.start, seg.middle_segment.end], 'area': seg.area()}
+        for seg in segment_thickness_dict_new.values()
+    ]
+
+    alignment = get_alignment_mean(line_vectors, 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)
+def rotate_network(
+    segment_thickness_dict: dict[str, Polygon],
+    rotate_angle: float, 
+    box_center: Tuple[float, float]
+) -> dict[str, object]:
+    """
+    Rotates a network of line segments around a given center point.
 
-    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)                 
-        ))
+    This function rotates each segment in the provided network by a specified angle around the center of a bounding box.
+    The segments are represented by their vertices and a middle segment, and both are transformed using a rotation matrix.
 
-    # Find the angle with the maximum alignment
-    max_angle, _ = max(results, key=lambda x: x[1])
+    Parameters:
+    -----------
+    segment_thickness_dict : dict[str, object]
+        A dictionary where the keys are segment IDs (as strings) and the values are segment objects. Each segment 
+        object must have a `vertices` attribute (list of vertex coordinates) and a `middle_segment` attribute.
+    rotate_angle : float
+        The angle in radians by which to rotate the network of segments.
+    box_center : Tuple[float, float]
+        The (x, y) coordinates representing the center point around which to rotate the network.
 
-    return max_angle
+    Returns:
+    --------
+    dict[str, object]
+        A new dictionary with rotated segments, where the keys are the same segment IDs and the values are the 
+        transformed segment objects with updated vertices and middle segments.
+    """
+    # Define the center and rotation matrix for rotation
+    center = np.array([box_center[0], box_center[1]])
+    rotation_matrix = np.array([[np.cos(rotate_angle), -np.sin(rotate_angle)], 
+                                [np.sin(rotate_angle), np.cos(rotate_angle)]])
+
+    # Create a new dictionary to store the rotated segments
+    segment_thickness_dict_new = {}
+
+    # Iterate over each segment and apply the rotation
+    for id, segment in segment_thickness_dict.items():
+        vertices_new = []
+        # Rotate each vertex of the segment
+        for v in segment.vertices:
+            v_rotate = rotate(v, center, rotation_matrix)
+            vertices_new.append(v_rotate)
+
+        # Rotate the start and end points of the middle segment
+        start = rotate(segment.middle_segment.start, center, rotation_matrix)
+        end = rotate(segment.middle_segment.end, center, rotation_matrix)
+
+        # Create a new middle segment with rotated coordinates
+        middle_segment_new = LineSegment(start=start, end=end)
+        
+        # Store the rotated segment in the new dictionary
+        segment_thickness_dict_new[id] = Polygon(vertices=vertices_new, middle_segment=middle_segment_new)
+
+    return segment_thickness_dict_new
+
+def clip_network(
+    segment_thickness_dict: dict[str, Polygon],
+    box_measurements: list[list[float]]
+) -> dict[str, object]:
+    """
+    Clips the segments in the network to fit within a bounding box.
+
+    This function clips each segment in the network so that only the portions that lie inside the bounding box are retained. 
+    The bounding box is represented as a polygon, and any segment that intersects the box is clipped to the intersection area.
+
+    Parameters:
+    -----------
+    segment_thickness_dict : dict[str, object]
+        A dictionary where the keys are segment IDs (as strings) and the values are segment objects. Each segment 
+        object must have a `vertices` attribute (list of vertex coordinates) and a `middle_segment` attribute.
+    box_measurements : list[list[float]]
+        A list of 4 sublists, each representing the [x, y] coordinates of a corner of the bounding box.
+
+    Returns:
+    --------
+    dict[str, object]
+        A dictionary containing the clipped segments, where the keys are the same segment IDs and the values are the 
+        clipped segment objects with updated vertices and middle segments.
+    """
+    # Create a Shapely Polygon from the bounding box measurements
+    box_new = Polygon_Shapely([
+        (box_measurements[0][0], box_measurements[0][1]), 
+        (box_measurements[1][0], box_measurements[1][1]), 
+        (box_measurements[2][0], box_measurements[2][1]), 
+        (box_measurements[3][0], box_measurements[3][1])
+    ])
+
+    # Dictionary to store the clipped segments
+    segment_thickness_dict_new = {}
+
+    # Iterate over each segment
+    for id, segment in enumerate(segment_thickness_dict.values()):
+        vertices_new = []
+        vertices = segment.vertices
+
+        # Create a Shapely polygon for the segment's vertices
+        pol = Polygon_Shapely(vertices)
+
+        # Find the intersection between the segment's polygon and the bounding box
+        intersection = box_new.intersection(pol)
+        if not intersection.is_empty:
+            # If there is an intersection, retrieve the clipped vertices
+            vertices_new = list(intersection.exterior.coords)
+  
+        if vertices_new:
+            # If new vertices exist, clip the middle segment as well
+            start = segment.middle_segment.start
+            end = segment.middle_segment.end
 
-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])
+            middle_segment_new = None
+            # Find the intersection between the middle segment and the bounding box
+            intersection = box_new.intersection(LineString([start, end]))
+            if not intersection.is_empty:
+                start = list(intersection.coords)[0]
+                end = list(intersection.coords)[-1]
+                middle_segment_new = LineSegment(start=start, end=end)
 
-    config_angles = [ item['angle'] for item in config]
-    orientated_config = []
+            # Create a new clipped polygon with updated vertices and middle segment
+            pol_new = Polygon(vertices=vertices_new, middle_segment=middle_segment_new)
+            pol_new.sort_vertices()  # Ensure vertices are sorted
+            segment_thickness_dict_new[id] = pol_new
 
-    # 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)
+    return segment_thickness_dict_new
 
-        # 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])])
+def translate_network(
+    segment_thickness_dict: dict[str, Polygon],
+    translation_vector: np.ndarray
+) -> dict[str, object]:
+    """
+    Translates a network of line segments by a given translation vector.
+
+    This function moves each segment in the network by applying the translation vector to the coordinates of the vertices
+    and the start and end points of the middle segment (if it exists).
+
+    Parameters:
+    -----------
+    segment_thickness_dict : dict[str, object]
+        A dictionary where the keys are segment IDs (as strings) and the values are segment objects. Each segment 
+        object must have `vertices` (list of vertex coordinates) and `middle_segment` attributes.
+    translation_vector : np.ndarray
+        A 2D numpy array representing the translation vector [x, y] that will be applied to all the vertices and 
+        middle segments of each segment.
 
-        # Calculate the intersection between the box and the line
-        intersection = polygon_box.intersection(line_middle_point)
+    Returns:
+    --------
+    dict[str, object]
+        A new dictionary with the translated segments, where the keys are the same segment IDs and the values are 
+        the translated segment objects.
+    """
+    # Create a new dictionary to store the translated segments
+    segment_thickness_dict_new = {}
 
-        # Check if the line intersects the polygon
-        if intersection.is_empty:
-            continue
+    # Iterate over each segment and apply the translation
+    for id, segment in segment_thickness_dict.items():
+        # Translate the vertices by adding the translation vector to each vertex
+        vertices_new = [np.array(v) + translation_vector for v in segment.vertices]
+        
+        # Check if the segment has a middle segment to translate
+        if segment.middle_segment is None:
+            middle_segment_new = None
         else:
-            length = intersection.length
-            midpoint = intersection.interpolate(length/2)
+            start = segment.middle_segment.start + translation_vector
+            end = segment.middle_segment.end + translation_vector
+            middle_segment_new = LineSegment(start=start, end=end)
+        
+        # Store the translated segment in the new dictionary
+        segment_thickness_dict_new[id] = Polygon(vertices=vertices_new, middle_segment=middle_segment_new)
 
-            x = midpoint.xy[0][0]
-            y = midpoint.xy[1][0]
+    return segment_thickness_dict_new
 
-            orientated_config.append({ 'location': (x,y), 'angle': angle_rotated, 'thickness': config[i]['thickness'] })
+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 orientated_config 
+    return float(np.mean(S_all))
 
-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,
+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
-    ) -> List[Tuple[Dict[str, LineSegment], Dict[str, Dict[str, object]], Dict[int, Polygon], np.ndarray]]:
+) -> 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(
+    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)]
+) -> List[Dict[str, dict]]:
     """
-    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.
+    Generates a set of networks of line segments with different thicknesses and orientations, and clips them to fit 
+    within a bounding box. The function also aligns the network to the maximum alignment angle with respect to the y-axis.
+
+    Parameters:
+    -----------
+    data_dict : Dict[str, dict]
+        A dictionary containing the initial network data. Must include the key 'segment_thickness_dict', which holds
+        the segment information.
+    orientation : List[int]
+        A list of orientations (angles in degrees or radians) to rotate the network. For each orientation, the network
+        is regenerated and rotated.
+    grid_points : int, optional
+        The number of grid points for calculating the maximum alignment angle (default is 360).
+    box_measurements : List[Tuple[float, float]], optional
+        A list of tuples representing the corner points of the bounding box (default is a unit square).
 
     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].
+    --------
+    List[Dict[str, dict]]
+        A list of dictionaries. Each dictionary contains the 'orientation' of the network and the updated 'data_dict' 
+        with the rotated and clipped segment information.
     """
-    # 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)
     
+    # Compute the center of the box
+    box_center = (np.array(box_measurements[0]) + np.array(box_measurements[2])) / 2
+    
+    # Extract the segment thickness dictionary from the input data
     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)
+    # 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)
+
+    # Store the initial unmodified configuration
+    output = [{'orientation': 'original', 'data_dict': data_dict}]
     
-    # Regenerate network for each orientation
-    output = []
+    # Loop through each given orientation, rotate, clip, and translate the network
     for o in orientation:
-        rotate_angle = o-max_angle
-        orientated_config = orientate_network(segment_thickness_dict, generated_config, rotate_angle, box_size)
+        # Compute the rotation angle for the current orientation relative to max alignment
+        rotate_angle = o - max_angle
+        
+        # Rotate the network by the computed angle
+        segment_thickness_dict_new = rotate_network(segment_thickness_dict, rotate_angle=rotate_angle, box_center=box_center)
 
-        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)
+        # Clip the rotated network to fit within the bounding box
+        segment_thickness_dict_new = clip_network(segment_thickness_dict_new, 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)
+    
+        # 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,
+            'jammed': None,
+            'generated_config': None
+        }
+        
+        # Append the result for this orientation
         output.append({'orientation': o, 'data_dict': data_dict_new})
     
     return output