refactor: create mesh point cloud

Author: oktomus

CMakeLists.txt

@@ -98,13 +98,15 @@ set (core_sources
     "${SRC_DIR}/core/math.h"
     "${SRC_DIR}/core/mesh.cpp"
     "${SRC_DIR}/core/mesh.h"
+    "${SRC_DIR}/core/mesh_point_cloud.cpp"
+    "${SRC_DIR}/core/mesh_point_cloud.h"
     "${SRC_DIR}/core/rasterized_mesh.cpp"
     "${SRC_DIR}/core/rasterized_mesh.h"
     "${SRC_DIR}/core/scene.cpp"
     "${SRC_DIR}/core/scene.h"
     "${SRC_DIR}/core/scene_loader.cpp"
     "${SRC_DIR}/core/scene_loader.h"
-    "${SRC_DIR}/thirdparty/nanoflann.hpp"
+    "${SRC_DIR}/thirdparty/nanoflann/nanoflann.hpp"
 )
 
 add_library(

src/core/closest_point_query.cpp

@@ -2,16 +2,27 @@
 
 #include "math.h"
 
+#include <chrono>
 #include <cstddef>
+#include <inttypes.h>
+#include <iostream>
 #include <limits>
 #include <vector>
 
 namespace core
 {
 
-ClosestPointQuery::ClosestPointQuery(const Mesh& mesh)
-  : m_mesh(mesh)
-{}
+ClosestPointQuery::ClosestPointQuery(const MeshPointCloud& mesh_point_cloud)
+  : m_mesh_point_cloud(mesh_point_cloud)
+{
+    // Start a timer to know how long it takes to build the query object.
+    auto timer_start = std::chrono::high_resolution_clock::now();
+
+    auto timer_stop = std::chrono::high_resolution_clock::now();
+    auto process_time = std::chrono::duration_cast<std::chrono::milliseconds>(timer_stop - timer_start).count();
+
+    std::printf("Generated mesh query tree in %" PRId64 "ms.", process_time);
+}
 
 bool ClosestPointQuery::get_closest_point(
     const glm::vec3&    query_point,
@@ -20,11 +31,7 @@ bool ClosestPointQuery::get_closest_point(
 {
     assert(max_distance > 0.0f);
 
-    const std::vector<Mesh::Vertex>& vertices = m_mesh.get_vertices();
-    const std::size_t vertex_count = vertices.size();
-    const std::vector<unsigned int>& triangles = m_mesh.get_triangles();
-    assert(triangles.size() % 3 == 0);
-    const std::size_t triangle_count = triangles.size() / 3;
+    const std::size_t triangle_count = m_mesh_point_cloud.kdtree_get_point_count() / 3;
 
     //=> Naive implementation.
     // 1. Go through each triangle
@@ -36,13 +43,9 @@ bool ClosestPointQuery::get_closest_point(
 
     for (std::size_t triangle_index = 0; triangle_index < triangle_count; ++triangle_index)
     {
-        const std::size_t v1_index = triangles[triangle_index * 3];
-        const std::size_t v2_index = triangles[triangle_index * 3 + 1];
-        const std::size_t v3_index = triangles[triangle_index * 3 + 2];
-
-        const glm::vec3& v1 = vertices[v1_index].pos;
-        const glm::vec3& v2 = vertices[v2_index].pos;
-        const glm::vec3& v3 = vertices[v3_index].pos;
+        const glm::vec3& v1 = m_mesh_point_cloud.kdtree_get_pt(triangle_index * 3);
+        const glm::vec3& v2 = m_mesh_point_cloud.kdtree_get_pt(triangle_index * 3 + 1);
+        const glm::vec3& v3 = m_mesh_point_cloud.kdtree_get_pt(triangle_index * 3 + 2);
 
         bool success = false;
         const glm::vec3 p = closest_point_in_triangle(

src/core/closest_point_query.h

@@ -1,16 +1,28 @@
 #pragma once
 
-#include "mesh.h"
+#include "mesh_point_cloud.h"
 
+#include <nanoflann/nanoflann.hpp>
 #include <glm/glm.hpp>
 
+#include <vector>
+
 namespace core
 {
 
+/**
+ * @brief Fast closest point to mesh.
+ *
+ * After creating the query object, just call
+ * `get_closest_point`.
+ *
+ * When creating the query object, a tree will
+ * be generated to speed up look up time.
+ */
 class ClosestPointQuery
 {
   public:
-    ClosestPointQuery(const Mesh& mesh);
+    ClosestPointQuery(const MeshPointCloud& mesh_point_cloud);
 
     /**
      * @brief Return the closest point on the mesh within the specified maximum search distance.
@@ -21,7 +33,7 @@ class ClosestPointQuery
         glm::vec3&          result) const;
 
   private:
-    const Mesh& m_mesh;
+    const MeshPointCloud& m_mesh_point_cloud;
 };
 
 } // namespace core

src/core/mesh_point_cloud.cpp

@@ -0,0 +1,31 @@
+#include "mesh_point_cloud.h"
+
+namespace core
+{
+
+MeshPointCloud::MeshPointCloud(const Mesh& mesh)
+  : m_mesh(mesh)
+{
+    // Add all mesh vertices in the point cloud.
+    // TODO: Uniform sample the mesh to generate a denser cloud.
+    const std::vector<Mesh::Vertex>& vertices = m_mesh.get_vertices();
+    const std::size_t vertex_count = vertices.size();
+    const std::vector<unsigned int>& triangles = m_mesh.get_triangles();
+    assert(triangles.size() % 3 == 0);
+    const std::size_t triangle_count = triangles.size() / 3;
+
+    m_points.reserve(triangle_count * 3);
+
+    for (std::size_t triangle_index = 0; triangle_index < triangle_count; ++triangle_index)
+    {
+        const std::size_t v1_index = triangles[triangle_index * 3];
+        const std::size_t v2_index = triangles[triangle_index * 3 + 1];
+        const std::size_t v3_index = triangles[triangle_index * 3 + 2];
+
+        m_points.push_back(vertices[v1_index].pos);
+        m_points.push_back(vertices[v2_index].pos);
+        m_points.push_back(vertices[v3_index].pos);
+    }
+}
+
+} // namespace core

src/core/mesh_point_cloud.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "mesh.h"
+
+#include <nanoflann/nanoflann.hpp>
+#include <glm/glm.hpp>
+
+#include <cstdint>
+#include <vector>
+
+namespace core
+{
+
+/**
+ * @brief Create a point cloud using a mesh.
+ * TODO: Allow to generate points on the mesh to
+ * increase precision.
+ */
+class MeshPointCloud
+{
+  public:
+    MeshPointCloud(const Mesh& mesh);
+
+    // nanoflann compatibility implementaiton.
+    inline std::size_t kdtree_get_point_count() const
+    {
+        return m_points.size();
+    }
+
+    inline float kdtree_get_pt(const std::size_t idx, int dim) const
+    {
+        if (dim == 0)
+            return m_points[idx].x;
+        else if (dim == 1)
+            return m_points[idx].y;
+        else
+            return m_points[idx].z;
+    }
+
+    inline glm::vec3 kdtree_get_pt(const std::size_t idx) const
+    {
+        return m_points[idx];
+    }
+
+    template<class BBOX>
+    bool kdtree_get_bbox(BBOX&) const
+    { return false; }
+
+  private:
+    const Mesh&             m_mesh;
+    std::vector<glm::vec3>  m_points;
+};
+
+} // namespace core

src/gui/mainwindow.cpp

@@ -5,6 +5,7 @@
 
 // core includes.
 #include "core/closest_point_query.h"
+#include "core/mesh_point_cloud.h"
 #include "core/scene.h"
 #include "core/scene_loader.h"
 
@@ -158,9 +159,11 @@ void MainWindow::load_scene(const std::string& path)
     // Load the scene.
     m_scene.reset(core::load_scene_from_file(path));
 
+    // Build a point cloud of the mesh.
+    m_mesh_point_cloud.reset(new core::MeshPointCloud(m_scene->get_mesh()));
+
     // Prepare closest point queries.
-    core::ClosestPointQuery* query = new core::ClosestPointQuery(m_scene->get_mesh());
-    m_closest_point_query.reset(query);
+    m_closest_point_query.reset(new core::ClosestPointQuery(*m_mesh_point_cloud));
 }
 
 // Constructor.
@@ -322,10 +325,13 @@ void MainWindow::find_closest_point()
     auto timer_start = std::chrono::high_resolution_clock::now();
 
     // Run the query.
-    m_closest_point_found = run && m_closest_point_query->get_closest_point(
-        m_query_point_pos,
-        m_query_point_max_serach_radius,
-        m_closest_point_pos);
+    for (int i = 0; i < 100; ++i)
+    {
+        m_closest_point_found = run && m_closest_point_query->get_closest_point(
+            m_query_point_pos,
+            m_query_point_max_serach_radius,
+            m_closest_point_pos);
+    }
 
     auto timer_stop = std::chrono::high_resolution_clock::now();
     m_closest_point_query_time = std::chrono::duration_cast<std::chrono::milliseconds>(timer_stop - timer_start).count();

src/gui/mainwindow.h

@@ -12,6 +12,7 @@
 // Forward declarations.
 class GLFWwindow;
 namespace core { class ClosestPointQuery; }
+namespace core { class MeshPointCloud; }
 namespace core { class Scene; }
 
 namespace gui
@@ -66,6 +67,7 @@ class MainWindow
     std::unique_ptr<Shader>                   m_drawing_shader;
     std::unique_ptr<Shader>                   m_point_shader;
 
+    std::unique_ptr<core::MeshPointCloud>     m_mesh_point_cloud;
     std::unique_ptr<core::ClosestPointQuery>  m_closest_point_query;
     glm::vec3                                 m_query_point_pos;
     float                                     m_query_point_max_serach_radius;