Spaces:

jainarham
/

text-to-3d

Sleeping

App Files Files Community

jainarham commited on Feb 9

Commit

5c3adf5

verified ·

1 Parent(s): 4c24702

Update nlp_processor.py

Browse files

Files changed (1) hide show

nlp_processor.py +611 -259

nlp_processor.py CHANGED Viewed

@@ -1,324 +1,676 @@
 """
-NLP Processor Module - FIXED QUANTITY SUPPORT
 """
 import re
-from typing import Dict, Any, Optional, List
 import logging
 logger = logging.getLogger(__name__)
-class NLPProcessor:
     def __init__(self):
-        # Shape vocabulary
         self.shapes = {
-            "cube": ["cube", "cubes", "box", "boxes", "block", "blocks"],
-            "sphere": ["sphere", "spheres", "ball", "balls", "orb", "orbs"],
-            "cylinder": ["cylinder", "cylinders", "tube", "tubes", "pipe", "pipes"],
-            "cone": ["cone", "cones", "pointed"],
-            "torus": ["torus", "toruses", "donut", "donuts", "ring", "rings"],
-            "pyramid": ["pyramid", "pyramids"],
-            "plane": ["plane", "planes", "floor", "ground", "platform"],
-            "capsule": ["capsule", "capsules", "pill", "pills"],
         }
-        # Color vocabulary
         self.colors = {
-            "red": "#ff0000",
-            "green": "#00ff00",
-            "blue": "#0000ff",
-            "yellow": "#ffff00",
-            "orange": "#ffa500",
-            "purple": "#800080",
-            "pink": "#ffc0cb",
-            "white": "#ffffff",
-            "black": "#333333",
-            "gray": "#808080",
-            "grey": "#808080",
-            "brown": "#8b4513",
-            "cyan": "#00ffff",
-            "magenta": "#ff00ff",
-            "gold": "#ffd700",
-            "golden": "#ffd700",
-            "silver": "#c0c0c0",
-            "bronze": "#cd7f32",
-            "navy": "#000080",
-            "teal": "#008080",
-            "lime": "#32cd32",
-            "coral": "#ff7f50",
-            "crimson": "#dc143c",
-            "violet": "#ee82ee",
-            "indigo": "#4b0082",
-            "maroon": "#800000",
-            "olive": "#808000",
-            "aqua": "#00ffff",
         }
-        # Size vocabulary
         self.sizes = {
-            "tiny": 0.3,
-            "very small": 0.4,
-            "small": 0.6,
-            "medium": 1.0,
-            "normal": 1.0,
-            "regular": 1.0,
-            "large": 1.5,
-            "big": 1.5,
-            "huge": 2.0,
-            "giant": 2.5,
-            "massive": 3.0,
         }
         # Number words
-        self.number_words = {
-            "one": 1, "a": 1, "an": 1,
-            "two": 2, "pair": 2,
-            "three": 3, "trio": 3,
-            "four": 4,
-            "five": 5,
-            "six": 6,
-            "seven": 7,
-            "eight": 8,
-            "nine": 9,
-            "ten": 10,
-            "eleven": 11,
-            "twelve": 12,
         }
-        # Modifications
         self.modifications = {
-            "bigger": {"action": "scale", "factor": 1.5},
-            "larger": {"action": "scale", "factor": 1.5},
-            "smaller": {"action": "scale", "factor": 0.7},
-            "taller": {"action": "scale_y", "factor": 1.5},
-            "shorter": {"action": "scale_y", "factor": 0.7},
-            "wider": {"action": "scale_x", "factor": 1.5},
-            "thinner": {"action": "scale_x", "factor": 0.7},
         }
-    def extract_quantity(self, text: str, shape_word: str) -> int:
-        """Extract quantity from text for a specific shape"""
-        text_lower = text.lower()
-        # Pattern 1: "3 cubes", "5 spheres"
-        pattern1 = rf'(\d+)\s*{shape_word}'
-        match1 = re.search(pattern1, text_lower)
-        if match1:
-            return int(match1.group(1))
-        # Pattern 2: "three cubes", "five spheres"
-        for word, num in self.number_words.items():
-            pattern2 = rf'\b{word}\s+{shape_word}'
-            if re.search(pattern2, text_lower):
-                return num
-        # Pattern 3: Just a number at the start "3 red cubes"
-        pattern3 = rf'(\d+)\s+\w+\s+{shape_word}'
-        match3 = re.search(pattern3, text_lower)
-        if match3:
-            return int(match3.group(1))
-        # Pattern 4: Number word at start "three red cubes"
-        for word, num in self.number_words.items():
-            pattern4 = rf'\b{word}\s+\w+\s+{shape_word}'
-            if re.search(pattern4, text_lower):
-                return num
-        # Pattern 5: Check for plural - if plural, assume at least context wants multiple
-        # Actually just return 1 for singular
-        return 1
-    def extract_shapes(self, text: str) -> List[Dict[str, Any]]:
-        """Extract shape mentions from text"""
-        shapes_found = []
         text_lower = text.lower()
-        for shape_type, synonyms in self.shapes.items():
-            for synonym in synonyms:
-                if synonym in text_lower:
-                    quantity = self.extract_quantity(text_lower, synonym)
-                    # Avoid duplicates
-                    already_found = any(s["type"] == shape_type for s in shapes_found)
-                    if not already_found:
-                        shapes_found.append({
-                            "type": shape_type,
-                            "quantity": quantity,
-                            "matched_word": synonym
-                        })
-                    break
-        return shapes_found
-    def extract_colors(self, text: str) -> List[str]:
-        """Extract color mentions"""
-        colors_found = []
-        text_lower = text.lower()
-        for color in self.colors.keys():
-            if color in text_lower:
-                colors_found.append(color)
-        return colors_found
-    def extract_size(self, text: str) -> Optional[float]:
-        """Extract size information"""
         text_lower = text.lower()
-        for size_word, scale in self.sizes.items():
-            if size_word in text_lower:
-                return scale
-        return None
-    def detect_modification(self, text: str, existing_context: Optional[Dict]) -> Dict[str, Any]:
-        """Detect if user wants to modify existing model"""
-        modification_keywords = [
-            "make it", "change", "modify", "update", "turn it",
-            "bigger", "smaller", "larger", "taller", "shorter",
-            "different color", "new color", "instead",
-            "more", "less", "add", "remove"
-        ]
-        text_lower = text.lower()
-        is_modification = any(kw in text_lower for kw in modification_keywords)
-        if is_modification and existing_context:
-            modifications = []
-            for mod_word, mod_action in self.modifications.items():
-                if mod_word in text_lower:
-                    modifications.append(mod_action)
-            new_colors = self.extract_colors(text)
-            if new_colors:
-                modifications.append({
-                    "action": "change_color",
-                    "color": new_colors[0]
-                })
-            return {
-                "is_modification": True,
-                "modifications": modifications,
-                "base_context": existing_context
-            }
-        return {"is_modification": False}
     def process_prompt(self, prompt: str, existing_context: Optional[Dict] = None) -> Dict[str, Any]:
-        """Main method to process prompt"""
         try:
-            text = prompt.lower().strip()
-            # Check for modification
-            mod_result = self.detect_modification(text, existing_context)
-            # Extract components
-            shapes = self.extract_shapes(text)
-            colors = self.extract_colors(text)
-            size = self.extract_size(text)
-            # Build interpretation
-            interpretation_parts = []
-            # Handle modifications
-            if mod_result["is_modification"] and existing_context:
-                interpretation_parts.append("Modifying existing model")
-                if not shapes:
-                    shapes = []
-                    for obj in existing_context.get("model_params", {}).get("objects", []):
-                        shapes.append({"type": obj.get("type", "cube"), "quantity": 1})
-            # Default shape if none found
-            if not shapes:
-                shapes = [{"type": "cube", "quantity": 1}]
-                interpretation_parts.append("No shape specified, using cube")
-            # Build description
-            shape_descriptions = []
-            for s in shapes:
-                qty = s.get("quantity", 1)
-                if qty > 1:
-                    shape_descriptions.append(f"{qty}x {s['type']}")
-                else:
-                    shape_descriptions.append(s['type'])
-            interpretation_parts.append(f"Creating: {', '.join(shape_descriptions)}")
-            if colors:
-                interpretation_parts.append(f"Color: {colors[0]}")
-            if size:
-                interpretation_parts.append(f"Scale: {size:.1f}x")
-            # Build objects list
-            objects = []
-            obj_index = 0
-            for shape in shapes:
-                quantity = shape.get("quantity", 1)
-                shape_type = shape.get("type", "cube")
-                for q in range(quantity):
-                    # Calculate position - spread objects out
-                    x_pos = (obj_index % 5) * 2.0 - 4.0  # -4, -2, 0, 2, 4
-                    z_pos = (obj_index // 5) * 2.0  # Rows
-                    if quantity == 1 and len(shapes) == 1:
-                        x_pos = 0
-                        z_pos = 0
-                    obj = {
-                        "type": shape_type,
-                        "color": self.colors.get(colors[0], "#808080") if colors else "#808080",
-                        "scale": size if size else 1.0,
-                        "position": {"x": x_pos, "y": 0, "z": z_pos},
-                        "rotation": {"x": 0, "y": 0, "z": 0}
-                    }
-                    objects.append(obj)
-                    obj_index += 1
-            # Apply modifications
-            if mod_result["is_modification"]:
-                for mod in mod_result.get("modifications", []):
-                    for obj in objects:
-                        if mod.get("action") == "scale":
-                            obj["scale"] = obj.get("scale", 1.0) * mod.get("factor", 1.0)
-                        elif mod.get("action") == "scale_y":
-                            if "scale_axes" not in obj:
-                                obj["scale_axes"] = {"x": 1, "y": 1, "z": 1}
-                            obj["scale_axes"]["y"] *= mod.get("factor", 1.0)
-                        elif mod.get("action") == "scale_x":
-                            if "scale_axes" not in obj:
-                                obj["scale_axes"] = {"x": 1, "y": 1, "z": 1}
-                            obj["scale_axes"]["x"] *= mod.get("factor", 1.0)
-                        elif mod.get("action") == "change_color":
-                            obj["color"] = self.colors.get(mod.get("color"), obj.get("color", "#808080"))
             model_params = {
                 "objects": objects,
                 "scene_settings": {
                     "background_color": "#1a1a2e",
-                    "ambient_light": 0.4,
                     "directional_light": 0.8
                 }
             }
-            logger.info(f"Processed: {len(objects)} objects created")
             return {
                 "success": True,
                 "original_prompt": prompt,
-                "interpretation": " | ".join(interpretation_parts),
                 "model_params": model_params,
-                "is_modification": mod_result.get("is_modification", False)
             }
         except Exception as e:
-            logger.error(f"NLP processing error: {str(e)}")
             return {
                 "success": False,
-                "error": f"Failed to process: {str(e)}",
-                "interpretation": "Error understanding request"
-            }

 """
+Advanced NLP Processor - Professional Grade
+Understands complex prompts, spatial relationships, and compositions
 """
 import re
 import logging
+from typing import Dict, Any, Optional, List, Tuple
+from dataclasses import dataclass
+from enum import Enum
 logger = logging.getLogger(__name__)
+class Relation(Enum):
+    NONE = "none"
+    ON_TOP = "on_top"
+    BELOW = "below"
+    NEXT_TO = "next_to"
+    LEFT_OF = "left_of"
+    RIGHT_OF = "right_of"
+    IN_FRONT = "in_front"
+    BEHIND = "behind"
+    INSIDE = "inside"
+    AROUND = "around"
+    BETWEEN = "between"
+class Arrangement(Enum):
+    NONE = "none"
+    ROW = "row"
+    COLUMN = "column"
+    CIRCLE = "circle"
+    GRID = "grid"
+    STACK = "stack"
+    RANDOM = "random"
+    INCREASING = "increasing"
+    DECREASING = "decreasing"
+@dataclass
+class ParsedObject:
+    shape: str
+    color: str
+    size: float
+    quantity: int
+    material: str
+    relation: Relation
+    relation_target: Optional[str]
+    arrangement: Arrangement
+    modifiers: List[str]
+class AdvancedNLPProcessor:
     def __init__(self):
+        self._init_vocabularies()
+        self._compile_patterns()
+        logger.info("Advanced NLP Processor initialized")
+    def _init_vocabularies(self):
+        """Initialize all vocabularies and mappings"""
+        # Shapes with synonyms
         self.shapes = {
+            "cube": ["cube", "cubes", "box", "boxes", "block", "blocks", "square", "squares"],
+            "sphere": ["sphere", "spheres", "ball", "balls", "orb", "orbs", "globe", "globes"],
+            "cylinder": ["cylinder", "cylinders", "tube", "tubes", "pipe", "pipes", "pillar", "pillars", "column", "columns"],
+            "cone": ["cone", "cones", "spike", "spikes"],
+            "torus": ["torus", "toruses", "tori", "donut", "donuts", "ring", "rings", "hoop", "hoops"],
+            "pyramid": ["pyramid", "pyramids", "tetrahedron", "tetrahedrons"],
+            "capsule": ["capsule", "capsules", "pill", "pills", "lozenge"],
+            "plane": ["plane", "planes", "floor", "ground", "platform", "base", "surface"],
         }
+        # Flatten for quick lookup
+        self.shape_lookup = {}
+        for canonical, synonyms in self.shapes.items():
+            for syn in synonyms:
+                self.shape_lookup[syn] = canonical
+        # Colors with hex values
         self.colors = {
+            # Basic
+            "red": "#e74c3c", "green": "#2ecc71", "blue": "#3498db",
+            "yellow": "#f1c40f", "orange": "#e67e22", "purple": "#9b59b6",
+            "pink": "#e91e63", "white": "#ecf0f1", "black": "#2c3e50",
+            "gray": "#95a5a6", "grey": "#95a5a6", "brown": "#8b4513",
+            # Extended
+            "cyan": "#00bcd4", "magenta": "#e91e63", "lime": "#8bc34a",
+            "teal": "#009688", "navy": "#1a237e", "maroon": "#800000",
+            "olive": "#808000", "coral": "#ff7f50", "salmon": "#fa8072",
+            "gold": "#ffd700", "golden": "#ffd700", "silver": "#c0c0c0",
+            "bronze": "#cd7f32", "copper": "#b87333", "platinum": "#e5e4e2",
+            "crimson": "#dc143c", "scarlet": "#ff2400", "ruby": "#e0115f",
+            "emerald": "#50c878", "jade": "#00a86b", "mint": "#98fb98",
+            "sapphire": "#0f52ba", "azure": "#007fff", "indigo": "#4b0082",
+            "violet": "#8f00ff", "lavender": "#e6e6fa", "plum": "#dda0dd",
+            "turquoise": "#40e0d0", "aqua": "#00ffff", "sky": "#87ceeb",
+            "peach": "#ffdab9", "beige": "#f5f5dc", "ivory": "#fffff0",
+            "cream": "#fffdd0", "tan": "#d2b48c", "chocolate": "#7b3f00",
+            "charcoal": "#36454f", "slate": "#708090", "steel": "#71797e",
+            # Metallic descriptors
+            "metallic": "#a8a9ad", "shiny": "#d4d4d4", "chrome": "#dbe4eb",
         }
+        # Sizes with scale factors
         self.sizes = {
+            "tiny": 0.25, "very small": 0.35, "small": 0.5, "little": 0.5,
+            "medium": 1.0, "normal": 1.0, "regular": 1.0, "average": 1.0,
+            "large": 1.5, "big": 1.5, "huge": 2.0, "giant": 2.5,
+            "massive": 3.0, "enormous": 3.5, "colossal": 4.0,
+            "mini": 0.3, "micro": 0.2, "nano": 0.15,
         }
         # Number words
+        self.numbers = {
+            "a": 1, "an": 1, "one": 1, "single": 1,
+            "two": 2, "pair": 2, "couple": 2, "double": 2,
+            "three": 3, "triple": 3, "trio": 3,
+            "four": 4, "quad": 4, "quadruple": 4,
+            "five": 5, "six": 6, "seven": 7, "eight": 8,
+            "nine": 9, "ten": 10, "eleven": 11, "twelve": 12,
+            "dozen": 12, "fifteen": 15, "twenty": 20,
+            "few": 3, "several": 4, "many": 6, "lots": 8,
         }
+        # Spatial relations
+        self.relations = {
+            # On top
+            "on": Relation.ON_TOP, "on top of": Relation.ON_TOP,
+            "above": Relation.ON_TOP, "over": Relation.ON_TOP,
+            "atop": Relation.ON_TOP, "upon": Relation.ON_TOP,
+            # Below
+            "under": Relation.BELOW, "below": Relation.BELOW,
+            "beneath": Relation.BELOW, "underneath": Relation.BELOW,
+            # Next to
+            "next to": Relation.NEXT_TO, "beside": Relation.NEXT_TO,
+            "by": Relation.NEXT_TO, "near": Relation.NEXT_TO,
+            "adjacent": Relation.NEXT_TO, "alongside": Relation.NEXT_TO,
+            # Left/Right
+            "left of": Relation.LEFT_OF, "to the left": Relation.LEFT_OF,
+            "right of": Relation.RIGHT_OF, "to the right": Relation.RIGHT_OF,
+            # Front/Behind
+            "in front of": Relation.IN_FRONT, "before": Relation.IN_FRONT,
+            "behind": Relation.BEHIND, "back of": Relation.BEHIND,
+            # Inside
+            "inside": Relation.INSIDE, "within": Relation.INSIDE,
+            "in": Relation.INSIDE,
+            # Around
+            "around": Relation.AROUND, "surrounding": Relation.AROUND,
+            # Between
+            "between": Relation.BETWEEN,
+        }
+        # Arrangements
+        self.arrangements = {
+            "row": Arrangement.ROW, "line": Arrangement.ROW, "horizontal": Arrangement.ROW,
+            "column": Arrangement.COLUMN, "vertical": Arrangement.COLUMN, "tower": Arrangement.STACK,
+            "circle": Arrangement.CIRCLE, "ring": Arrangement.CIRCLE, "circular": Arrangement.CIRCLE,
+            "grid": Arrangement.GRID, "matrix": Arrangement.GRID, "array": Arrangement.GRID,
+            "stack": Arrangement.STACK, "stacked": Arrangement.STACK, "pile": Arrangement.STACK,
+            "random": Arrangement.RANDOM, "scattered": Arrangement.RANDOM,
+            "increasing": Arrangement.INCREASING, "ascending": Arrangement.INCREASING,
+            "decreasing": Arrangement.DECREASING, "descending": Arrangement.DECREASING,
+        }
+        # Materials/textures
+        self.materials = {
+            "metallic": "metallic", "metal": "metallic", "shiny": "shiny",
+            "matte": "matte", "flat": "matte", "glossy": "glossy",
+            "glass": "glass", "transparent": "glass", "crystal": "glass",
+            "wood": "wood", "wooden": "wood", "stone": "stone",
+            "plastic": "plastic", "rubber": "rubber", "chrome": "chrome",
+            "brushed": "brushed", "polished": "polished", "rough": "rough",
+            "smooth": "smooth", "textured": "textured",
+        }
+        # Modification keywords for refinement
         self.modifications = {
+            "bigger": ("scale", 1.5), "larger": ("scale", 1.5),
+            "smaller": ("scale", 0.7), "tinier": ("scale", 0.5),
+            "taller": ("scale_y", 1.5), "shorter": ("scale_y", 0.7),
+            "wider": ("scale_x", 1.5), "thinner": ("scale_x", 0.7),
+            "longer": ("scale_z", 1.5), "deeper": ("scale_z", 1.5),
+            "double": ("scale", 2.0), "half": ("scale", 0.5),
+            "rotate": ("rotate_y", 45), "spin": ("rotate_y", 90),
+            "flip": ("rotate_x", 180), "tilt": ("rotate_z", 30),
         }
+    def _compile_patterns(self):
+        """Compile regex patterns for efficiency"""
+        # Number pattern: "5", "five", "a few"
+        number_words = '|'.join(self.numbers.keys())
+        self.num_pattern = re.compile(
+            rf'\b(\d+|{number_words})\b',
+            re.IGNORECASE
+        )
+        # Shape pattern
+        all_shapes = []
+        for synonyms in self.shapes.values():
+            all_shapes.extend(synonyms)
+        shape_words = '|'.join(sorted(all_shapes, key=len, reverse=True))
+        self.shape_pattern = re.compile(
+            rf'\b({shape_words})\b',
+            re.IGNORECASE
+        )
+        # Color pattern
+        color_words = '|'.join(sorted(self.colors.keys(), key=len, reverse=True))
+        self.color_pattern = re.compile(
+            rf'\b({color_words})\b',
+            re.IGNORECASE
+        )
+        # Size pattern
+        size_words = '|'.join(sorted(self.sizes.keys(), key=len, reverse=True))
+        self.size_pattern = re.compile(
+            rf'\b({size_words})\b',
+            re.IGNORECASE
+        )
+        # Relation pattern
+        relation_words = '|'.join(sorted(self.relations.keys(), key=len, reverse=True))
+        self.relation_pattern = re.compile(
+            rf'\b({relation_words})\b',
+            re.IGNORECASE
+        )
+        # Arrangement pattern
+        arr_words = '|'.join(sorted(self.arrangements.keys(), key=len, reverse=True))
+        self.arrangement_pattern = re.compile(
+            rf'\b({arr_words})\b',
+            re.IGNORECASE
+        )
+        # Material pattern
+        mat_words = '|'.join(sorted(self.materials.keys(), key=len, reverse=True))
+        self.material_pattern = re.compile(
+            rf'\b({mat_words})\b',
+            re.IGNORECASE
+        )
+        # Compound object pattern: "X on Y", "X with Y"
+        self.compound_pattern = re.compile(
+            r'(.+?)\s+(on|with|and|next to|beside|above|below|under|behind|in front of)\s+(.+)',
+            re.IGNORECASE
+        )
+    def _extract_number(self, text: str, shape_word: str) -> int:
+        """Extract quantity for a specific shape"""
         text_lower = text.lower()
+        # Pattern: "3 red cubes", "three cubes", "a cube"
+        patterns = [
+            rf'(\d+)\s+\w*\s*{shape_word}',  # "3 red cubes"
+            rf'(\d+)\s+{shape_word}',  # "3 cubes"
+        ]
+        for pattern in patterns:
+            match = re.search(pattern, text_lower)
+            if match:
+                return int(match.group(1))
+        # Check number words
+        for word, num in self.numbers.items():
+            patterns = [
+                rf'\b{word}\s+\w*\s*{shape_word}',
+                rf'\b{word}\s+{shape_word}',
+            ]
+            for pattern in patterns:
+                if re.search(pattern, text_lower):
+                    return num
+        return 1
+    def _parse_segment(self, text: str) -> ParsedObject:
+        """Parse a single object segment"""
+        text_lower = text.lower().strip()
+        # Find shape
+        shape = "cube"  # default
+        shape_match = self.shape_pattern.search(text_lower)
+        if shape_match:
+            matched = shape_match.group(1)
+            shape = self.shape_lookup.get(matched, "cube")
+        # Find color
+        color = "#808080"  # default gray
+        color_match = self.color_pattern.search(text_lower)
+        if color_match:
+            color = self.colors.get(color_match.group(1).lower(), "#808080")
+        # Find size
+        size = 1.0
+        size_match = self.size_pattern.search(text_lower)
+        if size_match:
+            size = self.sizes.get(size_match.group(1).lower(), 1.0)
+        # Find quantity
+        quantity = self._extract_number(text_lower, shape_match.group(1) if shape_match else "cube")
+        # Find material
+        material = "default"
+        mat_match = self.material_pattern.search(text_lower)
+        if mat_match:
+            material = self.materials.get(mat_match.group(1).lower(), "default")
+        # Find arrangement
+        arrangement = Arrangement.NONE
+        arr_match = self.arrangement_pattern.search(text_lower)
+        if arr_match:
+            arrangement = self.arrangements.get(arr_match.group(1).lower(), Arrangement.NONE)
+        # Collect modifiers
+        modifiers = []
+        for mod in ["smooth", "rough", "shiny", "matte", "glossy"]:
+            if mod in text_lower:
+                modifiers.append(mod)
+        return ParsedObject(
+            shape=shape,
+            color=color,
+            size=size,
+            quantity=quantity,
+            material=material,
+            relation=Relation.NONE,
+            relation_target=None,
+            arrangement=arrangement,
+            modifiers=modifiers
+        )
+    def _parse_compound(self, text: str) -> List[Tuple[ParsedObject, Relation, int]]:
+        """Parse compound prompts with relationships"""
+        results = []
         text_lower = text.lower()
+        # Split by "and" first for multiple independent objects
+        and_parts = re.split(r'\s+and\s+', text, flags=re.IGNORECASE)
+        for part in and_parts:
+            part = part.strip()
+            if not part:
+                continue
+            # Check for relational phrases
+            relation_found = False
+            for rel_phrase, relation in sorted(self.relations.items(), key=lambda x: len(x[0]), reverse=True):
+                pattern = rf'(.+?)\s+{re.escape(rel_phrase)}\s+(.+)'
+                match = re.match(pattern, part, re.IGNORECASE)
+                if match:
+                    # Object A relation Object B
+                    obj_a_text = match.group(1).strip()
+                    obj_b_text = match.group(2).strip()
+                    obj_b = self._parse_segment(obj_b_text)
+                    results.append((obj_b, Relation.NONE, -1))
+                    obj_a = self._parse_segment(obj_a_text)
+                    obj_a.relation = relation
+                    obj_a.relation_target = len(results) - 1
+                    results.append((obj_a, relation, len(results) - 1))
+                    relation_found = True
+                    break
+            if not relation_found:
+                # Single object or simple description
+                obj = self._parse_segment(part)
+                results.append((obj, Relation.NONE, -1))
+        return results
+    def _build_objects(self, parsed_items: List[Tuple[ParsedObject, Relation, int]]) -> List[Dict]:
+        """Convert parsed objects to 3D parameters with positions"""
+        objects = []
+        object_positions = {}  # Track positions by index
+        current_x = 0
+        current_z = 0
+        for idx, (parsed, relation, target_idx) in enumerate(parsed_items):
+            base_x, base_y, base_z = 0, 0, 0
+            # Calculate position based on relation
+            if relation != Relation.NONE and target_idx >= 0 and target_idx in object_positions:
+                target_pos = object_positions[target_idx]
+                base_x, base_y, base_z = target_pos
+                if relation == Relation.ON_TOP:
+                    base_y += 1.2 * parsed.size
+                elif relation == Relation.BELOW:
+                    base_y -= 1.2 * parsed.size
+                elif relation == Relation.NEXT_TO or relation == Relation.RIGHT_OF:
+                    base_x += 2.0 * parsed.size
+                elif relation == Relation.LEFT_OF:
+                    base_x -= 2.0 * parsed.size
+                elif relation == Relation.IN_FRONT:
+                    base_z += 2.0 * parsed.size
+                elif relation == Relation.BEHIND:
+                    base_z -= 2.0 * parsed.size
+            # Generate objects based on quantity and arrangement
+            for q in range(parsed.quantity):
+                obj_x, obj_y, obj_z = base_x, base_y, base_z
+                obj_scale = parsed.size
+                # Apply arrangement
+                if parsed.arrangement == Arrangement.ROW:
+                    obj_x += q * 2.2 * parsed.size
+                elif parsed.arrangement == Arrangement.COLUMN:
+                    obj_z += q * 2.2 * parsed.size
+                elif parsed.arrangement == Arrangement.STACK:
+                    obj_y += q * 1.2 * parsed.size
+                elif parsed.arrangement == Arrangement.CIRCLE:
+                    import math
+                    angle = (2 * math.pi * q) / parsed.quantity
+                    radius = max(2.0, parsed.quantity * 0.5) * parsed.size
+                    obj_x += math.cos(angle) * radius
+                    obj_z += math.sin(angle) * radius
+                elif parsed.arrangement == Arrangement.GRID:
+                    import math
+                    grid_size = int(math.ceil(math.sqrt(parsed.quantity)))
+                    row = q // grid_size
+                    col = q % grid_size
+                    obj_x += col * 2.2 * parsed.size
+                    obj_z += row * 2.2 * parsed.size
+                elif parsed.arrangement == Arrangement.INCREASING:
+                    obj_scale = parsed.size * (0.5 + q * 0.3)
+                    obj_x += q * 2.5 * parsed.size
+                elif parsed.arrangement == Arrangement.DECREASING:
+                    obj_scale = parsed.size * (1.5 - q * 0.2)
+                    obj_x += q * 2.5 * parsed.size
+                elif parsed.arrangement == Arrangement.RANDOM:
+                    import random
+                    obj_x += random.uniform(-3, 3)
+                    obj_z += random.uniform(-3, 3)
+                elif parsed.arrangement == Arrangement.NONE and parsed.quantity > 1:
+                    # Default: spread in a row
+                    obj_x += q * 2.2 * parsed.size
+                # No relation and no arrangement - use sequential positioning
+                if relation == Relation.NONE and parsed.arrangement == Arrangement.NONE and q == 0:
+                    if len(objects) > 0:
+                        obj_x = current_x
+                        current_x += 2.5 * parsed.size
+                obj = {
+                    "type": parsed.shape,
+                    "color": parsed.color,
+                    "scale": obj_scale,
+                    "position": {"x": obj_x, "y": obj_y, "z": obj_z},
+                    "rotation": {"x": 0, "y": 0, "z": 0},
+                    "material": parsed.material,
+                    "modifiers": parsed.modifiers
+                }
+                objects.append(obj)
+            # Store first object position for this parsed item
+            if objects:
+                last_obj = objects[-parsed.quantity] if parsed.quantity <= len(objects) else objects[-1]
+                object_positions[idx] = (
+                    last_obj["position"]["x"],
+                    last_obj["position"]["y"],
+                    last_obj["position"]["z"]
+                )
+                current_x = last_obj["position"]["x"] + 2.5 * parsed.size
+        # Center all objects
+        if objects:
+            min_x = min(o["position"]["x"] for o in objects)
+            max_x = max(o["position"]["x"] for o in objects)
+            min_z = min(o["position"]["z"] for o in objects)
+            max_z = max(o["position"]["z"] for o in objects)
+            center_x = (min_x + max_x) / 2
+            center_z = (min_z + max_z) / 2
+            for obj in objects:
+                obj["position"]["x"] -= center_x
+                obj["position"]["z"] -= center_z
+        return objects
     def process_prompt(self, prompt: str, existing_context: Optional[Dict] = None) -> Dict[str, Any]:
+        """Main processing method"""
         try:
+            logger.info(f"Processing: {prompt}")
+            # Check for modification request
+            if existing_context and self._is_modification(prompt):
+                return self._process_modification(prompt, existing_context)
+            # Parse the prompt
+            parsed_items = self._parse_compound(prompt)
+            if not parsed_items:
+                parsed_items = [(self._parse_segment(prompt), Relation.NONE, -1)]
+            # Build objects
+            objects = self._build_objects(parsed_items)
+            # Build interpretation
+            interpretation = self._build_interpretation(parsed_items, objects)
             model_params = {
                 "objects": objects,
                 "scene_settings": {
                     "background_color": "#1a1a2e",
+                    "ambient_light": 0.5,
                     "directional_light": 0.8
                 }
             }
+            logger.info(f"Generated {len(objects)} objects")
             return {
                 "success": True,
                 "original_prompt": prompt,
+                "interpretation": interpretation,
                 "model_params": model_params,
+                "is_modification": False
             }
         except Exception as e:
+            logger.error(f"Processing error: {str(e)}")
             return {
                 "success": False,
+                "error": str(e),
+                "interpretation": f"Error: {str(e)}"
+            }
+    def _is_modification(self, text: str) -> bool:
+        """Check if prompt is a modification request"""
+        mod_keywords = [
+            "make it", "change", "modify", "update", "make them",
+            "bigger", "smaller", "larger", "taller", "shorter",
+            "rotate", "spin", "flip", "move", "shift",
+            "different color", "change color", "new color",
+            "add more", "remove", "delete", "more", "less"
+        ]
+        text_lower = text.lower()
+        return any(kw in text_lower for kw in mod_keywords)
+    def _process_modification(self, prompt: str, context: Dict) -> Dict[str, Any]:
+        """Process modification request"""
+        text_lower = prompt.lower()
+        # Get existing objects
+        existing_objects = context.get("model_params", {}).get("objects", [])
+        if not existing_objects:
+            return self.process_prompt(prompt, None)
+        modified_objects = []
+        for obj in existing_objects:
+            new_obj = obj.copy()
+            new_obj["position"] = obj["position"].copy()
+            new_obj["rotation"] = obj.get("rotation", {"x": 0, "y": 0, "z": 0}).copy()
+            # Apply modifications
+            for mod_word, (action, value) in self.modifications.items():
+                if mod_word in text_lower:
+                    if action == "scale":
+                        new_obj["scale"] = obj.get("scale", 1.0) * value
+                    elif action == "scale_x":
+                        if "scale_axes" not in new_obj:
+                            new_obj["scale_axes"] = {"x": 1, "y": 1, "z": 1}
+                        new_obj["scale_axes"]["x"] *= value
+                    elif action == "scale_y":
+                        if "scale_axes" not in new_obj:
+                            new_obj["scale_axes"] = {"x": 1, "y": 1, "z": 1}
+                        new_obj["scale_axes"]["y"] *= value
+                    elif action == "scale_z":
+                        if "scale_axes" not in new_obj:
+                            new_obj["scale_axes"] = {"x": 1, "y": 1, "z": 1}
+                        new_obj["scale_axes"]["z"] *= value
+                    elif action.startswith("rotate"):
+                        axis = action.split("_")[1]
+                        new_obj["rotation"][axis] = new_obj["rotation"].get(axis, 0) + value
+            # Check for color change
+            color_match = self.color_pattern.search(text_lower)
+            if color_match and ("color" in text_lower or "change" in text_lower):
+                new_obj["color"] = self.colors.get(color_match.group(1).lower(), new_obj["color"])
+            modified_objects.append(new_obj)
+        # Check for "add more"
+        if "add" in text_lower or "more" in text_lower:
+            # Parse what to add
+            add_parsed = self._parse_segment(prompt)
+            if add_parsed.quantity > 0:
+                # Add new objects
+                last_x = max(o["position"]["x"] for o in modified_objects) if modified_objects else 0
+                for i in range(add_parsed.quantity):
+                    modified_objects.append({
+                        "type": add_parsed.shape,
+                        "color": add_parsed.color,
+                        "scale": add_parsed.size,
+                        "position": {"x": last_x + 2.5 * (i + 1), "y": 0, "z": 0},
+                        "rotation": {"x": 0, "y": 0, "z": 0},
+                        "material": add_parsed.material,
+                        "modifiers": add_parsed.modifiers
+                    })
+        model_params = {
+            "objects": modified_objects,
+            "scene_settings": context.get("model_params", {}).get("scene_settings", {
+                "background_color": "#1a1a2e",
+                "ambient_light": 0.5,
+                "directional_light": 0.8
+            })
+        }
+        return {
+            "success": True,
+            "original_prompt": prompt,
+            "interpretation": f"Modified {len(modified_objects)} object(s)",
+            "model_params": model_params,
+            "is_modification": True
+        }
+    def _build_interpretation(self, parsed_items: List[Tuple[ParsedObject, Relation, int]], objects: List[Dict]) -> str:
+        """Build human-readable interpretation"""
+        parts = []
+        for parsed, relation, target in parsed_items:
+            desc = []
+            if parsed.quantity > 1:
+                desc.append(f"{parsed.quantity}x")
+            if parsed.size != 1.0:
+                size_name = "small" if parsed.size < 1 else "large" if parsed.size > 1 else ""
+                if size_name:
+                    desc.append(size_name)
+            # Get color name
+            color_name = next((name for name, hex_val in self.colors.items() if hex_val == parsed.color), None)
+            if color_name:
+                desc.append(color_name)
+            desc.append(parsed.shape)
+            if parsed.arrangement != Arrangement.NONE:
+                desc.append(f"in {parsed.arrangement.value}")
+            if relation != Relation.NONE:
+                desc.append(relation.value.replace("_", " "))
+            parts.append(" ".join(desc))
+        interpretation = "Creating: " + ", ".join(parts)
+        interpretation += f" | Total: {len(objects)} objects"
+        return interpretation
+# Global instance
+_processor = None
+def get_processor() -> AdvancedNLPProcessor:
+    global _processor
+    if _processor is None:
+        _processor = AdvancedNLPProcessor()
+    return _processor
+class NLPProcessor:
+    """Wrapper for backward compatibility"""
+    def __init__(self):
+        self._processor = get_processor()
+    def process_prompt(self, prompt: str, existing_context: Optional[Dict] = None) -> Dict[str, Any]:
+        return self._processor.process_prompt(prompt, existing_context)