Update README.md

README.md

@@ -38,7 +38,8 @@ and structural design.
 This Hugging Face release contains **Bioinspired3D only**: a LoRA adapter that you load on top of the base model to generate **Blender Python scripts from natural-language prompts**.
 
 For the full **Bioinspired123D** agentic framework (retrieval + VLM critic + iterative repair), see the GitHub repo:
-https://github.com/lamm-mit/Bioinspired123D
+https://github.com/lamm-mit/Bioinspired123D . For training and evaluation scripts, see also the project GitHub.  
+
 
 ## Usage
 
@@ -130,7 +131,198 @@ Output: A Blender Python script (intended to be executed in Blender) that constr
 
 To encourage explicit reasoning, append a variant of: “Think step by step.” to the end of your prompt. For example: "Write Blender code to make a tubular structure with z-aligned tubules. Think step by step."
 
-### Notes:
+## Sample output #1
+
+### Example prompt
+```text
+Write Blender code to make a cellular structure with smooth curves and layers on top and bottom
+```
+### Example model output (Blender Python)
+```python
+import bpy
+import addon_utils
+
+# Clear the scene
+bpy.ops.object.select_all(action='SELECT')
+bpy.ops.object.delete(use_global=False)
+
+# Parameters for the sandwich structure
+strut_thickness = 0.2  # Thickness of the struts
+smoothness_level = 3  # Level of smoothness
+slab_thickness = 0.1  # Thickness of the top and bottom slabs
+
+def create_cellular_sandwich():
+    # Function to create a smooth cellular sandwich structure.
+    # Steps:
+    # 1. Create a cube.
+    # 2. Fracture the cube into pieces.
+    # 3. Apply wireframe modifier for cellular effect.
+    # 4. Apply subsurface modifier for smoothing.
+    # 5. Create top and bottom slabs.
+
+    # Enable the Fracture Cell add-on
+    addon_utils.enable('object_fracture_cell')
+
+    # Create a cube
+    bpy.ops.mesh.primitive_cube_add()
+    cube = bpy.context.active_object
+
+    # Scale the cube
+    cube.scale = (1, 1, 0.75)
+    bpy.ops.object.transform_apply(scale=True)
+
+    # Fracture the cube
+    bpy.ops.object.add_fracture_cell_objects(
+        source={'PARTICLE_OWN'},
+        source_limit=100,
+        source_noise=0.5,
+        cell_scale=(1, 1, 1),
+        recursion=0,
+        recursion_source_limit=8,
+        recursion_clamp=250,
+        recursion_chance=0.25,
+        recursion_chance_select='SIZE_MIN',
+        use_smooth_faces=False,
+        use_sharp_edges=True,
+        use_sharp_edges_apply=True,
+        use_data_match=True,
+        use_island_split=True,
+        margin=0.001,
+        material_index=0,
+        use_interior_vgroup=False,
+        mass_mode='VOLUME',
+        mass=1,
+        use_recenter=True,
+        use_remove_original=True,
+        collection_name='',
+        use_debug_points=False,
+        use_debug_redraw=True,
+        use_debug_bool=False
+    )
+
+    # Remove the original cube
+    if cube and cube.name in bpy.data.objects:
+        bpy.data.objects.remove(cube, do_unlink=True)
+
+    # Join fractured pieces
+    bpy.ops.object.select_all(action='DESELECT')
+    for obj in bpy.context.scene.objects:
+        if obj.type == 'MESH':
+            obj.select_set(True)
+            bpy.context.view_layer.objects.active = obj
+    bpy.ops.object.join()
+
+    # Clean up geometry
+    active_mesh = bpy.context.view_layer.objects.active
+    bpy.ops.object.mode_set(mode='EDIT')
+    bpy.ops.mesh.select_all(action='SELECT')
+    bpy.ops.mesh.remove_doubles(threshold=0.2)
+    bpy.ops.mesh.dissolve_limited()
+    bpy.ops.object.mode_set(mode='OBJECT')
+
+    # Wireframe Modifier
+    wireframe_mod = active_mesh.modifiers.new(name='Wireframe', type='WIREFRAME')
+    wireframe_mod.thickness = strut_thickness
+    wireframe_mod.offset = -1
+    wireframe_mod.use_even_offset = False
+    wireframe_mod.use_relative_offset = True
+    wireframe_mod.use_replace = True
+    bpy.ops.object.convert(target='MESH')
+
+    # Subsurface Modifier
+    subsurf_mod = active_mesh.modifiers.new(name='Subdivision', type='SUBSURF')
+    subsurf_mod.levels = smoothness_level
+    subsurf_mod.render_levels = smoothness_level
+
+    # Create slabs
+    slab_height = 1.5
+    bottom_slab_z = -slab_height / 2 - slab_thickness / 2
+    top_slab_z = slab_height / 2 + slab_thickness / 2
+
+    # Bottom slab
+    bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, bottom_slab_z))
+    bottom_slab = bpy.context.active_object
+    bottom_slab.scale = (1, 1, slab_thickness / 2)
+    bpy.ops.object.transform_apply(scale=True)
+
+    # Top slab
+    bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, top_slab_z))
+    top_slab = bpy.context.active_object
+    top_slab.scale = (1, 1, slab_thickness / 2)
+    bpy.ops.object.transform_apply(scale=True)
+
+# Create the sandwich structure
+create_cellular_sandwich()
+```
+### Rendered example (image)
+![image](https://cdn-uploads.huggingface.co/production/uploads/63cad3071b705cc951e26b3a/Z3Xd-GleEmGgj4YL3Cg9N.png)
+
+
+## Sample output #2
+### Example prompt
+```text
+Write Blender code to make a helical bioinspired structure with flat rectangular struts in each layer
+```
+### Example model output (Blender Python)
+```python
+import bpy
+import math
+
+bpy.ops.object.select_all(action='SELECT')
+bpy.ops.object.delete(use_global=False)
+
+# Parameters for the helical fiber structure
+ply_count = 7  # Number of plies in the structure
+angle_increment = 10  # Rotation angle for each ply
+fiber_form ='rect'  # Shape of the fibers
+
+# Dimensions of the structure
+structure_height = 2  # Total height of the structure
+plate_dimension = 2  # Width and length of each plate
+thickness_per_ply = structure_height / ply_count  # Thickness of each ply
+fiber_gap = 0.01  # Gap between fibers
+
+def create_fiber(form, diameter, x, y, z, thickness):
+    if form =='rect':
+        bpy.ops.mesh.primitive_cube_add(size=1.0, location=(x, y, z), rotation=(0, math.radians(90), 0))
+        fiber = bpy.context.object
+        fiber.dimensions = (thickness, diameter, plate_dimension)
+        return fiber
+
+def generate_ply(index):
+    # Generate a ply of fibers in a helical arrangement.
+    z_position = index * thickness_per_ply
+    rotation_angle = index * angle_increment
+
+    bpy.ops.object.empty_add(type='PLAIN_AXES', location=(0, 0, z_position))
+    empty_object = bpy.context.object
+
+    fiber_diameter = thickness_per_ply
+    fiber_distance = fiber_diameter + fiber_gap
+    fiber_count = max(1, int(plate_dimension / fiber_distance))
+
+    total_fiber_space = fiber_count * fiber_distance
+    start_y_position = -plate_dimension / 2 + fiber_distance / 2 + (plate_dimension - total_fiber_space) / 2
+
+    for i in range(fiber_count):
+        fiber_y_center = start_y_position + i * fiber_distance
+        fiber_instance = create_fiber(fiber_form, fiber_diameter, 0, fiber_y_center, z_position, thickness_per_ply)
+        fiber_instance.parent = empty_object
+        fiber_instance.matrix_parent_inverse = empty_object.matrix_world.inverted()
+
+    empty_object.rotation_euler[2] = math.radians(rotation_angle)
+    return empty_object
+
+# Create the helical structure
+for i in range(ply_count):
+    generate_ply(i)
+```
+
+### Rendered example (image)
+![image](https://cdn-uploads.huggingface.co/production/uploads/63cad3071b705cc951e26b3a/d7c2kNs2uwqQk8zPOlea9.png)
+
+
+## Notes:
 This adapter is meant to be used with the specified base model. Generated scripts should be treated like code: run in a sandboxed environment and validate geometry as needed.
 
 ## Citation