energy

CMakeLists.txt

@@ -94,6 +94,11 @@ include(metis)
 include(gmp)
 include(probabilistic_quadrics)
 
+# Dependencies for images
+include(stb)
+include(tinyexr)
+
+
 include(lagrange)
 lagrange_include_modules(bvh)
 
@@ -134,7 +139,12 @@ wmtk_target_link_system_libraries(wildmeshing_toolkit PUBLIC
     probabilistic_quadrics::probabilistic_quadrics
     paraviewo::paraviewo
     gmp::gmp
-)
+
+
+    miniz # MTAO: I had a build issue with windows not finding miniz at linktime - adding here to make sure it's there?
+    tinyexr
+    stb::image
+    )
 
 include(nlohmann_json)
 

components/wmtk_components/isotropic_remeshing/internal/IsotropicRemeshing.cpp

@@ -57,6 +57,8 @@ IsotropicRemeshing::IsotropicRemeshing(TriMesh& mesh, const double length, const
         op_settings.smooth_settings.position = m_position_handle;
         op_settings.smooth_settings.smooth_boundary = !m_lock_boundary;
 
+        op_settings.smooth_settings.initialize_invariants(m_mesh);
+
         m_scheduler.add_operation_type<tri_mesh::VertexTangentialLaplacianSmooth>(
             "smooth",
             op_settings);

src/wmtk/CMakeLists.txt

@@ -32,12 +32,20 @@ set(SRC_FILES
 )
 target_sources(wildmeshing_toolkit PRIVATE ${SRC_FILES})
 
+
+
+
 add_subdirectory(io)
 add_subdirectory(utils)
 add_subdirectory(attribute)
 add_subdirectory(simplex)
 add_subdirectory(operations)
+add_subdirectory(optimization)
 add_subdirectory(autogen)
+
 add_subdirectory(invariants)
 add_subdirectory(multimesh)
 
+add_subdirectory(function)
+add_subdirectory(image)
+

src/wmtk/Scheduler.cpp

@@ -27,6 +27,7 @@ void Scheduler::run_operation_on_all(PrimitiveType type, const std::string& name
     // enqueue_operations(ops);
     // TODO: pick some strategy for running these operations
     // tbb::parallel_for(ops, [&](const auto& ops) { (*op)(); });
+    spdlog::info("Ran {} [{}] ops, {} succeeded, {} failed", number_of_performed_operations(), name, number_of_successful_operations(), number_of_failed_operations());
 }
 
 void Scheduler::enqueue_operations(std::vector<std::unique_ptr<operations::Operation>>&& ops)

src/wmtk/Scheduler.hpp

@@ -5,7 +5,6 @@
 #include "operations/Operation.hpp"
 #include "operations/OperationFactory.hpp"
 
-
 namespace wmtk {
 
 //  Scheduler scheduler;
@@ -31,20 +30,37 @@ class Scheduler
     //        primitive_type,
     //        std::forward<Args>(args)...);
     //}
+
+    const operations::OperationFactoryBase& add_operation_factory(
+        const std::string& name,
+        std::unique_ptr<operations::OperationFactoryBase>&& ptr)
+    {
+        return *(m_factories[name] = std::move(ptr));
+    }
     template <typename OperationType>
-    void add_operation_type(const std::string& name)
+    const operations::OperationFactory<OperationType>& add_operation_type(
+        const std::string& name,
+        const operations::OperationSettings<OperationType>& settings)
     {
-        m_factories[name] = std::make_unique<operations::OperationFactory<OperationType>>();
+        return static_cast<const operations::OperationFactory<OperationType>&>(
+            add_operation_factory(
+                name,
+                std::make_unique<operations::OperationFactory<OperationType>>(settings)));
     }
 
     template <typename OperationType>
-    void add_operation_type(
+    const operations::OperationFactory<OperationType>& add_operation_type(
         const std::string& name,
-        const operations::OperationSettings<OperationType>& settings)
+        operations::OperationSettings<OperationType>&& settings)
     {
-        m_factories[name] = std::make_unique<operations::OperationFactory<OperationType>>(settings);
+        return static_cast<const operations::OperationFactory<OperationType>&>(
+            add_operation_factory(
+                name,
+                std::make_unique<operations::OperationFactory<OperationType>>(
+                    std::move(settings))));
     }
 
+
     void enqueue_operations(std::vector<std::unique_ptr<operations::Operation>>&& ops);
 
 

src/wmtk/Types.hpp

@@ -6,11 +6,21 @@ namespace wmtk {
 template <typename T, int C>
 using RowVectors = Eigen::Matrix<T, Eigen::Dynamic, C>;
 
+template <typename T, int R>
+using SquareMatrix = Eigen::Matrix<T, R, R>;
+
 template <typename T, int R>
 using Vector = Eigen::Matrix<T, R, 1>;
 template <typename T>
 using VectorX = Vector<T, Eigen::Dynamic>;
 
+template <typename T>
+using Vector2 = Vector<T, 2>;
+template <typename T>
+using Vector3 = Vector<T, 3>;
+template <typename T>
+using Vector4 = Vector<T, 4>;
+
 template <typename T, int C>
 using RowVector = Eigen::Matrix<T, 1, C>;
 template <typename T>

src/wmtk/attribute/AttributeHandle.hpp

@@ -2,7 +2,7 @@
 #include <type_traits>
 #include "wmtk/Primitive.hpp"
 namespace wmtk {
-    class Mesh;
+class Mesh;
 namespace attribute {
 template <typename T>
 class MeshAttributes;
@@ -36,6 +36,8 @@ class AttributeHandle
 
 
     bool operator==(const AttributeHandle& other) const { return index == other.index; }
+
+    bool is_valid() const { return index != -1; }
 };
 
 template <typename T>
@@ -71,6 +73,8 @@ class MeshAttributeHandle
         return std::is_same_v<T, U> && m_base_handle == o.m_base_handle &&
                m_primitive_type == o.m_primitive_type;
     }
+    bool is_valid() const { return m_base_handle.is_valid(); }
+    PrimitiveType primitive_type() const { return m_primitive_type; }
 };
 } // namespace attribute
 using AttributeHandle = attribute::AttributeHandle;

src/wmtk/attribute/MutableAccessor.hpp

@@ -35,6 +35,8 @@ class MutableAccessor : public ConstAccessor<T>
     using CachingBaseType::mesh;
     using CachingBaseType::stack_depth;
 
+    using ConstAccessorType::mesh;
+
 protected:
     using ConstAccessorType::base_type;
     using ConstAccessorType::caching_base_type;

src/wmtk/function/AMIPS.cpp

@@ -0,0 +1,9 @@
+#include "AMIPS.hpp"
+#include <wmtk/TriMesh.hpp>
+
+namespace wmtk::function {
+AMIPS::AMIPS(const TriMesh& mesh, const MeshAttributeHandle<double>& vertex_attribute_handle)
+    : AutodiffFunction(mesh, PrimitiveType::Face, vertex_attribute_handle)
+{}
+
+} // namespace wmtk::function

src/wmtk/function/AMIPS.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include "AutodiffFunction.hpp"
+namespace wmtk::function {
+class AMIPS : public AutodiffFunction
+{
+public:
+    AMIPS(const TriMesh& mesh, const MeshAttributeHandle<double>& vertex_attribute_handle);
+};
+
+} // namespace wmtk::function