Reject miniature duplicate sprites

app.py

@@ -1756,7 +1756,7 @@ def primary_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[byt
         is_background = is_background_spec(spec)
         attempts = 1 if is_background else PRIMARY_SPRITE_ATTEMPTS
         width, height = (1344, 768) if is_background else (768, 1024)
-        last_component_count = 0
+        last_failure_detail = "the last output did not contain one valid foreground subject"
         for attempt in range(attempts):
             seed = abs(hash(f"primary|{spec.role}|{spec.prompt}|{index}|{run_id}|{attempt}")) % 2147483647
             generator = torch.Generator(device="cuda").manual_seed(seed)
@@ -1774,15 +1774,19 @@ def primary_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[byt
             if is_background:
                 return content, None
 
-            last_component_count = estimated_foreground_subject_count(content)
-            if last_component_count == 1:
-                return content, None
-
-        if last_component_count > 1:
-            detail = f"the last output contained {last_component_count} significant foreground subjects"
-        else:
-            detail = "the last output did not contain one significant foreground subject"
-        return None, f"single-subject validation failed after {attempts} model attempts; {detail}"
+            subject_count = estimated_foreground_subject_count(content)
+            if subject_count != 1:
+                if subject_count > 1:
+                    last_failure_detail = f"the last output contained {subject_count} significant foreground subjects"
+                else:
+                    last_failure_detail = "the last output did not contain one significant foreground subject"
+                continue
+            if has_implausibly_thin_foreground_subject(content, spec):
+                last_failure_detail = "the last output contained an implausibly thin foreground silhouette"
+                continue
+            return content, None
+
+        return None, f"sprite validation failed after {attempts} model attempts; {last_failure_detail}"
     except Exception as exc:
         return None, short_error(exc)
 
@@ -1886,13 +1890,13 @@ def polish_diffusion_asset(image: Image.Image, spec: AssetSpec) -> bytes:
     return out.getvalue()
 
 
-def significant_foreground_component_areas(content: bytes) -> list[int]:
-    """Return material alpha components, ignoring small detached details and cleanup noise."""
+def foreground_component_geometry(content: bytes) -> list[tuple[int, tuple[int, int, int, int]]]:
+    """Return alpha-component areas and bounding boxes, largest first."""
     image = Image.open(io.BytesIO(content)).convert("RGBA")
     width, height = image.size
     alpha = image.getchannel("A").tobytes()
     foreground = bytearray(1 if value >= 64 else 0 for value in alpha)
-    areas: list[int] = []
+    components: list[tuple[int, tuple[int, int, int, int]]] = []
 
     for start in range(width * height):
         if not foreground[start]:
@@ -1900,11 +1904,17 @@ def significant_foreground_component_areas(content: bytes) -> list[int]:
         foreground[start] = 0
         stack = [start]
         area = 0
+        min_x = max_x = start % width
+        min_y = max_y = start // width
         while stack:
             current = stack.pop()
             area += 1
             x = current % width
             y = current // width
+            min_x = min(min_x, x)
+            max_x = max(max_x, x)
+            min_y = min(min_y, y)
+            max_y = max(max_y, y)
             for dy in (-1, 0, 1):
                 ny = y + dy
                 if ny < 0 or ny >= height:
@@ -1919,13 +1929,25 @@ def significant_foreground_component_areas(content: bytes) -> list[int]:
                     if foreground[neighbor]:
                         foreground[neighbor] = 0
                         stack.append(neighbor)
-        areas.append(area)
+        components.append((area, (min_x, min_y, max_x, max_y)))
+
+    return sorted(components, reverse=True)
+
+
+def significant_foreground_component_areas(content: bytes) -> list[int]:
+    """Return material alpha components, ignoring only genuinely small detached details."""
+    image = Image.open(io.BytesIO(content)).convert("RGBA")
+    width, height = image.size
+    components = foreground_component_geometry(content)
 
-    if not areas:
+    if not components:
         return []
-    largest = max(areas)
-    minimum = max(64, int(largest * 0.22), int(width * height * 0.005))
-    return sorted((area for area in areas if area >= minimum), reverse=True)
+    largest = components[0][0]
+    # A generated miniature duplicate can be much smaller than the primary view.
+    # Keep a small absolute/noise floor, but do not discard material components
+    # such as the reported 96px duplicate next to a 487px main silhouette.
+    minimum = max(64, int(largest * 0.12), int(width * height * 0.004))
+    return [area for area, _ in components if area >= minimum]
 
 
 def has_deep_vertical_foreground_valley(content: bytes) -> bool:
@@ -1978,6 +2000,24 @@ def estimated_foreground_subject_count(content: bytes) -> int:
     return 2 if has_deep_vertical_foreground_valley(content) else 1
 
 
+def has_implausibly_thin_foreground_subject(content: bytes, spec: AssetSpec) -> bool:
+    """Reject collapsed humanoid silhouettes without penalizing projectiles or narrow props."""
+    if sprite_archetype(spec) not in ("humanoid", "enemy"):
+        return False
+    components = foreground_component_geometry(content)
+    if not components:
+        return False
+    image = Image.open(io.BytesIO(content)).convert("RGBA")
+    _, (x0, y0, x1, y1) = components[0]
+    bbox_width = x1 - x0 + 1
+    bbox_height = y1 - y0 + 1
+    return (
+        bbox_width < max(14, int(image.width * 0.12))
+        and bbox_height >= int(image.height * 0.28)
+        and bbox_height >= bbox_width * 3.5
+    )
+
+
 def free_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[bytes | None, str | None]:
     global FREE_DIFFUSION_PIPE, FREE_DIFFUSION_ERROR
     if FREE_DIFFUSION_ERROR:
@@ -2228,6 +2268,8 @@ def validate_asset_png(content: bytes, spec: AssetSpec) -> list[str]:
             warnings.append("sprite has no significant foreground subject")
         elif subject_count > 1:
             warnings.append(f"sprite contains {subject_count} significant foreground subjects")
+        elif has_implausibly_thin_foreground_subject(content, spec):
+            warnings.append("sprite foreground silhouette is implausibly thin")
     return warnings