diff --git a/README.md b/README.md index 8dddcdf..729fb14 100644 --- a/README.md +++ b/README.md @@ -140,6 +140,22 @@ Outputs: - `layout_json`: reusable normalized coordinates and warnings - `layout_preview`: a diagnostic IMAGE showing the regions and optional labels +Optional FLUX.3 outputs: + +- `flux3_prompt`: a complete FLUX.3 scene caption followed by the native + bounding-box JSON array. Connect this to the FLUX.3 Klein prompt input; keep + the workflow's official prompt upsampler in the normal position. +- `flux3_boxes_json`: the same bounding-box array separately for inspection or + downstream processing. + +The `output_format` setting selects `legacy`, `flux3`, or `both` (default). +FLUX.3 boxes use `[top, left, bottom, right]` integer coordinates on a 0–1000 +top-left-origin grid. Every generated ID is also emitted as `` in the +caption. `flux3_reference_mode=editing` is intentionally rejected until source +coordinates and reference-image identifiers are available; the current VLM +inventory schema supports generation-style layouts only. Bounding boxes guide +placement and scale but are not hard pixel masks. + The planner uses normalized top-left-origin coordinates, configurable margins and spacing, and rejects malformed or invalid inventory fields with actionable errors. The preview is diagnostic only; feeding it to an image model does not diff --git a/dumas_clothing_layout_planner.py b/dumas_clothing_layout_planner.py index 2400100..2315cd2 100644 --- a/dumas_clothing_layout_planner.py +++ b/dumas_clothing_layout_planner.py @@ -352,6 +352,81 @@ def build_layout_prompt(plan: dict[str, Any]) -> str: return "\n".join(lines) +def _flux3_bbox(region: dict[str, Any], padding_percent: float = 0.0) -> list[int]: + """Convert a normalized region to FLUX.3's 0-1000 box format.""" + + padding = _bounded_number(padding_percent, "flux3_box_padding", 0, 40) / 100 + x, y = float(region["x"]), float(region["y"]) + width, height = float(region["width"]), float(region["height"]) + # Padding is internal: shrink the target box symmetrically without moving + # it outside the layout or changing the original legacy plan. + x += width * padding + y += height * padding + width *= max(0.0, 1 - 2 * padding) + height *= max(0.0, 1 - 2 * padding) + top = max(0, min(1000, round(y * 1000))) + left = max(0, min(1000, round(x * 1000))) + bottom = max(0, min(1000, round((y + height) * 1000))) + right = max(0, min(1000, round((x + width) * 1000))) + if top >= 1000: + top = 999 + if left >= 1000: + left = 999 + if bottom <= top: + bottom = min(1000, top + 1) + if right <= left: + right = min(1000, left + 1) + return [top, left, bottom, right] + + +def build_flux3_boxes( + plan: dict[str, Any], + padding_percent: float = 0.0, + include_descriptions: bool = True, +) -> list[dict[str, Any]]: + """Build FLUX.3 generation-style layout rows from an existing plan.""" + + rows = [] + for region in plan["regions"]: + description = region["description"] if include_descriptions else "" + if not description: + description = region["name"] + rows.append({ + "id": region["id"], + "bbox": _flux3_bbox(region, padding_percent), + "desc": description, + }) + return rows + + +def build_flux3_prompt( + plan: dict[str, Any], + padding_percent: float = 0.0, + include_descriptions: bool = True, +) -> tuple[str, str]: + """Return a FLUX.3 caption and its trailing JSON box array.""" + + boxes = build_flux3_boxes(plan, padding_percent, include_descriptions) + if not boxes: + return "", "[]" + references = [] + for region in plan["regions"]: + references.append(f"{region['name']} <{region['id']}>") + caption = ( + "A photorealistic 90-degree overhead flat-lay product photograph of " + "the exact physical objects identified in the supplied reference image, " + "arranged individually on a clean neutral surface with realistic materials, " + "natural fabric drape, soft studio lighting, and subtle contact shadows. " + f"The scene contains exactly these unique inventory entries: {', '.join(references)}. " + "Reproduce each item's original colours, materials, construction, prints, " + "graphics, and visible details faithfully. Display each object only once " + "inside its allocated region. Do not include the original person, mannequin, " + "duplicate garments, invented accessories, or unrelated props." + ) + boxes_json = json.dumps(boxes, ensure_ascii=False, separators=(",", ":")) + return f"{caption} {boxes_json}", boxes_json + + def _background(value: str) -> tuple[int, int, int]: text = str(value or DEFAULT_BACKGROUND).strip().lstrip("#") if len(text) == 3: @@ -394,8 +469,8 @@ def render_preview(plan: dict[str, Any], background_color: str, show_labels: boo class DumasClothingLayoutPlanner: CATEGORY = "Dumas/Image/Layout" DESCRIPTION = "Create a deterministic object layout from VLM inventory JSON." - RETURN_TYPES = ("STRING", "STRING", "IMAGE") - RETURN_NAMES = ("layout_prompt", "layout_json", "layout_preview") + RETURN_TYPES = ("STRING", "STRING", "IMAGE", "STRING", "STRING") + RETURN_NAMES = ("layout_prompt", "layout_json", "layout_preview", "flux3_prompt", "flux3_boxes_json") FUNCTION = "plan" @classmethod @@ -409,10 +484,19 @@ class DumasClothingLayoutPlanner: "spacing_percent": ("FLOAT", {"default": 3.0, "min": 0.0, "max": 20.0, "step": 0.5}), "background_color": ("STRING", {"default": DEFAULT_BACKGROUND}), "show_labels": ("BOOLEAN", {"default": True}), + "output_format": (["legacy", "flux3", "both"], {"default": "both"}), + "flux3_box_padding": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 40.0, "step": 0.5}), + "flux3_include_descriptions": ("BOOLEAN", {"default": True}), + "flux3_reference_mode": (["generation", "editing"], {"default": "generation"}), }} - def plan(self, inventory_json, canvas_width, canvas_height, layout_mode, margin_percent, spacing_percent, background_color, show_labels): + def plan(self, inventory_json, canvas_width, canvas_height, layout_mode, margin_percent, spacing_percent, background_color, show_labels, output_format, flux3_box_padding, flux3_include_descriptions, flux3_reference_mode): plan = plan_layout(inventory_json, canvas_width, canvas_height, layout_mode, margin_percent, spacing_percent) + if output_format in {"flux3", "both"} and flux3_reference_mode == "editing": + raise ValueError( + "flux3_reference_mode='editing' requires source bounding boxes and reference-image identifiers; " + "the current inventory schema only supports generation mode" + ) preview = render_preview(plan, background_color, show_labels) try: import numpy as np @@ -420,7 +504,12 @@ class DumasClothingLayoutPlanner: tensor = torch.from_numpy(np.asarray(preview).astype("float32") / 255.0)[None, ...] except ImportError as exc: raise RuntimeError("DUMAS Clothing Layout Planner requires ComfyUI's torch and numpy runtime") from exc - return build_layout_prompt(plan), json.dumps(plan, ensure_ascii=False, indent=2), tensor + flux3_prompt, flux3_boxes_json = "", "[]" + if output_format in {"flux3", "both"}: + flux3_prompt, flux3_boxes_json = build_flux3_prompt( + plan, flux3_box_padding, flux3_include_descriptions + ) + return build_layout_prompt(plan), json.dumps(plan, ensure_ascii=False, indent=2), tensor, flux3_prompt, flux3_boxes_json NODE_CLASS_MAPPINGS = {"DumasClothingLayoutPlanner": DumasClothingLayoutPlanner} diff --git a/tests/test_dumas_clothing_layout_planner.py b/tests/test_dumas_clothing_layout_planner.py index 71cf9f0..741056b 100644 --- a/tests/test_dumas_clothing_layout_planner.py +++ b/tests/test_dumas_clothing_layout_planner.py @@ -111,6 +111,44 @@ class ClothingLayoutPlannerTests(unittest.TestCase): self.assertIn("cotton shirt", prompt) self.assertIn("region", prompt) + def test_flux3_boxes_use_official_order_and_1000_grid(self): + plan = PLANNER.plan_layout(inventory( + {"id": "item_001", "name": "blue shirt", "description": "blue cotton"}, + {"id": "item_002", "name": "red bag", "description": "red leather"}, + ), 1200, 800, "grid") + rows = PLANNER.build_flux3_boxes(plan) + self.assertEqual(len(rows), 2) + for row in rows: + top, left, bottom, right = row["bbox"] + self.assertTrue(0 <= top < bottom <= 1000) + self.assertTrue(0 <= left < right <= 1000) + self.assertEqual(rows[0]["desc"], "blue cotton") + + def test_flux3_prompt_has_matching_tags_and_trailing_json(self): + plan = PLANNER.plan_layout(inventory({ + "id": "item_001", "name": "blue shirt", "description": "blue cotton", + })) + prompt, boxes_json = PLANNER.build_flux3_prompt(plan) + self.assertIn("", prompt) + self.assertTrue(prompt.endswith(boxes_json)) + self.assertEqual(json.loads(boxes_json)[0]["id"], "item_001") + + def test_flux3_padding_shrinks_without_changing_legacy_plan(self): + plan = PLANNER.plan_layout(inventory({"id": "item_001", "name": "shirt"})) + original = dict(plan["regions"][0]) + padded = PLANNER.build_flux3_boxes(plan, 10)[0]["bbox"] + self.assertEqual(plan["regions"][0], original) + self.assertGreater(padded[2] - padded[0], 0) + self.assertGreater(padded[3] - padded[1], 0) + + def test_flux3_editing_mode_requires_source_coordinates(self): + with self.assertRaisesRegex(ValueError, "editing.*source bounding boxes"): + PLANNER.DumasClothingLayoutPlanner().plan( + inventory({"id": "item_001", "name": "shirt"}), + 640, 480, "balanced", 5, 3, "#EEE8DC", True, + "flux3", 0, True, "editing", + ) + def test_invalid_fields_have_actionable_errors(self): with self.assertRaisesRegex(ValueError, "invalid unit"): PLANNER.normalize_inventory(inventory({"id": "x", "name": "X", "unit": "trio"}))