Add simulation_base file and updated examples

Author: abhinavj98

examples/Envy/Envy_simulation.py

@@ -1,294 +1,90 @@
+import sys
+sys.path.append('../../')
 from dataclasses import dataclass
 import numpy as np
-from helper import cut_from
+from simulation_base import SimulationConfig, TreeSimulationBase
 
 @dataclass
-class EnvySimulationConfig:
+class EnvySimulationConfig(SimulationConfig):
     """Configuration for Envy trellis tree simulation parameters."""
 
-    # Tying and Pruning
+    # Override base defaults for Envy-specific values
     num_iteration_tie: int = 5
     num_iteration_prune: int = 16
+    pruning_age_threshold: int = 6
+    derivation_length: int = 128
 
-    # Display
-    label: bool = True
-
-    # Support Structure
+    # Envy-specific Support Structure
     support_trunk_wire_point = None
     support_num_wires: int = 14
-    support_spacing_wires: int = 1
 
-    # Point Generation
+    # Envy-specific Point Generation (V-trellis)
     trellis_x_value: float = 0.45
     trellis_z_start: float = 0.6
     trellis_z_end: float = 3.4
     trellis_z_spacing: float = 0.45
 
-    # Energy and Tying Parameters
-    energy_threshold: float = 0.25
-    energy_decay_factor: float = 105
-    tolerance: float = 1e-5
-        # Energy and Tying Parameters
-    energy_distance_weight: float = 0.5  # Weight for distance in energy calculation (was hardcoded /2)
-    energy_threshold: float = 1.0  # Maximum energy threshold for tying
-    
-
-    # Pruning Parameters
-    pruning_age_threshold: int = 6
-
-    # L-System Parameters
-    derivation_length: int = 128
-
-    # Growth Parameters
+    # Envy-specific Growth Parameters
     growth_length: float = 0.1
     bud_spacing_age: int = 2
 
-    # Visualization Parameters
-    attractor_point_width: int = 10
-
-
-def generate_points_v_trellis(simulation_config):
-    """
-    Generate 3D points for the V-trellis wire structure.
 
-    Creates a linear array of wire attachment points along the x-axis at a fixed
-    height (z) and depth (y). The points are spaced evenly within the configured
-    z-range and used to construct the trellis support structure.
+class EnvySimulation(TreeSimulationBase):
     """
-    x = np.full((7,), simulation_config.trellis_x_value).astype(float)
-    y = np.full((7,), 0).astype(float)
-    z = np.arange(simulation_config.trellis_z_start,
-                  simulation_config.trellis_z_end,
-                  simulation_config.trellis_z_spacing)
-
-    pts = []
-    for i in range(x.shape[0]):
-        pts.append((-x[i], y[i], z[i]))
-        pts.append((x[i], y[i], z[i]))
-    return pts
-
-
-
-def get_energy_mat(branches, arch, simulation_config):
-    """
-    Calculate the energy matrix for optimal branch-to-wire assignment.
-    
-    This function computes an energy cost matrix where each entry represents the
-    "cost" of assigning a specific branch to a specific wire in the trellis system.
-    The energy is based on the Euclidean distance from wire attachment points to
-    both the start and end points of each branch, weighted by the simulation's
-    distance weight parameter.
+    Envy trellis architecture simulation.
     
-    The algorithm uses a greedy optimization approach where branches are assigned
-    to the lowest-energy available wire that hasn't reached capacity.
-    
-    Args:
-        branches: List of branch objects to be assigned to wires
-        arch: Support architecture object containing wire information
-        
-    Returns:
-        numpy.ndarray: Energy matrix of shape (num_branches, num_wires) where
-                      matrix[i][j] is the energy cost of assigning branch i to wire j.
-                      Untied branches and occupied wires have infinite energy (np.inf).
+    Implements the Envy V-trellis training system with wires arranged in a V-shape
+    on both sides of the tree row.
     """
-    num_branches = len(branches)
-    num_wires = len(arch.branch_supports)
-    
-    # Initialize energy matrix with infinite values (impossible assignments)
-    energy_matrix = np.full((num_branches, num_wires), np.inf)
-    
-    # Calculate energy costs for all valid branch-wire combinations
-    for branch_idx, branch in enumerate(branches):
-        # Skip branches that are already tied
-        if branch.tying.has_tied:
-            continue
-            
-        for wire_id, wire in arch.branch_supports.items():
-            # Skip wires that already have a branch attached
-            if wire.num_branch >= 1:
-                continue
-                
-            # Calculate weighted distance energy for this branch-wire pair
-            # Energy considers distance from wire to both branch endpoints
-            wire_point = np.array(wire.point)
-            branch_start = np.array(branch.location.start)
-            branch_end = np.array(branch.location.end)
-            
-            start_distance_energy = np.sum((wire_point - branch_start) ** 2)
-            end_distance_energy = np.sum((wire_point - branch_end) ** 2)
-            
-            total_energy = (start_distance_energy + end_distance_energy) * simulation_config.energy_distance_weight
-            
-            energy_matrix[branch_idx, wire_id] = total_energy
 
-    return energy_matrix
+    def generate_points(self):
+        """
+        Generate 3D points for the V-trellis wire structure.
 
-def decide_guide(energy_matrix, branches, arch, simulation_config):
-    """
-    Perform greedy assignment of branches to wires based on energy matrix.
-    
-    This function implements a greedy optimization algorithm that iteratively assigns
-    the branch-wire pair with the lowest energy cost. Once a branch is assigned to
-    a wire, both that branch and wire are marked as unavailable (infinite energy)
-    to prevent further assignments.
-    
-    The algorithm continues until no valid assignments remain (all remaining energies
-    are infinite or above the threshold).
-    
-    Args:
-        energy_matrix: numpy.ndarray of shape (num_branches, num_wires) with energy costs
-        branches: List of branch objects to be assigned
-        arch: Support architecture containing wire information
+        Creates a linear array of wire attachment points along the x-axis at a fixed
+        height (z) and depth (y). The points are spaced evenly within the configured
+        z-range and used to construct the trellis support structure.
         
-    Returns:
-        None: Modifies branches and arch in-place with new assignments
-    """
-    num_branches, num_wires = energy_matrix.shape
-    
-    # Early return if no branches or wires to assign
-    if num_branches == 0 or num_wires == 0:
-        return
-    
-    # Continue making assignments until no valid ones remain
-    while True:
-        # Find the minimum energy value and its position
-        min_energy_indices = np.argwhere(energy_matrix == np.min(energy_matrix))
-        
-        # If no valid indices found or matrix is empty, stop
-        if len(min_energy_indices) == 0:
-            break
-            
-        # Get the first (and typically only) minimum energy position
-        branch_idx, wire_id = min_energy_indices[0]
-        min_energy = energy_matrix[branch_idx, wire_id]
-        
-        # Stop if minimum energy is infinite (no valid assignments) or above threshold
-        if np.isinf(min_energy) or min_energy > simulation_config.energy_threshold:
-            break
-            
-        # Get the branch and wire objects
-        branch = branches[branch_idx]
-        wire = arch.branch_supports[wire_id]
-        
-        # Skip if branch is already tied (defensive check)
-        if branch.tying.has_tied:
-            # Mark this assignment as invalid and continue
-            energy_matrix[branch_idx, wire_id] = np.inf
-            continue
-            
-        # Perform the assignment
-        branch.tying.guide_target = wire
-        wire.add_branch()
-        
-        # Mark branch and wire as unavailable for future assignments
-        # Set entire row (branch) to infinity - this branch can't be assigned again
-        energy_matrix[branch_idx, :] = np.inf
-        # Set entire column (wire) to infinity - this wire can't accept more branches
-        energy_matrix[:, wire_id] = np.inf
-
-
-def prune(lstring, simulation_config):
-    """
-    Prune old branches that exceed the age threshold and haven't been tied to wires.
-
-    This function implements the pruning strategy for the tree training simulation.
-    It identifies branches that have grown too old (exceeding the pruning age threshold)
-    but haven't been successfully tied to trellis wires. Such branches are considered
-    unproductive and are removed from the L-System to encourage new growth.
-
-    The pruning criteria are:
-    1. Branch age exceeds the configured pruning threshold
-    2. Branch has not been tied to any trellis wire
-    3. Branch has not already been marked for cutting
-
-    When a branch meets all criteria, it is:
-    - Marked as cut (to prevent re-processing)
-    - Removed from the L-System string using cut_from()
-
-    Args:
-        lstring: The current L-System string containing modules and their parameters
-
-    Returns:
-        bool: True if a branch was pruned, False if no eligible branches found
-
-    Note:
-        This function processes one branch at a time and returns immediately after
-        pruning a single branch. It should be called repeatedly (e.g., in a while loop)
-        until no more pruning operations are possible. The cut_from() function handles
-        the actual removal of the branch and any dependent substructures from the string.
-    """
-    for position, symbol in enumerate(lstring):
-        # Check if this is a WoodStart module (represents a branch)
-        if symbol.name == 'WoodStart':
-            branch = symbol[0].type
-
-            # Check pruning criteria
-            age_exceeds_threshold = branch.info.age > simulation_config.pruning_age_threshold
-            not_tied_to_wire = not branch.tying.has_tied
-            not_already_cut = not branch.info.cut
-            is_prunable = branch.info.prunable
-
-            # Prune if all criteria are met
-            if age_exceeds_threshold and not_tied_to_wire and not_already_cut and is_prunable:
-                # Mark branch as cut to prevent re-processing
-                branch.info.cut = True
+        Returns:
+            list: List of (x, y, z) tuples representing wire attachment points in V-trellis formation
+        """
+        x = np.full((7,), self.config.trellis_x_value).astype(float)
+        y = np.full((7,), 0).astype(float)
+        z = np.arange(self.config.trellis_z_start,
+                      self.config.trellis_z_end,
+                      self.config.trellis_z_spacing)
+
+        pts = []
+        for i in range(x.shape[0]):
+            pts.append((-x[i], y[i], z[i]))
+            pts.append((x[i], y[i], z[i]))
+        return pts
+
+
+# Backwards compatibility: provide standalone functions that use the class
+def generate_points_v_trellis(simulation_config):
+    """Backward compatibility wrapper for generate_points."""
+    sim = EnvySimulation(simulation_config)
+    return sim.generate_points()
 
-                # Remove the branch from the L-System string
-                print("Pruning branch at position:", position, lstring[position])  # Debug statement
-                lstring = cut_from(position, lstring)
+def get_energy_mat(branches, arch, simulation_config):
+    """Backward compatibility wrapper for get_energy_mat."""
+    sim = EnvySimulation(simulation_config)
+    return sim.get_energy_mat(branches, arch)
 
-                return True
+def decide_guide(energy_matrix, branches, arch, simulation_config):
+    """Backward compatibility wrapper for decide_guide."""
+    sim = EnvySimulation(simulation_config)
+    return sim.decide_guide(energy_matrix, branches, arch)
 
-    return False
+def prune(lstring, simulation_config):
+    """Backward compatibility wrapper for prune."""
+    sim = EnvySimulation(simulation_config)
+    return sim.prune(lstring)
 
 def tie(lstring, simulation_config):
-    """
-    Perform tying operation on eligible branches in the L-System string.
-    
-    This function searches through the L-System string for 'WoodStart' modules that
-    represent branches ready for tying to trellis wires. It identifies branches that:
-    1. Have tying properties (tying attribute exists)
-    2. Have a defined tie axis (tie_axis is not None)
-    3. Have not been tied yet (tie_updated is False)
-    4. Have guide points available for wire attachment
-    
-    When an eligible branch is found, it performs the tying operation by:
-    - Marking the branch as tied (tie_updated = False)
-    - Adding the branch to the target wire
-    - Calling the branch's tie_lstring method to modify the L-System string
-    
-    Args:
-        lstring: The current L-System string containing modules and their parameters
-        
-    Returns:
-        bool: True if a tying operation was performed, False if no eligible branches found
-        
-    Note:
-        This function processes one branch at a time and returns immediately after
-        tying a single branch. It should be called repeatedly (e.g., in a while loop)
-        until no more tying operations are possible.
-    """
-    for position, symbol in enumerate(lstring):
-        # Check if this is a WoodStart module with tying capabilities
-        if (symbol == 'WoodStart' and 
-            hasattr(symbol[0].type, 'tying') and 
-            getattr(symbol[0].type.tying, 'tie_axis', None) is not None):
-            
-            branch = symbol[0].type
-            
-            # Skip branches that have already been processed for tying
-            if not branch.tying.tie_updated:
-                continue
-                
-            # Check if branch has guide points for wire attachment
-            if branch.tying.guide_points:
-                # Perform the tying operation
-                branch.tying.tie_updated = False
-                branch.tying.guide_target.add_branch()
-                
-                # Update the L-System string with tying modifications
-                lstring, modifications_count = branch.tie_lstring(lstring, position)
-                
-                return True
+    """Backward compatibility wrapper for tie."""
+    sim = EnvySimulation(simulation_config)
+    return sim.tie(lstring)
+
 
-    return False

examples/UFO/UFO.lpy

@@ -202,13 +202,13 @@ grow_object(plant_segment) :
       for module in plant_segment.post_bud_rule(plant_segment, simulation_config):
               nproduce new(module[0], *module[1])
 
-      if should_bud(plant_segment, simulation_config):
-          # Age-based bud production for lateral branching
-          nproduce bud(ParameterSet(type = plant_segment, num_buds = 0))
-          
-          if plant_segment.post_bud_rule(plant_segment, simulation_config):
-            for module in plant_segment.post_bud_rule(plant_segment, simulation_config):
-              nproduce new(module[0], *module[1])
+    if should_bud(plant_segment, simulation_config):
+        # Age-based bud production for lateral branching
+        nproduce bud(ParameterSet(type = plant_segment, num_buds = 0))
+        
+        if plant_segment.post_bud_rule(plant_segment, simulation_config):
+          for module in plant_segment.post_bud_rule(plant_segment, simulation_config):
+            nproduce new(module[0], *module[1])
 
     produce grow_object(plant_segment)
 

examples/UFO/UFO_prototypes.py

@@ -120,7 +120,7 @@ def post_bud_rule(self, plant_segment, simulation_config ):
     growth_length=0.05, 
     thickness_increment=0., 
     color=[0, 255, 0],
-    bud_spacing_age=2,  # Spurs bud every 1 age unit
+    bud_spacing_age=1,  # Spurs bud every 1 age unit
     curve_x_range=(-0.2, 0.2),  # Tighter bounds for spur curves
     curve_y_range=(-0.2, 0.2),  # Tighter bounds for spur curves
     curve_z_range=(-1, 1)       # Same Z range
@@ -151,7 +151,8 @@ def post_bud_rule(self, plant_segment, simulation_config ):
     bud_spacing_age=2,  # Trunk buds every 4 age units
     curve_x_range=(-0.3, 0.3),  # Conservative bounds for trunk
     curve_y_range=(-0.3, 0.3),  # Conservative bounds for trunk
-    curve_z_range=(-0.5, 0.5)   # Tighter Z range for trunk
+    curve_z_range=(-0.5, 0.5),   # Tighter Z range for trunk
+    prunable=False
 )
 
 branch_config = BasicWoodConfig(