Expose Poisson reconstruction parameters

- Expose full_depth, samples_per_node, and point_weight parameters
- Add comprehensive documentation for each parameter
- Add unit tests for parameter validation
- Fully backward compatible with default values
- All style checks applied

Fixes #7430

Author: Chevi-Koren

CHANGELOG.md

@@ -1,5 +1,5 @@
 ## Main
--   Exposed advanced parameters (`full_depth`, `samples_per_node`, `point_weight`, `confidence`, `exact_interpolation`) for Poisson surface reconstruction in `TriangleMesh.create_from_point_cloud_poisson` (PR #XXXX) (issue #7248)
+-   Exposed advanced parameters (`full_depth`, `samples_per_node`, `point_weight`) for Poisson surface reconstruction in `TriangleMesh.create_from_point_cloud_poisson` (PR #7430) (issue #7248)
 -   Upgrade stdgpu third-party library to commit d7c07d0.
 -   Fix performance for non-contiguous NumPy array conversion in pybind vector converters. This change removes restrictive `py::array::c_style` flags and adds a runtime contiguity check, improving Pandas-to-Open3D conversion speed by up to ~50×. (issue #5250)(PR #7343).
 -   Corrected documentation for Link Open3D in C++ projects (broken links).

cpp/open3d/geometry/SurfaceReconstructionPoisson.cpp

@@ -403,8 +403,6 @@ void Execute(const open3d::geometry::PointCloud& pcd,
              int full_depth,
              float samples_per_node,
              float point_weight,
-             float confidence,
-             bool exact_interpolation,
              UIntPack<FEMSigs...>) {
     static const int Dim = sizeof...(FEMSigs);
     typedef UIntPack<FEMSigs...> Sigs;
@@ -422,16 +420,16 @@ void Execute(const open3d::geometry::PointCloud& pcd,
     XForm<Real, Dim + 1> xForm, iXForm;
     xForm = XForm<Real, Dim + 1>::Identity();
 
-    // Keep hardcoded internal parameters
+    // Keep other internal parameters hardcoded
     float datax = 32.f;
     int base_depth = 0;
     int base_v_cycles = 1;
     float confidence_bias = 0.f;
     float cg_solver_accuracy = 1e-3f;
     int iters = 8;
-    
+
     // Parameters are now passed as function arguments:
-    // full_depth, samples_per_node, point_weight, confidence, exact_interpolation
+    // full_depth, samples_per_node, point_weight
 
     double startTime = Time();
     Real isoValue = 0;
@@ -467,31 +465,16 @@ void Execute(const open3d::geometry::PointCloud& pcd,
         pointStream.xform_ = &xForm;
 
         {
-            auto ProcessDataWithConfidence = [&](const Point<Real, Dim>& p,
-                                                 Open3DData& d) {
-                Real l = (Real)d.normal_.norm();
-                if (!l || l != l) return (Real)-1.;
-                return (Real)pow(l, confidence);
-            };
             auto ProcessData = [](const Point<Real, Dim>& p, Open3DData& d) {
                 Real l = (Real)d.normal_.norm();
                 if (!l || l != l) return (Real)-1.;
                 d.normal_ /= l;
                 return (Real)1.;
             };
-            if (confidence > 0) {
-                pointCount = FEMTreeInitializer<Dim, Real>::template Initialize<
-                        Open3DData>(tree.spaceRoot(), pointStream, depth,
-                                    samples, sampleData, true,
-                                    tree.nodeAllocators[0], tree.initializer(),
-                                    ProcessDataWithConfidence);
-            } else {
-                pointCount = FEMTreeInitializer<Dim, Real>::template Initialize<
-                        Open3DData>(tree.spaceRoot(), pointStream, depth,
-                                    samples, sampleData, true,
-                                    tree.nodeAllocators[0], tree.initializer(),
-                                    ProcessData);
-            }
+            pointCount = FEMTreeInitializer<Dim, Real>::template Initialize<
+                    Open3DData>(tree.spaceRoot(), pointStream, depth, samples,
+                                sampleData, true, tree.nodeAllocators[0],
+                                tree.initializer(), ProcessData);
         }
         iXForm = xForm.inverse();
 
@@ -618,7 +601,8 @@ void Execute(const open3d::geometry::PointCloud& pcd,
         // Add the interpolation constraints
         if (point_weight > 0) {
             profiler.start();
-            if (exact_interpolation) {
+            // Use approximate interpolation (default behavior)
+            if (false) {
                 iInfo = FEMTree<Dim, Real>::
                         template InitializeExactPointInterpolationInfo<Real, 0>(
                                 tree, samples,
@@ -728,9 +712,7 @@ TriangleMesh::CreateFromPointCloudPoisson(const PointCloud& pcd,
                                           int n_threads,
                                           int full_depth,
                                           float samples_per_node,
-                                          float point_weight,
-                                          float confidence,
-                                          bool exact_interpolation) {
+                                          float point_weight) {
     static const BoundaryType BType = DEFAULT_FEM_BOUNDARY;
     typedef IsotropicUIntPack<
             DIMENSION, FEMDegreeAndBType</* Degree */ 1, BType>::Signature>
@@ -756,7 +738,7 @@ TriangleMesh::CreateFromPointCloudPoisson(const PointCloud& pcd,
     std::vector<double> densities;
     Execute<float>(pcd, mesh, densities, static_cast<int>(depth), width, scale,
                    linear_fit, full_depth, samples_per_node, point_weight,
-                   confidence, exact_interpolation, FEMSigs());
+                   FEMSigs());
 
     ThreadPool::Terminate();
 

cpp/open3d/geometry/TriangleMesh.h

@@ -547,13 +547,24 @@ class TriangleMesh : public MeshBase {
     /// estimate the positions of iso-vertices.
     /// \param n_threads Number of threads used for reconstruction. Set to -1 to
     /// automatically determine it.
-    /// \param full_depth Minimum depth for density estimation. Below this depth,
-    /// the octree is complete.
-    /// \param samples_per_node Minimum number of sample points per octree node.
-    /// \param point_weight Importance of point interpolation constraints (2.0 * FEM degree).
-    /// \param confidence Confidence exponent for normal length-based weighting (0 = no weighting).
-    /// \param exact_interpolation If true, use exact point interpolation constraints.
+    /// \param full_depth Minimum depth for density estimation (default: 5).
+    /// Below this depth, the octree is complete (fully subdivided).
+    /// Higher values provide more stability in sparse regions but consume more
+    /// memory.
+    /// Recommended range: 3-7. Use higher values (6-7) if your point cloud has
+    /// sparse regions.
+    /// \param samples_per_node Minimum number of sample points per octree node
+    /// (default: 1.5). Controls adaptive octree refinement based on local point
+    /// density. Lower values (e.g., 1.0) allow finer subdivision and capture
+    /// more detail but may increase noise. Higher values (e.g., 3.0) suppress
+    /// noise but may lose fine details. Recommended range: 1.0-3.0.
+    /// \param point_weight Importance of point interpolation constraints
+    /// (default: 4.0). Controls the trade-off between data fidelity and surface
+    /// smoothness. Higher values (e.g., 10.0) prioritize fitting input points
+    /// exactly, resulting in surfaces closer to the data. Lower values produce
+    /// smoother surfaces. Recommended range: 2.0-10.0.
     /// \return The estimated TriangleMesh, and per vertex density values that
+    /// can be used to trim the mesh.
     static std::tuple<std::shared_ptr<TriangleMesh>, std::vector<double>>
     CreateFromPointCloudPoisson(const PointCloud &pcd,
                                 size_t depth = 8,
@@ -563,9 +574,7 @@ class TriangleMesh : public MeshBase {
                                 int n_threads = -1,
                                 int full_depth = 5,
                                 float samples_per_node = 1.5f,
-                                float point_weight = 4.0f,
-                                float confidence = 0.0f,
-                                bool exact_interpolation = false);
+                                float point_weight = 4.0f);
 
     /// Factory function to create a tetrahedron mesh (trianglemeshfactory.cpp).
     /// the mesh centroid will be at (0,0,0) and \p radius defines the

cpp/open3d/visualization/gui/PickPointsInteractor.cpp

@@ -74,8 +74,7 @@ class SelectionIndexLookup {
         std::string name;
         size_t start_index;
 
-        Obj(const std::string &n, size_t start)
-            : name(n), start_index(start) {};
+        Obj(const std::string &n, size_t start) : name(n), start_index(start){};
         bool IsValid() const { return !name.empty(); }
     };
 

cpp/pybind/geometry/trianglemesh.cpp

@@ -352,8 +352,7 @@ void pybind_trianglemesh_definitions(py::module &m) {
                         "pcd"_a, "depth"_a = 8, "width"_a = 0, "scale"_a = 1.1,
                         "linear_fit"_a = false, "n_threads"_a = -1,
                         "full_depth"_a = 5, "samples_per_node"_a = 1.5f,
-                        "point_weight"_a = 4.0f, "confidence"_a = 0.0f,
-                        "exact_interpolation"_a = false)
+                        "point_weight"_a = 4.0f)
             .def_static(
                     "create_from_oriented_bounding_box",
                     &TriangleMesh::CreateFromOrientedBoundingBox,

python/test/geometry/test_poisson_parameters.py

@@ -10,16 +10,13 @@
 import pytest
 
 
-@pytest.fixture
-def sample_point_cloud():
-    """Create a simple point cloud for testing."""
+def _create_point_cloud(num_points=100):
+    """Helper to create a point cloud with normals."""
+    np.random.seed(42)  # Fixed seed for reproducible tests
     pcd = o3d.geometry.PointCloud()
-    pcd.points = o3d.utility.Vector3dVector(
-        np.random.rand(100, 3) - 0.5
-    )
+    pcd.points = o3d.utility.Vector3dVector(np.random.rand(num_points, 3) - 0.5)
     pcd.normals = o3d.utility.Vector3dVector(
-        np.random.rand(100, 3) - 0.5
-    )
+        np.random.rand(num_points, 3) - 0.5)
     pcd.normalize_normals()
     return pcd
 
@@ -32,62 +29,63 @@ def _assert_valid_mesh(mesh, densities):
     assert len(densities) == len(mesh.vertices)
 
 
+@pytest.fixture
+def sample_point_cloud():
+    """Fixture that returns a simple point cloud for testing."""
+    return _create_point_cloud()
+
+
 def test_poisson_default_parameters(sample_point_cloud):
     """Test Poisson reconstruction with default parameters."""
     mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
-        sample_point_cloud, depth=6
-    )
+        sample_point_cloud, depth=6)
     _assert_valid_mesh(mesh, densities)
 
 
-@pytest.mark.parametrize("params,expected_valid", [
-    ({"depth": 6, "full_depth": 4, "samples_per_node": 2.0, 
-      "point_weight": 5.0, "confidence": 0.5, "exact_interpolation": True}, True),
-    ({"depth": 6, "full_depth": 3}, True),
-    ({"depth": 6, "full_depth": 5}, True),
-    ({"depth": 5, "samples_per_node": 1.0}, True),
-    ({"depth": 5, "samples_per_node": 3.0}, True),
+@pytest.mark.parametrize("params", [
+    {
+        "depth": 6,
+        "full_depth": 4,
+        "samples_per_node": 2.0,
+        "point_weight": 5.0
+    },
+    {
+        "depth": 6,
+        "full_depth": 3
+    },
+    {
+        "depth": 6,
+        "full_depth": 5
+    },
+    {
+        "depth": 5,
+        "samples_per_node": 1.0
+    },
+    {
+        "depth": 5,
+        "samples_per_node": 3.0
+    },
+    {
+        "depth": 5,
+        "point_weight": 4.0
+    },
+    {
+        "depth": 5,
+        "point_weight": 10.0
+    },
 ])
-def test_poisson_with_various_parameters(sample_point_cloud, params, expected_valid):
+def test_poisson_with_various_parameters(sample_point_cloud, params):
     """Test Poisson reconstruction with various parameter combinations."""
     mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
-        sample_point_cloud, **params
-    )
-    if expected_valid:
-        _assert_valid_mesh(mesh, densities)
-
-
-def test_poisson_parameter_variation(sample_point_cloud):
-    """Test that different parameters produce different results."""
-    # Run with default point_weight
-    mesh1, _ = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
-        sample_point_cloud, depth=5, point_weight=4.0
-    )
-    
-    # Run with higher point_weight (should produce different result)
-    mesh2, _ = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
-        sample_point_cloud, depth=5, point_weight=10.0
-    )
-    
-    # Meshes should be different (different vertex counts or positions)
-    # We just check they both succeeded and have positive vertex counts
-    assert len(mesh1.vertices) > 0
-    assert len(mesh2.vertices) > 0
+        sample_point_cloud, **params)
+    _assert_valid_mesh(mesh, densities)
 
 
 def test_poisson_backward_compatibility():
     """Test that old API calls still work (backward compatibility)."""
-    pcd = o3d.geometry.PointCloud()
-    pcd.points = o3d.utility.Vector3dVector(
-        np.random.rand(50, 3) - 0.5
-    )
-    pcd.normals = o3d.utility.Vector3dVector(
-        np.random.rand(50, 3) - 0.5
-    )
-    pcd.normalize_normals()
-    
+    pcd = _create_point_cloud(num_points=50)
+
     # Old-style call without new parameters
     mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
-        pcd, depth=5, scale=1.1, linear_fit=False
-    )
+        pcd, depth=5, scale=1.1, linear_fit=False)
     _assert_valid_mesh(mesh, densities)