fixes Codacy Static Code Analysis problem 1

Author: TsofnatMaman

cpp/open3d/geometry/PointCloudSmoothing.cpp

@@ -16,6 +16,7 @@
 namespace open3d {
 namespace geometry {
 namespace {
+// Helper functions for point cloud smoothing
 Eigen::Vector3d ComputeCentroid(const std::vector<Eigen::Vector3d>& points,
                                 const std::vector<int>& indices) {
     Eigen::Vector3d centroid = Eigen::Vector3d::Zero();
@@ -38,7 +39,7 @@ Eigen::Vector3d ComputeCentroid(const std::vector<Eigen::Vector3d>& points,
     return centroid;
 }
 
-Eigen::Vector3d ComputeWeightedCentroid(const open3d::geometry::PointCloud& pcd,
+Eigen::Vector3d ComputeWeightedCentroid(const PointCloud& pcd,
                                         const std::vector<int>& indices,
                                         const std::vector<double>& weights) {
     Eigen::Vector3d centroid = Eigen::Vector3d::Zero();
@@ -78,11 +79,10 @@ Eigen::Vector3d ComputeWeightedCentroid(const open3d::geometry::PointCloud& pcd,
 /// - Invalid indices are skipped.
 /// - If input sizes mismatch or no valid points exist, a zero matrix is
 /// returned.
-Eigen::Matrix3d ComputeWeightedCovariance(
-        const open3d::geometry::PointCloud& pcd,
-        const std::vector<int>& indices,
-        const std::vector<double>& weights,
-        const Eigen::Vector3d& centroid) {
+Eigen::Matrix3d ComputeWeightedCovariance(const PointCloud& pcd,
+                                          const std::vector<int>& indices,
+                                          const std::vector<double>& weights,
+                                          const Eigen::Vector3d& centroid) {
     Eigen::Matrix3d C = Eigen::Matrix3d::Zero();
 
     // ----------------------------
@@ -117,9 +117,9 @@ Eigen::Vector3d ProjectOntoPlane(const Eigen::Vector3d& p,
                                  const Eigen::Vector3d& normal) {
     return p - normal * ((p - centroid).dot(normal));
 }
-
 }  // namespace
 
+// Smoothing functions
 PointCloud PointCloud::SmoothMLS(const KDTreeSearchParam& search_param) const {
     if (points_.empty()) {
         utility::LogWarning(

cpp/tests/geometry/PointCloudSmoothing.cpp

@@ -15,46 +15,19 @@
 namespace open3d {
 namespace tests {
 
-// A point cloud that is a plane with some noise.
-static geometry::PointCloud CreateNoisyPlane(size_t n_points = 100,
-                                             double noise_std = 0.01) {
-    geometry::PointCloud pcd;
-    pcd.points_.resize(n_points);
-
-    std::mt19937 rng(0);  // Fixed seed so that the test is deterministic
-    std::uniform_real_distribution<double> dist_xy(-1.0, 1.0);
-    std::uniform_real_distribution<double> dist_z(-noise_std, noise_std);
-
-    for (size_t i = 0; i < n_points; ++i) {
-        pcd.points_[i] =
-                Eigen::Vector3d(dist_xy(rng), dist_xy(rng), dist_z(rng));
-    }
-    return pcd;
-}
-
-// Computes the average absolute distance to the Z=0 plane.
-static double AveragePlaneDistance(const geometry::PointCloud& pcd) {
-    if (pcd.IsEmpty()) {
-        return 0.0;
-    }
-    double total_dist = 0.0;
-    for (const auto& point : pcd.points_) {
-        total_dist += std::abs(point.z());
-    }
-    return total_dist / pcd.points_.size();
-}
-
 namespace {
-// Helper functions copied from PointCloudSmoothing.cpp for testing.
+// Helper functions for point cloud smoothing tests
 Eigen::Vector3d ComputeCentroid(const std::vector<Eigen::Vector3d>& points,
                                 const std::vector<int>& indices) {
     Eigen::Vector3d centroid = Eigen::Vector3d::Zero();
     if (indices.empty()) {
         return centroid;
     }
+
+    const int n_points = static_cast<int>(points.size());
     int valid_count = 0;
     for (int idx : indices) {
-        if (idx < 0 || idx >= static_cast<int>(points.size())) {
+        if (idx < 0 || idx >= n_points) {
             continue;
         }
         centroid += points[idx];
@@ -76,11 +49,11 @@ Eigen::Vector3d ComputeWeightedCentroid(const open3d::geometry::PointCloud& pcd,
     }
 
     double sum_w = 0.0;
-    const size_t n_points = pcd.points_.size();
+    const int n_points = static_cast<int>(pcd.points_.size());
 
     for (size_t i = 0; i < indices.size(); ++i) {
         int idx = indices[i];
-        if (idx < 0 || idx >= static_cast<int>(n_points)) {
+        if (idx < 0 || idx >= n_points) {
             continue;
         }
 
@@ -102,18 +75,24 @@ Eigen::Matrix3d ComputeWeightedCovariance(
         const std::vector<double>& weights,
         const Eigen::Vector3d& centroid) {
     Eigen::Matrix3d C = Eigen::Matrix3d::Zero();
+
     if (indices.size() != weights.size() || indices.empty()) {
         return C;
     }
-    const size_t n_points = pcd.points_.size();
+
+    const int n_points = static_cast<int>(pcd.points_.size());
+
     for (size_t i = 0; i < indices.size(); ++i) {
         const int idx = indices[i];
-        if (idx < 0 || idx >= static_cast<int>(n_points)) {
+
+        if (idx < 0 || idx >= n_points) {
             continue;
         }
+
         const Eigen::Vector3d diff = pcd.points_[idx] - centroid;
         C.noalias() += weights[i] * diff * diff.transpose();
     }
+
     return C;
 }
 
@@ -124,6 +103,35 @@ Eigen::Vector3d ProjectOntoPlane(const Eigen::Vector3d& p,
 }
 }  // namespace
 
+// A point cloud that is a plane with some noise.
+static geometry::PointCloud CreateNoisyPlane(size_t n_points = 100,
+                                             double noise_std = 0.01) {
+    geometry::PointCloud pcd;
+    pcd.points_.resize(n_points);
+
+    std::mt19937 rng(0);  // Fixed seed so that the test is deterministic
+    std::uniform_real_distribution<double> dist_xy(-1.0, 1.0);
+    std::uniform_real_distribution<double> dist_z(-noise_std, noise_std);
+
+    for (size_t i = 0; i < n_points; ++i) {
+        pcd.points_[i] =
+                Eigen::Vector3d(dist_xy(rng), dist_xy(rng), dist_z(rng));
+    }
+    return pcd;
+}
+
+// Computes the average absolute distance to the Z=0 plane.
+static double AveragePlaneDistance(const geometry::PointCloud& pcd) {
+    if (pcd.IsEmpty()) {
+        return 0.0;
+    }
+    double total_dist = 0.0;
+    for (const auto& point : pcd.points_) {
+        total_dist += std::abs(point.z());
+    }
+    return total_dist / pcd.points_.size();
+}
+
 TEST(PointCloudSmoothingHelpers, ComputeCentroid) {
     std::vector<Eigen::Vector3d> points = {
             {0, 0, 0}, {1, 1, 1}, {2, 2, 2}, {-1, -1, -1}};