{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": { "id": "GRUnii3wQSfI" }, "outputs": [], "source": [ "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "BBvXQhneQSfK" }, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "qDQLX3PArmh8" }, "source": [ "# **dino-mast3r-gs**\n", "#### **Gaussian Splat via Biplet-Square Normalization, DINO, MASt３R**
\n" ] }, { "cell_type": "markdown", "metadata": { "id": "g0gLgqSzQSfL" }, "source": [ "https://www.kaggle.com/code/stpeteishii/british-museum-dino-lightglue-colmap-gs-12" ] }, { "cell_type": "markdown", "metadata": { "id": "qZtYJZJaQSfM" }, "source": [ "\n", "## Key Features of This Pipeline\n", "\n", "* **Utilization of MASt3R**: Employs the new **MASt3R** model, which achieved outstanding results at **IMC2025** (Image Matching Challenge 2025).\n", "* **Process Integration**: MASt3R handles the tasks previously managed by the **ALIKED, LightGlue, and COLMAP** workflow mentioned in the previous notes.\n", "* **Pipeline Workflow**: The updated data flow follows this sequence:\n", "**Normalize → DINO → MASt3R → Gaussian Splatting**.\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "W7O6kI6eQSfM" }, "source": [ "\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "TzXf_eTxQsqq", "outputId": "12c1f4ef-1dd5-4457-8c67-83b1367bb75d" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Mounted at /content/drive\n" ] } ], "source": [ "from google.colab import drive\n", "drive.mount('/content/drive')" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "gfxyotuCQSfM", "outputId": "4697c769-5f34-4d25-f190-81206be2e55f" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Collecting pycolmap\n", " Downloading pycolmap-3.13.0-cp312-cp312-manylinux_2_28_x86_64.whl.metadata (10 kB)\n", "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from pycolmap) (2.0.2)\n", "Downloading pycolmap-3.13.0-cp312-cp312-manylinux_2_28_x86_64.whl (20.3 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m20.3/20.3 MB\u001b[0m \u001b[31m21.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hInstalling collected packages: pycolmap\n", "Successfully installed pycolmap-3.13.0\n" ] } ], "source": [ "!pip install pycolmap" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "BW8ssNQ0QSfM" }, "outputs": [], "source": [ "# MASt3R-based Gaussian Splatting Pipeline\n", "# Preserves: DINO pair selection + Biplet-Square Normalization\n", "# Replaces: ALIKED/LightGlue/COLMAP with MASt3R\n", "\n", "import os\n", "import sys\n", "import gc\n", "import h5py\n", "import numpy as np\n", "import torch\n", "import torch.nn.functional as F\n", "from tqdm import tqdm\n", "from pathlib import Path\n", "import subprocess\n", "from PIL import Image, ImageFilter\n", "import pycolmap\n", "import struct\n", "\n", "# Transformers for DINO\n", "from transformers import AutoImageProcessor, AutoModel\n", "\n", "# ============================================================================\n", "# Configuration\n", "# ============================================================================\n", "class Config:\n", " # Feature extraction\n", " N_KEYPOINTS = 8192\n", " IMAGE_SIZE = 1024\n", "\n", " # Pair selection - CRITICAL for memory\n", " GLOBAL_TOPK = 20 # Reduced from 50 - each image pairs with top 20\n", " MIN_MATCHES = 10\n", " RATIO_THR = 1.2\n", "\n", " # Paths\n", " DINO_MODEL = \"facebook/dinov2-base\"\n", "\n", " # MASt3R - Reduced size for memory\n", " MAST3R_MODEL = \"/content/mast3r/checkpoints/MASt3R_ViTLarge_BaseDecoder_512_catmlpdpt_metric.pth\"\n", " MAST3R_IMAGE_SIZE = 224 # Small size to save memory\n", "\n", " # Device\n", " DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "\n", "# ============================================================================\n", "# Memory Management Utilities\n", "# ============================================================================\n", "\n", "def clear_memory():\n", " \"\"\"Aggressively clear GPU and CPU memory\"\"\"\n", " gc.collect()\n", " if torch.cuda.is_available():\n", " torch.cuda.empty_cache()\n", " torch.cuda.synchronize()\n", "\n", "def get_memory_info():\n", " \"\"\"Get current memory usage\"\"\"\n", " if torch.cuda.is_available():\n", " allocated = torch.cuda.memory_allocated() / 1024**3\n", " reserved = torch.cuda.memory_reserved() / 1024**3\n", " print(f\"GPU Memory - Allocated: {allocated:.2f}GB, Reserved: {reserved:.2f}GB\")\n", "\n", " import psutil\n", " cpu_mem = psutil.virtual_memory().percent\n", " print(f\"CPU Memory Usage: {cpu_mem:.1f}%\")\n", "\n", "# ============================================================================\n", "# Environment Setup\n", "# ============================================================================\n", "\n", "def run_cmd(cmd, check=True, capture=False):\n", " \"\"\"Run command with better error handling\"\"\"\n", " print(f\"Running: {' '.join(cmd)}\")\n", " result = subprocess.run(\n", " cmd,\n", " capture_output=capture,\n", " text=True,\n", " check=False\n", " )\n", " if check and result.returncode != 0:\n", " print(f\"❌ Command failed with code {result.returncode}\")\n", " if capture:\n", " print(f\"STDOUT: {result.stdout}\")\n", " print(f\"STDERR: {result.stderr}\")\n", " return result\n", "\n", "\n", "def setup_base_environment():\n", " \"\"\"Setup base Python environment\"\"\"\n", " print(\"\\n=== Setting up Base Environment ===\")\n", "\n", " # NumPy fix for Python 3.12\n", " print(\"\\n📦 Fixing NumPy...\")\n", " run_cmd([sys.executable, \"-m\", \"pip\", \"uninstall\", \"-y\", \"numpy\"])\n", " run_cmd([sys.executable, \"-m\", \"pip\", \"install\", \"numpy==1.26.4\"])\n", "\n", " # PyTorch\n", " print(\"\\n📦 Installing PyTorch...\")\n", " run_cmd([\n", " sys.executable, \"-m\", \"pip\", \"install\",\n", " \"torch\", \"torchvision\", \"torchaudio\"\n", " ])\n", "\n", " # Core utilities\n", " print(\"\\n📦 Installing core utilities...\")\n", " run_cmd([\n", " sys.executable, \"-m\", \"pip\", \"install\",\n", " \"opencv-python\",\n", " \"pillow\",\n", " \"imageio\",\n", " \"imageio-ffmpeg\",\n", " \"plyfile\",\n", " \"tqdm\",\n", " \"tensorboard\",\n", " \"scipy\", # for rotation conversions and image resizing\n", " \"psutil\" # for memory monitoring\n", " ])\n", "\n", " # Transformers for DINO\n", " print(\"\\n📦 Installing transformers...\")\n", " run_cmd([\n", " sys.executable, \"-m\", \"pip\", \"install\",\n", " \"transformers==4.40.0\"\n", " ])\n", "\n", " # pycolmap for COLMAP format\n", " print(\"\\n📦 Installing pycolmap...\")\n", " run_cmd([sys.executable, \"-m\", \"pip\", \"install\", \"pycolmap\"])\n", "\n", " print(\"✓ Base environment setup complete!\")\n", "\n", "\n", "def setup_mast3r():\n", " \"\"\"Install and setup MASt3R\"\"\"\n", " print(\"\\n=== Setting up MASt3R ===\")\n", "\n", " os.chdir('/content')\n", "\n", " # Remove existing installation\n", " if os.path.exists('mast3r'):\n", " print(\"Removing existing MASt3R installation...\")\n", " os.system('rm -rf mast3r')\n", "\n", " # Clone repository\n", " print(\"Cloning MASt3R repository...\")\n", " os.system('git clone --recursive https://github.com/naver/mast3r')\n", " os.chdir('/content/mast3r')\n", "\n", " # Check dust3r directory\n", " print(\"Checking dust3r structure...\")\n", " os.system('ls -la dust3r/')\n", "\n", " # Install dust3r\n", " print(\"Installing dust3r...\")\n", " os.system('cd dust3r && python -m pip install -e .')\n", "\n", " # Install croco\n", " print(\"Installing croco...\")\n", " os.system('cd dust3r/croco && python -m pip install -e .')\n", "\n", " # Install requirements\n", " print(\"Installing MASt3R requirements...\")\n", " os.system('pip install -r requirements.txt')\n", "\n", " # Download model weights\n", " print(\"Downloading model weights...\")\n", " os.system('mkdir -p checkpoints')\n", " os.system('wget -P checkpoints/ https://download.europe.naverlabs.com/ComputerVision/MASt3R/MASt3R_ViTLarge_BaseDecoder_512_catmlpdpt_metric.pth')\n", "\n", " # Install additional dependencies\n", " print(\"Installing additional dependencies...\")\n", " os.system('pip install trimesh matplotlib roma')\n", "\n", " # Add to path\n", " sys.path.insert(0, '/content/mast3r')\n", " sys.path.insert(0, '/content/mast3r/dust3r')\n", "\n", " # Verification\n", " print(\"\\n🔍 Verifying MASt3R installation...\")\n", " try:\n", " from mast3r.model import AsymmetricMASt3R\n", " print(\" ✓ MASt3R import: OK\")\n", " except Exception as e:\n", " print(f\" ❌ MASt3R import failed: {e}\")\n", " raise\n", "\n", " print(\"✓ MASt3R setup complete!\")\n", "\n", "# ============================================================================\n", "# Step 0: Biplet-Square Normalization (PRESERVED FROM ORIGINAL)\n", "# ============================================================================\n", "\n", "def normalize_image_sizes_biplet(input_dir, output_dir=None, size=1024):\n", " \"\"\"\n", " Generates two square crops (Left & Right or Top & Bottom)\n", " from each image in a directory.\n", " \"\"\"\n", " if output_dir is None:\n", " output_dir = input_dir\n", "\n", " os.makedirs(output_dir, exist_ok=True)\n", "\n", " print(f\"Generating 2 cropped squares (Left/Right or Top/Bottom) for each image...\")\n", " print()\n", "\n", " converted_count = 0\n", " size_stats = {}\n", "\n", " for img_file in sorted(os.listdir(input_dir)):\n", " if not img_file.lower().endswith(('.jpg', '.jpeg', '.png')):\n", " continue\n", "\n", " input_path = os.path.join(input_dir, img_file)\n", "\n", " try:\n", " img = Image.open(input_path)\n", " original_size = img.size\n", "\n", " size_key = f\"{original_size[0]}x{original_size[1]}\"\n", " size_stats[size_key] = size_stats.get(size_key, 0) + 1\n", "\n", " # Generate 2 crops\n", " crops = generate_two_crops(img, size)\n", "\n", " base_name, ext = os.path.splitext(img_file)\n", " for mode, cropped_img in crops.items():\n", " output_path = os.path.join(output_dir, f\"{base_name}_{mode}{ext}\")\n", " cropped_img.save(output_path, quality=95)\n", "\n", " converted_count += 1\n", " print(f\" ✓ {img_file}: {original_size} → 2 square images generated\")\n", "\n", " except Exception as e:\n", " print(f\" ✗ Error processing {img_file}: {e}\")\n", "\n", " print(f\"\\nProcessing complete: {converted_count} source images processed\")\n", " print(f\"Original size distribution: {size_stats}\")\n", " return converted_count\n", "\n", "\n", "def generate_two_crops(img, size):\n", " \"\"\"\n", " Crops the image into a square and returns 2 variations\n", " (Left/Right for landscape, Top/Bottom for portrait).\n", " \"\"\"\n", " width, height = img.size\n", " crop_size = min(width, height)\n", " crops = {}\n", "\n", " if width > height:\n", " # Landscape → Left & Right\n", " positions = {\n", " 'left': 0,\n", " 'right': width - crop_size\n", " }\n", " for mode, x_offset in positions.items():\n", " box = (x_offset, 0, x_offset + crop_size, crop_size)\n", " crops[mode] = img.crop(box).resize(\n", " (size, size),\n", " Image.Resampling.LANCZOS\n", " )\n", "\n", " else:\n", " # Portrait or Square → Top & Bottom\n", " positions = {\n", " 'top': 0,\n", " 'bottom': height - crop_size\n", " }\n", " for mode, y_offset in positions.items():\n", " box = (0, y_offset, crop_size, y_offset + crop_size)\n", " crops[mode] = img.crop(box).resize(\n", " (size, size),\n", " Image.Resampling.LANCZOS\n", " )\n", "\n", " return crops\n", "\n", "# ============================================================================\n", "# Step 1: DINO-based Pair Selection (PRESERVED FROM ORIGINAL)\n", "# ============================================================================\n", "\n", "def load_torch_image(fname, device):\n", " \"\"\"Load image as torch tensor\"\"\"\n", " import torchvision.transforms as T\n", "\n", " img = Image.open(fname).convert('RGB')\n", " transform = T.Compose([\n", " T.ToTensor(),\n", " ])\n", " return transform(img).unsqueeze(0).to(device)\n", "\n", "def extract_dino_global(image_paths, model_path, device):\n", " \"\"\"Extract DINO global descriptors with memory management\"\"\"\n", " print(\"\\n=== Extracting DINO Global Features ===\")\n", " print(\"Initial memory state:\")\n", " get_memory_info()\n", "\n", " processor = AutoImageProcessor.from_pretrained(model_path)\n", " model = AutoModel.from_pretrained(model_path).eval().to(device)\n", "\n", " global_descs = []\n", " batch_size = 4 # Small batch to save memory\n", "\n", " for i in tqdm(range(0, len(image_paths), batch_size)):\n", " batch_paths = image_paths[i:i+batch_size]\n", " batch_imgs = []\n", "\n", " for img_path in batch_paths:\n", " img = load_torch_image(img_path, device)\n", " batch_imgs.append(img)\n", "\n", " batch_tensor = torch.cat(batch_imgs, dim=0)\n", "\n", " with torch.no_grad():\n", " inputs = processor(images=batch_tensor, return_tensors=\"pt\", do_rescale=False).to(device)\n", " outputs = model(**inputs)\n", " desc = F.normalize(outputs.last_hidden_state[:, 1:].max(dim=1)[0], dim=1, p=2)\n", " global_descs.append(desc.cpu())\n", "\n", " # Clear batch memory\n", " del batch_tensor, inputs, outputs, desc\n", " clear_memory()\n", "\n", " global_descs = torch.cat(global_descs, dim=0)\n", "\n", " del model, processor\n", " clear_memory()\n", "\n", " print(\"After DINO extraction:\")\n", " get_memory_info()\n", "\n", " return global_descs\n", "\n", "def build_topk_pairs(global_feats, k, device):\n", " \"\"\"Build top-k similar pairs from global features\"\"\"\n", " g = global_feats.to(device)\n", " sim = g @ g.T\n", " sim.fill_diagonal_(-1)\n", "\n", " N = sim.size(0)\n", " k = min(k, N - 1)\n", "\n", " topk_indices = torch.topk(sim, k, dim=1).indices.cpu()\n", "\n", " pairs = []\n", " for i in range(N):\n", " for j in topk_indices[i]:\n", " j = j.item()\n", " if i < j:\n", " pairs.append((i, j))\n", "\n", " # Remove duplicates\n", " pairs = list(set(pairs))\n", "\n", " return pairs\n", "\n", "def select_diverse_pairs(pairs, max_pairs, num_images):\n", " \"\"\"\n", " Select diverse pairs to ensure good image coverage\n", " Strategy: Select pairs that maximize image coverage\n", " \"\"\"\n", " import random\n", " random.seed(42)\n", "\n", " if len(pairs) <= max_pairs:\n", " return pairs\n", "\n", " print(f\"Selecting {max_pairs} diverse pairs from {len(pairs)} candidates...\")\n", "\n", " # Count how many times each image appears in pairs\n", " image_counts = {i: 0 for i in range(num_images)}\n", " for i, j in pairs:\n", " image_counts[i] += 1\n", " image_counts[j] += 1\n", "\n", " # Sort pairs by: prefer pairs with less-connected images\n", " def pair_score(pair):\n", " i, j = pair\n", " # Lower score = images appear in fewer pairs = more diverse\n", " return image_counts[i] + image_counts[j]\n", "\n", " pairs_scored = [(pair, pair_score(pair)) for pair in pairs]\n", " pairs_scored.sort(key=lambda x: x[1])\n", "\n", " # Select pairs greedily to maximize coverage\n", " selected = []\n", " selected_images = set()\n", "\n", " # Phase 1: Select pairs that add new images (greedy coverage)\n", " for pair, score in pairs_scored:\n", " if len(selected) >= max_pairs:\n", " break\n", " i, j = pair\n", " # Prefer pairs that include new images\n", " if i not in selected_images or j not in selected_images:\n", " selected.append(pair)\n", " selected_images.add(i)\n", " selected_images.add(j)\n", "\n", " # Phase 2: Fill remaining slots with high-similarity pairs\n", " if len(selected) < max_pairs:\n", " remaining = [p for p, s in pairs_scored if p not in selected]\n", " random.shuffle(remaining)\n", " selected.extend(remaining[:max_pairs - len(selected)])\n", "\n", " print(f\"Selected pairs cover {len(selected_images)} / {num_images} images ({100*len(selected_images)/num_images:.1f}%)\")\n", "\n", " return selected\n", "\n", "def get_image_pairs_dino(image_paths, max_pairs=None):\n", " \"\"\"DINO-based pair selection with intelligent limiting\"\"\"\n", " device = Config.DEVICE\n", "\n", " # DINO global features\n", " global_feats = extract_dino_global(image_paths, Config.DINO_MODEL, device)\n", " pairs = build_topk_pairs(global_feats, Config.GLOBAL_TOPK, device)\n", "\n", " print(f\"Initial pairs from DINO: {len(pairs)}\")\n", "\n", " # Apply intelligent pair selection if limit specified\n", " if max_pairs and len(pairs) > max_pairs:\n", " pairs = select_diverse_pairs(pairs, max_pairs, len(image_paths))\n", "\n", " return pairs\n", "\n", "# ============================================================================\n", "# Step 2: MASt3R Reconstruction (REPLACES ALIKED/LIGHTGLUE/COLMAP)\n", "# ============================================================================\n", "\n", "def load_mast3r_model(device='cuda'):\n", " \"\"\"Load MASt3R model\"\"\"\n", " from mast3r.model import AsymmetricMASt3R\n", "\n", " model = AsymmetricMASt3R.from_pretrained(Config.MAST3R_MODEL).to(device)\n", " model.eval()\n", "\n", " print(f\"✓ MASt3R model loaded on {device}\")\n", " return model\n", "\n", "def load_images_for_mast3r(image_paths, size=224):\n", " \"\"\"Load images using DUSt3R's format with reduced size\"\"\"\n", " print(f\"\\n=== Loading images for MASt3R (size={size}) ===\")\n", "\n", " from dust3r.utils.image import load_images\n", "\n", " # Load images using DUSt3R's loader with reduced size\n", " images = load_images(image_paths, size=size, verbose=True)\n", "\n", " return images\n", "\n", "def run_mast3r_pairs(model, image_paths, pairs, device='cuda', batch_size=1, max_pairs=None):\n", " \"\"\"Run MASt3R on selected pairs with memory management\"\"\"\n", " print(\"\\n=== Running MASt3R Reconstruction ===\")\n", " print(\"Initial memory state:\")\n", " get_memory_info()\n", "\n", " from dust3r.inference import inference\n", " from dust3r.cloud_opt import global_aligner, GlobalAlignerMode\n", "\n", " # Limit number of pairs if specified\n", " if max_pairs and len(pairs) > max_pairs:\n", " print(f\"Limiting pairs from {len(pairs)} to {max_pairs}\")\n", " # Select pairs more evenly distributed\n", " step = max(1, len(pairs) // max_pairs)\n", " pairs = pairs[::step][:max_pairs]\n", "\n", " print(f\"Processing {len(pairs)} pairs...\")\n", "\n", " # Load images in smaller size\n", " print(f\"Loading {len(image_paths)} images at {Config.MAST3R_IMAGE_SIZE}x{Config.MAST3R_IMAGE_SIZE}...\")\n", " images = load_images_for_mast3r(image_paths, size=Config.MAST3R_IMAGE_SIZE)\n", "\n", " print(f\"Loaded {len(images)} images\")\n", " print(\"After loading images:\")\n", " get_memory_info()\n", "\n", " # Create all image pairs at once\n", " print(f\"Creating {len(pairs)} image pairs...\")\n", " mast3r_pairs = []\n", " for idx1, idx2 in tqdm(pairs, desc=\"Preparing pairs\"):\n", " mast3r_pairs.append((images[idx1], images[idx2]))\n", "\n", " print(f\"Running MASt3R inference on {len(mast3r_pairs)} pairs...\")\n", "\n", " # Run inference (this returns the dict format we need)\n", " output = inference(mast3r_pairs, model, device, batch_size=batch_size, verbose=True)\n", "\n", " # Clear pairs from memory\n", " del mast3r_pairs\n", " clear_memory()\n", "\n", " print(\"✓ MASt3R inference complete\")\n", " print(\"After inference:\")\n", " get_memory_info()\n", "\n", " # Global alignment\n", " print(\"Running global alignment...\")\n", " scene = global_aligner(\n", " output,\n", " device=device,\n", " mode=GlobalAlignerMode.PointCloudOptimizer\n", " )\n", "\n", " # Clear output after creating scene\n", " del output\n", " clear_memory()\n", "\n", " print(\"Computing global alignment...\")\n", " loss = scene.compute_global_alignment(\n", " init=\"mst\",\n", " niter=150, # Reduced from 300\n", " schedule='cosine',\n", " lr=0.01\n", " )\n", "\n", " print(f\"✓ Global alignment complete (final loss: {loss:.6f})\")\n", " print(\"Final memory state:\")\n", " get_memory_info()\n", "\n", " return scene, images" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "3jaKQxcDQSfN" }, "outputs": [], "source": [ "def extract_colmap_data(scene, image_paths, max_points=1000000):\n", " \"\"\"\n", " Extract COLMAP-compatible camera parameters and 3D points from MASt3R scene\n", "\n", " Args:\n", " scene: MASt3R scene object\n", " image_paths: List of image paths\n", " max_points: Maximum number of 3D points to extract (default: 1M)\n", " \"\"\"\n", " print(\"\\n=== Extracting COLMAP-compatible data ===\")\n", "\n", " # Extract point cloud\n", " pts_all = scene.get_pts3d()\n", " print(f\"pts_all type: {type(pts_all)}\")\n", "\n", " if isinstance(pts_all, list):\n", " print(f\"pts_all is a list with {len(pts_all)} elements\")\n", " if len(pts_all) > 0:\n", " print(f\"First element type: {type(pts_all[0])}\")\n", " if hasattr(pts_all[0], 'shape'):\n", " print(f\"First element shape: {pts_all[0].shape}\")\n", "\n", " pts_all = torch.stack([p if isinstance(p, torch.Tensor) else torch.tensor(p)\n", " for p in pts_all])\n", " print(f\"pts_all shape after conversion: {pts_all.shape}\")\n", "\n", " if len(pts_all.shape) == 4:\n", " print(f\"Found batched point cloud: {pts_all.shape}\")\n", " B, H, W, _ = pts_all.shape\n", " pts3d = pts_all.reshape(-1, 3).detach().cpu().numpy()\n", "\n", " # Extract colors\n", " colors = []\n", " for img_path in image_paths:\n", " img = Image.open(img_path).resize((W, H))\n", " colors.append(np.array(img))\n", " colors = np.stack(colors).reshape(-1, 3) / 255.0\n", " else:\n", " pts3d = pts_all.detach().cpu().numpy() if isinstance(pts_all, torch.Tensor) else pts_all\n", " colors = np.ones((len(pts3d), 3)) * 0.5\n", "\n", " print(f\"✓ Extracted {len(pts3d)} 3D points from {len(image_paths)} images\")\n", "\n", " # **DOWNSAMPLE POINTS TO REDUCE MEMORY USAGE**\n", " if len(pts3d) > max_points:\n", " print(f\"\\n⚠ Downsampling from {len(pts3d)} to {max_points} points to reduce memory usage...\")\n", "\n", " # Remove invalid points first\n", " valid_mask = ~(np.isnan(pts3d).any(axis=1) | np.isinf(pts3d).any(axis=1))\n", " pts3d_valid = pts3d[valid_mask]\n", " colors_valid = colors[valid_mask]\n", "\n", " # Random sampling\n", " indices = np.random.choice(len(pts3d_valid), size=max_points, replace=False)\n", " pts3d = pts3d_valid[indices]\n", " colors = colors_valid[indices]\n", "\n", " print(f\"✓ Downsampled to {len(pts3d)} points\")\n", "\n", " # Extract camera parameters\n", " print(\"Extracting camera parameters...\")\n", "\n", " # 【重要】MASt3Rのポーズはcamera-to-world形式\n", " # COLMAPはworld-to-camera形式を要求するので逆行列が必要\n", " poses_c2w = scene.get_im_poses().detach().cpu().numpy()\n", " print(f\"Retrieved camera-to-world poses: shape {poses_c2w.shape}\")\n", "\n", " # camera-to-world を world-to-camera に変換\n", " poses = []\n", " for i, pose_c2w in enumerate(poses_c2w):\n", " # 4x4行列の逆行列を計算\n", " pose_w2c = np.linalg.inv(pose_c2w)\n", " poses.append(pose_w2c)\n", "\n", " poses = np.array(poses)\n", " print(f\"Converted to world-to-camera poses for COLMAP\")\n", "\n", " # 焦点距離と主点を取得\n", " focals = scene.get_focals().detach().cpu().numpy()\n", " pp = scene.get_principal_points().detach().cpu().numpy()\n", " print(f\"Focals shape: {focals.shape}\")\n", " print(f\"Principal points shape: {pp.shape}\")\n", "\n", " # MASt3Rの処理サイズ（通常224x224）\n", " mast3r_size = 224.0\n", "\n", " cameras = []\n", " for i, img_path in enumerate(image_paths):\n", " img = Image.open(img_path)\n", " W, H = img.size\n", "\n", " # 元画像サイズとのスケール比\n", " scale = W / mast3r_size\n", "\n", " # focalsは[N,1]の形式（fx=fyの等方性カメラ）\n", " if focals.shape[1] == 1:\n", " focal_mast3r = float(focals[i, 0])\n", " fx = fy = focal_mast3r * scale\n", " else:\n", " fx = float(focals[i, 0]) * scale\n", " fy = float(focals[i, 1]) * scale\n", "\n", " # 主点もスケーリング\n", " cx = float(pp[i, 0]) * scale\n", " cy = float(pp[i, 1]) * scale\n", "\n", " camera = {\n", " 'camera_id': i + 1,\n", " 'model': 'PINHOLE',\n", " 'width': W,\n", " 'height': H,\n", " 'params': [fx, fy, cx, cy]\n", " }\n", " cameras.append(camera)\n", "\n", " if i == 0:\n", " print(f\"\\nExample camera 0:\")\n", " print(f\" Image size: {W}x{H}\")\n", " print(f\" MASt3R focal: {focal_mast3r:.2f}, pp: ({pp[i,0]:.2f}, {pp[i,1]:.2f})\")\n", " print(f\" Scaled fx={fx:.2f}, fy={fy:.2f}, cx={cx:.2f}, cy={cy:.2f}\")\n", " print(f\" Pose (first row): {poses[i][0]}\")\n", "\n", " print(f\"\\n✓ Extracted {len(cameras)} cameras and {len(poses)} poses\")\n", "\n", " return pts3d, colors, cameras, poses" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "id": "vXQ7EHrrQSfO" }, "outputs": [], "source": [ "import struct\n", "from pathlib import Path\n", "\n", "def save_colmap_reconstruction(pts3d, colors, cameras, poses, image_paths, output_dir):\n", " \"\"\"Save reconstruction in COLMAP binary format by writing files directly\"\"\"\n", " print(\"\\n=== Saving COLMAP reconstruction ===\")\n", "\n", " sparse_dir = Path(output_dir) / 'sparse' / '0'\n", " sparse_dir.mkdir(parents=True, exist_ok=True)\n", "\n", " print(f\" Writing COLMAP files directly to {sparse_dir}...\")\n", "\n", " # Write cameras.bin\n", " write_cameras_binary(cameras, sparse_dir / 'cameras.bin')\n", " print(f\" ✓ Wrote {len(cameras)} cameras\")\n", "\n", " # Write images.bin\n", " write_images_binary(image_paths, cameras, poses, sparse_dir / 'images.bin')\n", " print(f\" ✓ Wrote {len(image_paths)} images\")\n", "\n", " # Write points3D.bin\n", " num_points = write_points3d_binary(pts3d, colors, sparse_dir / 'points3D.bin')\n", " print(f\" ✓ Wrote {num_points} 3D points\")\n", "\n", " print(f\"\\n✓ COLMAP reconstruction saved to {sparse_dir}\")\n", " print(f\" Cameras: {len(cameras)}\")\n", " print(f\" Images: {len(image_paths)}\")\n", " print(f\" Points: {num_points}\")\n", "\n", " return sparse_dir\n", "\n", "\n", "def write_cameras_binary(cameras, output_file):\n", " \"\"\"Write cameras.bin in COLMAP binary format\"\"\"\n", " with open(output_file, 'wb') as f:\n", " # Write number of cameras\n", " f.write(struct.pack('Q', len(cameras)))\n", "\n", " for i, cam in enumerate(cameras):\n", " camera_id = cam.get('camera_id', i + 1)\n", "\n", " # Model ID: 1 = PINHOLE\n", " model_id = 1\n", " width = cam['width']\n", " height = cam['height']\n", " params = cam['params'] # [fx, fy, cx, cy]\n", "\n", " f.write(struct.pack('i', camera_id))\n", " f.write(struct.pack('i', model_id))\n", " f.write(struct.pack('Q', width))\n", " f.write(struct.pack('Q', height))\n", "\n", " # Write 4 parameters for PINHOLE model\n", " for param in params[:4]:\n", " f.write(struct.pack('d', param))\n", "\n", "\n", "def write_images_binary(image_paths, cameras, poses, output_file):\n", " \"\"\"Write images.bin in COLMAP binary format\"\"\"\n", " with open(output_file, 'wb') as f:\n", " # Write number of images\n", " f.write(struct.pack('Q', len(image_paths)))\n", "\n", " for i, (img_path, pose) in enumerate(zip(image_paths, poses)):\n", " image_id = i + 1\n", " camera_id = cameras[i].get('camera_id', i + 1)\n", " image_name = os.path.basename(img_path)\n", "\n", " # Extract rotation and translation\n", " R = pose[:3, :3]\n", " t = pose[:3, 3]\n", "\n", " # Convert rotation matrix to quaternion [w, x, y, z]\n", " qvec = rotmat2qvec(R)\n", " tvec = t\n", "\n", " # Write image data\n", " f.write(struct.pack('i', image_id))\n", "\n", " # Write quaternion (4 doubles)\n", " for q in qvec:\n", " f.write(struct.pack('d', float(q)))\n", "\n", " # Write translation vector (3 doubles)\n", " for tv in tvec:\n", " f.write(struct.pack('d', float(tv)))\n", "\n", " # Write camera ID\n", " f.write(struct.pack('i', camera_id))\n", "\n", " # Write image name (null-terminated string)\n", " f.write(image_name.encode('utf-8') + b'\\x00')\n", "\n", " # Write number of 2D points (0 for now, as we don't have 2D-3D correspondences)\n", " f.write(struct.pack('Q', 0))\n", "\n", "\n", "def write_points3d_binary(pts3d, colors, output_file):\n", " \"\"\"Write points3D.bin in COLMAP binary format\"\"\"\n", " # Filter out invalid points\n", " valid_indices = []\n", " for i, pt in enumerate(pts3d):\n", " if not (np.isnan(pt).any() or np.isinf(pt).any()):\n", " valid_indices.append(i)\n", "\n", " with open(output_file, 'wb') as f:\n", " # Write number of points\n", " f.write(struct.pack('Q', len(valid_indices)))\n", "\n", " for idx, point_id in enumerate(valid_indices):\n", " pt = pts3d[point_id]\n", " color = colors[point_id]\n", "\n", " # Write point3D ID\n", " f.write(struct.pack('Q', point_id))\n", "\n", " # Write XYZ coordinates (3 doubles)\n", " for coord in pt:\n", " f.write(struct.pack('d', float(coord)))\n", "\n", " # Write RGB color (3 unsigned chars)\n", " col_int = (color * 255).astype(np.uint8)\n", " for c in col_int:\n", " f.write(struct.pack('B', int(c)))\n", "\n", " # Write error (1 double) - set to 0\n", " f.write(struct.pack('d', 0.0))\n", "\n", " # Write track length (number of images seeing this point)\n", " # Set to 0 as we don't have track information\n", " f.write(struct.pack('Q', 0))\n", "\n", " # Progress indicator\n", " if (idx + 1) % 1000000 == 0:\n", " print(f\" Wrote {idx + 1} / {len(valid_indices)} points...\")\n", "\n", " return len(valid_indices)\n", "\n", "\n", "def rotmat2qvec(R):\n", " \"\"\"\n", " Convert rotation matrix to quaternion in COLMAP format [w, x, y, z]\n", "\n", " Args:\n", " R: 3x3 rotation matrix\n", "\n", " Returns:\n", " qvec: quaternion [w, x, y, z]\n", " \"\"\"\n", " # Ensure R is a numpy array\n", " R = np.asarray(R, dtype=np.float64)\n", "\n", " # Calculate trace\n", " trace = np.trace(R)\n", "\n", " if trace > 0:\n", " s = 0.5 / np.sqrt(trace + 1.0)\n", " w = 0.25 / s\n", " x = (R[2, 1] - R[1, 2]) * s\n", " y = (R[0, 2] - R[2, 0]) * s\n", " z = (R[1, 0] - R[0, 1]) * s\n", " elif R[0, 0] > R[1, 1] and R[0, 0] > R[2, 2]:\n", " s = 2.0 * np.sqrt(1.0 + R[0, 0] - R[1, 1] - R[2, 2])\n", " w = (R[2, 1] - R[1, 2]) / s\n", " x = 0.25 * s\n", " y = (R[0, 1] + R[1, 0]) / s\n", " z = (R[0, 2] + R[2, 0]) / s\n", " elif R[1, 1] > R[2, 2]:\n", " s = 2.0 * np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2])\n", " w = (R[0, 2] - R[2, 0]) / s\n", " x = (R[0, 1] + R[1, 0]) / s\n", " y = 0.25 * s\n", " z = (R[1, 2] + R[2, 1]) / s\n", " else:\n", " s = 2.0 * np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1])\n", " w = (R[1, 0] - R[0, 1]) / s\n", " x = (R[0, 2] + R[2, 0]) / s\n", " y = (R[1, 2] + R[2, 1]) / s\n", " z = 0.25 * s\n", "\n", " qvec = np.array([w, x, y, z], dtype=np.float64)\n", "\n", " # Normalize\n", " qvec = qvec / np.linalg.norm(qvec)\n", "\n", " return qvec" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "C0khcLW5QSfO" }, "outputs": [], "source": [ "# ============================================================================\n", "# Step 3: Gaussian Splatting Training\n", "# ============================================================================\n", "\n", "def setup_gaussian_splatting():\n", " \"\"\"Setup Gaussian Splatting\"\"\"\n", " print(\"\\n=== Setting up Gaussian Splatting ===\")\n", "\n", " os.chdir('/content')\n", "\n", " WORK_DIR = \"gaussian-splatting\"\n", "\n", " if not os.path.exists(WORK_DIR):\n", " print(\"Cloning Gaussian Splatting repository...\")\n", " run_cmd([\n", " \"git\", \"clone\", \"--recursive\",\n", " \"https://github.com/graphdeco-inria/gaussian-splatting.git\",\n", " WORK_DIR\n", " ])\n", " else:\n", " print(\"✓ Repository already exists\")\n", "\n", " os.chdir(WORK_DIR)\n", "\n", " # Install requirements\n", " print(\"Installing Gaussian Splatting requirements...\")\n", " run_cmd([sys.executable, \"-m\", \"pip\", \"install\", \"-r\", \"requirements.txt\"])\n", "\n", " # Build submodules\n", " print(\"\\n📦 Building Gaussian Splatting submodules...\")\n", "\n", " submodules = {\n", " \"diff-gaussian-rasterization\":\n", " \"https://github.com/graphdeco-inria/diff-gaussian-rasterization.git\",\n", " \"simple-knn\":\n", " \"https://github.com/camenduru/simple-knn.git\"\n", " }\n", "\n", " for name, repo in submodules.items():\n", " print(f\"\\n📦 Installing {name}...\")\n", " path = os.path.join(\"submodules\", name)\n", " if not os.path.exists(path):\n", " run_cmd([\"git\", \"clone\", repo, path])\n", " run_cmd([sys.executable, \"-m\", \"pip\", \"install\", path])\n", "\n", " print(\"✓ Gaussian Splatting setup complete!\")\n", "\n", "\n", "def train_gaussian_splatting(colmap_dir, image_dir, output_dir, iterations=2000):\n", " \"\"\"Train Gaussian Splatting model\"\"\"\n", " print(\"\\n\" + \"=\"*70)\n", " print(\"Step 6: Training Gaussian Splatting\")\n", " print(\"=\"*70)\n", "\n", " print(\"\\n=== Training Gaussian Splatting ===\")\n", "\n", " # Reduce memory usage with smaller resolution\n", " cmd = [\n", " 'python', 'train.py',\n", " '-s', colmap_dir,\n", " '--images', image_dir,\n", " '-m', output_dir,\n", " '--iterations', str(iterations),\n", " '--test_iterations', '1000', str(iterations),\n", " '--save_iterations', '1000', str(iterations),\n", " '--resolution', '2', # Reduce resolution to 1/2\n", " '--densify_grad_threshold', '0.001', # Higher threshold = fewer Gaussians\n", " '--densification_interval', '200', # Less frequent densification\n", " '--opacity_reset_interval', '5000', # Less frequent reset\n", " ]\n", "\n", " print(f\"Command: {' '.join(cmd)}\\n\")\n", "\n", " result = subprocess.run(\n", " cmd,\n", " cwd='/content/gaussian-splatting',\n", " capture_output=True,\n", " text=True\n", " )\n", "\n", " print(result.stdout)\n", " if result.stderr:\n", " print(\"STDERR:\", result.stderr)\n", "\n", " if result.returncode != 0:\n", " raise RuntimeError(\"Gaussian Splatting training failed\")\n", "\n", " # Check output\n", " if not os.path.exists(os.path.join(output_dir, f'point_cloud/iteration_{iterations}/point_cloud.ply')):\n", " raise RuntimeError(f\"Expected output not found at iteration {iterations}\")\n", "\n", " print(f\"\\n✓ Gaussian Splatting training completed successfully\")\n", " print(f\" Output: {output_dir}\")\n", "\n", " return output_dir" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "utQCdljBQSfO" }, "outputs": [], "source": [ "# ============================================================================\n", "# Main Pipeline\n", "# ============================================================================\n", "def main_pipeline(image_dir, output_dir, square_size=224, iterations=2000,\n", " max_images=None, max_pairs=10000, max_points=100000):\n", " \"\"\"\n", " Main pipeline for DINO matching -> MASt3R -> Gaussian Splatting\n", "\n", " Args:\n", " image_dir: Directory containing input images\n", " output_dir: Directory for output files\n", " square_size: Size to resize images for processing\n", " iterations: Number of training iterations\n", " max_images: Maximum number of images to process (None = all)\n", " max_pairs: Maximum number of image pairs for matching\n", " max_points: Maximum number of 3D points to extract (default: 1M)\n", " \"\"\"\n", " os.makedirs(output_dir, exist_ok=True)\n", "\n", " setup_base_environment()\n", " clear_memory()\n", "\n", " setup_mast3r()\n", " clear_memory()\n", "\n", " setup_gaussian_splatting()\n", " clear_memory()\n", "\n", " # Step 1: Normalize images to biplet-square format\n", " print(\"\\n\" + \"=\"*70)\n", " print(\"Step 1: Biplet-Square Normalization\")\n", " print(\"=\"*70)\n", "\n", " processed_image_dir = os.path.join(output_dir, \"processed_images\")\n", "\n", " # Get original images first\n", " original_image_paths = sorted([\n", " os.path.join(image_dir, f)\n", " for f in os.listdir(image_dir)\n", " if f.lower().endswith(('.jpg', '.jpeg', '.png'))\n", " ])\n", "\n", " # Limit original images if specified\n", " if max_images and len(original_image_paths) > max_images:\n", " print(f\"\\n⚠️ Limiting to {max_images} original images\")\n", " original_image_paths = original_image_paths[:max_images]\n", "\n", " print(f\"Processing {len(original_image_paths)} original images → ~{len(original_image_paths)*2} after biplet-square\")\n", "\n", " # Only process the selected images\n", " temp_dir = os.path.join(output_dir, \"temp_originals\")\n", " os.makedirs(temp_dir, exist_ok=True)\n", "\n", " # Copy selected images to temp directory\n", " for img_path in original_image_paths:\n", " import shutil\n", " shutil.copy(img_path, temp_dir)\n", "\n", " # Process the temp directory\n", " normalize_image_sizes_biplet(\n", " input_dir=temp_dir,\n", " output_dir=processed_image_dir,\n", " size=square_size\n", " )\n", "\n", " # Clean up temp directory\n", " shutil.rmtree(temp_dir)\n", "\n", " # Get processed image paths\n", " image_paths = sorted([\n", " os.path.join(processed_image_dir, f)\n", " for f in os.listdir(processed_image_dir)\n", " if f.lower().endswith(('.jpg', '.jpeg', '.png'))\n", " ])\n", "\n", " print(f\"\\n📸 Processing {len(image_paths)} images (after biplet-square)\")\n", " print(f\"⚠️ Will use maximum {max_pairs} pairs to save memory\")\n", "\n", " # Step 2: DINO-based pair selection\n", " print(\"\\n\" + \"=\"*70)\n", " print(\"Step 2: DINO Pair Selection\")\n", " print(\"=\"*70)\n", "\n", " pairs = get_image_pairs_dino(image_paths, max_pairs=max_pairs)\n", " clear_memory()\n", "\n", " print(f\"✓ Using {len(pairs)} pairs for reconstruction\")\n", "\n", " # Step 3: MASt3R reconstruction\n", " print(\"\\n\" + \"=\"*70)\n", " print(\"Step 3: MASt3R Reconstruction\")\n", " print(\"=\"*70)\n", "\n", " device = Config.DEVICE\n", " model = load_mast3r_model(device)\n", "\n", " scene, mast3r_images = run_mast3r_pairs(\n", " model, image_paths, pairs, device,\n", " max_pairs=None # Already limited in get_image_pairs_dino\n", " )\n", "\n", " # Clear model from memory\n", " del model\n", " clear_memory()\n", "\n", " # Step 4: Extract COLMAP-compatible data\n", " print(\"\\n\" + \"=\"*70)\n", " print(\"Step 4: Converting to COLMAP Format\")\n", " print(\"=\"*70)\n", "\n", " # Extract COLMAP-compatible data with point limit\n", " pts3d, colors, cameras, poses = extract_colmap_data(\n", " scene, image_paths, max_points=max_points\n", " )\n", "\n", " # Clear scene from memory\n", " del scene, mast3r_images\n", " clear_memory()\n", "\n", " # Step 5: Save COLMAP reconstruction\n", " colmap_dir = os.path.join(output_dir, 'colmap')\n", " sparse_dir = save_colmap_reconstruction(\n", " pts3d, colors, cameras, poses, image_paths, colmap_dir\n", " )\n", "\n", " # Clear reconstruction data\n", " del pts3d, colors, cameras, poses\n", " clear_memory()\n", "\n", " # Step 6: Train Gaussian Splatting\n", " print(\"\\n\" + \"=\"*70)\n", " print(\"Step 6: Training Gaussian Splatting\")\n", " print(\"=\"*70)\n", "\n", " gs_output = train_gaussian_splatting(\n", " colmap_dir=colmap_dir,\n", " image_dir=processed_image_dir,\n", " output_dir=output_dir,\n", " iterations=iterations\n", " )\n", "\n", " print(\"\\n\" + \"=\"*70)\n", " print(\"✅ Full Pipeline Successfully Completed!\")\n", " print(\"=\"*70)\n", " print(f\"\\nGaussian Splatting model saved at: {gs_output}\")\n", "\n", " return gs_output" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000, "referenced_widgets": [ "66574f32fe124150a4d8624d7cfcf139", "dd67e856b0be4aebb04c23fa9e0eb160", "bb503eb30ab4486a879222ea24bf8c7f", "6cbc7ce2f8504e23874712834d84e62f", "6854bc3c3c7d4e90bc8e2e3cba5f8e4c", "631bcea348934cf4b60606e743bdcbf4", "d32352cf67cb4ba293df249c26cc29e2", "276cd897a9cb4e06b5925e20a101da8a", "f12742a50e5f455f89702313c9452e7f", "15da0d046f044911bf33a1f9e21129ff", "07bf97e4a0ca490396adf5a5d6d42190", "8f62f0e31c4444ad98d5bf11be100569", "b6f8605959e146f29d8e1d1d8a255dc5", "7a3fc8f0a5fa437e99f75fe1d2848777", "6e9513634acb43f58ac3f34d98e7f021", "c11d28362df94ad2a22a37d3ef3eff79", "a2a410402051486db3575a75860d83e6", "357058e75c04432eac5306269043689d", "4adacdabec634c99ba7d7b1a6ef9d36d", "8f561b54c8b64e11ae2ccbc27ffa56f7", "7919e72c83cb49b6a45deb64d717e874", "6d3bc0c4b8f44125b4518894cadf0ef9", "523cb6945e534e3eb6155668a5420c47", "8040f9622a8440009bad502625f0f0ba", "49d9e30cc9c54d5da88cea6da52b37cd", "53cab2383cb74d8296fa94e90885f16a", "9c8f9e0706574225bd71eaef7c1e1e21", "0600615ab3cb4a4f99253d28a8da092c", "310651e666f24251a3e3fada3e4103d1", "2a545a8322a145abb6af50e1309549d0", "1a84acadaf094f7d820a6d189496f086", "caca7f2bfc7e42daad183c31c302a3e6", "febf82cd619c4ea9819d8555e0fcccf1" ] }, "id": "3dIlSxVMQSfO", "outputId": "bdd74805-e62f-4745-f5c0-9dfa7cc16b45" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "=== Setting up Base Environment ===\n", "\n", "📦 Fixing NumPy...\n", "Running: /usr/bin/python3 -m pip uninstall -y numpy\n", "Running: /usr/bin/python3 -m pip install numpy==1.26.4\n", "\n", "📦 Installing PyTorch...\n", "Running: /usr/bin/python3 -m pip install torch torchvision torchaudio\n", "\n", "📦 Installing core utilities...\n", "Running: /usr/bin/python3 -m pip install opencv-python pillow imageio imageio-ffmpeg plyfile tqdm tensorboard scipy psutil\n", "\n", "📦 Installing transformers...\n", "Running: /usr/bin/python3 -m pip install transformers==4.40.0\n", "\n", "📦 Installing pycolmap...\n", "Running: /usr/bin/python3 -m pip install pycolmap\n", "✓ Base environment setup complete!\n", "\n", "=== Setting up MASt3R ===\n", "Cloning MASt3R repository...\n", "Checking dust3r structure...\n", "Installing dust3r...\n", "Installing croco...\n", "Installing MASt3R requirements...\n", "Downloading model weights...\n", "Installing additional dependencies...\n", "\n", "🔍 Verifying MASt3R installation...\n", "Warning, cannot find cuda-compiled version of RoPE2D, using a slow pytorch version instead\n", " ✓ MASt3R import: OK\n", "✓ MASt3R setup complete!\n", "\n", "=== Setting up Gaussian Splatting ===\n", "Cloning Gaussian Splatting repository...\n", "Running: git clone --recursive https://github.com/graphdeco-inria/gaussian-splatting.git gaussian-splatting\n", "Installing Gaussian Splatting requirements...\n", "Running: /usr/bin/python3 -m pip install -r requirements.txt\n", "❌ Command failed with code 1\n", "\n", "📦 Building Gaussian Splatting submodules...\n", "\n", "📦 Installing diff-gaussian-rasterization...\n", "Running: /usr/bin/python3 -m pip install submodules/diff-gaussian-rasterization\n", "\n", "📦 Installing simple-knn...\n", "Running: /usr/bin/python3 -m pip install submodules/simple-knn\n", "✓ Gaussian Splatting setup complete!\n", "\n", "======================================================================\n", "Step 1: Biplet-Square Normalization\n", "======================================================================\n", "Processing 20 original images → ~40 after biplet-square\n", "Generating 2 cropped squares (Left/Right or Top/Bottom) for each image...\n", "\n", " ✓ image_001.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_002.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_003.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_004.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_005.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_006.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_007.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_008.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_009.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_010.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_011.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_012.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_013.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_014.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_015.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_016.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_017.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_018.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_019.jpeg: (1440, 1920) → 2 square images generated\n", " ✓ image_020.jpeg: (1440, 1920) → 2 square images generated\n", "\n", "Processing complete: 20 source images processed\n", "Original size distribution: {'1440x1920': 20}\n", "\n", "📸 Processing 40 images (after biplet-square)\n", "⚠️ Will use maximum 400 pairs to save memory\n", "\n", "======================================================================\n", "Step 2: DINO Pair Selection\n", "======================================================================\n", "\n", "=== Extracting DINO Global Features ===\n", "Initial memory state:\n", "GPU Memory - Allocated: 0.00GB, Reserved: 0.00GB\n", "CPU Memory Usage: 7.8%\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", "You will be able to reuse this secret in all of your notebooks.\n", "Please note that authentication is recommended but still optional to access public models or datasets.\n", " warnings.warn(\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "preprocessor_config.json: 0%| | 0.00/436 [00:00\n", "✓ MASt3R model loaded on cuda\n", "\n", "=== Running MASt3R Reconstruction ===\n", "Initial memory state:\n", "GPU Memory - Allocated: 2.58GB, Reserved: 2.69GB\n", "CPU Memory Usage: 17.1%\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/content/mast3r/dust3r/dust3r/cloud_opt/base_opt.py:275: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n", " @torch.cuda.amp.autocast(enabled=False)\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Processing 400 pairs...\n", "Loading 40 images at 224x224...\n", "\n", "=== Loading images for MASt3R (size=224) ===\n", ">> Loading a list of 40 images\n", " - adding /content/output/processed_images/image_001_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_001_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_002_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_002_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_003_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_003_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_004_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_004_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_005_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_005_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_006_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_006_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_007_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_007_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_008_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_008_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_009_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_009_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_010_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_010_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_011_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_011_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_012_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_012_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_013_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_013_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_014_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_014_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_015_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_015_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_016_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_016_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_017_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_017_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_018_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_018_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_019_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_019_top.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_020_bottom.jpeg with resolution 700x700 --> 224x224\n", " - adding /content/output/processed_images/image_020_top.jpeg with resolution 700x700 --> 224x224\n", " (Found 40 images)\n", "Loaded 40 images\n", "After loading images:\n", "GPU Memory - Allocated: 2.58GB, Reserved: 2.69GB\n", "CPU Memory Usage: 17.1%\n", "Creating 400 image pairs...\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "Preparing pairs: 100%|██████████| 400/400 [00:00<00:00, 702563.48it/s]\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Running MASt3R inference on 400 pairs...\n", ">> Inference with model on 400 image pairs\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "\r 0%| | 0/400 [00:00\n", "pts_all is a list with 40 elements\n", "First element type: \n", "First element shape: torch.Size([224, 224, 3])\n", "pts_all shape after conversion: torch.Size([40, 224, 224, 3])\n", "Found batched point cloud: torch.Size([40, 224, 224, 3])\n", "✓ Extracted 2007040 3D points from 40 images\n", "\n", "⚠ Downsampling from 2007040 to 1000 points to reduce memory usage...\n", "✓ Downsampled to 1000 points\n", "Extracting camera parameters...\n", "Retrieved camera-to-world poses: shape (40, 4, 4)\n", "Converted to world-to-camera poses for COLMAP\n", "Focals shape: (40, 1)\n", "Principal points shape: (40, 2)\n", "\n", "Example camera 0:\n", " Image size: 700x700\n", " MASt3R focal: 271.84, pp: (112.00, 112.00)\n", " Scaled fx=849.51, fy=849.51, cx=350.00, cy=350.00\n", " Pose (first row): [ 0.98978937 -0.12818362 0.06233642 0.01966449]\n", "\n", "✓ Extracted 40 cameras and 40 poses\n", "\n", "=== Saving COLMAP reconstruction ===\n", " Writing COLMAP files directly to /content/output/colmap/sparse/0...\n", " ✓ Wrote 40 cameras\n", " ✓ Wrote 40 images\n", " ✓ Wrote 1000 3D points\n", "\n", "✓ COLMAP reconstruction saved to /content/output/colmap/sparse/0\n", " Cameras: 40\n", " Images: 40\n", " Points: 1000\n", "\n", "======================================================================\n", "Step 6: Training Gaussian Splatting\n", "======================================================================\n", "\n", "======================================================================\n", "Step 6: Training Gaussian Splatting\n", "======================================================================\n", "\n", "=== Training Gaussian Splatting ===\n", "Command: python train.py -s /content/output/colmap --images /content/output/processed_images -m /content/output --iterations 2000 --test_iterations 1000 2000 --save_iterations 1000 2000 --resolution 2 --densify_grad_threshold 0.001 --densification_interval 200 --opacity_reset_interval 5000\n", "\n", "Optimizing /content/output\n", "Output folder: /content/output [19/01 15:47:11]\n", "\n", "Reading camera 1/40\n", "Reading camera 2/40\n", "Reading camera 3/40\n", "Reading camera 4/40\n", "Reading camera 5/40\n", "Reading camera 6/40\n", "Reading camera 7/40\n", "Reading camera 8/40\n", "Reading camera 9/40\n", "Reading camera 10/40\n", "Reading camera 11/40\n", "Reading camera 12/40\n", "Reading camera 13/40\n", "Reading camera 14/40\n", "Reading camera 15/40\n", "Reading camera 16/40\n", "Reading camera 17/40\n", "Reading camera 18/40\n", "Reading camera 19/40\n", "Reading camera 20/40\n", "Reading camera 21/40\n", "Reading camera 22/40\n", "Reading camera 23/40\n", "Reading camera 24/40\n", "Reading camera 25/40\n", "Reading camera 26/40\n", "Reading camera 27/40\n", "Reading camera 28/40\n", "Reading camera 29/40\n", "Reading camera 30/40\n", "Reading camera 31/40\n", "Reading camera 32/40\n", "Reading camera 33/40\n", "Reading camera 34/40\n", "Reading camera 35/40\n", "Reading camera 36/40\n", "Reading camera 37/40\n", "Reading camera 38/40\n", "Reading camera 39/40\n", "Reading camera 40/40 [19/01 15:47:11]\n", "Converting point3d.bin to .ply, will happen only the first time you open the scene. [19/01 15:47:11]\n", "Loading Training Cameras [19/01 15:47:11]\n", "Loading Test Cameras [19/01 15:47:12]\n", "Number of points at initialisation : 1000 [19/01 15:47:12]\n", "\n", "[ITER 1000] Evaluating train: L1 0.08684776574373246 PSNR 17.6593807220459 [19/01 15:47:24]\n", "\n", "[ITER 1000] Saving Gaussians [19/01 15:47:24]\n", "\n", "[ITER 2000] Evaluating train: L1 0.07794528901576997 PSNR 18.424603271484376 [19/01 15:47:33]\n", "\n", "[ITER 2000] Saving Gaussians [19/01 15:47:33]\n", "\n", "Training complete. [19/01 15:47:33]\n", "\n", "STDERR: 2026-01-19 15:47:06.621052: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", "E0000 00:00:1768837626.640983 6390 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", "E0000 00:00:1768837626.646862 6390 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", "W0000 00:00:1768837626.663309 6390 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", "W0000 00:00:1768837626.663332 6390 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", "W0000 00:00:1768837626.663334 6390 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", "W0000 00:00:1768837626.663335 6390 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", "\n", "Training progress: 0%| | 0/2000 [00:00