import gradio as gr import numpy as np import matplotlib.pyplot as plt from matplotlib import cm import plotly.graph_objects as go import trimesh from shapely.geometry import box, Point from shapely.affinity import scale from scipy.spatial import ConvexHull import re import io import os import tempfile import base64 from PIL import Image, ImageDraw, ImageFont import warnings warnings.filterwarnings('ignore') # Enhanced imports for parametric CAD try: import cadquery as cq CADQUERY_AVAILABLE = True print("✅ CadQuery available - Parametric CAD enabled") except ImportError: CADQUERY_AVAILABLE = False print("⚠️ CadQuery not available - Using Trimesh fallbacks") # Check boolean backend def get_bool_backend_name(): try: backend = trimesh.interfaces.boolean.get_bool_engine() return backend except Exception: return None BOOL_BACKEND = get_bool_backend_name() if BOOL_BACKEND is None: print("⚠️ No boolean backend detected. Install 'manifold3d' for robust operations") else: print(f"✅ Boolean backend detected: {BOOL_BACKEND}") # ===================================================== # ENHANCED CAD UTILITIES # ===================================================== def cq_to_trimesh(cq_obj): """Export CadQuery object to temporary STL then load as trimesh.Trimesh""" if not CADQUERY_AVAILABLE: raise RuntimeError("CadQuery not available") with tempfile.NamedTemporaryFile(suffix=".stl", delete=False) as tmp: tmp_path = tmp.name try: cq.exporters.export(cq_obj, tmp_path, exportType="STL") mesh = trimesh.load(tmp_path) if hasattr(mesh, "is_watertight") and not mesh.is_watertight: try: mesh = mesh.fill_holes() except Exception: pass return mesh finally: try: os.remove(tmp_path) except Exception: pass def safe_union(a, b): """Enhanced union with multiple fallback strategies""" if hasattr(a, "union"): try: return a.union(b) except Exception: pass try: return trimesh.boolean.union([a, b], engine=BOOL_BACKEND) except Exception: try: combined = trimesh.util.concatenate([a, b]) return combined except Exception: return a def safe_difference(a, b): """Enhanced difference with multiple fallback strategies""" if hasattr(a, "difference"): try: return a.difference(b) except Exception: pass try: return trimesh.boolean.difference([a, b], engine=BOOL_BACKEND) except Exception: return a def export_mesh(mesh, filename): """Export mesh to various formats""" ext = os.path.splitext(filename)[1].lower() if ext in ['.stl', '.obj', '.ply', '.glb']: try: mesh.export(filename) return filename except Exception as e: raise RuntimeError(f"Export failed: {str(e)}") else: raise RuntimeError("Unsupported export format. Use .stl, .obj, .ply, .glb") # ===================================================== # ENHANCED PROMPT PARSING # ===================================================== DIM_FIELDS = [ 'length', 'width', 'height', 'radius', 'diameter', 'thickness', 'outer_radius', 'inner_radius', 'depth', 'size', 'panel_count', 'frame_width', 'spacing', 'num_shelves', 'rail_width', 'leg_size', 'panel_thickness', 'hole_radius', 'wall_thickness' ] def extract_key_values(prompt): """Extract key=value pairs (numeric) into dict""" kv = {} for m in re.finditer(r'([a-zA-Z_]+)\s*[:=]\s*([0-9]+\.?[0-9]*)', prompt): k = m.group(1).lower() v = float(m.group(2)) kv[k] = v return kv def extract_x_pattern(prompt): """Extract patterns like 10x20x30 (assumes order length x width x height)""" m = re.search(r'(\d+\.?\d*)\s*[x×]\s*(\d+\.?\d*)\s*[x×]\s*(\d+\.?\d*)', prompt) if m: return float(m.group(1)), float(m.group(2)), float(m.group(3)) return None def filter_numeric(dims): """Return filtered dict containing only numeric values expected by builders""" out = {} for k, v in dims.items(): if v is None: continue if k in ('panel_count', 'mullions_v', 'mullions_h', 'num_shelves'): out[k] = int(v) else: out[k] = float(v) return out # ===================================================== # TEXT TO CAD PARSER AND GENERATOR # ===================================================== class TextToCADGenerator: """Enhanced Text-to-CAD generator with all shapes""" def __init__(self): self.shapes_library = { # Basic shapes 'cube': self._create_cube, 'box': self._create_cube, 'sphere': self._create_sphere, 'ball': self._create_sphere, 'cylinder': self._create_cylinder, 'tube': self._create_cylinder, 'cone': self._create_cone, 'pyramid': self._create_pyramid, 'torus': self._create_torus, 'ring': self._create_torus, # Mechanical parts 'gear': self._create_gear, 'bracket': self._create_bracket, 'plate': self._create_plate, 'rod': self._create_rod, 'washer': self._create_washer, 'screw': self._create_screw, 'bolt': self._create_screw, 'nut': self._create_nut, 'bearing': self._create_bearing, 'flange': self._create_flange, 'pipe': self._create_pipe, # Architectural frames 'doorframe': self._create_door_frame, 'door_frame': self._create_door_frame, 'windowframe': self._create_window_frame, 'window_frame': self._create_window_frame, 'gypsumframe': self._create_gypsum_frame, 'gypsum_frame': self._create_gypsum_frame, 'drywall_frame': self._create_gypsum_frame, # Furniture frames 'bedframe': self._create_bed_frame, 'bed_frame': self._create_bed_frame, 'tableframe': self._create_table_frame, 'table_frame': self._create_table_frame, 'chairframe': self._create_chair_frame, 'chair_frame': self._create_chair_frame, 'shelfframe': self._create_shelf_frame, 'shelf_frame': self._create_shelf_frame, 'cabinetframe': self._create_cabinet_frame, 'cabinet_frame': self._create_cabinet_frame, # Enhanced parametric builders 'water_tank': self._create_water_tank, 'watertank': self._create_water_tank, 'tank': self._create_water_tank, 'parametric_washer': self._create_parametric_washer, 'parametric_nut': self._create_parametric_nut, 'parametric_bracket': self._create_parametric_bracket, 'parametric_door': self._create_parametric_door, 'parametric_window': self._create_parametric_window } def parse_prompt(self, prompt: str): """Enhanced prompt parsing with key=value and pattern recognition""" p = prompt.lower().strip() # Start with enhanced dimension extraction dimensions = self._extract_dimensions(p) # Add key=value parsing kv_pairs = extract_key_values(p) for k, v in kv_pairs.items(): if k in dimensions: dimensions[k] = v elif k == 'panels': dimensions['panel_count'] = int(v) elif k == 'frames': dimensions['frame_width'] = v # Add NxMxP pattern recognition pattern = extract_x_pattern(p) if pattern: dimensions['length'], dimensions['width'], dimensions['height'] = pattern # Enhanced shape identification shape_type = None for shape in self.shapes_library.keys(): if shape.replace('_', ' ') in p or shape in p: shape_type = shape break # Additional keyword mapping if shape_type is None: for keyword in ['tank', 'panel']: if keyword in p: if keyword == 'tank': shape_type = 'water_tank' if 'water_tank' in self.shapes_library else 'cylinder' elif keyword == 'panel': shape_type = 'gypsum_panel' if 'gypsum_panel' in self.shapes_library else 'plate' if not shape_type: shape_type = 'cube' color = self._extract_color(p) # Detect precision preference precision = 'high' if any(word in p for word in ['precise', 'parametric', 'high', 'accurate']) else 'fast' if any(word in p for word in ['fast', 'approx', 'quick']): precision = 'fast' return { 'shape': shape_type, 'dimensions': dimensions, 'color': color, 'precision': precision, 'prompt': prompt } def _extract_dimensions(self, prompt: str): """Extract dimensions from prompt""" dimensions = { 'length': 10, 'width': 10, 'height': 10, 'radius': 5, 'diameter': 10, 'depth': 10, 'thickness': 5, 'spacing': 400, 'num_shelves': 4, 'rail_width': 80, 'leg_size': 50, 'panel_thickness': 18 } patterns = { 'length': r'length\s*[:=]?\s*(\d+\.?\d*)', 'width': r'width\s*[:=]?\s*(\d+\.?\d*)', 'height': r'height\s*[:=]?\s*(\d+\.?\d*)', 'radius': r'radius\s*[:=]?\s*(\d+\.?\d*)', 'diameter': r'diameter\s*[:=]?\s*(\d+\.?\d*)', 'depth': r'depth\s*[:=]?\s*(\d+\.?\d*)', 'size': r'size\s*[:=]?\s*(\d+\.?\d*)', 'thick': r'thick\w*\s*[:=]?\s*(\d+\.?\d*)', 'spacing': r'spacing\s*[:=]?\s*(\d+\.?\d*)', 'shelves': r'shelves\s*[:=]?\s*(\d+)', 'rail': r'rail\s*[:=]?\s*(\d+\.?\d*)', 'leg': r'leg\s*[:=]?\s*(\d+\.?\d*)', 'panel': r'panel\s*[:=]?\s*(\d+\.?\d*)' } for key, pattern in patterns.items(): match = re.search(pattern, prompt, re.IGNORECASE) if match: value = float(match.group(1)) if key == 'size': dimensions['length'] = dimensions['width'] = dimensions['height'] = value elif key == 'thick': dimensions['thickness'] = value elif key == 'shelves': dimensions['num_shelves'] = int(value) elif key == 'rail': dimensions['rail_width'] = value elif key == 'leg': dimensions['leg_size'] = value elif key == 'panel': dimensions['panel_thickness'] = value else: dimensions[key] = value # Handle patterns like "10x20x30" dimension_match = re.search(r'(\d+\.?\d*)\s*[x×]\s*(\d+\.?\d*)\s*[x×]\s*(\d+\.?\d*)', prompt) if dimension_match: dimensions['length'] = float(dimension_match.group(1)) dimensions['width'] = float(dimension_match.group(2)) dimensions['height'] = float(dimension_match.group(3)) return dimensions def _extract_color(self, prompt: str): """Extract color from prompt""" colors = ['red', 'blue', 'green', 'yellow', 'orange', 'purple', 'pink', 'brown', 'black', 'white', 'gray', 'grey'] for color in colors: if color in prompt: return color return 'lightblue' # Shape creation methods def _create_cube(self, dims): return trimesh.creation.box(extents=[dims['length'], dims['width'], dims['height']]) def _create_sphere(self, dims): radius = dims.get('radius', dims.get('diameter', 10) / 2) return trimesh.creation.icosphere(subdivisions=2, radius=radius) def _create_cylinder(self, dims): radius = dims.get('radius', dims.get('diameter', 10) / 2) height = dims.get('height', 10) return trimesh.creation.cylinder(radius=radius, height=height) def _create_cone(self, dims): radius = dims.get('radius', dims.get('diameter', 10) / 2) height = dims.get('height', 10) return trimesh.creation.cone(radius=radius, height=height) def _create_pyramid(self, dims): height = dims.get('height', 10) base_size = dims.get('width', 10) vertices = np.array([ [0, 0, height], [-base_size/2, -base_size/2, 0], [base_size/2, -base_size/2, 0], [base_size/2, base_size/2, 0], [-base_size/2, base_size/2, 0] ]) faces = np.array([ [0, 1, 2], [0, 2, 3], [0, 3, 4], [0, 4, 1], [1, 4, 3], [1, 3, 2] ]) return trimesh.Trimesh(vertices=vertices, faces=faces) def _create_torus(self, dims): major_radius = dims.get('radius', 10) minor_radius = major_radius * 0.3 return trimesh.creation.torus(major_radius=major_radius, minor_radius=minor_radius) def _create_gear(self, dims): radius = dims.get('radius', 10) height = dims.get('height', 5) return trimesh.creation.cylinder(radius=radius, height=height) def _create_bracket(self, dims): length = dims.get('length', 20) width = dims.get('width', 10) height = dims.get('height', 15) thickness = min(3, width * 0.3, height * 0.3) try: base = trimesh.creation.box(extents=[length, width, thickness]) base = base.apply_translation([0, 0, -height/2 + thickness/2]) vertical = trimesh.creation.box(extents=[thickness, width, height]) vertical = vertical.apply_translation([length/2 - thickness/2, 0, 0]) return base.union(vertical) except: return trimesh.creation.box(extents=[length, width, height]) def _create_plate(self, dims): return trimesh.creation.box(extents=[dims.get('length', 20), dims.get('width', 15), dims.get('height', 2)]) def _create_rod(self, dims): radius = dims.get('radius', 2) length = dims.get('length', 20) rod = trimesh.creation.cylinder(radius=radius, height=length) return rod.apply_transform(trimesh.transformations.rotation_matrix(np.pi/2, [0, 1, 0])) def _create_washer(self, dims): outer_radius = dims.get('radius', 10) inner_radius = outer_radius * 0.4 height = dims.get('height', 2) try: outer = trimesh.creation.cylinder(radius=outer_radius, height=height) inner = trimesh.creation.cylinder(radius=inner_radius, height=height * 1.1) return outer.difference(inner) except Exception: # Fallback: return outer cylinder if boolean operation fails return trimesh.creation.cylinder(radius=outer_radius, height=height) def _create_screw(self, dims): radius = dims.get('radius', 3) length = dims.get('length', 20) head_radius = radius * 1.5 head_height = radius try: body = trimesh.creation.cylinder(radius=radius, height=length) head = trimesh.creation.cylinder(radius=head_radius, height=head_height) head = head.apply_translation([0, 0, length/2 + head_height/2]) return body.union(head) except Exception: # Fallback: return just the body cylinder if union fails return trimesh.creation.cylinder(radius=radius, height=length) def _create_nut(self, dims): radius = dims.get('radius', 5) height = dims.get('height', 4) inner_radius = radius * 0.4 try: outer = trimesh.creation.cylinder(radius=radius, height=height, sections=6) inner = trimesh.creation.cylinder(radius=inner_radius, height=height * 1.1) return outer.difference(inner) except Exception: # Fallback: return hexagonal cylinder without hole return trimesh.creation.cylinder(radius=radius, height=height, sections=6) def _create_bearing(self, dims): outer_radius = dims.get('radius', 10) inner_radius = outer_radius * 0.6 height = dims.get('height', 5) try: outer = trimesh.creation.cylinder(radius=outer_radius, height=height) inner = trimesh.creation.cylinder(radius=inner_radius, height=height * 1.1) return outer.difference(inner) except Exception: # Fallback: return outer cylinder without hole return trimesh.creation.cylinder(radius=outer_radius, height=height) def _create_flange(self, dims): outer_radius = dims.get('radius', 15) inner_radius = outer_radius * 0.4 height = dims.get('height', 5) try: outer = trimesh.creation.cylinder(radius=outer_radius, height=height) inner = trimesh.creation.cylinder(radius=inner_radius, height=height * 1.1) return outer.difference(inner) except Exception: # Fallback: return outer cylinder without hole return trimesh.creation.cylinder(radius=outer_radius, height=height) def _create_pipe(self, dims): outer_radius = dims.get('radius', 10) inner_radius = outer_radius * 0.8 length = dims.get('length', 30) try: outer = trimesh.creation.cylinder(radius=outer_radius, height=length) inner = trimesh.creation.cylinder(radius=inner_radius, height=length * 1.1) return outer.difference(inner) except Exception: # Fallback: return solid cylinder without hole return trimesh.creation.cylinder(radius=outer_radius, height=length) # ===================================================== # ARCHITECTURAL FRAMES # ===================================================== def _create_door_frame(self, dims): """Create a door frame with header and side jambs""" width = dims.get('width', 900) # Door opening width (mm) height = dims.get('height', 2100) # Door opening height (mm) depth = dims.get('depth', 150) # Frame depth (mm) thickness = dims.get('thickness', 50) # Frame thickness (mm) try: # Create the outer frame box outer_width = width + 2 * thickness outer_height = height + thickness # No bottom piece frame_box = trimesh.creation.box(extents=[outer_width, depth, outer_height]) # Create the opening to subtract opening = trimesh.creation.box(extents=[width, depth * 1.1, height]) opening = opening.apply_translation([0, 0, -thickness/2]) return frame_box.difference(opening) except Exception: # Fallback: create L-shaped frame pieces # Left jamb left = trimesh.creation.box(extents=[thickness, depth, height]) left = left.apply_translation([-(width/2 + thickness/2), 0, 0]) # Right jamb right = trimesh.creation.box(extents=[thickness, depth, height]) right = right.apply_translation([(width/2 + thickness/2), 0, 0]) # Header header = trimesh.creation.box(extents=[width + 2*thickness, depth, thickness]) header = header.apply_translation([0, 0, height/2 + thickness/2]) try: return left.union(right).union(header) except Exception: return trimesh.creation.box(extents=[outer_width, depth, outer_height]) def _create_window_frame(self, dims): """Create a window frame with sill""" width = dims.get('width', 1200) # Window opening width (mm) height = dims.get('height', 1000) # Window opening height (mm) depth = dims.get('depth', 100) # Frame depth (mm) thickness = dims.get('thickness', 50) # Frame thickness (mm) sill_height = dims.get('sill_height', 20) # Window sill height (mm) try: # Create the outer frame box outer_width = width + 2 * thickness outer_height = height + 2 * thickness frame_box = trimesh.creation.box(extents=[outer_width, depth, outer_height]) # Create the opening to subtract opening = trimesh.creation.box(extents=[width, depth * 1.1, height]) # Create window sill (extended bottom piece) sill = trimesh.creation.box(extents=[outer_width + 100, depth + 50, sill_height]) sill = sill.apply_translation([0, 25, -(outer_height/2 + sill_height/2)]) frame_with_opening = frame_box.difference(opening) return frame_with_opening.union(sill) except Exception: # Fallback: create frame pieces separately # Create 4 sides of the window frame left = trimesh.creation.box(extents=[thickness, depth, height + 2*thickness]) left = left.apply_translation([-(width/2 + thickness/2), 0, 0]) right = trimesh.creation.box(extents=[thickness, depth, height + 2*thickness]) right = right.apply_translation([(width/2 + thickness/2), 0, 0]) top = trimesh.creation.box(extents=[width, depth, thickness]) top = top.apply_translation([0, 0, height/2 + thickness/2]) bottom = trimesh.creation.box(extents=[width, depth, thickness]) bottom = bottom.apply_translation([0, 0, -(height/2 + thickness/2)]) try: return left.union(right).union(top).union(bottom) except Exception: return trimesh.creation.box(extents=[outer_width, depth, outer_height]) def _create_gypsum_frame(self, dims): """Create a gypsum/drywall frame structure""" width = dims.get('width', 2400) # Frame width (mm) height = dims.get('height', 2700) # Frame height (mm) depth = dims.get('depth', 100) # Stud depth (mm) stud_width = dims.get('stud_width', 50) # Stud width (mm) spacing = dims.get('spacing', 400) # Stud spacing (mm) try: # Create top and bottom plates top_plate = trimesh.creation.box(extents=[width, depth, stud_width]) top_plate = top_plate.apply_translation([0, 0, height/2 - stud_width/2]) bottom_plate = trimesh.creation.box(extents=[width, depth, stud_width]) bottom_plate = bottom_plate.apply_translation([0, 0, -height/2 + stud_width/2]) # Create vertical studs stud_height = height - 2 * stud_width num_studs = int(width / spacing) + 1 studs = [] for i in range(num_studs): x_pos = -width/2 + i * spacing if x_pos <= width/2: stud = trimesh.creation.box(extents=[stud_width, depth, stud_height]) stud = stud.apply_translation([x_pos, 0, 0]) studs.append(stud) # Combine all pieces frame = top_plate.union(bottom_plate) for stud in studs: frame = frame.union(stud) return frame except Exception: # Fallback: simple rectangular frame return trimesh.creation.box(extents=[width, depth, height]) # ===================================================== # FURNITURE FRAMES # ===================================================== def _create_bed_frame(self, dims): """Create a bed frame structure""" length = dims.get('length', 2000) # Bed length (mm) width = dims.get('width', 1500) # Bed width (mm) height = dims.get('height', 400) # Frame height (mm) rail_width = dims.get('rail_width', 80) # Rail thickness (mm) rail_height = dims.get('rail_height', 200) # Rail height (mm) try: # Create head rail head_rail = trimesh.creation.box(extents=[width, rail_width, rail_height]) head_rail = head_rail.apply_translation([0, length/2 - rail_width/2, rail_height/2 - height/2]) # Create foot rail foot_rail = trimesh.creation.box(extents=[width, rail_width, rail_height * 0.6]) foot_rail = foot_rail.apply_translation([0, -length/2 + rail_width/2, rail_height*0.3 - height/2]) # Create side rails left_rail = trimesh.creation.box(extents=[rail_width, length - 2*rail_width, rail_width]) left_rail = left_rail.apply_translation([-width/2 + rail_width/2, 0, -height/2 + rail_width/2]) right_rail = trimesh.creation.box(extents=[rail_width, length - 2*rail_width, rail_width]) right_rail = right_rail.apply_translation([width/2 - rail_width/2, 0, -height/2 + rail_width/2]) # Create support slats (simplified as a platform) platform = trimesh.creation.box(extents=[width - 2*rail_width, length - 2*rail_width, 20]) platform = platform.apply_translation([0, 0, -height/2 + 20]) return head_rail.union(foot_rail).union(left_rail).union(right_rail).union(platform) except Exception: # Fallback: simple platform return trimesh.creation.box(extents=[width, length, height]) def _create_table_frame(self, dims): """Create a table frame structure""" length = dims.get('length', 1200) # Table length (mm) width = dims.get('width', 800) # Table width (mm) height = dims.get('height', 750) # Table height (mm) top_thickness = dims.get('top_thickness', 30) # Top thickness (mm) leg_size = dims.get('leg_size', 50) # Leg cross-section (mm) try: # Create table top table_top = trimesh.creation.box(extents=[length, width, top_thickness]) table_top = table_top.apply_translation([0, 0, height/2 - top_thickness/2]) # Create legs leg_height = height - top_thickness leg_positions = [ [-length/2 + leg_size, -width/2 + leg_size, -top_thickness/2], [length/2 - leg_size, -width/2 + leg_size, -top_thickness/2], [-length/2 + leg_size, width/2 - leg_size, -top_thickness/2], [length/2 - leg_size, width/2 - leg_size, -top_thickness/2] ] frame = table_top for pos in leg_positions: leg = trimesh.creation.box(extents=[leg_size, leg_size, leg_height]) leg = leg.apply_translation(pos) frame = frame.union(leg) return frame except Exception: # Fallback: solid block return trimesh.creation.box(extents=[length, width, height]) def _create_chair_frame(self, dims): """Create a chair frame structure""" width = dims.get('width', 450) # Seat width (mm) depth = dims.get('depth', 400) # Seat depth (mm) seat_height = dims.get('seat_height', 450) # Seat height (mm) back_height = dims.get('back_height', 350) # Back height above seat (mm) frame_size = dims.get('frame_size', 30) # Frame member size (mm) try: # Create seat frame seat = trimesh.creation.box(extents=[width, depth, frame_size]) seat = seat.apply_translation([0, 0, seat_height - frame_size/2]) # Create backrest back = trimesh.creation.box(extents=[width, frame_size, back_height]) back = back.apply_translation([0, depth/2 - frame_size/2, seat_height + back_height/2]) # Create legs leg_positions = [ [-width/2 + frame_size/2, -depth/2 + frame_size/2], [width/2 - frame_size/2, -depth/2 + frame_size/2], [-width/2 + frame_size/2, depth/2 - frame_size/2], [width/2 - frame_size/2, depth/2 - frame_size/2] ] frame = seat.union(back) for x, y in leg_positions: leg = trimesh.creation.box(extents=[frame_size, frame_size, seat_height]) leg = leg.apply_translation([x, y, seat_height/2 - frame_size/2]) frame = frame.union(leg) return frame except Exception: # Fallback: simple chair block total_height = seat_height + back_height return trimesh.creation.box(extents=[width, depth, total_height]) def _create_shelf_frame(self, dims): """Create a shelf frame structure""" width = dims.get('width', 800) # Shelf width (mm) depth = dims.get('depth', 300) # Shelf depth (mm) height = dims.get('height', 1800) # Total height (mm) shelf_thickness = dims.get('shelf_thickness', 20) # Shelf thickness (mm) num_shelves = dims.get('num_shelves', 4) # Number of shelves try: # Create vertical sides left_side = trimesh.creation.box(extents=[shelf_thickness, depth, height]) left_side = left_side.apply_translation([-width/2 + shelf_thickness/2, 0, 0]) right_side = trimesh.creation.box(extents=[shelf_thickness, depth, height]) right_side = right_side.apply_translation([width/2 - shelf_thickness/2, 0, 0]) # Create shelves shelf_spacing = (height - shelf_thickness) / (num_shelves - 1) frame = left_side.union(right_side) for i in range(num_shelves): z_pos = -height/2 + shelf_thickness/2 + i * shelf_spacing shelf = trimesh.creation.box(extents=[width - 2*shelf_thickness, depth, shelf_thickness]) shelf = shelf.apply_translation([0, 0, z_pos]) frame = frame.union(shelf) return frame except Exception: # Fallback: solid block return trimesh.creation.box(extents=[width, depth, height]) def _create_cabinet_frame(self, dims): """Create a cabinet frame structure""" width = dims.get('width', 600) # Cabinet width (mm) depth = dims.get('depth', 350) # Cabinet depth (mm) height = dims.get('height', 720) # Cabinet height (mm) panel_thickness = dims.get('panel_thickness', 18) # Panel thickness (mm) try: # Create cabinet box # Left side left = trimesh.creation.box(extents=[panel_thickness, depth, height]) left = left.apply_translation([-width/2 + panel_thickness/2, 0, 0]) # Right side right = trimesh.creation.box(extents=[panel_thickness, depth, height]) right = right.apply_translation([width/2 - panel_thickness/2, 0, 0]) # Top top = trimesh.creation.box(extents=[width, depth, panel_thickness]) top = top.apply_translation([0, 0, height/2 - panel_thickness/2]) # Bottom bottom = trimesh.creation.box(extents=[width, depth, panel_thickness]) bottom = bottom.apply_translation([0, 0, -height/2 + panel_thickness/2]) # Back panel back_panel = trimesh.creation.box(extents=[width - 2*panel_thickness, panel_thickness, height - 2*panel_thickness]) back_panel = back_panel.apply_translation([0, depth/2 - panel_thickness/2, 0]) return left.union(right).union(top).union(bottom).union(back_panel) except Exception: # Fallback: solid block return trimesh.creation.box(extents=[width, depth, height]) # ===================================================== # PARAMETRIC BUILDERS (CadQuery + Trimesh Fallbacks) # ===================================================== def _create_parametric_washer(self, dims): """Enhanced washer with CadQuery precision""" outer_radius = dims.get('outer_radius', dims.get('radius', 20)) inner_radius = dims.get('inner_radius', outer_radius * 0.4) thickness = dims.get('thickness', 3) if CADQUERY_AVAILABLE: try: outer = cq.Workplane("XY").circle(outer_radius).extrude(thickness) inner = cq.Workplane("XY").circle(inner_radius).extrude(thickness + 0.01) washer = outer.cut(inner) return cq_to_trimesh(washer) except Exception: pass # Fallback to existing method return self._create_washer(dims) def _create_parametric_nut(self, dims): """Enhanced nut with CadQuery precision""" radius = dims.get('radius', 10) thickness = dims.get('thickness', dims.get('height', 6)) hole_radius = dims.get('hole_radius', radius * 0.4) if CADQUERY_AVAILABLE: try: nut = cq.Workplane("XY").polygon(6, radius * 2).extrude(thickness) nut = nut.faces(">Z").workplane().hole(hole_radius * 2) return cq_to_trimesh(nut) except Exception: pass # Fallback to existing method return self._create_nut(dims) def _create_parametric_bracket(self, dims): """Enhanced bracket with CadQuery precision""" leg1 = dims.get('length', 100) leg2 = dims.get('height', 80) thickness = dims.get('thickness', 6) hole_diam = dims.get('hole_radius', 4) * 2 hole_offset = dims.get('depth', 20) if CADQUERY_AVAILABLE: try: legA = cq.Workplane("XY").box(leg1, thickness, thickness).translate((leg1/2 - leg1, 0, 0)) legB = cq.Workplane("XY").box(thickness, thickness, leg2).translate((0, 0, leg2/2)) combined = legA.union(legB) if hole_diam > 0: combined = combined.faces(">Z").workplane().pushPoints([(hole_offset - leg1/2, 0), (leg1 - hole_offset - leg1/2, 0)]).hole(hole_diam) return cq_to_trimesh(combined) except Exception: pass # Fallback to existing method return self._create_bracket(dims) def _create_parametric_door(self, dims): """Enhanced door with CadQuery precision""" width = dims.get('width', 900) height = dims.get('height', 2100) thickness = dims.get('thickness', 40) panel_count = dims.get('panel_count', 2) frame_width = dims.get('frame_width', 60) if CADQUERY_AVAILABLE: try: door = cq.Workplane("XY").box(width, thickness, height) # Add panel insets if panel_count > 0: panel_h = (height - 2*frame_width - (panel_count-1)*frame_width) / panel_count z0 = -height/2 + frame_width + panel_h/2 for i in range(int(panel_count)): door = door.faces(">Y").workplane().center(0, z0 - (-height/2)).rect(width - 2*frame_width, panel_h - frame_width/2).cutBlind(-frame_width/4) z0 += panel_h + frame_width return cq_to_trimesh(door) except Exception: pass # Fallback to existing method return self._create_door_frame(dims) def _create_parametric_window(self, dims): """Enhanced window with CadQuery precision""" width = dims.get('width', 1200) height = dims.get('height', 1200) frame_thickness = dims.get('thickness', dims.get('depth', 60)) glass_thickness = dims.get('glass_thickness', 6) if CADQUERY_AVAILABLE: try: # Create frame outer = cq.Workplane("XY").box(width, frame_thickness, height) inner = cq.Workplane("XY").box(width - 2*frame_thickness, frame_thickness + 2, height - 2*frame_thickness) frame = outer.cut(inner) # Add glass glass = cq.Workplane("XY").box(width - 2*frame_thickness - 2, glass_thickness, height - 2*frame_thickness - 2) return cq_to_trimesh(frame.union(glass)) except Exception: pass # Fallback to existing method return self._create_window_frame(dims) def _create_water_tank(self, dims): """Create a cylindrical water tank""" diameter = dims.get('diameter', 1000) height = dims.get('height', 1200) wall_thickness = dims.get('wall_thickness', dims.get('thickness', 8)) outer_radius = diameter / 2 inner_radius = outer_radius - wall_thickness if CADQUERY_AVAILABLE: try: outer = cq.Workplane("XY").circle(outer_radius).extrude(height) inner = cq.Workplane("XY").circle(inner_radius).extrude(height + 1) tank = outer.cut(inner) # Add lid lid = cq.Workplane("XY").circle(outer_radius + 10).extrude(5).translate((0, 0, height/2 + 2.5)) return cq_to_trimesh(tank.union(lid)) except Exception: pass # Trimesh fallback try: outer = trimesh.creation.cylinder(radius=outer_radius, height=height, sections=128) inner = trimesh.creation.cylinder(radius=inner_radius, height=height*1.01, sections=128) return safe_difference(outer, inner) except Exception: return trimesh.creation.cylinder(radius=outer_radius, height=height) def generate_3d_model(self, params): """Generate 3D model based on parameters""" shape_func = self.shapes_library.get(params['shape'], self._create_cube) return shape_func(params['dimensions']) def generate_3d_visualization(self, mesh, color='lightblue'): """Generate interactive 3D visualization using Plotly""" vertices = mesh.vertices faces = mesh.faces color_map = { 'red': '#FF0000', 'blue': '#0000FF', 'green': '#00FF00', 'yellow': '#FFFF00', 'orange': '#FFA500', 'purple': '#800080', 'pink': '#FFC0CB', 'brown': '#A52A2A', 'black': '#000000', 'white': '#FFFFFF', 'gray': '#808080', 'grey': '#808080', 'lightblue': '#ADD8E6' } mesh_color = color_map.get(color, '#ADD8E6') fig = go.Figure(data=[ go.Mesh3d( x=vertices[:, 0], y=vertices[:, 1], z=vertices[:, 2], i=faces[:, 0], j=faces[:, 1], k=faces[:, 2], color=mesh_color, opacity=0.8, lighting=dict(ambient=0.18, diffuse=1, fresnel=0.1, specular=1, roughness=0.05), lightposition=dict(x=100, y=200, z=0) ) ]) fig.update_layout( title="3D CAD Model", scene=dict( xaxis_title="X (mm)", yaxis_title="Y (mm)", zaxis_title="Z (mm)", camera=dict(eye=dict(x=1.5, y=1.5, z=1.5)) ), width=800, height=600 ) return fig # ===================================================== # 2D PLATE DESIGN AND G-CODE GENERATOR # ===================================================== def parse_plate_description(description): """Parse textual description to extract geometric parameters for a plate""" width, height = 100, 100 holes = [] slots = [] ovals = [] # Find width and height match = re.search(r'(\d+)\s*mm\s*[xX×]\s*(\d+)\s*mm', description) if match: width = int(match.group(1)) height = int(match.group(2)) # Find circular holes for center_match in re.finditer(r'(hole|circle|circular cutout)[^\d]*(\d+)\s*mm', description): diameter = int(center_match.group(2)) holes.append({ 'x': width / 2, 'y': height / 2, 'diameter': diameter }) # Find slots for slot_match in re.finditer(r'(\d+)\s*mm\s+long\s+and\s+(\d+)\s*mm\s+wide\s+slot', description): slots.append({ 'x': width / 2, 'y': height / 2, 'length': int(slot_match.group(1)), 'width': int(slot_match.group(2)) }) # Find ovals for oval_match in re.finditer(r'oval\s+hole\s+(\d+)\s*mm\s+long\s+and\s+(\d+)\s*mm\s+wide', description): ovals.append({ 'x': width / 2, 'y': height / 2, 'length': int(oval_match.group(1)), 'width': int(oval_match.group(2)) }) return { "width": width, "height": height, "holes": holes, "slots": slots, "ovals": ovals } def generate_3_view_drawings(description): """Generate a 3-view engineering drawing from the description""" parsed = parse_plate_description(description) width = parsed["width"] height = parsed["height"] depth = 5 holes = parsed["holes"] slots = parsed["slots"] ovals = parsed["ovals"] fig, axes = plt.subplots(1, 3, figsize=(15, 5)) views = ['Top View', 'Front View', 'Side View'] for ax, view in zip(axes, views): ax.set_title(view) ax.grid(True, linestyle='--', linewidth=0.5) ax.set_aspect('equal', adjustable='box') if view == "Top View": # Draw the main plate shape = box(0, 0, width, height) x, y = shape.exterior.xy ax.plot(x, y, color='black') # Draw features for hole in holes: r = hole['diameter'] / 2 circle = Point(hole['x'], hole['y']).buffer(r) hx, hy = circle.exterior.xy ax.plot(hx, hy, color='black') for slot in slots: slot_shape = Point(slot['x'], slot['y']).buffer(1) slot_shape = scale(slot_shape, slot['length']/2, slot['width']/2) sx, sy = slot_shape.exterior.xy ax.plot(sx, sy, color='black') for oval in ovals: ellipse = Point(oval['x'], oval['y']).buffer(1) ellipse = scale(ellipse, oval['length'] / 2, oval['width'] / 2) ox, oy = ellipse.exterior.xy ax.plot(ox, oy, color='black') ax.set_xlim(-10, width + 10) ax.set_ylim(-10, height + 10) elif view == "Front View": shape = box(0, 0, width, depth) x, y = shape.exterior.xy ax.plot(x, y, color='black') ax.set_xlim(-10, width + 10) ax.set_ylim(-10, depth + 10) elif view == "Side View": shape = box(0, 0, height, depth) x, y = shape.exterior.xy ax.plot(x, y, color='black') ax.set_xlim(-10, height + 10) ax.set_ylim(-10, depth + 10) plt.tight_layout() # Convert to PIL Image buf = io.BytesIO() plt.savefig(buf, format='png', dpi=150, bbox_inches='tight') buf.seek(0) img = Image.open(buf) plt.close() return img def generate_gcode(description): """Generate G-code for milling the part based on the description""" parsed = parse_plate_description(description) gcode = [ "G21 ; Set units to mm", "G90 ; Use absolute positioning", "G17 ; Select XY plane", "M3 S1000 ; Start spindle", "G0 Z5 ; Lift Z to a safe height" ] # Mill the outer rectangle w, h = parsed['width'], parsed['height'] gcode.extend([ "\n; --- Mill Outer Profile ---", "G0 X0 Y0 ; Move to starting corner", "G1 Z-1 F100 ; Plunge down", f"G1 X{w} F300 ; Mill along X", f"G1 Y{h} ; Mill along Y", f"G1 X0 ; Mill back along X", "G1 Y0 ; Mill back to start", "G0 Z5 ; Retract Z" ]) # Mill circular holes for hole in parsed['holes']: x, y, d = hole['x'], hole['y'], hole['diameter'] r = d / 2 gcode.extend([ f"\n; --- Mill Hole at X{x}, Y{y}, D{d} ---", f"G0 X{x - r} Y{y} ; Move to start of circle", "G1 Z-1 F100 ; Plunge down", f"G2 I{r} J0 F200 ; Mill full circle (CW)", "G0 Z5 ; Retract Z" ]) # Mill slots for slot in parsed['slots']: x, y, l, w_slot = slot['x'], slot['y'], slot['length'], slot['width'] r = w_slot / 2 x_start = x - (l - w_slot) / 2 x_end = x + (l - w_slot) / 2 gcode.extend([ f"\n; --- Mill Slot at center X{x}, Y{y} ---", f"G0 X{x_start} Y{y - r}", "G1 Z-1 F100", f"G1 X{x_end} F200", f"G2 I0 J{r}", f"G1 X{x_start}", f"G2 I0 J{r}", "G0 Z5" ]) # Ovals for oval in parsed['ovals']: x, y, l, w_oval = oval['x'], oval['y'], oval['length'], oval['width'] gcode.append(f"\n; --- Oval hole at X{x}, Y{y} (manual operation needed) ---") gcode.append(f"; Oval of length {l} and width {w_oval} cannot be interpolated with simple G2/G3") gcode.append("\nM5 ; Stop spindle") gcode.append("G0 X0 Y0 ; Return to home") gcode.append("M30 ; End of program") return "\n".join(gcode) # ===================================================== # CFD SOLVER # ===================================================== def run_cfd_simulation(Lx=2.0, Ly=1.0, Nx=41, Ny=21, inlet_velocity=0.005, density=1.0, viscosity=0.05, obstacle_params=None, max_iterations=1000): """Run CFD simulation with given parameters""" try: dx = Lx / (Nx - 1) dy = Ly / (Ny - 1) # Initialize fields u = np.zeros((Ny, Nx)) v = np.zeros((Ny, Nx)) p = np.ones((Ny, Nx)) # Create obstacle mask obstacle_mask = np.zeros((Ny, Nx), dtype=bool) if obstacle_params: ox1, oy1, ox2, oy2 = obstacle_params if ox1 != 0 or oy1 != 0 or ox2 != 0 or oy2 != 0: i_ox1 = max(0, int(round(ox1 / dx))) j_oy1 = max(0, int(round(oy1 / dy))) i_ox2 = min(Nx - 1, int(round(ox2 / dx))) j_oy2 = min(Ny - 1, int(round(oy2 / dy))) obstacle_mask[j_oy1:j_oy2, i_ox1:i_ox2] = True dt = 0.01 nu = viscosity / density # Simple simulation loop for iteration in range(max_iterations): un = u.copy() vn = v.copy() # Apply boundary conditions u[:, 0] = inlet_velocity # Inlet v[:, 0] = 0.0 u[:, -1] = u[:, -2] # Outlet v[:, -1] = v[:, -2] u[0, :] = 0.0 # Walls u[-1, :] = 0.0 v[0, :] = 0.0 v[-1, :] = 0.0 u[obstacle_mask] = 0.0 v[obstacle_mask] = 0.0 # Simple explicit update (simplified) for j in range(1, Ny-1): for i in range(1, Nx-1): if obstacle_mask[j, i]: continue # Diffusion terms diff_u = nu * ((un[j, i+1] - 2*un[j, i] + un[j, i-1])/dx**2 + (un[j+1, i] - 2*un[j, i] + un[j-1, i])/dy**2) diff_v = nu * ((vn[j, i+1] - 2*vn[j, i] + vn[j, i-1])/dx**2 + (vn[j+1, i] - 2*vn[j, i] + vn[j-1, i])/dy**2) u[j, i] = un[j, i] + dt * diff_u v[j, i] = vn[j, i] + dt * diff_v # Check convergence if iteration % 100 == 0: diff = np.max(np.abs(u - un)) if diff < 1e-6: break # Generate visualization x = np.linspace(0, Lx, Nx) y = np.linspace(0, Ly, Ny) X, Y = np.meshgrid(x, y) # Mask obstacle points u_plot = u.copy() v_plot = v.copy() u_plot[obstacle_mask] = np.nan v_plot[obstacle_mask] = np.nan velocity_magnitude = np.sqrt(u_plot**2 + v_plot**2) # Create plot fig, axes = plt.subplots(1, 2, figsize=(15, 6)) # Velocity magnitude im1 = axes[0].contourf(X, Y, velocity_magnitude, levels=20, cmap='viridis') axes[0].set_title('Velocity Magnitude') axes[0].set_xlabel('X (m)') axes[0].set_ylabel('Y (m)') plt.colorbar(im1, ax=axes[0]) # Streamlines axes[1].streamplot(x, y, u_plot, v_plot, density=2, color='blue', linewidth=0.8) axes[1].set_title('Flow Streamlines') axes[1].set_xlabel('X (m)') axes[1].set_ylabel('Y (m)') if np.any(obstacle_mask): for ax in axes: ax.contour(X, Y, obstacle_mask, levels=[0.5], colors='red', linewidths=2) plt.tight_layout() # Convert to image buf = io.BytesIO() plt.savefig(buf, format='png', dpi=150, bbox_inches='tight') buf.seek(0) img = Image.open(buf) plt.close() return img, f"CFD simulation completed after {iteration+1} iterations" except Exception as e: # Return error image fig, ax = plt.subplots(figsize=(10, 6)) ax.text(0.5, 0.5, f"CFD Error: {str(e)}", ha='center', va='center', fontsize=12) ax.set_xlim(0, 1) ax.set_ylim(0, 1) plt.title("CFD Simulation Error") buf = io.BytesIO() plt.savefig(buf, format='png', dpi=150, bbox_inches='tight') buf.seek(0) img = Image.open(buf) plt.close() return img, f"Error: {str(e)}" # ===================================================== # ORTHOGRAPHIC VIEWS GENERATOR (6 views + flexible grid) # ===================================================== def generate_orthographic_views(mesh, layout="2x3"): """ Generate 6 orthographic views (Front, Back, Top, Bottom, Left, Right) and a combined grid image with customizable layout. Args: mesh: 3D mesh with `.vertices` layout (str): Grid layout e.g. "2x3", "3x2", "1x6", "6x1" Returns: PIL Image: Combined orthographic views """ try: projections = [ ("Front (XY)", [0, 1]), ("Back (XY)", [0, 1]), ("Top (XZ)", [0, 2]), ("Bottom (XZ)", [0, 2]), ("Left (YZ)", [1, 2]), ("Right (YZ)", [1, 2]), ] views = [] titles = [] # --- Generate individual images --- for title, axes_idx in projections: fig, ax = plt.subplots(figsize=(4, 4)) ax.set_title(title) ax.set_aspect('equal') ax.grid(True, alpha=0.3) vertices_2d = mesh.vertices[:, axes_idx] if len(vertices_2d) > 3: try: hull = ConvexHull(vertices_2d) hull_points = vertices_2d[hull.vertices] hull_points = np.vstack([hull_points, hull_points[0]]) ax.plot(hull_points[:, 0], hull_points[:, 1], 'b-', linewidth=2) except Exception as hull_err: print(f"Hull error on {title}: {hull_err}") buf = io.BytesIO() plt.savefig(buf, format='png', dpi=120, bbox_inches='tight') buf.seek(0) img = Image.open(buf) plt.close(fig) views.append(img) titles.append(title) # --- Parse layout --- try: rows, cols = map(int, layout.lower().split("x")) if rows * cols < 6: raise ValueError("Layout grid too small for 6 views.") except Exception: print(f"Invalid layout '{layout}', defaulting to 2x3") rows, cols = 2, 3 # --- Create combined grid --- fig, axs = plt.subplots(rows, cols, figsize=(4*cols, 4*rows)) axs = np.array(axs).reshape(-1) # Flatten to 1D array for easy indexing for ax, view_img, title in zip(axs, views, titles): ax.imshow(view_img) ax.set_title(title, fontsize=10) ax.axis("off") # Hide extra empty subplots if grid > 6 for ax in axs[len(views):]: ax.axis("off") plt.tight_layout() buf = io.BytesIO() plt.savefig(buf, format='png', dpi=150, bbox_inches='tight') buf.seek(0) combined_img = Image.open(buf) plt.close(fig) return combined_img except Exception as e: # Return error image fig, ax = plt.subplots(figsize=(10, 6)) ax.text(0.5, 0.5, f"Orthographic Views Error: {str(e)}", ha='center', va='center', fontsize=12, color='red') ax.set_xlim(0, 1) ax.set_ylim(0, 1) plt.title("Orthographic Views Error") buf = io.BytesIO() plt.savefig(buf, format='png', dpi=150, bbox_inches='tight') buf.seek(0) img = Image.open(buf) plt.close() return img # ===================================================== # MAIN APPLICATION FUNCTIONS # ===================================================== # Initialize CAD generator cad_generator = TextToCADGenerator() def process_text_to_cad(prompt, precision_choice="High (parametric)", export_format="stl", grid_layout="2x3"): """Enhanced CAD processing with precision modes and export capabilities""" try: params = cad_generator.parse_prompt(prompt) # Override precision based on UI choice params['precision'] = 'high' if precision_choice.lower().startswith('h') else 'fast' # Use parametric builders for high precision when available if params['precision'] == 'high' and params['shape'] in ['washer', 'nut', 'bracket', 'door', 'window']: # Try parametric version first parametric_shape = f"parametric_{params['shape']}" if parametric_shape in cad_generator.shapes_library: original_shape = params['shape'] params['shape'] = parametric_shape try: mesh_3d = cad_generator.generate_3d_model(params) except Exception: # Fallback to original shape params['shape'] = original_shape mesh_3d = cad_generator.generate_3d_model(params) else: mesh_3d = cad_generator.generate_3d_model(params) else: mesh_3d = cad_generator.generate_3d_model(params) # Generate 3D visualization fig_3d = cad_generator.generate_3d_visualization(mesh_3d, params['color']) # Generate enhanced orthographic views views_result = generate_orthographic_views(mesh_3d, layout=grid_layout) if len(views_result) >= 7: # 6 individual views + combined ortho_views = views_result[6] # Use combined view else: ortho_views = views_result[0] if views_result else None # Enhanced summary dims = params['dimensions'] dim_summary = [] for key, value in dims.items(): if value is not None and key in ['length', 'width', 'height', 'radius', 'diameter', 'thickness']: dim_summary.append(f"{key.title()}: {value}mm") backend_info = "✅ CadQuery (parametric)" if CADQUERY_AVAILABLE and params['precision'] == 'high' else "⚡ Trimesh (fast)" boolean_info = f"Boolean backend: {BOOL_BACKEND}" if BOOL_BACKEND else "No boolean backend" summary = f""" **🔧 Generated CAD Model Summary:** - **Shape:** {params['shape'].replace('_', ' ').replace('parametric ', '').title()} - **Dimensions:** {', '.join(dim_summary) if dim_summary else 'Default dimensions'} - **Color:** {params['color'].title()} - **Precision Mode:** {params['precision'].title()} precision - **CAD Backend:** {backend_info} - **{boolean_info}** - **Original Prompt:** "{params['prompt']}" ✅ The model has been successfully generated with 6-view orthographic projections. """ # Optional export export_path = None if export_format and mesh_3d: try: tmpfile = tempfile.NamedTemporaryFile(suffix=f'.{export_format}', delete=False) tmpname = tmpfile.name tmpfile.close() export_mesh(mesh_3d, tmpname) export_path = tmpname except Exception as e: export_path = None print(f"Export error: {e}") return fig_3d, ortho_views, summary, export_path except Exception as e: error_msg = f"Error generating CAD model: {str(e)}" placeholder_fig = go.Figure() placeholder_fig.add_annotation(text=error_msg, x=0.5, y=0.5, showarrow=False) # Create error image fig, ax = plt.subplots(figsize=(8, 4)) ax.text(0.5, 0.5, error_msg, ha='center', va='center', fontsize=12, color='red') ax.set_xlim(0, 1) ax.set_ylim(0, 1) ax.axis('off') buf = io.BytesIO() plt.savefig(buf, format='png', dpi=150, bbox_inches='tight') buf.seek(0) error_img = Image.open(buf) plt.close() return placeholder_fig, error_img, error_msg, None def process_plate_design(description): """Process plate description and generate outputs""" try: if not description.strip(): return None, "Please enter a description.", None drawing = generate_3_view_drawings(description) gcode = generate_gcode(description) return drawing, gcode, "Plate design generated successfully!" except Exception as e: error_msg = f"Error generating plate design: {str(e)}" return None, error_msg, None def process_cfd_simulation(length, height, grid_x, grid_y, inlet_vel, density, viscosity, obs_x1, obs_y1, obs_x2, obs_y2, max_iter): """Process CFD simulation with given parameters""" try: obstacle_params = None if obs_x1 != 0 or obs_y1 != 0 or obs_x2 != 0 or obs_y2 != 0: obstacle_params = (obs_x1, obs_y1, obs_x2, obs_y2) result_img, message = run_cfd_simulation( Lx=length, Ly=height, Nx=grid_x, Ny=grid_y, inlet_velocity=inlet_vel, density=density, viscosity=viscosity, obstacle_params=obstacle_params, max_iterations=max_iter ) return result_img, message except Exception as e: error_msg = f"CFD simulation error: {str(e)}" return None, error_msg # ===================================================== # GRADIO INTERFACE # ===================================================== def create_gradio_interface(): """Create comprehensive Gradio interface""" with gr.Blocks(title="Kelmoid Genesis LLM Prototype", theme=gr.themes.Soft()) as demo: gr.Markdown(""" # 🔧 Kelmoid Genesis LLM Prototype **AI-Powered CAD Engineering Suite for Design, Analysis, and Manufacturing** This suite includes: - 🎨 **Text-to-CAD Generator**: Create 3D models from natural language - 📐 **2D Plate Designer**: Generate technical drawings and G-code - 🌊 **CFD Simulator**: Computational fluid dynamics analysis - 📋 **Orthographic Views**: Generate technical drawings from 3D models """) with gr.Tabs(): # ===================================================== # TAB 1: TEXT TO CAD # ===================================================== with gr.TabItem("🎨 Text-to-CAD Generator"): gr.Markdown("### Convert natural language descriptions into 3D CAD models") with gr.Row(): with gr.Column(scale=2): cad_prompt = gr.Textbox( label="Design Prompt", placeholder="e.g., 'Create a door width=900 height=2100 thickness=40 panels=2' or 'washer radius=20 thickness=3'", lines=3 ) with gr.Row(): precision_choice = gr.Radio( ["High (parametric)", "Fast (approximate)"], value="High (parametric)", label="Precision Mode", info="High uses CadQuery for accuracy, Fast uses Trimesh for speed" ) export_format = gr.Dropdown( ["stl", "obj", "ply", "glb"], value="stl", label="Export Format" ) grid_layout = gr.Dropdown( ["2x3", "3x2", "1x6", "6x1"], value="2x3", label="Orthographic Layout" ) cad_generate_btn = gr.Button("🚀 Generate CAD Model", variant="primary", size="lg") download_file = gr.File(label="Download CAD File", visible=False) gr.Markdown("**Quick Examples:**") with gr.Row(): gr.Button("Cube 20x20x20", size="sm").click( lambda: "Create a cube with 20x20x20 dimensions", outputs=cad_prompt ) gr.Button("Cylinder r=10, h=15", size="sm").click( lambda: "Design a cylinder with radius 10mm and height 15mm", outputs=cad_prompt ) gr.Button("Bearing OD=20, ID=10", size="sm").click( lambda: "Make a bearing with outer diameter 20mm and inner diameter 10mm", outputs=cad_prompt ) gr.Button("L-Bracket 30x20x15", size="sm").click( lambda: "Create an L-shaped bracket 30x20x15mm", outputs=cad_prompt ) with gr.Row(): gr.Button("Parametric Door", size="sm").click( lambda: "Create parametric door width=900 height=2100 thickness=40 panels=2", outputs=cad_prompt ) gr.Button("Water Tank", size="sm").click( lambda: "Design water tank diameter=1000 height=1200 wall_thickness=8", outputs=cad_prompt ) gr.Button("Precision Washer", size="sm").click( lambda: "Create parametric washer outer_radius=25 inner_radius=10 thickness=3", outputs=cad_prompt ) gr.Button("Hex Nut M12", size="sm").click( lambda: "Make parametric nut radius=12 thickness=10 hole_radius=6", outputs=cad_prompt ) with gr.Row(): with gr.Column(): cad_3d_output = gr.Plot(label="Interactive 3D Model") with gr.Column(): cad_ortho_output = gr.Image(label="Orthographic Views", type="pil") cad_summary_output = gr.Markdown(label="Generation Summary") cad_generate_btn.click( fn=process_text_to_cad, inputs=[cad_prompt, precision_choice, export_format, grid_layout], outputs=[cad_3d_output, cad_ortho_output, cad_summary_output, download_file] ) # ===================================================== # TAB 2: 2D PLATE DESIGNER # ===================================================== with gr.TabItem("📐 2D Plate Designer"): gr.Markdown("### Generate technical drawings and G-code for 2D plates") with gr.Row(): with gr.Column(scale=2): plate_description = gr.Textbox( lines=5, label="Plate Description", placeholder="e.g., A 100mm x 50mm plate with a 20mm diameter hole and a 30mm long and 10mm wide slot" ) plate_generate_btn = gr.Button("📋 Generate Plate Design", variant="primary") gr.Markdown("**Examples:**") with gr.Column(): gr.Button("150x100mm plate with 25mm hole").click( lambda: "A 150mm x 100mm plate with a 25mm diameter circular cutout", outputs=plate_description ) gr.Button("100x100mm plate with slot").click( lambda: "A 100mm x 100mm plate with a 50mm long and 10mm wide slot", outputs=plate_description ) gr.Button("120x80mm plate with oval").click( lambda: "A 120mm x 80mm plate with an oval hole 40mm long and 20mm wide", outputs=plate_description ) with gr.Row(): with gr.Column(): plate_drawing_output = gr.Image(label="3-View Technical Drawing", type="pil") with gr.Column(): plate_gcode_output = gr.Code(label="Generated G-Code") plate_status_output = gr.Textbox(label="Status") plate_generate_btn.click( fn=process_plate_design, inputs=[plate_description], outputs=[plate_drawing_output, plate_gcode_output, plate_status_output] ) # ===================================================== # TAB 3: CFD SIMULATOR # ===================================================== with gr.TabItem("🌊 kelmoid CFD Simulator"): gr.Markdown("### Computational Fluid Dynamics Simulation") with gr.Row(): with gr.Column(scale=1): gr.Markdown("**Domain Parameters:**") cfd_length = gr.Number(label="Channel Length (m)", value=2.0, minimum=0.1, maximum=10.0) cfd_height = gr.Number(label="Channel Height (m)", value=1.0, minimum=0.1, maximum=5.0) cfd_grid_x = gr.Number(label="Grid Points X", value=41, minimum=21, maximum=101) cfd_grid_y = gr.Number(label="Grid Points Y", value=21, minimum=11, maximum=51) gr.Markdown("**Flow Parameters:**") cfd_inlet_vel = gr.Number(label="Inlet Velocity (m/s)", value=0.005, minimum=0.001, maximum=0.1) cfd_density = gr.Number(label="Fluid Density (kg/m³)", value=1.0, minimum=0.1, maximum=10.0) cfd_viscosity = gr.Number(label="Dynamic Viscosity (Pa·s)", value=0.05, minimum=0.001, maximum=1.0) gr.Markdown("**Obstacle (optional):**") cfd_obs_x1 = gr.Number(label="Obstacle X1", value=0.5, minimum=0.0, maximum=2.0) cfd_obs_y1 = gr.Number(label="Obstacle Y1", value=0.2, minimum=0.0, maximum=1.0) cfd_obs_x2 = gr.Number(label="Obstacle X2", value=0.7, minimum=0.0, maximum=2.0) cfd_obs_y2 = gr.Number(label="Obstacle Y2", value=0.8, minimum=0.0, maximum=1.0) cfd_max_iter = gr.Number(label="Max iterations", value=1000, minimum=100, maximum=5000) cfd_simulate_btn = gr.Button("🌊 Run CFD Simulation", variant="primary") with gr.Column(scale=2): cfd_result_output = gr.Image(label="CFD Results", type="pil") cfd_status_output = gr.Textbox(label="Simulation Status") cfd_simulate_btn.click( fn=process_cfd_simulation, inputs=[cfd_length, cfd_height, cfd_grid_x, cfd_grid_y, cfd_inlet_vel, cfd_density, cfd_viscosity, cfd_obs_x1, cfd_obs_y1, cfd_obs_x2, cfd_obs_y2, cfd_max_iter], outputs=[cfd_result_output, cfd_status_output] ) gr.Markdown(""" --- ### 📚 Usage Guide: **🔧 Enhanced Text-to-CAD Generator:** - **Basic Shapes**: cube, sphere, cylinder, cone, pyramid, torus, gear, plate, rod - **Mechanical Parts**: bracket, washer, screw, bolt, nut, bearing, flange, pipe - **Architectural Frames**: door frame, window frame, gypsum frame, drywall frame, water tank - **Furniture Frames**: bed frame, table frame, chair frame, shelf frame, cabinet frame - **Parametric Models**: parametric_door, parametric_window, parametric_washer, parametric_nut, parametric_bracket - **Precision Modes**: High (CadQuery parametric) vs Fast (Trimesh approximate) - **Key=Value Syntax**: Use `width=900 height=2100 thickness=40` for precise control - **Export Formats**: STL, OBJ, PLY, GLB for 3D printing and CAD software - **Dimension Keywords**: length, width, height, radius, diameter, thickness, depth, spacing, panels, frames - **Colors**: red, blue, green, yellow, orange, purple, pink, brown, black, white, gray **🎯 Pro Tips:** - Use `parametric_` prefix for high-precision mechanical parts - Include `panels=4` for doors, `wall_thickness=8` for tanks - Try `NxMxP` patterns like `100x50x25` for quick dimensions **2D Plate Designer:** - Describe plates with dimensions like "100mm x 50mm" - Add features: "20mm diameter hole", "30mm long and 10mm wide slot", "oval hole 40mm long and 20mm wide" - Generates technical drawings and CNC G-code **CFD Simulator:** - Simulates fluid flow through channels with optional obstacles - Adjust grid resolution for accuracy vs. speed - Lower viscosity = higher Reynolds number = more turbulent flow **🚀 Enhanced Features:** - **CadQuery Integration**: Precise parametric CAD when available - **Boolean Backend**: Advanced geometry operations with manifold3d - **6-View Orthographics**: Professional engineering drawings - **Export Support**: Direct download of STL/OBJ/PLY/GLB files - **Key=Value Parsing**: `width=900 thickness=40` syntax support **Note:** This application supports both CPU-based fast prototyping and precision parametric CAD modeling. """) return demo # ===================================================== # MAIN EXECUTION # ===================================================== if __name__ == "__main__": demo = create_gradio_interface() demo.launch( share=True, server_name="0.0.0.0", server_port=7860, show_error=True )