Simplify background removal: remove multiprocessing entirely

- Alpha matting works perfectly without multiprocessing
- OpenMP conflicts are already handled by environment variables
- Eliminates daemon process compatibility issues completely
- Much simpler, cleaner, and more reliable code
- Direct alpha matting with proper fallback to standard removal

hy3dshape/hy3dshape/rembg.py

@@ -14,23 +14,16 @@
 
 import os
 import io
-import multiprocessing
 import traceback
 import numpy as np
 
-# Set OpenMP environment variables to prevent fork() errors
+# Set OpenMP environment variables to prevent threading conflicts
+# This allows rembg to run safely in the main thread without multiprocessing
 os.environ["OMP_NUM_THREADS"] = "1"  # Limit OpenMP to single thread
 os.environ["PYTHONFAULTHANDLER"] = "1"  # Better error reporting
 os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"  # Avoid Intel MKL errors
 os.environ["OMP_THREAD_LIMIT"] = "1"  # Limit total number of OpenMP threads
 
-# Fix daemon process multiprocessing by using spawn instead of fork
-try:
-    multiprocessing.set_start_method('spawn', force=True)
-    print("Set multiprocessing start method to 'spawn' for daemon compatibility")
-except RuntimeError as e:
-    print(f"Could not set multiprocessing start method: {e}")
-
 from PIL import Image
 from rembg import remove, new_session
 
@@ -78,11 +71,10 @@ def _remove_bg_in_process(image_bytes, use_alpha_matting=True):
 
 class BackgroundRemover():
     def __init__(self):
-        # Initialize background remover with multiprocessing using spawn method
-        # OpenMP conflicts are handled by environment variables and process isolation
-        print("Initializing BackgroundRemover with multiprocessing (spawn method)")
-        self.session = None  # Session will be created in subprocess
-        self.max_retries = 2
+        # Initialize background remover with direct processing
+        # OpenMP conflicts are prevented by environment variables set at module level
+        print("Initializing BackgroundRemover with direct processing (no multiprocessing needed)")
+        self.session = None  # Session will be created per request
 
     def __call__(self, image: Image.Image):
         if not isinstance(image, Image.Image):
@@ -102,44 +94,45 @@ class BackgroundRemover():
             if image.mode != 'RGBA':
                 image = image.convert('RGBA')
             
-            print("Starting background removal with multiprocessing (spawn method)...")
-            
-            # Convert image to bytes for passing to subprocess
-            img_bytes = io.BytesIO()
-            image.save(img_bytes, format='PNG')
-            img_bytes = img_bytes.getvalue()
+            print("Starting direct background removal (OpenMP conflicts handled by environment variables)...")
             
-            # Try with alpha matting first (high quality)
+            # Try alpha matting first (high quality)
             print("Attempting alpha matting background removal...")
-            for attempt in range(self.max_retries):
-                try:
-                    with multiprocessing.Pool(processes=1) as pool:
-                        result = pool.apply(_remove_bg_in_process, args=(img_bytes, True))
-                    
-                    if result is not None:
-                        print("Alpha matting successful")
-                        return Image.open(io.BytesIO(result))
-                    break  # Exit retry loop if we got a result (even if None)
-                except Exception as e:
-                    print(f"Alpha matting attempt {attempt + 1} failed: {e}")
-                    if attempt == self.max_retries - 1:
-                        break
+            try:
+                session = new_session()
+                output = remove(
+                    image,
+                    session=session,
+                    bgcolor=[255, 255, 255, 0],
+                    alpha_matting=True,
+                    alpha_matting_foreground_threshold=220,
+                    alpha_matting_background_threshold=5,
+                    alpha_matting_erode_structure_size=5,
+                    alpha_matting_base_size=512,
+                )
+                print("Alpha matting successful!")
+                return output
+            except Exception as e:
+                print(f"Alpha matting failed: {e}")
+                import traceback
+                traceback.print_exc()
             
-            # If alpha matting fails, try without it
+            # If alpha matting fails, try standard background removal
             print("Alpha matting failed, falling back to standard background removal")
-            for attempt in range(self.max_retries):
-                try:
-                    with multiprocessing.Pool(processes=1) as pool:
-                        result = pool.apply(_remove_bg_in_process, args=(img_bytes, False))
-                    
-                    if result is not None:
-                        print("Standard background removal successful")
-                        return Image.open(io.BytesIO(result))
-                    break  # Exit retry loop if we got a result (even if None)
-                except Exception as e:
-                    print(f"Standard background removal attempt {attempt + 1} failed: {e}")
-                    if attempt == self.max_retries - 1:
-                        break
+            try:
+                session = new_session()
+                output = remove(
+                    image,
+                    session=session,
+                    bgcolor=[255, 255, 255, 0],
+                    alpha_matting=False,
+                )
+                print("Standard background removal successful!")
+                return output
+            except Exception as e:
+                print(f"Standard background removal failed: {e}")
+                import traceback
+                traceback.print_exc()
             
             # If all else fails, return the original image
             print("Background removal completely failed, returning original image")