Add example Envy

Author: abhinavj98

examples/Envy/Envy.lpy

@@ -0,0 +1,266 @@
+"""
+Tying, Pruning and labelling Envy architecture trees
+"""
+import sys
+sys.path.append('../../')
+from stochastic_tree import Support, BasicWood, TreeBranch, BasicWoodConfig
+import time
+from helper import *
+import numpy as np
+import random as rd
+from examples.Envy.Envy_prototypes import basicwood_prototypes, Trunk
+from examples.Envy.Envy_simulation import EnvySimulationConfig, generate_points_v_trellis, get_energy_mat, decide_guide, tie, prune
+from dataclasses import dataclass
+import time
+
+#init  
+main_trunk = Trunk(copy_from = basicwood_prototypes['trunk'])
+
+# Create simulation configuration
+simulation_config = EnvySimulationConfig()
+
+
+
+trellis_support = Support(generate_points_v_trellis(simulation_config), simulation_config.support_num_wires, simulation_config.support_spacing_wires, simulation_config.support_trunk_wire_point)
+tying_interval_iterations = simulation_config.num_iteration_tie
+pruning_interval_iterations = simulation_config.num_iteration_prune
+main_trunk.tying.guide_target = trellis_support.trunk_wire
+
+def StartEach(lstring):
+    """
+    Initialize tying updates for trunk and branches at the start of each iteration.
+    
+    This function is called at the beginning of each L-System derivation iteration
+    to prepare the tree structure for potential tying operations. It ensures that
+    both the trunk and all child branches are ready to participate in the tying
+    process by updating their tying status.
+    
+    The function performs two main tasks:
+    1. Updates the trunk's tying status if it has a wire target and hasn't been updated
+    2. Updates all child branches' tying status if they haven't been updated
+    
+    Args:
+        lstring: The current L-System string (not used in this function but required
+                by L-Py's callback interface)
+        
+    Returns:
+        None: Modifies global tree structures in-place
+        
+    Note:
+        This function relies on global variables: branch_hierarchy, trellis_support, main_trunk.
+        It should be called automatically by L-Py at the start of each iteration.
+    """
+    global branch_hierarchy, trellis_support, main_trunk
+    
+    # Update trunk tying status if it has a wire target and needs updating
+    if trellis_support.trunk_wire and not main_trunk.tying.tie_updated:
+        main_trunk.tie_update()
+
+    # Update tying status for all child branches that need it
+    for branch in branch_hierarchy[main_trunk.name]:
+        if not branch.tying.tie_updated:
+            branch.tie_update()
+    
+  
+def EndEach(lstring):
+    """
+    Perform tying and pruning operations at the end of each L-System iteration.
+
+    This function is the main orchestration point for the tree training simulation.
+    It executes tying operations (assigning branches to trellis wires) and pruning
+    operations based on configurable iteration intervals. The tying process uses
+    energy-based optimization to find optimal branch-to-wire assignments.
+
+    The function performs the following sequence when tying is scheduled:
+    1. Updates the trunk's guide target (ties trunk first)
+    2. Calculates energy matrix for all branch-wire combinations
+    3. Uses greedy optimization to assign branches to lowest-energy wires
+    4. Updates guide targets for all assigned branches
+    5. Performs actual tying operations in the L-System string
+    6. Prunes old branches if pruning iteration is reached
+
+    Args:
+        lstring: The current L-System string containing modules and their parameters
+
+    Returns:
+        The modified L-System string after tying and pruning operations
+
+    Note:
+        This function relies on global variables and is called automatically by L-Py
+        at the end of each derivation iteration. Tying occurs every tying_interval_iterations
+        iterations, while pruning occurs every pruning_interval_iterations iterations.
+    """
+    global branch_hierarchy, trellis_support, tying_interval_iterations
+
+    current_iteration = getIterationNb() + 1 #GetIterationNb is an L-Py function
+
+    # Check if this is a tying iteration
+    if current_iteration % tying_interval_iterations == 0:
+        # Tie trunk to its target wire first (one iteration before branches)
+        if trellis_support.trunk_wire:
+            main_trunk.update_guide(main_trunk.tying.guide_target)
+
+        # Calculate energy costs for optimal branch-to-wire assignments
+        branches = branch_hierarchy[main_trunk.name]
+        energy_matrix = get_energy_mat(branches, trellis_support, simulation_config)
+
+        # Perform greedy optimization to assign branches to wires
+        decide_guide(energy_matrix, branches, trellis_support, simulation_config)
+
+        # Update guide targets for all assigned branches
+        for branch in branches:
+            branch.update_guide(branch.tying.guide_target)
+
+        # Execute tying operations in the L-System string
+        while tie(lstring, simulation_config):
+            pass  # Continue until no more tying operations are possible
+
+        # Check if this is also a pruning iteration
+    if current_iteration % pruning_interval_iterations == 0:
+        # Prune branches until no more can be pruned
+        while prune(lstring, simulation_config):
+            pass
+
+    return lstring
+
+
+
+branch_hierarchy = {}
+branch_hierarchy[main_trunk.name] = []	
+enable_color_labeling = simulation_config.label 
+# =============================================================================
+# L-SYSTEM GRAMMAR DEFINITION
+# =============================================================================
+# This section defines the formal grammar for the Envy tree growth simulation.
+# The L-System uses modules (symbols) to represent different plant components
+# and their growth behaviors.
+
+# -----------------------------------------------------------------------------
+# MODULE DECLARATIONS
+# -----------------------------------------------------------------------------
+# Define the vocabulary of symbols used in the L-System grammar.
+# Each module represents a different type of plant component or operation.
+
+module Attractors     # Trellis support structure that guides branch growth
+module grow_object    # Growing plant parts (trunk, branches, spurs) with length/thickness
+module bud           # Dormant buds that can break to produce new branches
+module branch        # Branch segments in the L-System string
+module WoodStart     # Starting point of wood segments (used for tying operations)
+
+# -----------------------------------------------------------------------------
+# GLOBAL L-SYSTEM PARAMETERS
+# -----------------------------------------------------------------------------
+# Create a growth guide curve for the initial trunk development
+trunk_guide_curve = create_bezier_curve(x_range = (-1, 1), y_range = (-1, 1), z_range = (0, 10), seed_value=time.time())
+
+# -----------------------------------------------------------------------------
+# AXIOM (STARTING STRING)
+# -----------------------------------------------------------------------------
+# The initial L-System string that begins the simulation.
+# Starts with the trellis attractors, sets up the trunk guide curve,
+# and initializes the trunk growth with proper orientation.
+Axiom: Attractors(trellis_support)SetGuide(trunk_guide_curve, main_trunk.growth.max_length)[@GcGetPos(main_trunk.location.start)WoodStart(ParameterSet(type = main_trunk))grow_object(main_trunk)GetPos(main_trunk.location.end)@Ge]
+
+# -----------------------------------------------------------------------------
+# DERIVATION PARAMETERS
+# -----------------------------------------------------------------------------
+# Set the maximum number of derivation steps for the L-System
+derivation length: simulation_config.derivation_length
+
+# -----------------------------------------------------------------------------
+# PRODUCTION RULES
+# -----------------------------------------------------------------------------
+# Define how each module type evolves during each derivation step.
+# These rules control the growth, branching, and development of the tree.
+
+production:
+
+# GROW_OBJECT PRODUCTION RULE
+# Handles the growth of plant segments (trunk, branches, spurs)
+# Determines whether to continue growing, stop, or produce buds
+grow_object(plant_segment) :
+  if plant_segment == None:
+    # Null object - terminate this branch
+    produce *
+  if plant_segment.length >= plant_segment.growth.max_length:
+    # Maximum length reached - stop growing this segment
+    nproduce *
+  else:
+    # Continue growing - update segment properties
+    nproduce SetContour(plant_segment.contour)
+    #Update internal state of the plant segment
+    plant_segment.grow_one()
+    #Update physical representation
+    if enable_color_labeling:
+      # Add color visualization if labeling is enabled -- Can this be moved to the start of building the segment?
+      r, g, b = plant_segment.info.color
+      nproduce SetColor(r,g,b)
+    #Produce internode segment
+    nproduce I(plant_segment.growth.growth_length, plant_segment.growth.thickness, plant_segment)
+    #Produce bud
+    if plant_segment.pre_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)
+
+# BUD PRODUCTION RULE
+# Controls bud break and branch initiation
+# Determines when buds activate to produce new branches
+bud(bud_parameters) :
+ if bud_parameters.type.is_bud_break(bud_parameters.num_buds):
+   # Bud break condition met - create new branch
+
+   new_branch = bud_parameters.type.create_branch()
+   if new_branch == None:
+     # Branch creation failed - terminate
+     produce *
+   # Register new branch in parent-child relationship tracking
+   branch_hierarchy[new_branch.name] = []
+   branch_hierarchy[bud_parameters.type.name].append(new_branch)
+   # Update branch counters
+   bud_parameters.num_buds+=1
+   bud_parameters.type.info.num_branches+=1
+
+   if hasattr(new_branch, 'curve_x_range'):
+     # Curved branches: set up custom growth guide curve
+     curve = create_bezier_curve(x_range=new_branch.curve_x_range, y_range=new_branch.curve_y_range, z_range=new_branch.curve_z_range, seed_value=time.time())
+     nproduce[@GcSetGuide(curve, new_branch.growth.max_length)
+   else:
+     # Straight branches: use default orientation
+     nproduce [@Gc
+   # Produce new branch with random orientation and growth object
+   nproduce @RGetPos(new_branch.location.start)WoodStart(ParameterSet(type = new_branch))/(rd.random()*360)&(rd.random()*360)grow_object(new_branch)GetPos(new_branch.location.end)@Ge]bud(bud_parameters)
+
+
+# -----------------------------------------------------------------------------
+# GEOMETRIC INTERPRETATION (HOMOMORPHISM)
+# -----------------------------------------------------------------------------
+# Map abstract L-System modules to concrete 3D geometry for rendering.
+# These rules define how the symbolic representation becomes visual.
+
+homomorphism:
+
+# Internode segments become cylinders with length and radius
+I(a,r,o) --> F(a,r)
+# Branch segments also become cylinders
+S(a,r,o) --> F(a,r)
+
+# -----------------------------------------------------------------------------
+# ATTRACTOR VISUALIZATION
+# -----------------------------------------------------------------------------
+# Additional production rules for displaying trellis attractor points
+production:
+Attractors(trellis_support):
+  # Display enabled attractor points as visual markers
+  points_to_display = trellis_support.attractor_grid.get_enabled_points()
+  if len(points_to_display) > 0:
+    produce [,(3) @g(PointSet(points_to_display,width=simulation_config.attractor_point_width))]