refactor: use official pixelfixer.api.process to match retrodiffusion behavior exactly

app.py

@@ -18,67 +18,76 @@ def process_image(input_image_path, color_limit, export_scale):
     if input_image_path is None:
         return None, None, "Please upload an image."
         
-    # Parse color limit
+    # Parse settings
     k_colors = 0
     if color_limit != "Unlimited":
         k_colors = int(color_limit)
         
-    # Parse scale multiplier
     scale_mult = int(export_scale.replace("x", ""))
         
-    # Get original filename
     original_name = os.path.basename(input_image_path)
     base, _ = os.path.splitext(original_name)
-    
-    # We want to avoid generic names like 'image' if possible
     if base.startswith("image") and len(base) > 5:
         base = "image"
         
-    input_image = Image.open(input_image_path)
-    rgba = np.array(input_image.convert("RGBA"))
+    # Use the official API to match the web app's exact behavior
+    from pixelfixer.api import process
     
-    t0 = time.time()
+    # Read the image file as bytes
+    with open(input_image_path, "rb") as f:
+        img_bytes = f.read()
+        
     try:
-        r = detect(rgba)
+        # Call the exact same pipeline used by the official server
+        result = process(
+            img_bytes, 
+            mode="full", 
+            two_stage=True, 
+            k_colors=k_colors, 
+            return_png=False
+        )
     except Exception as e:
-        return None, None, f"Error detecting pixel grid: {str(e)}"
+        return None, f"Error processing image: {str(e)}", None
         
-    dt = round(time.time() - t0, 2)
-    
-    # Create a unique temp directory for this generation
+    # Create a unique temp directory
     tmp_dir = tempfile.mkdtemp()
     
-    # Generate and save overlay
-    overlay_img = Image.fromarray(_overlay(rgba, r))
-    overlay_path = os.path.join(tmp_dir, f"{base}-overlay.png")
-    overlay_img.save(overlay_path, format="PNG")
+    # The result contains the pure pixel art array (1x scale)
+    low_res_array = result["array"]
     
-    # Generate and save extraction with accurate colors
-    from pixelfixer.reconstruct import two_stage_pack
-    low = two_stage_pack(rgba, int(r["cols"]), int(r["rows"]), k_colors=k_colors)
-    
-    # Strictly enforce color palette if limit is set
+    # If the user requested a strict color limit, we still need to enforce it via k-means
     if k_colors > 0:
         from pixelfixer.quantize import kmeans_quantize
-        low, _, _ = kmeans_quantize(low, k=k_colors)
+        low_res_array, _, _ = kmeans_quantize(low_res_array, k=k_colors)
         
-    extract_img = Image.fromarray(low)
+    extract_img = Image.fromarray(low_res_array)
     
     # Upscale using perfect multiples to maintain aspect ratio and crispness
-    target_w = int(r["cols"]) * scale_mult
-    target_h = int(r["rows"]) * scale_mult
+    target_w = result["cols"] * scale_mult
+    target_h = result["rows"] * scale_mult
     extract_img = extract_img.resize((target_w, target_h), Image.NEAREST)
     
     extract_path = os.path.join(tmp_dir, f"{base}-pixelated.png")
     extract_img.save(extract_path, format="PNG")
     
-    # Create info string
-    info = f"Grid detected: {r['cols']}x{r['rows']}\n"
+    # Optional: We can still generate the overlay using the underlying image and result data
+    try:
+        input_img = Image.open(input_image_path).convert("RGBA")
+        rgba = np.array(input_img)
+        overlay_img = Image.fromarray(_overlay(rgba, result))
+        overlay_path = os.path.join(tmp_dir, f"{base}-overlay.png")
+        overlay_img.save(overlay_path, format="PNG")
+    except Exception:
+        overlay_path = None
+    
+    # Create info string exactly as reported by the official engine
+    info = f"Grid detected: {result['cols']}x{result['rows']}\n"
     info += f"Output size: {target_w}x{target_h} ({export_scale} scale)\n"
-    info += f"Step size: {r['step_x']}x{r['step_y']}\n"
+    info += f"Step size: {result['step_x']}x{result['step_y']}\n"
+    info += f"Confidence: {result['confidence'].upper()} ({result['consensus']})\n"
     if k_colors > 0:
         info += f"Colors: {k_colors}\n"
-    info += f"Processing time: {dt}s"
+    info += f"Detect: {result['detect_s']}s | Recon: {result['recon_s']}s"
     
     return extract_path, info, overlay_path