Simple init from bootstrap

Author: csparker247

CMakeLists.txt

@@ -1,8 +1,12 @@
 cmake_minimum_required(VERSION 3.17)
-project(abf++)
+project(OpenABF)
 
 set(CMAKE_CXX_STANDARD 14)
 
 include_directories(${CMAKE_SOURCE_DIR}/include)
+set(public_hdrs
+    include/OpenABF/ABF.hpp
+    include/OpenABF/HalfEdgeMesh.hpp
+)
 
-add_executable(abf_test main.cpp)
+add_executable(abf_test ${public_hdrs} main.cpp)

README.md

@@ -1 +1 @@
-# ABF++
+# OpenABF

include/OpenABF/ABF.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "OpenABF/HalfEdgeMesh.hpp"
+
+namespace OpenABF
+{
+
+template <typename T, size_t Dims = 3>
+class ABF
+{
+    struct VertProperties {
+    };
+
+    struct EdgeProperties {
+        T alpha{0};
+        T beta{0};
+        T weight{0};
+    };
+
+    struct FaceProperties {
+    };
+
+    using HEM =
+        HalfEdgeMesh<T, Dims, VertProperties, EdgeProperties, FaceProperties>;
+
+public:
+    HEM mesh;
+};
+
+}  // namespace OpenABF

include/abf++/HalfEdgeMesh.hpp include/OpenABF/HalfEdgeMesh.hppinclude/abf++/HalfEdgeMesh.hpp renamed to include/OpenABF/HalfEdgeMesh.hpp

@@ -3,10 +3,14 @@
 #include <algorithm>
 #include <array>
 #include <iostream>
+#include <iterator>
 #include <map>
 #include <memory>
 #include <vector>
 
+namespace OpenABF
+{
+
 namespace detail
 {
 struct ExpandType {
@@ -17,19 +21,24 @@ struct ExpandType {
 };
 }  // namespace detail
 
-struct DefaultEdgeProperties {
-};
+template <typename T>
 struct DefaultVertexProperties {
 };
+
+template <typename T>
+struct DefaultEdgeProperties {
+};
+
+template <typename T>
 struct DefaultFaceProperties {
 };
 
 template <
-    typename T = float,
+    typename T,
     size_t Dim = 3,
-    typename VertexProperties = DefaultVertexProperties,
-    typename EdgeProperties = DefaultEdgeProperties,
-    typename FaceProperties = DefaultFaceProperties>
+    typename VertexProperties = DefaultVertexProperties<T>,
+    typename EdgeProperties = DefaultEdgeProperties<T>,
+    typename FaceProperties = DefaultFaceProperties<T>>
 class HalfEdgeMesh
 {
 private:
@@ -57,13 +66,31 @@ class HalfEdgeMesh
             return std::make_shared<Vertex>(std::forward<Args>(args)...);
         }
 
-        bool is_boundary() const
+        auto edges() -> std::vector<EdgePtr>
         {
-            if (edge) {
-                return edge->pair == nullptr;
-            }
-            throw std::runtime_error(
-                "Unreferenced vertex: " + std::to_string(idx));
+            std::vector<EdgePtr> ret;
+            auto e = edge;
+            do {
+                if (not e->pair) {
+                    throw std::runtime_error(
+                        "Cannot enumerate edges for boundary_vertices vertex.");
+                }
+                ret.push_back(e);
+                e = e->pair->next;
+            } while (e != edge);
+            return ret;
+        }
+
+        auto is_boundary() const -> bool
+        {
+            auto e = edge;
+            do {
+                if (not e->pair) {
+                    return true;
+                }
+                e = e->pair->next;
+            } while (e != edge);
+            return false;
         }
 
         size_t idx{0};
@@ -78,6 +105,8 @@ class HalfEdgeMesh
             return std::make_shared<Edge>(std::forward<Args>(args)...);
         }
 
+        auto is_boundary() const -> bool { return pair == nullptr; }
+
         EdgePtr pair;
         EdgePtr next;
         VertPtr vertex;
@@ -102,7 +131,7 @@ class HalfEdgeMesh
     HalfEdgeMesh() = default;
 
     template <typename... Args>
-    size_t insertVertex(Args... args)
+    auto insertVertex(Args... args) -> size_t
     {
         auto vert = Vertex::New(std::forward<Args>(args)...);
         vert->idx = verts_.size();
@@ -111,7 +140,7 @@ class HalfEdgeMesh
     }
 
     template <typename... Args>
-    size_t insertFace(Args... args)
+    auto insertFace(Args... args) -> size_t
     {
         // Make a new face structure
         auto face = Face::New();
@@ -121,6 +150,7 @@ class HalfEdgeMesh
         EdgePtr prevEdge;
         for (const auto& idx : {args...}) {
             // Make a new edge
+            // TODO: Make sure edge doesn't already exist?
             auto newEdge = Edge::New();
             newEdge->face = face;
 
@@ -178,9 +208,33 @@ class HalfEdgeMesh
         return faces_.size() - 1;
     }
 
+    auto vertices() -> std::vector<VertPtr> { return verts_; }
+
+    auto edges() -> std::vector<EdgePtr> { return edges_; }
+
+    auto faces() -> std::vector<FacePtr> { return faces_; }
+
+    auto interior_vertices() -> std::vector<VertPtr>
+    {
+        std::vector<VertPtr> ret;
+        std::copy_if(
+            verts_.begin(), verts_.end(), std::back_inserter(ret),
+            [](auto x) { return not x->is_boundary(); });
+        return ret;
+    }
+
+    auto boundary_vertices() -> std::vector<VertPtr>
+    {
+        std::vector<VertPtr> ret;
+        std::copy_if(
+            verts_.begin(), verts_.end(), std::back_inserter(ret),
+            [](auto x) { return x->is_boundary(); });
+        return ret;
+    }
+
 private:
     // Find edge by start and end vertex indices
-    EdgePtr find_edge_(size_t start, size_t end)
+    auto find_edge_(size_t start, size_t end) -> EdgePtr
     {
         // Get edges with this start index
         auto range = edges_.equal_range(start);
@@ -194,4 +248,5 @@ class HalfEdgeMesh
         }
         return nullptr;
     }
-};
+};
+}  // namespace OpenABF

include/abf++/ABF.hpp

@@ -1,19 +1,41 @@
 #include <iostream>
 
-#include "abf++/ABF.hpp"
-#include "abf++/HalfEdgeMesh.hpp"
+#include "OpenABF/ABF.hpp"
+#include "OpenABF/HalfEdgeMesh.hpp"
 
 int main()
 {
-    HalfEdgeMesh<> hem;
+    OpenABF::ABF<float> abf;
 
-    hem.insertVertex(0, 0, 0);
-    hem.insertVertex(1, 0, 0);
-    hem.insertVertex(1, -1, 0);
-    hem.insertVertex(1, 1, 0);
+    abf.mesh.insertVertex(0, 0, 0);
+    abf.mesh.insertVertex(1, 0, 0);
+    abf.mesh.insertVertex(1, -1, 0);
+    abf.mesh.insertVertex(1, 1, 0);
 
-    hem.insertFace(0, 1, 2);
-    hem.insertFace(0, 3, 1);
+    abf.mesh.insertFace(0, 1, 2);
+    abf.mesh.insertFace(0, 3, 1);
+    abf.mesh.insertFace(0, 2, 3);
 
-    std::cout << "End." << std::endl;
+    std::cout << "Interior vertices: [edges]" << std::endl;
+    size_t count{0};
+    for (const auto& v : abf.mesh.interior_vertices()) {
+        std::cout << "\t- Vertex " << v->idx << ": ";
+        for (const auto& e : v->edges()) {
+            if (count++ > 0) {
+                std::cout << ", ";
+            }
+            std::cout << e->vertex->idx << "<->" << e->next->vertex->idx;
+        }
+    }
+    std::cout << std::endl;
+
+    std::cout << "Boundary vertices: ";
+    count = 0;
+    for (const auto& v : abf.mesh.boundary_vertices()) {
+        if (count++ > 0) {
+            std::cout << ", ";
+        }
+        std::cout << v->idx;
+    }
+    std::cout << std::endl;
 }