Spaces:
Runtime error
Runtime error
Download app.py from florislindeman/texture-mapper: direct link, hf CLI and curl.
- Browser
- Download file 15.9 kB
-
https://huggingface.co/spaces/florislindeman/texture-mapper/resolve/main/app.py
- Command line
-
hf download hf://spaces/florislindeman/texture-mapper/app.py
-
curl -L -o app.py https://huggingface.co/spaces/florislindeman/texture-mapper/resolve/main/app.py
15.9 kB
| # ============================================ | |
| # 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) | |
| async def root(): | |
| return {"status": "online", "service": "AI Texture Mapper v2.0 - Improved"} | |
| 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 | |
| } | |
| 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) |