Upload 3 files

config.py

@@ -24,18 +24,18 @@ TRIGGER_WORD = "p1x3l4rt, pixel art"
 
 # Face detection configuration
 FACE_DETECTION_CONFIG = {
-    "model_name": "antelopev2",
+    "model_name": "buffalo_l",
     "det_size": (640, 640),
     "ctx_id": 0
 }
 
-# Recommended resolutions
+# Recommended resolutions (multiples of 64 for stable diffusion)
 RECOMMENDED_SIZES = [
-    (896, 1152),   # Portrait
-    (1152, 896),   # Landscape
-    (832, 1216),   # Tall portrait
-    (1216, 832),   # Wide landscape
-    (1024, 1024)   # Square
+    (896, 1152),   # Portrait (14:18 ratio)
+    (1152, 896),   # Landscape (18:14 ratio)
+    (832, 1216),   # Tall portrait (13:19 ratio)
+    (1216, 832),   # Wide landscape (19:13 ratio)
+    (1024, 1024)   # Square (1:1 ratio)
 ]
 
 # Default generation parameters

generator.py

@@ -161,11 +161,22 @@ class RetroArtConverter:
                 # Get original dimensions
                 orig_width, orig_height = image.size
                 
+                # Ensure dimensions are multiples of 64 for better processing
+                detect_width = int((orig_width // 64) * 64) or 64
+                detect_height = int((orig_height // 64) * 64) or 64
+                
+                # Resize if needed
+                if detect_width != orig_width or detect_height != orig_height:
+                    detect_image = image.resize((detect_width, detect_height), Image.LANCZOS)
+                    print(f"[DEPTH] Resized for detection: {orig_width}x{orig_height} -> {detect_width}x{detect_height}")
+                else:
+                    detect_image = image
+                
                 # Generate depth map with Leres (better quality than Zoe)
                 with torch.no_grad():
-                    depth_image = self.leres_depth(image)
+                    depth_image = self.leres_depth(detect_image)
                 
-                # Ensure output matches original size
+                # Resize back to original dimensions
                 if depth_image.size != (orig_width, orig_height):
                     depth_image = depth_image.resize((orig_width, orig_height), Image.LANCZOS)
                 

utils.py

@@ -395,10 +395,10 @@ def get_demographic_description(age, gender_code):
 
 def calculate_optimal_size(original_width, original_height, recommended_sizes=None, max_dimension=1536):
     """
-    Calculate optimal size maintaining aspect ratio with dimensions as multiples of 8.
+    Calculate optimal size maintaining aspect ratio with dimensions as multiples of 64.
     
     This updated version supports ANY aspect ratio (not just predefined ones),
-    while ensuring dimensions are multiples of 8 and keeping total pixels reasonable.
+    while ensuring dimensions are multiples of 64 and keeping total pixels reasonable.
     
     Args:
         original_width: Original image width
@@ -407,7 +407,7 @@ def calculate_optimal_size(original_width, original_height, recommended_sizes=No
         max_dimension: Maximum allowed dimension (default 1536)
     
     Returns:
-        Tuple of (optimal_width, optimal_height) as multiples of 8
+        Tuple of (optimal_width, optimal_height) as multiples of 64
     """
     aspect_ratio = original_width / original_height
     
@@ -423,15 +423,15 @@ def calculate_optimal_size(original_width, original_height, recommended_sizes=No
                 best_diff = diff
                 best_match = (width, height)
         
-        # Ensure dimensions are multiples of 8
+        # Ensure dimensions are multiples of 64
         width, height = best_match
-        width = int((width // 8) * 8)
-        height = int((height // 8) * 8)
+        width = int((width // 64) * 64)
+        height = int((height // 64) * 64)
         
         return width, height
     
     # NEW: Support any aspect ratio
-    # Strategy: Keep aspect ratio, scale to reasonable total pixels, round to multiples of 8
+    # Strategy: Keep aspect ratio, scale to reasonable total pixels, round to multiples of 64
     
     # Target total pixels (around 1 megapixel for SDXL, adjustable)
     target_pixels = 1024 * 1024  # ~1MP, good balance for SDXL
@@ -455,23 +455,23 @@ def calculate_optimal_size(original_width, original_height, recommended_sizes=No
         optimal_height = max_dimension
         optimal_width = optimal_height * aspect_ratio
     
-    # Round to nearest multiple of 8
-    width = int(round(optimal_width / 8) * 8)
-    height = int(round(optimal_height / 8) * 8)
+    # Round to nearest multiple of 64
+    width = int(round(optimal_width / 64) * 64)
+    height = int(round(optimal_height / 64) * 64)
     
     # Ensure minimum size (at least 512 on shortest side)
     min_dimension = 512
     if min(width, height) < min_dimension:
         if width < height:
             width = min_dimension
-            height = int(round((width / aspect_ratio) / 8) * 8)
+            height = int(round((width / aspect_ratio) / 64) * 64)
         else:
             height = min_dimension
-            width = int(round((height * aspect_ratio) / 8) * 8)
+            width = int(round((height * aspect_ratio) / 64) * 64)
     
-    # Final safety check: ensure multiples of 8
-    width = max(8, int((width // 8) * 8))
-    height = max(8, int((height // 8) * 8))
+    # Final safety check: ensure multiples of 64
+    width = max(64, int((width // 64) * 64))
+    height = max(64, int((height // 64) * 64))
     
     print(f"[SIZING] Aspect ratio: {aspect_ratio:.3f}, Output: {width}x{height} ({width*height/1e6:.2f}MP)")