Upload 6 files

README.md

@@ -23,6 +23,11 @@ This folder contains the AR overlay modules and dependency pins to apply on top
 
 ## How to apply
 
+Important: This package is a merge patch, not a full Space repository.
+Do not replace the whole duplicated Space with only these files.
+Keep the original `app.py` from the duplicated IDM-VTON Space (or provide your own `app.py` that calls `launch()`).
+If `app.py` is missing or exits immediately, Space can fail with messages like "signal is aborted without reason" or exit code 0.
+
 1. Duplicate yisol/IDM-VTON into your own Space.
 2. Copy pipeline/\*.py into the Space pipeline folder.
 3. Merge AR endpoint function into app.py and expose api_name as ar_overlay.

cloth_warper.py

@@ -0,0 +1,45 @@
+from PIL import Image
+import numpy as np
+
+
+def remove_white_background(img_pil: Image.Image, threshold: int = 240) -> Image.Image:
+  rgba = img_pil.convert("RGBA")
+  data = np.array(rgba)
+  r, g, b, a = data[:, :, 0], data[:, :, 1], data[:, :, 2], data[:, :, 3]
+
+  white_mask = (r > threshold) & (g > threshold) & (b > threshold)
+  data[:, :, 3] = np.where(white_mask, 0, a)
+  return Image.fromarray(data)
+
+
+def warp_cloth_to_torso(
+  cloth_pil: Image.Image,
+  torso_box: tuple,
+  image_size: tuple,
+  alpha: float = 0.78,
+) -> Image.Image:
+  width, height = image_size
+  x1, y1, x2, y2 = torso_box
+
+  region_w = x2 - x1
+  region_h = y2 - y1
+
+  if region_w <= 0 or region_h <= 0:
+    return Image.new("RGBA", (width, height), (0, 0, 0, 0))
+
+  cloth_rgba = remove_white_background(cloth_pil)
+  cloth_resized = cloth_rgba.resize((region_w, region_h), Image.LANCZOS)
+
+  r, g, b, a = cloth_resized.split()
+  a = a.point(lambda px: int(px * alpha))
+  cloth_resized = Image.merge("RGBA", (r, g, b, a))
+
+  canvas = Image.new("RGBA", (width, height), (0, 0, 0, 0))
+  canvas.paste(cloth_resized, (x1, y1), cloth_resized)
+  return canvas
+
+
+def blend_on_person(person_pil: Image.Image, cloth_canvas: Image.Image) -> Image.Image:
+  person_rgba = person_pil.convert("RGBA")
+  result = Image.alpha_composite(person_rgba, cloth_canvas)
+  return result.convert("RGB")

pose_estimator.py

@@ -0,0 +1,81 @@
+# MediaPipe Pose for AR overlay tab
+
+from PIL import Image
+import mediapipe as mp
+import numpy as np
+
+mp_pose = mp.solutions.pose
+mp_drawing = mp.solutions.drawing_utils
+
+LANDMARK = mp_pose.PoseLandmark
+TORSO_INDICES = [
+  LANDMARK.LEFT_SHOULDER.value,
+  LANDMARK.RIGHT_SHOULDER.value,
+  LANDMARK.LEFT_HIP.value,
+  LANDMARK.RIGHT_HIP.value,
+]
+
+
+def extract_pose_mediapipe(image_pil: Image.Image):
+  img_rgb = np.array(image_pil.convert("RGB"))
+  height, width = img_rgb.shape[:2]
+
+  with mp_pose.Pose(
+    static_image_mode=True,
+    model_complexity=1,
+    enable_segmentation=False,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5,
+  ) as pose:
+    results = pose.process(img_rgb)
+
+  if not results.pose_landmarks:
+    return None
+
+  landmarks_raw = results.pose_landmarks.landmark
+
+  landmarks = {}
+  for idx, name in enumerate(LANDMARK):
+    px = int(landmarks_raw[idx].x * width)
+    py = int(landmarks_raw[idx].y * height)
+    landmarks[name.name] = (px, py)
+
+  skeleton_canvas = np.zeros_like(img_rgb)
+  mp_drawing.draw_landmarks(
+    skeleton_canvas,
+    results.pose_landmarks,
+    mp_pose.POSE_CONNECTIONS,
+    landmark_drawing_spec=mp_drawing.DrawingSpec(
+      color=(0, 255, 200), thickness=2, circle_radius=4
+    ),
+    connection_drawing_spec=mp_drawing.DrawingSpec(color=(100, 180, 255), thickness=2),
+  )
+
+  torso_x = [landmarks_raw[idx].x * width for idx in TORSO_INDICES]
+  torso_y = [landmarks_raw[idx].y * height for idx in TORSO_INDICES]
+
+  pad_x = int((max(torso_x) - min(torso_x)) * 0.12)
+  pad_y_top = int((max(torso_y) - min(torso_y)) * 0.08)
+  pad_y_bottom = int((max(torso_y) - min(torso_y)) * 0.05)
+
+  x1 = max(0, int(min(torso_x)) - pad_x)
+  y1 = max(0, int(min(torso_y)) - pad_y_top)
+  x2 = min(width, int(max(torso_x)) + pad_x)
+  y2 = min(height, int(max(torso_y)) + pad_y_bottom)
+
+  return {
+    "landmarks": landmarks,
+    "skeleton_pil": Image.fromarray(skeleton_canvas),
+    "torso_box": (x1, y1, x2, y2),
+    "image_size": (width, height),
+  }
+
+
+def draw_skeleton_overlay(image_pil: Image.Image, pose_data: dict, alpha: float = 0.6):
+  base = np.array(image_pil.convert("RGB")).astype(float)
+  skeleton = np.array(pose_data["skeleton_pil"].convert("RGB")).astype(float)
+
+  skeleton_mask = (skeleton.sum(axis=2) > 0).astype(float)[:, :, np.newaxis]
+  blended = base * (1 - skeleton_mask * alpha) + skeleton * skeleton_mask * alpha
+
+  return Image.fromarray(blended.astype(np.uint8))