reconstruct3d 0.1.0__py3-none-any.whl

reconstruct3d/calibrate.py

@@ -0,0 +1,199 @@
+"""Calibración de la matriz intrínseca a partir de un video de un tablero.
+
+Graba un video moviendo un patrón de ajedrez (chessboard) frente a la cámara,
+cubriendo distintas zonas/ángulos del encuadre, y este script estima K y los
+coeficientes de distorsión con `cv2.calibrateCamera`. Escribe (o crea) el
+`camera.json` que consume el resto del pipeline.
+
+A diferencia de pegar una K a mano, aquí `proc_size` queda fijado a la resolución
+NATIVA del video de calibración, así que el punto principal cae cerca del centro
+y no hay riesgo de desalinear K con la resolución de proceso.
+
+Uso directo:
+    uv run python calibrate.py data/calib.mp4                 # automático
+    uv run python calibrate.py data/calib.mp4 --board 9x6 --square 0.025
+    uv run python calibrate.py data/calib.mp4 --interactive   # revisar vistas a mano
+
+Vía pipeline:
+    uv run python pipeline.py calibrate data/calib.mp4
+    uv run python pipeline.py all data/video.mp4 --calibrate data/calib.mp4
+"""
+import argparse
+import json
+import os
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+DEFAULT_CAMERA_JSON = "camera.json"
+
+
+def _parse_board(s):
+    """'9x6' -> (9, 6) = (esquinas internas en X, en Y)."""
+    parts = str(s).lower().replace("×", "x").split("x")
+    if len(parts) != 2:
+        raise ValueError(f"Formato de tablero inválido: '{s}'. Usa COLSxROWS, p.ej. 9x6.")
+    return int(parts[0]), int(parts[1])
+
+
+def collect_corners(video_path, board, square_size, k_skip=10, max_views=40,
+                    min_spacing=0.04, interactive=False):
+    """Recorre el video, detecta el tablero y junta correspondencias 3D-2D.
+
+    Solo acepta una vista si sus esquinas difieren lo suficiente de las ya
+    aceptadas (min_spacing, fracción de la diagonal de imagen), para forzar
+    variedad de poses y no saturar con frames casi idénticos.
+
+    Devuelve (objpoints, imgpoints, image_size, frames_aceptados).
+    """
+    cols, rows = board
+    # Patrón 3D del tablero (Z=0), escalado por el lado real del cuadrado.
+    objp = np.zeros((rows * cols, 3), np.float32)
+    objp[:, :2] = np.mgrid[0:cols, 0:rows].T.reshape(-1, 2)
+    objp *= float(square_size)
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError(f"No se pudo abrir el video: {video_path}")
+    n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    diag = float(np.hypot(w, h))
+
+    flags = (cv2.CALIB_CB_ADAPTIVE_THRESH | cv2.CALIB_CB_NORMALIZE_IMAGE |
+             cv2.CALIB_CB_FAST_CHECK)
+    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+
+    objpoints, imgpoints, accepted_centers, used_frames = [], [], [], []
+    print(f"[calib] video {w}x{h}, {n_frames} frames | tablero {cols}x{rows} | "
+          f"cuadrado={square_size} | revisando 1 de cada {k_skip}")
+
+    idxs = range(0, n_frames, k_skip)
+    for i in tqdm(idxs, desc="Buscando tablero"):
+        cap.set(cv2.CAP_PROP_POS_FRAMES, i)
+        ret, frame = cap.read()
+        if not ret:
+            break
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        found, corners = cv2.findChessboardCorners(gray, (cols, rows), flags)
+        if not found:
+            continue
+        corners = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
+        center = corners.reshape(-1, 2).mean(axis=0)
+
+        # ¿suficientemente distinta de las vistas ya aceptadas?
+        if accepted_centers:
+            d = min(np.linalg.norm(center - c) for c in accepted_centers)
+            if d < min_spacing * diag and not interactive:
+                continue
+
+        if interactive:
+            vis = frame.copy()
+            cv2.drawChessboardCorners(vis, (cols, rows), corners, found)
+            cv2.putText(vis, f"aceptadas={len(objpoints)}  [a]ceptar [s]altar [q]terminar",
+                        (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+            cv2.imshow("calibracion", vis)
+            key = cv2.waitKey(0) & 0xFF
+            if key == ord('q'):
+                break
+            if key != ord('a'):
+                continue
+
+        objpoints.append(objp.copy())
+        imgpoints.append(corners)
+        accepted_centers.append(center)
+        used_frames.append(i)
+        if len(objpoints) >= max_views:
+            break
+
+    cap.release()
+    if interactive:
+        cv2.destroyAllWindows()
+    return objpoints, imgpoints, (w, h), used_frames
+
+
+def calibrate_from_video(video_path, board=(9, 6), square_size=0.025, k_skip=10,
+                         max_views=40, interactive=False):
+    """Estima K + distorsión. Devuelve un dict listo para camera.json."""
+    objpoints, imgpoints, image_size, used = collect_corners(
+        video_path, board, square_size, k_skip=k_skip,
+        max_views=max_views, interactive=interactive,
+    )
+    n = len(objpoints)
+    if n < 5:
+        raise RuntimeError(
+            f"Solo se detectó el tablero en {n} vistas (mínimo 5, ideal >=15). "
+            "Graba el patrón cubriendo más zonas y ángulos del encuadre, o baja --k-skip.")
+
+    print(f"[calib] calibrando con {n} vistas (frames: {used[:8]}{'...' if n > 8 else ''})")
+    rms, K, dist, _rvecs, _tvecs = cv2.calibrateCamera(
+        objpoints, imgpoints, image_size, None, None)
+
+    w, h = image_size
+    print(f"[calib] RMS reproyección: {rms:.4f} px")
+    print(f"[calib] K=[fx={K[0,0]:.2f} fy={K[1,1]:.2f} cx={K[0,2]:.2f} cy={K[1,2]:.2f}]  "
+          f"(centro imagen ~ {w/2:.0f},{h/2:.0f})")
+
+    return {
+        "_calibracion": (f"Generado por calibrate.py desde '{os.path.basename(video_path)}'. "
+                         f"RMS reproyección={rms:.4f}px, {n} vistas, tablero {board[0]}x{board[1]}, "
+                         f"cuadrado={square_size}."),
+        "K": K.tolist(),
+        "dist_coeffs": dist.ravel().tolist(),
+        "proc_size": [int(w), int(h)],
+    }
+
+
+def save_camera_json(camera_dict, path=DEFAULT_CAMERA_JSON):
+    """Escribe el camera.json (haciendo backup si ya existía)."""
+    if os.path.exists(path):
+        bak = path + ".bak"
+        os.replace(path, bak)
+        print(f"[calib] {path} existía -> respaldado en {bak}")
+    with open(path, "w") as f:
+        json.dump(camera_dict, f, indent=2, ensure_ascii=False)
+    print(f"[calib] camera.json escrito en {path}")
+    return path
+
+
+def find_calibration_source(search_dirs=("data/calib", "data", ".")):
+    """Busca un video de calibración para el modo auto-detección.
+
+    Devuelve la ruta del primer candidato cuyo nombre sugiere calibración
+    (contiene 'calib'), o None. Usado por el pipeline cuando no hay camera.json.
+    """
+    exts = (".mp4", ".mov", ".avi", ".mkv")
+    for d in search_dirs:
+        if not os.path.isdir(d):
+            continue
+        for fn in sorted(os.listdir(d)):
+            if "calib" in fn.lower() and fn.lower().endswith(exts):
+                return os.path.join(d, fn)
+    return None
+
+
+def run_calibration(video_path, board=(9, 6), square_size=0.025, k_skip=10,
+                    max_views=40, interactive=False, out=DEFAULT_CAMERA_JSON):
+    """Calibra y guarda camera.json. Devuelve la ruta escrita."""
+    cam = calibrate_from_video(video_path, board=board, square_size=square_size,
+                               k_skip=k_skip, max_views=max_views, interactive=interactive)
+    return save_camera_json(cam, out)
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="Calibración de cámara desde un video de tablero.")
+    p.add_argument("video", help="Video del patrón de ajedrez (mp4/MOV/avi).")
+    p.add_argument("--board", default="9x6", type=_parse_board,
+                   help="Esquinas internas COLSxROWS del tablero (default 9x6).")
+    p.add_argument("--square", default=0.025, type=float,
+                   help="Lado real del cuadrado en metros (default 0.025). Fija la escala métrica.")
+    p.add_argument("--k-skip", default=10, type=int, help="Revisar 1 de cada k frames (default 10).")
+    p.add_argument("--max-views", default=40, type=int, help="Máx. vistas a usar (default 40).")
+    p.add_argument("--interactive", action="store_true",
+                   help="Revisar y aceptar cada vista a mano (ventana OpenCV).")
+    p.add_argument("--out", default=DEFAULT_CAMERA_JSON, help="Ruta de salida (default camera.json).")
+    args = p.parse_args()
+    run_calibration(args.video, board=args.board, square_size=args.square,
+                    k_skip=args.k_skip, max_views=args.max_views,
+                    interactive=args.interactive, out=args.out)

reconstruct3d/cgal_mesh/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.16)
+project(mesh_reconstruct CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+find_package(CGAL REQUIRED)
+
+add_executable(mesh_reconstruct mesh_reconstruct.cpp)
+target_link_libraries(mesh_reconstruct PRIVATE CGAL::CGAL)
+
+# Eigen es necesario para el solver de Poisson. Si está disponible, se enlaza el
+# soporte de CGAL; Advancing Front no lo necesita.
+find_package(Eigen3 QUIET)
+if(TARGET CGAL::Eigen3_support)
+  target_link_libraries(mesh_reconstruct PRIVATE CGAL::Eigen3_support)
+elseif(Eigen3_FOUND)
+  target_link_libraries(mesh_reconstruct PRIVATE Eigen3::Eigen)
+endif()

reconstruct3d/cgal_mesh/mesh_reconstruct.cpp

@@ -0,0 +1,312 @@
+// mesh_reconstruct.cpp — Reconstrucción de malla desde una nube de puntos densa
+// usando CGAL. Lee un PLY (puntos + color), limpia la nube (outliers +
+// simplificación + suavizado), reconstruye una superficie y la POST-PROCESA
+// (elimina islas de ruido + suavizado de malla) antes de escribir el PLY.
+//
+// Métodos de reconstrucción:
+//   - afront  (Advancing Front): interpola los puntos, respeta bordes abiertos
+//             (ideal para fachadas). Fiel pero hereda el ruido como picos.
+//   - poisson (Poisson screened): superficie implícita suave y cerrada; tolera
+//             mucho mejor el ruido. Necesita normales (se estiman).
+//
+// El color SIEMPRE se transfiere desde la nube original (vecino más cercano),
+// así que sobrevive al suavizado/remallado.
+//
+// Uso:
+//   mesh_reconstruct INPUT.ply OUTPUT.ply [opciones]
+//     --method afront|poisson         (default afront)
+//     --outlier-pct P                 elimina P% de outliers (default 2.0; 0=off)
+//     --simplify CELL                 grid simplify (default 0=auto~2x spacing; <0=off)
+//     --smooth K                      jet smooth de PUNTOS con K vecinos (default 0=off)
+//     --mesh-smooth ITERS             suavizado tangencial de la MALLA (default 0=off)
+//     --min-component FRAC            elimina componentes < FRAC*caras (default 0.0=off)
+//     --afront-radius R               longitud máx. de arista relativa al spacing (default 5.0)
+//     --poisson-spacing-mult M        multiplica el spacing de Poisson (default 1.0)
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Point_set_3.h>
+#include <CGAL/Point_set_3/IO.h>
+#include <CGAL/remove_outliers.h>
+#include <CGAL/grid_simplify_point_set.h>
+#include <CGAL/jet_estimate_normals.h>
+#include <CGAL/mst_orient_normals.h>
+#include <CGAL/jet_smooth_point_set.h>
+#include <CGAL/compute_average_spacing.h>
+#include <CGAL/advancing_front_surface_reconstruction.h>
+#include <CGAL/poisson_surface_reconstruction.h>
+#include <CGAL/Surface_mesh.h>
+#include <CGAL/Search_traits_3.h>
+#include <CGAL/Search_traits_adapter.h>
+#include <CGAL/Orthogonal_k_neighbor_search.h>
+#include <CGAL/property_map.h>
+#include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
+#include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
+#include <CGAL/Polygon_mesh_processing/repair_polygon_soup.h>
+#include <CGAL/Polygon_mesh_processing/connected_components.h>
+#include <CGAL/Polygon_mesh_processing/tangential_relaxation.h>
+#include <CGAL/boost/graph/helpers.h>
+
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <string>
+#include <vector>
+
+typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
+typedef Kernel::Point_3   Point;
+typedef Kernel::Vector_3  Vector;
+typedef CGAL::Point_set_3<Point, Vector> Point_set;
+typedef CGAL::Surface_mesh<Point> SMesh;
+typedef std::array<unsigned char, 3> Color;
+typedef CGAL::Parallel_if_available_tag Concurrency_tag;
+namespace PMP = CGAL::Polygon_mesh_processing;
+
+// ----------------------------------------------------------------------------
+struct Args {
+  std::string input, output;
+  std::string method = "afront";
+  double outlier_pct = 2.0;
+  double simplify = 0.0;      // 0 = auto, <0 = off
+  int    smooth = 0;          // jet smooth de puntos
+  int    mesh_smooth = 0;     // suavizado tangencial de la malla
+  double min_component = 0.0; // fracción de caras; 0 = off
+  double afront_radius = 5.0;
+  double poisson_spacing_mult = 1.0;
+};
+
+static Args parse(int argc, char** argv) {
+  Args a;
+  if (argc < 3) {
+    std::cerr << "uso: mesh_reconstruct INPUT.ply OUTPUT.ply [opciones]\n";
+    std::exit(2);
+  }
+  a.input = argv[1];
+  a.output = argv[2];
+  for (int i = 3; i < argc; ++i) {
+    std::string k = argv[i];
+    auto next = [&]() -> const char* { return (i + 1 < argc) ? argv[++i] : "0"; };
+    if (k == "--method")                    a.method = next();
+    else if (k == "--outlier-pct")          a.outlier_pct = std::atof(next());
+    else if (k == "--simplify")             a.simplify = std::atof(next());
+    else if (k == "--smooth")               a.smooth = std::atoi(next());
+    else if (k == "--mesh-smooth")          a.mesh_smooth = std::atoi(next());
+    else if (k == "--min-component")        a.min_component = std::atof(next());
+    else if (k == "--afront-radius")        a.afront_radius = std::atof(next());
+    else if (k == "--poisson-spacing-mult") a.poisson_spacing_mult = std::atof(next());
+    else std::cerr << "[warn] opción desconocida: " << k << "\n";
+  }
+  return a;
+}
+
+static bool get_color_maps(const Point_set& ps,
+                           Point_set::Property_map<unsigned char>& r,
+                           Point_set::Property_map<unsigned char>& g,
+                           Point_set::Property_map<unsigned char>& b) {
+  auto or_ = ps.property_map<unsigned char>("red");
+  auto og_ = ps.property_map<unsigned char>("green");
+  auto ob_ = ps.property_map<unsigned char>("blue");
+  if (!or_ || !og_ || !ob_) return false;
+  r = *or_; g = *og_; b = *ob_;
+  return true;
+}
+
+// Color por vecino más cercano: KD-tree indexado sobre (in_pts, in_cols).
+static std::vector<Color> transfer_colors(const std::vector<Point>& in_pts,
+                                          const std::vector<Color>& in_cols,
+                                          const std::vector<Point>& out_V) {
+  typedef CGAL::Search_traits_3<Kernel> Base;
+  typedef CGAL::Pointer_property_map<Point>::const_type PMap;
+  typedef CGAL::Search_traits_adapter<std::size_t, PMap, Base> Traits;
+  typedef CGAL::Orthogonal_k_neighbor_search<Traits> KNN;
+  typedef KNN::Tree Tree;
+  typedef KNN::Distance Distance;
+
+  PMap pmap = CGAL::make_property_map(in_pts);
+  std::vector<std::size_t> idx(in_pts.size());
+  std::iota(idx.begin(), idx.end(), 0);
+  Tree tree(idx.begin(), idx.end(), KNN::Splitter(), Traits(pmap));
+  Distance dist(pmap);
+
+  std::vector<Color> out(out_V.size(), Color{200, 200, 200});
+  for (std::size_t i = 0; i < out_V.size(); ++i) {
+    KNN search(tree, out_V[i], 1, 0, true, dist);
+    if (search.begin() != search.end())
+      out[i] = in_cols[search.begin()->first];
+  }
+  return out;
+}
+
+static bool write_ply(const std::string& path,
+                      const std::vector<Point>& V,
+                      const std::vector<Color>& C,
+                      const std::vector<std::array<std::size_t, 3>>& F) {
+  std::ofstream out(path);
+  if (!out) return false;
+  const bool has_color = (C.size() == V.size());
+  out << "ply\nformat ascii 1.0\n";
+  out << "element vertex " << V.size() << "\n";
+  out << "property float x\nproperty float y\nproperty float z\n";
+  if (has_color)
+    out << "property uchar red\nproperty uchar green\nproperty uchar blue\n";
+  out << "element face " << F.size() << "\n";
+  out << "property list uchar int vertex_indices\nend_header\n";
+  for (std::size_t i = 0; i < V.size(); ++i) {
+    out << V[i].x() << " " << V[i].y() << " " << V[i].z();
+    if (has_color)
+      out << " " << (int)C[i][0] << " " << (int)C[i][1] << " " << (int)C[i][2];
+    out << "\n";
+  }
+  for (const auto& f : F)
+    out << "3 " << f[0] << " " << f[1] << " " << f[2] << "\n";
+  return true;
+}
+
+// Post-procesa la malla in-place: elimina componentes pequeñas y suaviza.
+static void postprocess(SMesh& sm, const Args& a) {
+  if (a.min_component > 0) {
+    std::size_t nfaces = sm.number_of_faces();
+    std::size_t thr = (std::size_t)std::max(1.0, a.min_component * nfaces);
+    std::size_t removed = PMP::keep_large_connected_components(sm, thr);
+    sm.collect_garbage();
+    std::cerr << "[mesh] componentes < " << thr << " caras eliminadas: " << removed
+              << " -> caras " << sm.number_of_faces() << "\n";
+  }
+  if (a.mesh_smooth > 0) {
+    // Constreñir los vértices de borde para no encoger la superficie abierta.
+    auto vcm = sm.add_property_map<SMesh::Vertex_index, bool>("v:constrained", false).first;
+    for (auto h : halfedges(sm))
+      if (CGAL::is_border(h, sm)) vcm[target(h, sm)] = true;
+    PMP::tangential_relaxation(
+        sm, CGAL::parameters::number_of_iterations(a.mesh_smooth)
+                .vertex_is_constrained_map(vcm));
+    std::cerr << "[mesh] suavizado tangencial de malla: " << a.mesh_smooth
+              << " iteraciones\n";
+  }
+}
+
+// ----------------------------------------------------------------------------
+int main(int argc, char** argv) {
+  Args a = parse(argc, argv);
+
+  Point_set points;
+  std::cerr << "[mesh] leyendo " << a.input << " ...\n";
+  if (!CGAL::IO::read_point_set(a.input, points)) {
+    std::cerr << "[mesh] ERROR: no se pudo leer " << a.input << "\n";
+    return 1;
+  }
+  std::cerr << "[mesh] puntos leídos: " << points.size() << "\n";
+  if (points.empty()) return 1;
+
+  // Guardar la nube original (con color) para transferir color al final.
+  Point_set::Property_map<unsigned char> cr, cg, cb;
+  bool has_color = get_color_maps(points, cr, cg, cb);
+  std::cerr << "[mesh] color en la nube: " << (has_color ? "sí" : "no") << "\n";
+  std::vector<Point> orig_pts;
+  std::vector<Color> orig_cols;
+  if (has_color) {
+    orig_pts.reserve(points.size());
+    for (auto idx : points) { orig_pts.push_back(points.point(idx)); orig_cols.push_back({cr[idx], cg[idx], cb[idx]}); }
+  }
+
+  // 1) Outliers.
+  if (a.outlier_pct > 0) {
+    auto rm = CGAL::remove_outliers<Concurrency_tag>(
+        points, 24, CGAL::parameters::threshold_percent(a.outlier_pct));
+    std::size_t before = points.size();
+    points.remove(rm, points.end());
+    points.collect_garbage();
+    std::cerr << "[mesh] outliers eliminados: " << (before - points.size())
+              << " -> quedan " << points.size() << "\n";
+  }
+
+  double spacing = CGAL::compute_average_spacing<Concurrency_tag>(points, 6);
+  std::cerr << "[mesh] average spacing ~ " << spacing << "\n";
+
+  // 2) Grid simplify (densidad uniforme + denoise). 0 = auto(2x spacing), <0 = off.
+  if (a.simplify >= 0) {
+    double cell = (a.simplify > 0) ? a.simplify : 2.0 * spacing;
+    auto rm = CGAL::grid_simplify_point_set(points, cell);
+    std::size_t before = points.size();
+    points.remove(rm, points.end());
+    points.collect_garbage();
+    std::cerr << "[mesh] grid simplify (celda=" << cell << "): " << before
+              << " -> " << points.size() << "\n";
+  }
+
+  // 3) Jet smooth de puntos opcional (denoise antes de reconstruir).
+  if (a.smooth > 0) {
+    CGAL::jet_smooth_point_set<Concurrency_tag>(points, a.smooth);
+    std::cerr << "[mesh] jet smooth de puntos con " << a.smooth << " vecinos\n";
+  }
+
+  // --- Reconstrucción -> Surface_mesh ---
+  SMesh sm;
+  if (a.method == "afront") {
+    std::vector<Point> pts;
+    pts.reserve(points.size());
+    for (auto idx : points) pts.push_back(points.point(idx));
+    std::cerr << "[mesh] Advancing Front sobre " << pts.size() << " puntos...\n";
+    std::vector<std::array<std::size_t, 3>> facets;
+    CGAL::advancing_front_surface_reconstruction(
+        pts.begin(), pts.end(), std::back_inserter(facets));
+    std::cerr << "[mesh] triángulos (crudos): " << facets.size() << "\n";
+    PMP::repair_polygon_soup(pts, facets);
+    PMP::orient_polygon_soup(pts, facets);
+    PMP::polygon_soup_to_polygon_mesh(pts, facets, sm);
+  } else if (a.method == "poisson") {
+    points.add_normal_map();
+    std::cerr << "[mesh] estimando normales (jet)...\n";
+    CGAL::jet_estimate_normals<Concurrency_tag>(points, 18);
+    auto unoriented = CGAL::mst_orient_normals(points, 18);
+    points.remove(unoriented, points.end());
+    points.collect_garbage();
+    std::cerr << "[mesh] normales orientadas; puntos: " << points.size() << "\n";
+    double sp = spacing * a.poisson_spacing_mult;
+    std::cerr << "[mesh] Poisson (spacing=" << sp << ")...\n";
+    if (!CGAL::poisson_surface_reconstruction_delaunay(
+            points.begin(), points.end(), points.point_map(),
+            points.normal_map(), sm, sp)) {
+      std::cerr << "[mesh] ERROR: Poisson falló\n";
+      return 1;
+    }
+  } else {
+    std::cerr << "[mesh] ERROR: método desconocido '" << a.method
+              << "' (usa afront|poisson)\n";
+    return 2;
+  }
+  std::cerr << "[mesh] malla: " << sm.number_of_vertices() << " vértices, "
+            << sm.number_of_faces() << " caras\n";
+
+  // --- Post-procesado (limpieza + suavizado) ---
+  postprocess(sm, a);
+
+  // --- Volcado: vértices + caras, con color transferido de la nube original ---
+  std::vector<Point> V;
+  std::vector<std::array<std::size_t, 3>> F;
+  std::vector<std::size_t> vmap(sm.number_of_vertices() ? (*(--sm.vertices().end()) + 1) : 0, 0);
+  for (auto v : sm.vertices()) { vmap[(std::size_t)v] = V.size(); V.push_back(sm.point(v)); }
+  for (auto f : sm.faces()) {
+    std::array<std::size_t, 3> tri; int k = 0;
+    for (auto v : CGAL::vertices_around_face(sm.halfedge(f), sm))
+      if (k < 3) tri[k++] = vmap[(std::size_t)v];
+    if (k == 3) F.push_back(tri);
+  }
+  if (F.empty()) { std::cerr << "[mesh] ERROR: malla vacía\n"; return 1; }
+
+  std::vector<Color> C;
+  if (has_color && !orig_pts.empty()) {
+    std::cerr << "[mesh] transfiriendo color por vecino más cercano...\n";
+    C = transfer_colors(orig_pts, orig_cols, V);
+  }
+
+  std::cerr << "[mesh] escribiendo " << a.output << " (" << V.size()
+            << " vértices, " << F.size() << " triángulos)\n";
+  if (!write_ply(a.output, V, C, F)) {
+    std::cerr << "[mesh] ERROR al escribir " << a.output << "\n";
+    return 1;
+  }
+  std::cerr << "[mesh] OK\n";
+  return 0;
+}