@createlex/createlexgenai 1.0.0

package/python/ui_slice_host.py

@@ -0,0 +1,637 @@
+import os
+import re
+import shutil
+import tempfile
+import time
+import uuid
+from collections import deque
+from typing import Any, Dict, List, Tuple
+
+try:
+    from PIL import Image, ImageChops, ImageFilter
+
+    _HAS_PILLOW = True
+    _PILLOW_ERROR = ""
+except Exception as pillow_error:
+    Image = None
+    ImageChops = None
+    ImageFilter = None
+    _HAS_PILLOW = False
+    _PILLOW_ERROR = str(pillow_error)
+
+
+def has_pillow() -> Tuple[bool, str]:
+    return _HAS_PILLOW, _PILLOW_ERROR
+
+
+def _sanitize_asset_name(name: str) -> str:
+    sanitized = re.sub(r"[^A-Za-z0-9_]+", "_", (name or "").strip())
+    sanitized = re.sub(r"_+", "_", sanitized).strip("_")
+    if not sanitized:
+        sanitized = f"UI_{uuid.uuid4().hex[:8]}"
+    if sanitized[0].isdigit():
+        sanitized = f"UI_{sanitized}"
+    return sanitized[:64]
+
+
+def _estimate_background_palette(rgb_image, sample_stride: int = 8, max_colors: int = 4):
+    width, height = rgb_image.size
+    pixels = rgb_image.load()
+    sampled_bins: Dict[tuple, int] = {}
+
+    def add_sample(x: int, y: int):
+        r, g, b = pixels[x, y]
+        key = (r // 16, g // 16, b // 16)
+        sampled_bins[key] = sampled_bins.get(key, 0) + 1
+
+    for x in range(0, width, sample_stride):
+        add_sample(x, 0)
+        add_sample(x, height - 1)
+    for y in range(0, height, sample_stride):
+        add_sample(0, y)
+        add_sample(width - 1, y)
+
+    if not sampled_bins:
+        return [(0, 0, 0)]
+
+    sorted_bins = sorted(sampled_bins.items(), key=lambda kv: kv[1], reverse=True)[:max_colors]
+    palette = []
+    for (rb, gb, bb), _ in sorted_bins:
+        palette.append((rb * 16 + 8, gb * 16 + 8, bb * 16 + 8))
+    return palette
+
+
+def _build_foreground_mask(rgba_image, alpha_threshold: int, background_tolerance: int):
+    width, height = rgba_image.size
+    alpha_channel = rgba_image.split()[3]
+    alpha_data = alpha_channel.tobytes()
+    non_opaque_alpha = sum(1 for value in alpha_data if value < 250)
+    has_meaningful_alpha = non_opaque_alpha > max(32, (width * height) // 1000)
+
+    if has_meaningful_alpha:
+        alpha_mask = alpha_channel.point(lambda px: 255 if px > alpha_threshold else 0)
+        return alpha_mask, "alpha"
+
+    rgb = rgba_image.convert("RGB")
+    palette = _estimate_background_palette(rgb)
+    mask = Image.new("L", (width, height), 0)
+    rgb_pixels = rgb.load()
+    mask_pixels = mask.load()
+
+    for y in range(height):
+        for x in range(width):
+            r, g, b = rgb_pixels[x, y]
+            color_distance = min(abs(r - pr) + abs(g - pg) + abs(b - pb) for pr, pg, pb in palette)
+            if color_distance > background_tolerance:
+                mask_pixels[x, y] = 255
+
+    return mask, "color"
+
+
+def _threshold_mask(mask_image, threshold: int = 127):
+    return mask_image.point(lambda px: 255 if px > threshold else 0)
+
+
+def _expand_bbox(bbox, padding: int, width: int, height: int):
+    min_x, min_y, max_x, max_y = bbox
+    return [
+        max(0, int(min_x) - padding),
+        max(0, int(min_y) - padding),
+        min(width - 1, int(max_x) + padding),
+        min(height - 1, int(max_y) + padding),
+    ]
+
+
+def _bbox_iou(bbox_a, bbox_b):
+    ax0, ay0, ax1, ay1 = bbox_a
+    bx0, by0, bx1, by1 = bbox_b
+    inter_x0 = max(ax0, bx0)
+    inter_y0 = max(ay0, by0)
+    inter_x1 = min(ax1, bx1)
+    inter_y1 = min(ay1, by1)
+    if inter_x1 < inter_x0 or inter_y1 < inter_y0:
+        return 0.0
+    inter_area = (inter_x1 - inter_x0 + 1) * (inter_y1 - inter_y0 + 1)
+    area_a = (ax1 - ax0 + 1) * (ay1 - ay0 + 1)
+    area_b = (bx1 - bx0 + 1) * (by1 - by0 + 1)
+    union_area = max(1, area_a + area_b - inter_area)
+    return inter_area / float(union_area)
+
+
+def _extract_active_bands(active_flags: List[bool], min_len: int):
+    bands = []
+    start_idx = -1
+    for idx, active in enumerate(active_flags):
+        if active and start_idx < 0:
+            start_idx = idx
+        elif not active and start_idx >= 0:
+            end_idx = idx - 1
+            if end_idx - start_idx + 1 >= min_len:
+                bands.append((start_idx, end_idx))
+            start_idx = -1
+
+    if start_idx >= 0:
+        end_idx = len(active_flags) - 1
+        if end_idx - start_idx + 1 >= min_len:
+            bands.append((start_idx, end_idx))
+    return bands
+
+
+def _tighten_component_from_bbox(mask_image, bbox, minimum_area: int = 1):
+    width, height = mask_image.size
+    min_x, min_y, max_x, max_y = bbox
+    min_x = max(0, min(width - 1, int(min_x)))
+    min_y = max(0, min(height - 1, int(min_y)))
+    max_x = max(0, min(width - 1, int(max_x)))
+    max_y = max(0, min(height - 1, int(max_y)))
+    if max_x < min_x or max_y < min_y:
+        return None
+
+    mask_data = mask_image.tobytes()
+    area = 0
+    tight_min_x = max_x
+    tight_min_y = max_y
+    tight_max_x = min_x
+    tight_max_y = min_y
+
+    for y in range(min_y, max_y + 1):
+        row_offset = y * width
+        for x in range(min_x, max_x + 1):
+            if mask_data[row_offset + x] == 0:
+                continue
+            area += 1
+            if x < tight_min_x:
+                tight_min_x = x
+            if x > tight_max_x:
+                tight_max_x = x
+            if y < tight_min_y:
+                tight_min_y = y
+            if y > tight_max_y:
+                tight_max_y = y
+
+    if area < minimum_area or tight_max_x < tight_min_x or tight_max_y < tight_min_y:
+        return None
+
+    bbox_width = tight_max_x - tight_min_x + 1
+    bbox_height = tight_max_y - tight_min_y + 1
+    return {
+        "bbox": [tight_min_x, tight_min_y, tight_max_x, tight_max_y],
+        "area": area,
+        "bbox_width": bbox_width,
+        "bbox_height": bbox_height,
+        "center_x": (tight_min_x + tight_max_x) / 2.0,
+        "center_y": (tight_min_y + tight_max_y) / 2.0,
+    }
+
+
+def _dedupe_components(components: List[Dict[str, Any]], max_components: int):
+    unique_components: List[Dict[str, Any]] = []
+    for component in sorted(components, key=lambda item: item.get("area", 0), reverse=True):
+        bbox = component.get("bbox")
+        if not bbox:
+            continue
+        duplicate = False
+        for existing in unique_components:
+            if _bbox_iou(bbox, existing.get("bbox")) > 0.88:
+                duplicate = True
+                break
+        if duplicate:
+            continue
+        unique_components.append(component)
+        if len(unique_components) >= max_components:
+            break
+    return unique_components
+
+
+def _extract_projection_components(mask_image, min_area: int, max_components: int, min_row_fill: float, min_col_fill: float):
+    width, height = mask_image.size
+    mask_data = mask_image.tobytes()
+    row_counts = [0] * height
+    for y in range(height):
+        row_offset = y * width
+        row_counts[y] = sum(1 for x in range(width) if mask_data[row_offset + x] != 0)
+
+    min_row_pixels = max(2, int(width * min_row_fill))
+    row_active = [count >= min_row_pixels for count in row_counts]
+    row_bands = _extract_active_bands(row_active, min_len=max(4, height // 180))
+
+    components: List[Dict[str, Any]] = []
+    for row_start, row_end in row_bands:
+        band_height = row_end - row_start + 1
+        col_counts = [0] * width
+        for y in range(row_start, row_end + 1):
+            row_offset = y * width
+            for x in range(width):
+                if mask_data[row_offset + x] != 0:
+                    col_counts[x] += 1
+
+        min_col_pixels = max(2, int(band_height * min_col_fill))
+        col_active = [count >= min_col_pixels for count in col_counts]
+        col_bands = _extract_active_bands(col_active, min_len=max(4, width // 260))
+        if not col_bands:
+            col_bands = [(0, width - 1)]
+
+        for col_start, col_end in col_bands:
+            tightened = _tighten_component_from_bbox(
+                mask_image,
+                [col_start, row_start, col_end, row_end],
+                minimum_area=min_area,
+            )
+            if tightened:
+                components.append(tightened)
+
+    components.sort(key=lambda item: item["area"], reverse=True)
+    return components[:max_components]
+
+
+def _extract_connected_components(mask_image, min_area: int, max_components: int):
+    width, height = mask_image.size
+    mask_data = mask_image.tobytes()
+    visited = bytearray(width * height)
+    components: List[Dict[str, Any]] = []
+
+    for y in range(height):
+        for x in range(width):
+            idx = y * width + x
+            if visited[idx] or mask_data[idx] == 0:
+                continue
+
+            queue = deque([idx])
+            visited[idx] = 1
+            min_x = max_x = x
+            min_y = max_y = y
+            area = 0
+
+            while queue:
+                current_idx = queue.popleft()
+                cx = current_idx % width
+                cy = current_idx // width
+                area += 1
+
+                if cx < min_x:
+                    min_x = cx
+                if cx > max_x:
+                    max_x = cx
+                if cy < min_y:
+                    min_y = cy
+                if cy > max_y:
+                    max_y = cy
+
+                if cx > 0:
+                    left_idx = current_idx - 1
+                    if not visited[left_idx] and mask_data[left_idx] != 0:
+                        visited[left_idx] = 1
+                        queue.append(left_idx)
+                if cx < width - 1:
+                    right_idx = current_idx + 1
+                    if not visited[right_idx] and mask_data[right_idx] != 0:
+                        visited[right_idx] = 1
+                        queue.append(right_idx)
+                if cy > 0:
+                    up_idx = current_idx - width
+                    if not visited[up_idx] and mask_data[up_idx] != 0:
+                        visited[up_idx] = 1
+                        queue.append(up_idx)
+                if cy < height - 1:
+                    down_idx = current_idx + width
+                    if not visited[down_idx] and mask_data[down_idx] != 0:
+                        visited[down_idx] = 1
+                        queue.append(down_idx)
+
+            if area < min_area:
+                continue
+
+            bbox_width = max_x - min_x + 1
+            bbox_height = max_y - min_y + 1
+            components.append(
+                {
+                    "bbox": [min_x, min_y, max_x, max_y],
+                    "area": area,
+                    "bbox_width": bbox_width,
+                    "bbox_height": bbox_height,
+                    "center_x": (min_x + max_x) / 2.0,
+                    "center_y": (min_y + max_y) / 2.0,
+                }
+            )
+
+    components.sort(key=lambda item: item["area"], reverse=True)
+    return components[:max_components]
+
+
+def _extract_aggressive_components(mask_image, min_area: int, max_components: int):
+    width, height = mask_image.size
+    image_area = max(1, width * height)
+    relaxed_min_area = max(24, int(min_area * 0.20))
+    candidate_components: List[Dict[str, Any]] = []
+
+    erosion_settings = [(3, 1), (3, 2), (5, 1), (5, 2), (7, 1)]
+    for kernel_size, iterations in erosion_settings:
+        if ImageFilter is None:
+            break
+
+        eroded_mask = mask_image
+        for _ in range(iterations):
+            eroded_mask = eroded_mask.filter(ImageFilter.MinFilter(kernel_size))
+        eroded_mask = _threshold_mask(eroded_mask, threshold=127)
+
+        connected = _extract_connected_components(eroded_mask, min_area=relaxed_min_area, max_components=max_components * 6)
+        projected = _extract_projection_components(
+            eroded_mask,
+            min_area=relaxed_min_area,
+            max_components=max_components * 6,
+            min_row_fill=0.008,
+            min_col_fill=0.012,
+        )
+
+        expand_padding = kernel_size * iterations + 3
+        for component in connected + projected:
+            expanded_bbox = _expand_bbox(component["bbox"], expand_padding, width, height)
+            tightened = _tighten_component_from_bbox(mask_image, expanded_bbox, minimum_area=max(24, int(min_area * 0.25)))
+            if tightened:
+                candidate_components.append(tightened)
+
+    direct_projection = _extract_projection_components(
+        mask_image,
+        min_area=max(24, int(min_area * 0.25)),
+        max_components=max_components * 6,
+        min_row_fill=0.008,
+        min_col_fill=0.012,
+    )
+    candidate_components.extend(direct_projection)
+
+    deduped = _dedupe_components(candidate_components, max_components=max_components * 6)
+    non_dominant = [component for component in deduped if component.get("area", 0) / float(image_area) < 0.90]
+    if len(non_dominant) >= 2:
+        deduped = non_dominant
+    deduped.sort(key=lambda item: item.get("area", 0), reverse=True)
+    return deduped[:max_components]
+
+
+def _extract_components_for_mockup(mask_image, min_area: int, max_components: int, slice_mode: str):
+    connected_components = _extract_connected_components(mask_image, min_area=min_area, max_components=max_components)
+    metrics = {"connected_component_count": len(connected_components)}
+    if slice_mode == "connected":
+        return connected_components, "connected", metrics
+
+    should_try_aggressive = slice_mode == "aggressive" or len(connected_components) <= 1
+    if should_try_aggressive:
+        aggressive_components = _extract_aggressive_components(mask_image, min_area=min_area, max_components=max_components)
+        metrics["aggressive_component_count"] = len(aggressive_components)
+        if aggressive_components and (slice_mode == "aggressive" or len(aggressive_components) > len(connected_components)):
+            return aggressive_components, "aggressive", metrics
+
+    return connected_components, "connected", metrics
+
+
+def _classify_component(component: Dict[str, Any], index: int, image_width: int, image_height: int, button_index: int):
+    width_ratio = component["bbox_width"] / float(max(1, image_width))
+    height_ratio = component["bbox_height"] / float(max(1, image_height))
+    area_ratio = component["area"] / float(max(1, image_width * image_height))
+    center_x_ratio = component["center_x"] / float(max(1, image_width))
+    center_y_ratio = component["center_y"] / float(max(1, image_height))
+
+    kind = f"slice_{index + 1:02d}"
+    label = kind
+    if index == 0 and area_ratio > 0.20:
+        kind = "panel_main"
+        label = kind
+    elif width_ratio > 0.16 and 0.03 < height_ratio < 0.26 and center_y_ratio > 0.50 and area_ratio < 0.18:
+        kind = "button_primary" if button_index == 0 else "button_secondary"
+        label = kind
+    elif center_x_ratio < 0.35 and center_y_ratio > 0.35:
+        kind = "icon_left"
+        label = kind
+    elif center_x_ratio > 0.65 and center_y_ratio > 0.35:
+        kind = "icon_right"
+        label = kind
+    elif width_ratio > 0.30 and height_ratio < 0.20 and center_y_ratio < 0.35:
+        kind = "header"
+        label = kind
+
+    return kind, label
+
+
+def _assign_component_alpha(source_crop, mask_crop):
+    if source_crop.mode != "RGBA":
+        source_crop = source_crop.convert("RGBA")
+    _, _, _, source_alpha = source_crop.split()
+    composed_alpha = ImageChops.multiply(source_alpha, mask_crop)
+    source_crop.putalpha(composed_alpha)
+    return source_crop
+
+
+def _apply_corner_chroma_key(rgba_image, tolerance: int = 24):
+    if rgba_image.mode != "RGBA":
+        rgba_image = rgba_image.convert("RGBA")
+
+    width, height = rgba_image.size
+    if width < 4 or height < 4:
+        return rgba_image
+
+    corner_samples = []
+    sample_points = [
+        (0, 0), (1, 1), (width - 1, 0), (width - 2, 1),
+        (0, height - 1), (1, height - 2), (width - 1, height - 1), (width - 2, height - 2),
+    ]
+    for x, y in sample_points:
+        r, g, b, a = rgba_image.getpixel((max(0, min(width - 1, x)), max(0, min(height - 1, y))))
+        if a > 10:
+            corner_samples.append((r, g, b))
+
+    if len(corner_samples) < 4:
+        return rgba_image
+
+    avg_r = sum(color[0] for color in corner_samples) / float(len(corner_samples))
+    avg_g = sum(color[1] for color in corner_samples) / float(len(corner_samples))
+    avg_b = sum(color[2] for color in corner_samples) / float(len(corner_samples))
+    brightness = (avg_r + avg_g + avg_b) / 3.0
+    color_spread = max(
+        max(abs(color[0] - avg_r), abs(color[1] - avg_g), abs(color[2] - avg_b))
+        for color in corner_samples
+    )
+
+    # Only key very-flat bright corners to avoid damaging intended artwork.
+    if brightness < 165.0 or color_spread > max(12.0, float(tolerance)):
+        return rgba_image
+
+    keyed = rgba_image.copy()
+    pixels = keyed.load()
+    for y in range(height):
+        for x in range(width):
+            r, g, b, a = pixels[x, y]
+            if a <= 0:
+                continue
+            if (
+                abs(r - avg_r) <= tolerance and
+                abs(g - avg_g) <= tolerance and
+                abs(b - avg_b) <= tolerance
+            ):
+                pixels[x, y] = (r, g, b, 0)
+
+    return keyed
+
+
+def auto_slice_ui_mockup_host(
+    source_image_path: str,
+    destination_folder: str = "/Game/UI/AutoSlices",
+    base_name: str = "UI_Mockup",
+    max_slices: int = 16,
+    min_component_area_ratio: float = 0.0025,
+    alpha_threshold: int = 8,
+    background_tolerance: int = 28,
+    include_full_image: bool = True,
+    margin_px: int = 3,
+    slice_mode: str = "auto",
+    enable_chroma_key: bool = True,
+    chroma_tolerance: int = 24,
+) -> Dict[str, Any]:
+    if not _HAS_PILLOW:
+        return {"success": False, "error": f"Pillow is not available in MCP host runtime: {_PILLOW_ERROR}"}
+
+    if not source_image_path:
+        return {"success": False, "error": "Missing required argument: source_image_path"}
+    if not os.path.isfile(source_image_path):
+        return {"success": False, "error": f"source_image_path does not exist: {source_image_path}"}
+    if max_slices < 1:
+        return {"success": False, "error": "max_slices must be >= 1"}
+    if min_component_area_ratio <= 0 or min_component_area_ratio >= 1:
+        return {"success": False, "error": "min_component_area_ratio must be between 0 and 1"}
+    if slice_mode not in {"auto", "connected", "aggressive"}:
+        return {"success": False, "error": "slice_mode must be one of: auto, connected, aggressive"}
+    if chroma_tolerance < 0:
+        return {"success": False, "error": "chroma_tolerance must be >= 0"}
+
+    temp_dir = tempfile.mkdtemp(prefix="createlex_ui_host_slices_")
+    cleanup_on_fail = True
+    try:
+        with Image.open(source_image_path) as source_image:
+            rgba_image = source_image.convert("RGBA")
+            image_width, image_height = rgba_image.size
+            min_area = max(64, int(image_width * image_height * min_component_area_ratio))
+
+            foreground_mask, mask_mode = _build_foreground_mask(
+                rgba_image, alpha_threshold=alpha_threshold, background_tolerance=background_tolerance
+            )
+            components, segmentation_mode, segmentation_metrics = _extract_components_for_mockup(
+                foreground_mask,
+                min_area=min_area,
+                max_components=max_slices,
+                slice_mode=slice_mode,
+            )
+
+            if not components:
+                segmentation_mode = "fallback_full_image"
+                segmentation_metrics = {"connected_component_count": 0}
+                components = [
+                    {
+                        "bbox": [0, 0, image_width - 1, image_height - 1],
+                        "area": image_width * image_height,
+                        "bbox_width": image_width,
+                        "bbox_height": image_height,
+                        "center_x": image_width / 2.0,
+                        "center_y": image_height / 2.0,
+                    }
+                ]
+
+            sanitized_base = _sanitize_asset_name(base_name or os.path.splitext(os.path.basename(source_image_path))[0])
+            slice_records: List[Dict[str, Any]] = []
+
+            if include_full_image:
+                full_name = _sanitize_asset_name(f"{sanitized_base}_full_mockup")
+                full_path = os.path.join(temp_dir, f"{full_name}.png")
+                rgba_image.save(full_path, "PNG")
+                slice_records.append(
+                    {
+                        "name": full_name,
+                        "label": "full_mockup",
+                        "kind": "full_mockup",
+                        "asset_path": "",
+                        "file_path": full_path,
+                        "bbox": [0, 0, image_width - 1, image_height - 1],
+                        "area": image_width * image_height,
+                        "width": image_width,
+                        "height": image_height,
+                        "is_fallback": True,
+                    }
+                )
+
+            button_index = 0
+            for idx, component in enumerate(components):
+                min_x, min_y, max_x, max_y = component["bbox"]
+                min_x = max(0, min_x - margin_px)
+                min_y = max(0, min_y - margin_px)
+                max_x = min(image_width - 1, max_x + margin_px)
+                max_y = min(image_height - 1, max_y + margin_px)
+                crop_box = (min_x, min_y, max_x + 1, max_y + 1)
+
+                kind, label = _classify_component(component, idx, image_width, image_height, button_index)
+                if "button_" in kind:
+                    button_index += 1
+
+                slice_name = _sanitize_asset_name(f"{sanitized_base}_{label}")
+                slice_file = os.path.join(temp_dir, f"{slice_name}.png")
+
+                source_crop = rgba_image.crop(crop_box)
+                mask_crop = foreground_mask.crop(crop_box)
+                final_crop = _assign_component_alpha(source_crop, mask_crop)
+                if enable_chroma_key:
+                    final_crop = _apply_corner_chroma_key(final_crop, tolerance=chroma_tolerance)
+                final_bbox = final_crop.getbbox()
+                if final_bbox:
+                    final_crop = final_crop.crop(final_bbox)
+                if final_crop.size[0] < 2 or final_crop.size[1] < 2:
+                    continue
+
+                final_crop.save(slice_file, "PNG")
+                slice_records.append(
+                    {
+                        "name": slice_name,
+                        "label": label,
+                        "kind": kind,
+                        "asset_path": "",
+                        "file_path": slice_file,
+                        "bbox": [min_x, min_y, max_x, max_y],
+                        "area": component["area"],
+                        "width": final_crop.size[0],
+                        "height": final_crop.size[1],
+                        "is_fallback": False,
+                    }
+                )
+
+        if not slice_records:
+            return {"success": False, "error": "Host auto-slicing produced no slice images."}
+
+        manifest = {
+            "source_image_path": source_image_path,
+            "source_width": image_width,
+            "source_height": image_height,
+            "destination_folder": destination_folder,
+            "base_name": sanitized_base,
+            "generated_at": time.time(),
+            "mask_mode": mask_mode,
+            "slice_mode": slice_mode,
+            "segmentation_mode": segmentation_mode,
+            "segmentation_metrics": segmentation_metrics,
+            "enable_chroma_key": bool(enable_chroma_key),
+            "chroma_tolerance": int(chroma_tolerance),
+            "slices": slice_records,
+            "background_asset_path": "",
+            "host_side_slicing": True,
+        }
+
+        cleanup_on_fail = False
+        return {
+            "success": True,
+            "message": f"Generated {len(slice_records)} host-side slice files.",
+            "slice_count": len(slice_records),
+            "segmentation_mode": segmentation_mode,
+            "segmentation_metrics": segmentation_metrics,
+            "manifest": manifest,
+            "temp_dir": temp_dir,
+        }
+    except Exception as error:
+        return {"success": False, "error": f"Host auto-slice failure: {error}"}
+    finally:
+        if cleanup_on_fail and os.path.isdir(temp_dir):
+            shutil.rmtree(temp_dir, ignore_errors=True)
+