# ============================================ # BESTAND 1: app.py - VERBETERDE VERSIE # ============================================ # Sla dit op als: app.py en vervang de oude versie from fastapi import FastAPI, File, UploadFile, Form from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import StreamingResponse import cv2 import numpy as np from PIL import Image import io import base64 class ImprovedTextureMapper: def __init__(self): self.sift = cv2.SIFT_create() def detect_table_surface(self, image): """Verbeterde tafel detectie met perspectief - FLEXIBEL""" gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) h, w = image.shape[:2] # Multi-scale edge detection met lagere thresholds edges1 = cv2.Canny(gray, 20, 80) edges2 = cv2.Canny(gray, 40, 120) edges = cv2.bitwise_or(edges1, edges2) # Morfologische operaties kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)) edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel, iterations=3) edges = cv2.dilate(edges, kernel, iterations=2) # Vind contouren contours, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) valid_surfaces = [] for contour in contours: area = cv2.contourArea(contour) # VEEL flexibeler area thresholds min_area = (w * h) * 0.05 # Minimaal 5% van image max_area = (w * h) * 0.85 # Maximaal 85% van image if area < min_area or area > max_area: continue # Approximate naar polygon peri = cv2.arcLength(contour, True) # Probeer verschillende epsilon waarden for epsilon_factor in [0.01, 0.02, 0.03, 0.04]: approx = cv2.approxPolyDP(contour, epsilon_factor * peri, True) # Accept 4-hoekige vormen (tafel) if len(approx) == 4: corners = approx.reshape(4, 2).astype(np.float32) # Basic validatie (niet te extreem) if self._is_plausible_surface(corners, w, h): valid_surfaces.append({ 'corners': corners, 'area': area, 'epsilon': epsilon_factor }) break # Als geen 4-hoeken gevonden, probeer grootste contour te forceren naar 4 hoeken if not valid_surfaces and len(contours) > 0: # Sorteer op area contours_sorted = sorted(contours, key=cv2.contourArea, reverse=True) for contour in contours_sorted[:5]: # Top 5 grootste area = cv2.contourArea(contour) if area < (w * h) * 0.05: continue # Forcer naar convex hull en dan 4 hoeken hull = cv2.convexHull(contour) peri = cv2.arcLength(hull, True) approx = cv2.approxPolyDP(hull, 0.05 * peri, True) if len(approx) >= 4: # Neem 4 meest extreme punten corners = self._get_extreme_corners(approx.reshape(-1, 2)) if self._is_plausible_surface(corners, w, h): valid_surfaces.append({ 'corners': corners.astype(np.float32), 'area': area, 'epsilon': 0.05 }) break # Sorteer op area (grootste eerst) valid_surfaces.sort(key=lambda x: x['area'], reverse=True) return [s['corners'] for s in valid_surfaces] def _get_extreme_corners(self, points): """Vind 4 meest extreme punten (corners)""" # Top-left: kleinste sum tl = points[np.argmin(points.sum(axis=1))] # Bottom-right: grootste sum br = points[np.argmax(points.sum(axis=1))] # Top-right: kleinste diff (x-y) tr = points[np.argmin(np.diff(points, axis=1))] # Bottom-left: grootste diff bl = points[np.argmax(np.diff(points, axis=1))] return np.array([tl, tr, br, bl], dtype=np.float32) def _is_plausible_surface(self, corners, img_w, img_h): """Minder strenge validatie - is het een plausibel oppervlak?""" # Check if corners are within image bounds if np.any(corners < 0) or np.any(corners[:, 0] >= img_w) or np.any(corners[:, 1] >= img_h): return False # Check if niet te klein x_range = corners[:, 0].max() - corners[:, 0].min() y_range = corners[:, 1].max() - corners[:, 1].min() if x_range < img_w * 0.1 or y_range < img_h * 0.1: return False # Check aspect ratio (niet te extreem lang/breed) aspect = max(x_range, y_range) / (min(x_range, y_range) + 1) if aspect > 5: # Max 5:1 ratio return False return True def order_corners(self, corners): """Order corners: top-left, top-right, bottom-right, bottom-left""" # Bereken centroid center = corners.mean(axis=0) # Sorteer op hoek vanaf center angles = np.arctan2(corners[:, 1] - center[1], corners[:, 0] - center[0]) sorted_indices = np.argsort(angles) # Rotate zodat top-left eerst komt corners_sorted = corners[sorted_indices] # Find top-left (kleinste y + x) sums = corners_sorted.sum(axis=1) top_left_idx = np.argmin(sums) # Rotate array zodat top-left op index 0 is corners_ordered = np.roll(corners_sorted, -top_left_idx, axis=0) return corners_ordered def apply_texture_with_perspective(self, interior, texture, corners): """Apply texture met correcte perspectief transformatie""" # Order corners dst_corners = self.order_corners(corners) # Bereken texture dimensions met perspectief h, w = texture.shape[:2] # Source corners (texture) - altijd rechthoek src_corners = np.float32([ [0, 0], [w, 0], [w, h], [0, h] ]) # Bereken homography matrix H, status = cv2.findHomography(src_corners, dst_corners, cv2.RANSAC, 5.0) if H is None: return interior # Warp texture naar perspectief warped = cv2.warpPerspective( texture, H, (interior.shape[1], interior.shape[0]), flags=cv2.INTER_LINEAR ) # Maak mask mask = np.zeros(interior.shape[:2], dtype=np.uint8) cv2.fillPoly(mask, [dst_corners.astype(np.int32)], 255) # Maak mask zachter (blur edges) mask = cv2.GaussianBlur(mask, (7, 7), 3) # Lighting adjustment - match met omgeving warped = self._adjust_lighting_advanced(warped, interior, mask) # Seamless clone voor natuurlijk resultaat try: center = tuple(dst_corners.mean(axis=0).astype(int)) result = cv2.seamlessClone(warped, interior, mask, center, cv2.MIXED_CLONE) except Exception as e: print(f"Seamless clone failed: {e}, using alpha blend") # Fallback: advanced alpha blending mask_3ch = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR).astype(np.float32) / 255.0 # Blend met edge feathering result = (warped * mask_3ch * 0.9 + interior * (1 - mask_3ch * 0.9)).astype(np.uint8) return result def _adjust_lighting_advanced(self, texture, reference, mask): """Geavanceerde lighting adjustment""" # Converteer naar LAB texture_lab = cv2.cvtColor(texture, cv2.COLOR_BGR2LAB).astype(np.float32) ref_lab = cv2.cvtColor(reference, cv2.COLOR_BGR2LAB).astype(np.float32) # Extract reference region mask_bool = mask > 127 if not np.any(mask_bool): return texture # Match L, A, B channels separately for i in range(3): texture_channel = texture_lab[:, :, i] ref_channel = ref_lab[:, :, i] # Get stats van reference region ref_values = ref_channel[mask_bool] if len(ref_values) == 0: continue ref_mean = ref_values.mean() ref_std = ref_values.std() # Get stats van texture texture_mean = texture_channel[mask_bool].mean() if np.any(mask_bool) else texture_channel.mean() texture_std = texture_channel[mask_bool].std() if np.any(mask_bool) else texture_channel.std() if texture_std > 0: # Normaliseer en schaal texture_lab[:, :, i] = ( (texture_channel - texture_mean) / texture_std * ref_std * 0.7 + ref_mean ) # Clip en converteer terug texture_lab = np.clip(texture_lab, 0, 255) result = cv2.cvtColor(texture_lab.astype(np.uint8), cv2.COLOR_LAB2BGR) return result app = FastAPI(title="AI Texture Mapper API") app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) mapper = ImprovedTextureMapper() def pil_to_cv2(pil_image): return cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR) @app.get("/") async def root(): return {"status": "online", "service": "AI Texture Mapper v2.0 - Improved"} @app.post("/api/process") async def process_complete( interior: UploadFile = File(...), pattern: UploadFile = File(...), method: str = Form("edges"), max_surfaces: int = Form(1) ): try: interior_pil = Image.open(interior.file) pattern_pil = Image.open(pattern.file) interior_cv = pil_to_cv2(interior_pil) pattern_cv = pil_to_cv2(pattern_pil) # Detecteer tafel surfaces surfaces = mapper.detect_table_surface(interior_cv) if not surfaces: return { "success": False, "error": "Geen tafeloppervlak gedetecteerd. Probeer een foto met duidelijke tafelranden.", "num_surfaces": 0 } # Maak preview met gedetecteerde surfaces preview = interior_cv.copy() for i, surface in enumerate(surfaces[:max_surfaces]): # Teken polygon cv2.polylines(preview, [surface.astype(np.int32)], True, (0, 255, 0), 4) # Teken corners for corner in surface: cv2.circle(preview, tuple(corner.astype(int)), 8, (255, 0, 0), -1) # Teken nummer center = surface.mean(axis=0).astype(int) cv2.putText(preview, f"#{i+1}", tuple(center), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 255, 0), 3) # Apply texture op alle surfaces result = interior_cv.copy() for surface in surfaces[:max_surfaces]: result = mapper.apply_texture_with_perspective(result, pattern_cv, surface) # Converteer naar base64 _, preview_buffer = cv2.imencode('.jpg', preview, [cv2.IMWRITE_JPEG_QUALITY, 95]) _, result_buffer = cv2.imencode('.jpg', result, [cv2.IMWRITE_JPEG_QUALITY, 95]) preview_base64 = base64.b64encode(preview_buffer).decode('utf-8') result_base64 = base64.b64encode(result_buffer).decode('utf-8') return { "success": True, "num_surfaces": len(surfaces[:max_surfaces]), "preview": f"data:image/jpeg;base64,{preview_base64}", "result": f"data:image/jpeg;base64,{result_base64}", "info": f"Processed {len(surfaces[:max_surfaces])} surface(s) with improved perspective mapping" } except Exception as e: return { "success": False, "error": f"Processing error: {str(e)}", "num_surfaces": 0 } @app.post("/api/process-manual") async def process_manual( interior: UploadFile = File(...), pattern: UploadFile = File(...), manual_corners: str = Form(...) ): """ Process with manually selected corners """ try: import json interior_pil = Image.open(interior.file) pattern_pil = Image.open(pattern.file) interior_cv = pil_to_cv2(interior_pil) pattern_cv = pil_to_cv2(pattern_pil) # Parse manual corners from JSON string try: corners_data = json.loads(manual_corners) except: # If already parsed, use as is corners_data = manual_corners # Convert to numpy array - handle both formats if isinstance(corners_data, str): corners_data = json.loads(corners_data) # Ensure it's a list of [x, y] coordinates corners_list = [] for corner in corners_data: if isinstance(corner, dict): # Handle {x: ..., y: ...} format if 'x' in corner and 'y' in corner: corners_list.append([float(corner['x']), float(corner['y'])]) elif 0 in corner and 1 in corner: corners_list.append([float(corner[0]), float(corner[1])]) else: raise ValueError(f"Invalid corner dict format: {corner}") elif isinstance(corner, (list, tuple)) and len(corner) == 2: # Handle [x, y] format corners_list.append([float(corner[0]), float(corner[1])]) else: raise ValueError(f"Invalid corner format: {corner}") if len(corners_list) != 4: return { "success": False, "error": f"Exact 4 hoeken vereist, maar {len(corners_list)} ontvangen", "num_surfaces": 0 } corners = np.array(corners_list, dtype=np.float32) # Scale corners to match image dimensions if needed img_h, img_w = interior_cv.shape[:2] # Check if corners need scaling (if they're normalized 0-1) max_x = max(c[0] for c in corners_list) max_y = max(c[1] for c in corners_list) if max_x <= 1.0 and max_y <= 1.0: # Corners are normalized, scale to image size corners[:, 0] *= img_w corners[:, 1] *= img_h # Apply texture with manual corners result = mapper.apply_texture_with_perspective(interior_cv, pattern_cv, corners) # Convert to base64 _, result_buffer = cv2.imencode('.jpg', result, [cv2.IMWRITE_JPEG_QUALITY, 95]) result_base64 = base64.b64encode(result_buffer).decode('utf-8') return { "success": True, "result": f"data:image/jpeg;base64,{result_base64}", "info": "Patroon toegepast met handmatige hoeken" } except Exception as e: import traceback return { "success": False, "error": f"Processing error: {str(e)}\nTraceback: {traceback.format_exc()}", "num_surfaces": 0 } if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)