Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,12 @@
+# Python virtual environment
+.venv/
+venv/
+
+# Python cache files
+__pycache__/
+*.pyc
+
+# IDE and OS files
+.idea/
+.vscode/
+.DS_Store

README.md

@@ -1,3 +1,24 @@
----
-license: apache-2.0
----
+# S23DR 2025 Challenge: 4th Place Solution
+
+This repository contains the 4th place solution for the S23DR 2025 Challenge. For more details, refer to the writeup included in this repository.
+
+## Approach
+
+The solution is a fully handcrafted pipeline based on classical computer vision and geometry. It builds on the official baseline with improvements in edge detection, depth assignment, and 3D merging. No learned models were used.
+
+## Final Score
+
+- **HSS Mean:** 0.3309
+- **Corner F1:** 0.4310
+- **Edge IOU:** 0.2773
+
+## How to Run
+
+The competition platform executes `script.py` to generate predictions. To run locally, you would need a dataset entry and could call the `predict_wireframe` function from `solution.py`.
+
+## File Structure
+
+- `solution.py`: Contains the main logic for the wireframe prediction pipeline.
+- `script.py`: The entry point script for the Hugging Face competition platform.
+- `requirements.txt`: Lists all Python dependencies.
+- `hoho2025/`: A helper module containing color mappings.

hoho2025/color_mappings.py

@@ -0,0 +1,209 @@
+gestalt_color_mapping = {
+    "unclassified": (215, 62, 138),
+    "apex": (235, 88, 48),
+    "eave_end_point": (248, 130, 228),
+    "flashing_end_point": (71, 11, 161),
+    "ridge": (214, 251, 248),
+    "rake": (13, 94, 47),
+    "eave": (54, 243, 63),
+    "post": (187, 123, 236),
+    "ground_line": (136, 206, 14),
+    "flashing": (162, 162, 32),
+    "step_flashing": (169, 255, 219),
+    "hip": (8, 89, 52),
+    "valley": (85, 27, 65),
+    "roof": (215, 232, 179),
+    "door": (110, 52, 23),
+    "garage": (50, 233, 171),
+    "window": (230, 249, 40),
+    "shutter": (122, 4, 233),
+    "fascia": (95, 230, 240),
+    "soffit": (2, 102, 197),
+    "horizontal_siding": (131, 88, 59),
+    "vertical_siding": (110, 187, 198),
+    "brick": (171, 252, 7),
+    "concrete": (32, 47, 246),
+    "other_wall": (112, 61, 240),
+    "trim": (151, 206, 58),
+    "unknown": (127, 127, 127),
+    "transition_line": (0,0,0),
+}
+
+ade20k_color_mapping = {
+    'wall': (120, 120, 120),
+    'building;edifice': (180, 120, 120),
+    'sky': (6, 230, 230),
+    'floor;flooring': (80, 50, 50),
+    'tree': (4, 200, 3),
+    'ceiling': (120, 120, 80),
+    'road;route': (140, 140, 140),
+    'bed': (204, 5, 255),
+    'windowpane;window': (230, 230, 230),
+    'grass': (4, 250, 7),
+    'cabinet': (224, 5, 255),
+    'sidewalk;pavement': (235, 255, 7),
+    'person;individual;someone;somebody;mortal;soul': (150, 5, 61),
+    'earth;ground': (120, 120, 70),
+    'door;double;door': (8, 255, 51),
+    'table': (255, 6, 82),
+    'mountain;mount': (143, 255, 140),
+    'plant;flora;plant;life': (204, 255, 4),
+    'curtain;drape;drapery;mantle;pall': (255, 51, 7),
+    'chair': (204, 70, 3),
+    'car;auto;automobile;machine;motorcar': (0, 102, 200),
+    'water': (61, 230, 250),
+    'painting;picture': (255, 6, 51),
+    'sofa;couch;lounge': (11, 102, 255),
+    'shelf': (255, 7, 71),
+    'house': (255, 9, 224),
+    'sea': (9, 7, 230),
+    'mirror': (220, 220, 220),
+    'rug;carpet;carpeting': (255, 9, 92),
+    'field': (112, 9, 255),
+    'armchair': (8, 255, 214),
+    'seat': (7, 255, 224),
+    'fence;fencing': (255, 184, 6),
+    'desk': (10, 255, 71),
+    'rock;stone': (255, 41, 10),
+    'wardrobe;closet;press': (7, 255, 255),
+    'lamp': (224, 255, 8),
+    'bathtub;bathing;tub;bath;tub': (102, 8, 255),
+    'railing;rail': (255, 61, 6),
+    'cushion': (255, 194, 7),
+    'base;pedestal;stand': (255, 122, 8),
+    'box': (0, 255, 20),
+    'column;pillar': (255, 8, 41),
+    'signboard;sign': (255, 5, 153),
+    'chest;of;drawers;chest;bureau;dresser': (6, 51, 255),
+    'counter': (235, 12, 255),
+    'sand': (160, 150, 20),
+    'sink': (0, 163, 255),
+    'skyscraper': (140, 140, 140),
+    'fireplace;hearth;open;fireplace': (250, 10, 15),
+    'refrigerator;icebox': (20, 255, 0),
+    'grandstand;covered;stand': (31, 255, 0),
+    'path': (255, 31, 0),
+    'stairs;steps': (255, 224, 0),
+    'runway': (153, 255, 0),
+    'case;display;case;showcase;vitrine': (0, 0, 255),
+    'pool;table;billiard;table;snooker;table': (255, 71, 0),
+    'pillow': (0, 235, 255),
+    'screen;door;screen': (0, 173, 255),
+    'stairway;staircase': (31, 0, 255),
+    'river': (11, 200, 200),
+    'bridge;span': (255 ,82, 0),
+    'bookcase': (0, 255, 245),
+    'blind;screen': (0, 61, 255),
+    'coffee;table;cocktail;table': (0, 255, 112),
+    'toilet;can;commode;crapper;pot;potty;stool;throne': (0, 255, 133),
+    'flower': (255, 0, 0),
+    'book': (255, 163, 0),
+    'hill': (255, 102, 0),
+    'bench': (194, 255, 0),
+    'countertop': (0, 143, 255),
+    'stove;kitchen;stove;range;kitchen;range;cooking;stove': (51, 255, 0),
+    'palm;palm;tree': (0, 82, 255),
+    'kitchen;island': (0, 255, 41),
+    'computer;computing;machine;computing;device;data;processor;electronic;computer;information;processing;system': (0, 255, 173),
+    'swivel;chair': (10, 0, 255),
+    'boat': (173, 255, 0),
+    'bar': (0, 255, 153),
+    'arcade;machine': (255, 92, 0),
+    'hovel;hut;hutch;shack;shanty': (255, 0, 255),
+    'bus;autobus;coach;charabanc;double-decker;jitney;motorbus;motorcoach;omnibus;passenger;vehicle': (255, 0, 245),
+    'towel': (255, 0, 102),
+    'light;light;source': (255, 173, 0),
+    'truck;motortruck': (255, 0, 20),
+    'tower': (255, 184, 184),
+    'chandelier;pendant;pendent': (0, 31, 255),
+    'awning;sunshade;sunblind': (0, 255, 61),
+    'streetlight;street;lamp': (0, 71, 255),
+    'booth;cubicle;stall;kiosk': (255, 0, 204),
+    'television;television;receiver;television;set;tv;tv;set;idiot;box;boob;tube;telly;goggle;box': (0, 255, 194),
+    'airplane;aeroplane;plane': (0, 255, 82),
+    'dirt;track': (0, 10, 255),
+    'apparel;wearing;apparel;dress;clothes': (0, 112, 255),
+    'pole': (51, 0, 255),
+    'land;ground;soil': (0, 194, 255),
+    'bannister;banister;balustrade;balusters;handrail': (0, 122, 255),
+    'escalator;moving;staircase;moving;stairway': (0, 255, 163),
+    'ottoman;pouf;pouffe;puff;hassock': (255, 153, 0),
+    'bottle': (0, 255, 10),
+    'buffet;counter;sideboard': (255, 112, 0),
+    'poster;posting;placard;notice;bill;card': (143, 255, 0),
+    'stage': (82, 0, 255),
+    'van': (163, 255, 0),
+    'ship': (255, 235, 0),
+    'fountain': (8, 184, 170),
+    'conveyer;belt;conveyor;belt;conveyer;conveyor;transporter': (133, 0, 255),
+    'canopy': (0, 255, 92),
+    'washer;automatic;washer;washing;machine': (184, 0, 255),
+    'plaything;toy': (255, 0, 31),
+    'swimming;pool;swimming;bath;natatorium': (0, 184, 255),
+    'stool': (0, 214, 255),
+    'barrel;cask': (255, 0, 112),
+    'basket;handbasket': (92, 255, 0),
+    'waterfall;falls': (0, 224, 255),
+    'tent;collapsible;shelter': (112, 224, 255),
+    'bag': (70, 184, 160),
+    'minibike;motorbike': (163, 0, 255),
+    'cradle': (153, 0, 255),
+    'oven': (71, 255, 0),
+    'ball': (255, 0, 163),
+    'food;solid;food': (255, 204, 0),
+    'step;stair': (255, 0, 143),
+    'tank;storage;tank': (0, 255, 235),
+    'trade;name;brand;name;brand;marque': (133, 255, 0),
+    'microwave;microwave;oven': (255, 0, 235),
+    'pot;flowerpot': (245, 0, 255),
+    'animal;animate;being;beast;brute;creature;fauna': (255, 0, 122),
+    'bicycle;bike;wheel;cycle': (255, 245, 0),
+    'lake': (10, 190, 212),
+    'dishwasher;dish;washer;dishwashing;machine': (214, 255, 0),
+    'screen;silver;screen;projection;screen': (0, 204, 255),
+    'blanket;cover': (20, 0, 255),
+    'sculpture': (255, 255, 0),
+    'hood;exhaust;hood': (0, 153, 255),
+    'sconce': (0, 41, 255),
+    'vase': (0, 255, 204),
+    'traffic;light;traffic;signal;stoplight': (41, 0, 255),
+    'tray': (41, 255, 0),
+    'ashcan;trash;can;garbage;can;wastebin;ash;bin;ash-bin;ashbin;dustbin;trash;barrel;trash;bin': (173, 0, 255),
+    'fan': (0, 245, 255),
+    'pier;wharf;wharfage;dock': (71, 0, 255),
+    'crt;screen': (122, 0, 255),
+    'plate': (0, 255, 184),
+    'monitor;monitoring;device': (0, 92, 255),
+    'bulletin;board;notice;board': (184, 255, 0),
+    'shower': (0, 133, 255),
+    'radiator': (255, 214, 0),
+    'glass;drinking;glass': (25, 194, 194),
+    'clock': (102, 255, 0),
+    'flag': (92, 0, 255),
+}
+
+
+EDGE_CLASSES = {'cornice_return': 0,
+                'cornice_strip': 1,
+                'eave': 2,
+                'flashing': 3,
+                'hip': 4,
+                'rake': 5,
+                'ridge': 6,
+                'step_flashing': 7,
+                'transition_line': 8,
+                'valley': 9}
+EDGE_CLASSES_BY_ID = {v: k for k, v in EDGE_CLASSES.items()}
+
+edge_color_mapping = {
+    'cornice_return': (215, 62, 138),
+    'cornice_strip': (235, 88, 48),
+    'eave':  (54, 243, 63),
+    "flashing": (162, 162, 32),
+    'hip': (8, 89, 52),
+    'rake': (13, 94, 47),
+    'ridge': (214, 251, 248),
+    "step_flashing": (169, 255, 219),
+    'transition_line': (200,0,50),
+    'valley': (85, 27, 65),
+}

requirements.txt

@@ -0,0 +1,8 @@
+numpy
+opencv-python
+scikit-learn
+scipy
+pycolmap
+Pillow
+pyarrow
+pandas

script.py

@@ -0,0 +1,76 @@
+import gc
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from datasets import load_dataset
+from tqdm import tqdm
+from solution import predict_wireframe
+
+
+def empty_solution():
+    """Return a minimal valid solution in case of an error."""
+    return np.zeros((2, 3)), []
+
+
+def main():
+    """
+    Main script for the S23DR 2025 Challenge.
+    This script loads the test dataset using the competition's specific
+    method, runs the prediction pipeline, and saves the results.
+    """
+    print("------------ Setting up data paths ------------")
+    # This is the essential path where data is stored in the submission environment.
+    data_path = Path('/tmp/data')
+
+    print("------------ Loading dataset ------------")
+    # This data loading logic is preserved from the original script to ensure
+    # compatibility with the submission environment.
+    data_files = {
+        "validation": [str(p) for p in data_path.rglob('*public*/**/*.tar')],
+        "test": [str(p) for p in data_path.rglob('*private*/**/*.tar')],
+    }
+    print(f"Found data files: {data_files}")
+
+    dataset = load_dataset(
+        str(data_path / 'hoho25k_test_x.py'),
+        data_files=data_files,
+        trust_remote_code=True,
+        writer_batch_size=100,
+    )
+    print(f"Dataset loaded successfully: {dataset}")
+
+    print('------------ Starting prediction loop ---------------')
+    solution = []
+    for subset_name in dataset.keys():
+        print(f"Predicting for subset: {subset_name}")
+        for i, entry in enumerate(tqdm(dataset[subset_name], desc=f"Processing {subset_name}")):
+            try:
+                # Run your prediction pipeline
+                pred_vertices, pred_edges = predict_wireframe(entry)
+            except Exception as e:
+                # If your pipeline fails, provide an empty solution and log the error.
+                print(f"Error processing sample {entry.get('order_id', 'UNKNOWN')}: {e}")
+                pred_vertices, pred_edges = empty_solution()
+
+            # Append the result in the required format.
+            solution.append(
+                {
+                    'order_id': entry['order_id'],
+                    'wf_vertices': pred_vertices.tolist(),
+                    'wf_edges': pred_edges,
+                }
+            )
+
+            # Periodically run garbage collection to manage memory.
+            if (i + 1) % 50 == 0:
+                gc.collect()
+
+    print('------------ Saving results ---------------')
+    sub = pd.DataFrame(solution, columns=["order_id", "wf_vertices", "wf_edges"])
+    sub.to_parquet("submission.parquet", index=False)
+    print("------------ Done ------------")
+
+
+if __name__ == "__main__":
+    main()

solution.py

@@ -0,0 +1,492 @@
+import io
+import tempfile
+import zipfile
+from collections import defaultdict
+from typing import Tuple, List, Dict, Any
+
+import cv2
+import numpy as np
+import pycolmap
+from PIL import Image as PImage
+from scipy.spatial.distance import cdist
+from sklearn.cluster import DBSCAN
+
+from hoho2025.color_mappings import ade20k_color_mapping, gestalt_color_mapping
+
+
+class Config:
+    """Configuration for wireframe extraction pipeline."""
+    EDGE_THRESHOLD = 15.5
+    MERGE_THRESHOLD = 0.65
+    PRUNE_DISTANCE = 3.0
+    SEARCH_RADIUS = 14
+    MIN_EDGE_LENGTH = 0.15
+    MAX_EDGE_LENGTH = 27.0
+    MORPHOLOGY_KERNEL = 3
+    REFINEMENT_CLUSTER_EPS = 0.45
+    REFINEMENT_MIN_SAMPLES = 1
+
+
+def empty_solution() -> Tuple[np.ndarray, List[Tuple[int, int]]]:
+    """Returns an empty wireframe solution."""
+    return np.zeros((2, 3)), [(0, 1)]
+
+
+def get_vertices_and_edges_from_segmentation(
+    gest_seg_np: np.ndarray, edge_th: float = Config.EDGE_THRESHOLD
+) -> Tuple[List[Dict[str, Any]], List[Tuple[int, int]]]:
+    """
+    Detects roof vertices and edges from a Gestalt segmentation mask.
+
+    Args:
+        gest_seg_np: Segmentation mask as a numpy array.
+        edge_th: Distance threshold for associating edges to vertices.
+
+    Returns:
+        vertices: List of detected vertices with coordinates and type.
+        connections: List of edge connections (vertex index pairs).
+    """
+    vertices, connections = [], []
+    if not isinstance(gest_seg_np, np.ndarray):
+        gest_seg_np = np.array(gest_seg_np)
+
+    # Vertex detection
+    for v_type, color_name in [("apex", "apex"), ("eave_end_point", "eave_end_point")]:
+        color = np.array(gestalt_color_mapping[color_name])
+        mask = cv2.inRange(gest_seg_np, color - 0.5, color + 0.5)
+        if mask.sum() == 0:
+            continue
+
+        output = cv2.connectedComponentsWithStats(mask, 8, cv2.CV_32S)
+        numLabels, labels, stats, centroids = output
+        for i in range(1, numLabels):
+            mask_i = (labels == i).astype(np.uint8)
+            M = cv2.moments(mask_i)
+            if M["m00"] > 0:
+                cx, cy = M["m10"] / M["m00"], M["m01"] / M["m00"]
+            else:
+                ys, xs = np.where(mask_i)
+                if len(xs) > 0:
+                    cx, cy = np.mean(xs), np.mean(ys)
+                else:
+                    continue
+            vertices.append({"xy": np.array([cx, cy]), "type": v_type})
+
+    if not vertices:
+        return [], []
+
+    apex_pts = np.array([v['xy'] for v in vertices])
+
+    # Edge detection
+    edge_classes = ['eave', 'ridge', 'rake', 'valley']
+    for edge_class in edge_classes:
+        if edge_class not in gestalt_color_mapping:
+            continue
+        edge_color = np.array(gestalt_color_mapping[edge_class])
+        mask_raw = cv2.inRange(gest_seg_np, edge_color - 0.5, edge_color + 0.5)
+
+        # Improved morphology: close then open
+        kernel = np.ones((Config.MORPHOLOGY_KERNEL, Config.MORPHOLOGY_KERNEL), np.uint8)
+        mask = cv2.morphologyEx(mask_raw, cv2.MORPH_CLOSE, kernel)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((2, 2), np.uint8))
+
+        if mask.sum() == 0:
+            continue
+
+        output = cv2.connectedComponentsWithStats(mask, 8, cv2.CV_32S)
+        numLabels, labels, stats, centroids = output
+        for lbl in range(1, numLabels):
+            ys, xs = np.where(labels == lbl)
+            if len(xs) < 2:
+                continue
+            pts_for_fit = np.column_stack([xs, ys]).astype(np.float32)
+            line_params = cv2.fitLine(
+                pts_for_fit, distType=cv2.DIST_L2, param=0, reps=0.01, aeps=0.01
+            )
+            vx, vy, x0, y0 = line_params.ravel()
+            proj = ((xs - x0) * vx + (ys - y0) * vy)
+            p1 = np.array([x0 + proj.min() * vx, y0 + proj.min() * vy])
+            p2 = np.array([x0 + proj.max() * vx, y0 + proj.max() * vy])
+            if len(apex_pts) < 2:
+                continue
+            dists = np.array([point_to_segment_dist(apex_pts[i], p1, p2) for i in range(len(apex_pts))])
+            near_indices = np.where(dists <= edge_th)[0]
+            if len(near_indices) < 2:
+                continue
+            for i in range(len(near_indices)):
+                for j in range(i + 1, len(near_indices)):
+                    conn = tuple(sorted((near_indices[i], near_indices[j])))
+                    if conn not in connections:
+                        connections.append(conn)
+    return vertices, connections
+
+
+def get_uv_depth(
+    vertices: List[Dict[str, Any]],
+    depth_fitted: np.ndarray,
+    sparse_depth: np.ndarray,
+    search_radius: int = Config.SEARCH_RADIUS,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Assigns depth to each vertex using a weighted search in the sparse depth map.
+
+    Args:
+        vertices: List of detected vertices.
+        depth_fitted: Dense depth map.
+        sparse_depth: Sparse depth map.
+        search_radius: Search radius for depth assignment.
+
+    Returns:
+        uv: 2D coordinates of vertices.
+        vertex_depth: Depth values for each vertex.
+    """
+    uv = np.array([vert['xy'] for vert in vertices], dtype=np.float32)
+    uv_int = np.round(uv).astype(np.int32)
+    H, W = depth_fitted.shape[:2]
+    uv_int[:, 0] = np.clip(uv_int[:, 0], 0, W - 1)
+    uv_int[:, 1] = np.clip(uv_int[:, 1], 0, H - 1)
+    vertex_depth = np.zeros(len(vertices), dtype=np.float32)
+
+    for i, (x_i, y_i) in enumerate(uv_int):
+        x0, x1 = max(0, x_i - search_radius), min(W, x_i + search_radius + 1)
+        y0, y1 = max(0, y_i - search_radius), min(H, y_i + search_radius + 1)
+        region = sparse_depth[y0:y1, x0:x1]
+        valid_y, valid_x = np.where(region > 0)
+
+        if valid_y.size > 0:
+            global_x, global_y = x0 + valid_x, y0 + valid_y
+            dist_sq = (global_x - x_i) ** 2 + (global_y - y_i) ** 2
+            weights = np.exp(-dist_sq / (2 * (search_radius / 3) ** 2))
+            vertex_depth[i] = np.sum(weights * region[valid_y, valid_x]) / np.sum(weights)
+        else:
+            vertex_depth[i] = depth_fitted[y_i, x_i]
+
+    return uv, vertex_depth
+
+
+def read_colmap_rec(colmap_data: bytes) -> pycolmap.Reconstruction:
+    """Reads a COLMAP reconstruction from a zipped binary."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        with zipfile.ZipFile(io.BytesIO(colmap_data), "r") as zf:
+            zf.extractall(tmpdir)
+        rec = pycolmap.Reconstruction(tmpdir)
+        return rec
+
+
+def convert_entry_to_human_readable(entry: Dict[str, Any]) -> Dict[str, Any]:
+    """Converts a raw entry to a human-readable format."""
+    out = {}
+    for k, v in entry.items():
+        if k == 'colmap_binary':
+            out[k] = read_colmap_rec(v)
+        elif k in ['K', 'R', 't']:
+            try:
+                out[k] = np.array(v)
+            except ValueError:
+                out[k] = v
+        else:
+            out[k] = v
+    out['__key__'] = entry.get('order_id', 'unknown_id')
+    return out
+
+
+def get_house_mask(ade20k_seg: np.ndarray) -> np.ndarray:
+    """Returns a mask for house/building regions from ADE20K segmentation."""
+    house_classes_ade20k = [
+        'wall', 'house', 'building;edifice', 'door;double;door', 'windowpane;window'
+    ]
+    np_seg = np.array(ade20k_seg)
+    full_mask = np.zeros(np_seg.shape[:2], dtype=np.uint8)
+    for c in house_classes_ade20k:
+        if c in ade20k_color_mapping:
+            color = np.array(ade20k_color_mapping[c])
+            mask = cv2.inRange(np_seg, color - 0.5, color + 0.5)
+            full_mask = np.logical_or(full_mask, mask)
+    return full_mask
+
+
+def point_to_segment_dist(pt: np.ndarray, seg_p1: np.ndarray, seg_p2: np.ndarray) -> float:
+    """Computes the distance from a point to a line segment."""
+    if np.allclose(seg_p1, seg_p2):
+        return np.linalg.norm(pt - seg_p1)
+    seg_vec = seg_p2 - seg_p1
+    pt_vec = pt - seg_p1
+    seg_len2 = seg_vec.dot(seg_vec)
+    t = max(0, min(1, pt_vec.dot(seg_vec) / seg_len2))
+    proj = seg_p1 + t * seg_vec
+    return np.linalg.norm(pt - proj)
+
+
+def get_sparse_depth(
+    colmap_rec: pycolmap.Reconstruction, img_id_substring: str, depth: np.ndarray
+) -> Tuple[np.ndarray, bool, Any]:
+    """Projects COLMAP 3D points into the image to create a sparse depth map."""
+    H, W = depth.shape
+    found_img = None
+    for img_id_c, col_img in colmap_rec.images.items():
+        if img_id_substring in col_img.name:
+            found_img = col_img
+            break
+    if found_img is None:
+        return np.zeros((H, W), dtype=np.float32), False, None
+    points_xyz = [
+        p3D.xyz for pid, p3D in colmap_rec.points3D.items() if found_img.has_point3D(pid)
+    ]
+    if not points_xyz:
+        return np.zeros((H, W), dtype=np.float32), False, found_img
+    points_xyz = np.array(points_xyz)
+    uv, z_vals = [], []
+    for xyz in points_xyz:
+        proj = found_img.project_point(xyz)
+        if proj is not None:
+            u_i, v_i = int(round(proj[0])), int(round(proj[1]))
+            if 0 <= u_i < W and 0 <= v_i < H:
+                uv.append((u_i, v_i))
+                mat4x4 = np.eye(4)
+                mat4x4[:3, :4] = found_img.cam_from_world.matrix()
+                p_cam = mat4x4 @ np.array([xyz[0], xyz[1], xyz[2], 1.0])
+                z_vals.append(p_cam[2] / p_cam[3])
+    uv, z_vals = np.array(uv, dtype=int), np.array(z_vals)
+    depth_out = np.zeros((H, W), dtype=np.float32)
+    if len(uv) > 0:
+        depth_out[uv[:, 1], uv[:, 0]] = z_vals
+    return depth_out, True, found_img
+
+
+def fit_scale_robust_median(
+    depth: np.ndarray, sparse_depth: np.ndarray, validity_mask: np.ndarray = None
+) -> Tuple[float, np.ndarray]:
+    """Fits a scale factor between dense and sparse depth using the median ratio."""
+    mask = (sparse_depth > 0.1) & (depth > 0.1) & (sparse_depth < 50) & (depth < 50)
+    if validity_mask is not None:
+        mask &= validity_mask
+    X, Y = depth[mask], sparse_depth[mask]
+    if len(X) < 5:
+        return 1.0, depth
+    ratios = Y / X
+    alpha = np.median(ratios)
+    return alpha, alpha * depth
+
+
+def get_fitted_dense_depth(
+    depth: np.ndarray, colmap_rec: pycolmap.Reconstruction, img_id: str, ade20k_seg: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray, bool, Any]:
+    """Fits the dense depth map to the sparse COLMAP depth."""
+    depth_np = np.array(depth) / 1000.0
+    depth_sparse, found_sparse, col_img = get_sparse_depth(colmap_rec, img_id, depth_np)
+    if not found_sparse:
+        return depth_np, np.zeros_like(depth_np), False, None
+    house_mask = get_house_mask(ade20k_seg)
+    k, depth_fitted = fit_scale_robust_median(depth_np, depth_sparse, validity_mask=house_mask)
+    return depth_fitted, depth_sparse, True, col_img
+
+
+def project_vertices_to_3d(
+    uv: np.ndarray, depth_vert: np.ndarray, col_img: Any
+) -> np.ndarray:
+    """Projects 2D vertices to 3D using camera intrinsics and depth."""
+    xy_local = np.ones((len(uv), 3))
+    K = col_img.camera.calibration_matrix()
+    xy_local[:, 0] = (uv[:, 0] - K[0, 2]) / K[0, 0]
+    xy_local[:, 1] = (uv[:, 1] - K[1, 2]) / K[1, 1]
+    vertices_3d_local = xy_local * depth_vert[..., None]
+    world_to_cam = np.eye(4)
+    world_to_cam[:3] = col_img.cam_from_world.matrix()
+    cam_to_world = np.linalg.inv(world_to_cam)
+    vertices_3d_homogeneous = cv2.convertPointsToHomogeneous(vertices_3d_local)
+    vertices_3d = cv2.transform(vertices_3d_homogeneous, cam_to_world)
+    return cv2.convertPointsFromHomogeneous(vertices_3d).reshape(-1, 3)
+
+
+def merge_vertices_3d(
+    vert_edge_per_image: Dict[int, Tuple[List[Dict[str, Any]], List[Tuple[int, int]], np.ndarray]],
+    th: float = Config.MERGE_THRESHOLD,
+) -> Tuple[np.ndarray, List[Tuple[int, int]]]:
+    """
+    Merges 3D vertices and edges across multiple views.
+
+    Args:
+        vert_edge_per_image: Dictionary of per-image vertices, edges, and 3D vertices.
+        th: Distance threshold for merging.
+
+    Returns:
+        new_vertices: Merged 3D vertices.
+        new_connections: Merged edge connections.
+    """
+    all_3d_vertices, connections_3d, types = [], [], []
+    cur_start = 0
+    for cimg_idx, (vertices, connections, vertices_3d) in vert_edge_per_image.items():
+        if len(vertices) == 0 or len(vertices_3d) == 0:
+            continue
+        types += [int(v['type'] == 'apex') for v in vertices]
+        all_3d_vertices.append(vertices_3d)
+        connections_3d += [(x + cur_start, y + cur_start) for (x, y) in connections]
+        cur_start += len(vertices_3d)
+    if len(all_3d_vertices) == 0:
+        return np.array([]), []
+    all_3d_vertices = np.concatenate(all_3d_vertices, axis=0)
+    if len(all_3d_vertices) == 0:
+        return np.array([]), []
+    distmat = cdist(all_3d_vertices, all_3d_vertices)
+    types = np.array(types).reshape(-1, 1)
+    same_types = cdist(types, types)
+    mask_to_merge = (distmat <= th) & (same_types == 0)
+    new_vertices, new_connections = [], []
+    to_merge = sorted(list(set([tuple(a.nonzero()[0].tolist()) for a in mask_to_merge])))
+    to_merge_final = defaultdict(list)
+    for i in range(len(all_3d_vertices)):
+        for j in to_merge:
+            if i in j:
+                to_merge_final[i] += j
+    for k, v in to_merge_final.items():
+        to_merge_final[k] = list(set(v))
+    already_there, merged = set(), []
+    for k, v in to_merge_final.items():
+        if k in already_there:
+            continue
+        merged.append(v)
+        for vv in v:
+            already_there.add(vv)
+    old_idx_to_new = {}
+    count = 0
+    for idxs in merged:
+        if len(idxs) > 0:
+            new_vertices.append(all_3d_vertices[idxs].mean(axis=0))
+            for idx in idxs:
+                old_idx_to_new[idx] = count
+            count += 1
+    if len(new_vertices) == 0:
+        return np.array([]), []
+    new_vertices = np.array(new_vertices)
+    for conn in connections_3d:
+        if conn[0] in old_idx_to_new and conn[1] in old_idx_to_new:
+            new_con = sorted((old_idx_to_new[conn[0]], old_idx_to_new[conn[1]]))
+            if new_con[0] != new_con[1] and new_con not in new_connections:
+                new_connections.append(new_con)
+    return new_vertices, new_connections
+
+
+def prune_too_far(
+    all_3d_vertices: np.ndarray, connections_3d: List[Tuple[int, int]], colmap_rec: pycolmap.Reconstruction, th: float = Config.PRUNE_DISTANCE
+) -> Tuple[np.ndarray, List[Tuple[int, int]]]:
+    """Prunes 3D vertices and edges that are too far from COLMAP points."""
+    if len(all_3d_vertices) == 0:
+        return all_3d_vertices, connections_3d
+    xyz_sfm = np.array([v.xyz for v in colmap_rec.points3D.values()])
+    if len(xyz_sfm) == 0:
+        return all_3d_vertices, connections_3d
+    distmat = cdist(all_3d_vertices, xyz_sfm)
+    mask = distmat.min(axis=1) <= th
+    if not np.any(mask):
+        return np.empty((0, 3)), []
+    old_to_new_idx = {old: new for new, old in enumerate(np.where(mask)[0])}
+    new_vertices = all_3d_vertices[mask]
+    new_connections = []
+    for u, v in connections_3d:
+        if u in old_to_new_idx and v in old_to_new_idx:
+            new_connections.append((old_to_new_idx[u], old_to_new_idx[v]))
+    return new_vertices, new_connections
+
+
+def metric_aware_refine(
+    vertices: np.ndarray, edges: List[Tuple[int, int]]
+) -> Tuple[np.ndarray, List[Tuple[int, int]]]:
+    """
+    Refines vertices and edges using clustering and edge length constraints.
+
+    Args:
+        vertices: 3D vertex coordinates.
+        edges: List of edge connections.
+
+    Returns:
+        final_vertices: Refined 3D vertices.
+        final_edges: Refined edge connections.
+    """
+    if len(vertices) < 2:
+        return vertices, edges
+    clustering = DBSCAN(
+        eps=Config.REFINEMENT_CLUSTER_EPS, min_samples=Config.REFINEMENT_MIN_SAMPLES
+    ).fit(vertices)
+    labels = clustering.labels_
+    refined_vertices = vertices.copy()
+    refined_centers = {}
+    for label in set(labels):
+        if label == -1:
+            continue
+        refined_centers[label] = np.mean(vertices[labels == label], axis=0)
+    for i, label in enumerate(labels):
+        if label in refined_centers:
+            refined_vertices[i] = refined_centers[label]
+    final_edges_set = set()
+    for u, v in edges:
+        if u >= len(refined_vertices) or v >= len(refined_vertices):
+            continue
+        p1 = refined_vertices[u]
+        p2 = refined_vertices[v]
+        dist = np.linalg.norm(p1 - p2)
+        if Config.MIN_EDGE_LENGTH <= dist <= Config.MAX_EDGE_LENGTH:
+            if not np.allclose(p1, p2, atol=1e-3):
+                final_edges_set.add(tuple(sorted((u, v))))
+    if not final_edges_set:
+        return np.empty((0, 3)), []
+    used_idxs = set(u for u, v in final_edges_set) | set(v for u, v in final_edges_set)
+    sorted_used_idxs = sorted(list(used_idxs))
+    final_map = {old_id: new_id for new_id, old_id in enumerate(sorted_used_idxs)}
+    final_vertices = np.array([refined_vertices[old_id] for old_id in sorted_used_idxs])
+    final_edges = [(final_map[u], final_map[v]) for u, v in final_edges_set]
+    return final_vertices, final_edges
+
+
+def predict_wireframe(entry: Dict[str, Any]) -> Tuple[np.ndarray, List[Tuple[int, int]]]:
+    """
+    Main prediction function for the S23DR wireframe challenge.
+
+    Args:
+        entry: Input data entry.
+
+    Returns:
+        final_vertices: 3D vertices of the wireframe.
+        final_edges: Edge connections.
+    """
+    try:
+        good_entry = convert_entry_to_human_readable(entry)
+        colmap_rec = good_entry['colmap_binary']
+        vert_edge_per_image = {}
+        for i, (gest_img, img_id, ade_seg, depth_img) in enumerate(
+            zip(
+                good_entry['gestalt'],
+                good_entry['image_ids'],
+                good_entry['ade'],
+                good_entry['depth'],
+            )
+        ):
+            depth_size = (gest_img.width, gest_img.height)
+            gest_seg_np = np.array(gest_img.resize(depth_size)).astype(np.uint8)
+            vertices, connections = get_vertices_and_edges_from_segmentation(gest_seg_np)
+            if not vertices:
+                vert_edge_per_image[i] = ([], [], [])
+            else:
+                depth_fitted, depth_sparse, found_sparse, col_img = get_fitted_dense_depth(
+                    depth_img, colmap_rec, img_id, ade_seg
+                )
+                if found_sparse and col_img is not None:
+                    uv, depth_vert = get_uv_depth(vertices, depth_fitted, depth_sparse)
+                    vertices_3d = project_vertices_to_3d(uv, depth_vert, col_img)
+                    vert_edge_per_image[i] = (vertices, connections, vertices_3d)
+                else:
+                    vert_edge_per_image[i] = (vertices, connections, [])
+        all_3d_vertices, connections_3d = merge_vertices_3d(vert_edge_per_image)
+        all_3d_vertices, connections_3d = prune_too_far(
+            all_3d_vertices, connections_3d, colmap_rec
+        )
+        final_vertices, final_edges = metric_aware_refine(
+            all_3d_vertices, connections_3d
+        )
+        if len(final_vertices) < 2 or len(final_edges) < 1:
+            return empty_solution()
+        return final_vertices, final_edges
+    except Exception as e:
+        print(f"An error occurred in the main prediction pipeline: {e}")
+        import traceback
+        traceback.print_exc()
+        return empty_solution()