Update app.py

app.py

@@ -7,85 +7,70 @@ import torchvision.transforms as transforms
 from skimage.filters import sobel
 from skimage.restoration import denoise_tv_chambolle
 from scipy.interpolate import Rbf
-from scipy.ndimage import map_coordinates
 
 
-# Function to estimate a normal map from the cloth texture
+# Function to estimate a normal map from cloth texture
 def estimate_normal_map(image):
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     sobel_x = sobel(gray)
     sobel_y = sobel(gray)
+    
     normal_map = np.stack([sobel_x, sobel_y, np.ones_like(sobel_x)], axis=-1)
-    normal_map = normal_map / np.linalg.norm(normal_map, axis=-1, keepdims=True)
+    normal_map /= np.linalg.norm(normal_map, axis=-1, keepdims=True)
+
     return (normal_map * 255).astype(np.uint8)
 
 
 # Function to apply Thin Plate Spline (TPS) warping
-def apply_tps_warping(text_image, normal_map):
-    h, w = text_image.shape[:2]
+def apply_tps_warping(design, normal_map):
+    h, w = design.shape[:2]
     x, y = np.meshgrid(np.arange(w), np.arange(h))
     
-    # Generate control points from the normal map
+    # Generate warp offsets from normal map
     control_x = x + (normal_map[:, :, 0] - 128) * 0.5
     control_y = y + (normal_map[:, :, 1] - 128) * 0.5
 
-    # Interpolate using Radial Basis Function (RBF)
+    # Apply Radial Basis Function (RBF) interpolation
     rbf_x = Rbf(x.flatten(), y.flatten(), control_x.flatten(), function='thin_plate')
     rbf_y = Rbf(x.flatten(), y.flatten(), control_y.flatten(), function='thin_plate')
 
     warped_x = rbf_x(x, y).astype(np.float32)
     warped_y = rbf_y(x, y).astype(np.float32)
 
-    # Apply warping
-    warped_text = cv2.remap(text_image, warped_x, warped_y, interpolation=cv2.INTER_LINEAR)
-    
-    return warped_text
+    # Warp the design
+    warped_design = cv2.remap(design, warped_x, warped_y, interpolation=cv2.INTER_LINEAR)
 
+    return warped_design
 
-# Function to blend text onto cloth using Poisson editing
-def blend_text_cloth(cloth, text, x=50, y=50):
+
+# Function to blend design onto the cloth using Poisson Editing
+def blend_design_cloth(cloth, design, x=50, y=50):
     cloth_bgr = np.array(cloth)
-    text_bgr = np.array(text)
+    design_bgr = np.array(design)
 
     normal_map = estimate_normal_map(cloth_bgr)
 
-    # Resize text to fit on cloth
-    text_resized = cv2.resize(text_bgr, (cloth_bgr.shape[1] // 2, cloth_bgr.shape[0] // 5))
+    # Resize design to fit the center of the cloth
+    design_resized = cv2.resize(design_bgr, (cloth_bgr.shape[1] // 2, cloth_bgr.shape[0] // 5))
     
     # Convert to grayscale and create a mask
-    text_gray = cv2.cvtColor(text_resized, cv2.COLOR_BGR2GRAY)
-    _, mask = cv2.threshold(text_gray, 1, 255, cv2.THRESH_BINARY)
+    design_gray = cv2.cvtColor(design_resized, cv2.COLOR_BGR2GRAY)
+    _, mask = cv2.threshold(design_gray, 1, 255, cv2.THRESH_BINARY)
 
-    # Warp text using normal map
-    warped_text = apply_tps_warping(text_resized, normal_map)
+    # Warp design using normal map
+    warped_design = apply_tps_warping(design_resized, normal_map)
 
-    # Blend the text using Poisson editing
-    center = (x + text_resized.shape[1] // 2, y + text_resized.shape[0] // 2)
-    blended = cv2.seamlessClone(warped_text, cloth_bgr, mask, center, cv2.MIXED_CLONE)
+    # Blend using Poisson seamless cloning
+    center = (x + design_resized.shape[1] // 2, y + design_resized.shape[0] // 2)
+    blended = cv2.seamlessClone(warped_design, cloth_bgr, mask, center, cv2.MIXED_CLONE)
 
     return Image.fromarray(blended)
 
 
 # Gradio function
-def process_image(cloth_image, text, font_size=32, font_color=(255, 0, 0), x=50, y=50):
-    # Convert font color input
-    font_color = tuple(map(int, font_color.strip("()").split(",")))
-
-    # Create a blank image with text
-    text_img = Image.new('RGB', (400, 200), (0, 0, 0, 0))
-    draw = ImageDraw.Draw(text_img)
-
-    try:
-        font = ImageFont.truetype("arial.ttf", font_size)
-    except:
-        font = ImageFont.load_default()
-
-    draw.text((50, 50), text, font=font, fill=font_color)
-    text_img = np.array(text_img)
-
-    # Blend text onto cloth
-    result = blend_text_cloth(cloth_image, text_img, x, y)
-
+def process_image(cloth_image, design_image, x=50, y=50):
+    # Blend design onto cloth
+    result = blend_design_cloth(cloth_image, design_image, x, y)
     return result
 
 
@@ -94,15 +79,13 @@ interface = gr.Interface(
     fn=process_image,
     inputs=[
         gr.Image(type="pil", label="Upload Cloth Image"),
-        gr.Textbox(label="Text to Blend", value="Sample Text"),
-        gr.Slider(10, 100, step=2, label="Font Size", value=32),
-        gr.Textbox(label="Font Color (RGB)", value="(255, 0, 0)"),
+        gr.Image(type="pil", label="Upload Design"),
         gr.Slider(0, 1000, step=10, label="X Coordinate", value=50),
         gr.Slider(0, 1000, step=10, label="Y Coordinate", value=50),
     ],
     outputs=gr.Image(type="pil", label="Blended Output"),
-    title="Advanced Text-Cloth Blending",
-    description="Upload a cloth image and blend text naturally using advanced warping & blending techniques.",
+    title="Advanced Cloth Design Blending",
+    description="Upload a cloth image and a design to blend them naturally using advanced warping & Poisson blending.",
 )
 
 # Launch the app