TriWildMesh.h

#pragma once
 
#include <wmtk/MeshData.hpp>
 
#include <wmtk/TriOptimizerMesh.h>
 
#include <wmtk/SurfaceTagAttributes.h>
#include <cstdlib>
 
#include <wmtk/utils/PartitionMesh.h>
#include <wmtk/utils/VectorUtils.h>
#include <polysolve/nonlinear/Problem.hpp>
#include <wmtk/AttributeCollection.hpp>
#include <wmtk/Types.hpp>
#include <wmtk/envelope/CompositeEnvelopes.hpp>
#include <wmtk/envelope/Envelope.hpp>
#include <wmtk/optimization/SmoothVertex.hpp>
#include <wmtk/optimization/solver.hpp>
#include <wmtk/threading/enumerable_thread_specific.hpp>
 
// clang-format off
#include <wmtk/utils/DisableWarnings.hpp>
#include <fastenvelope/FastEnvelope.h>
#include <wmtk/utils/EnableWarnings.hpp>
// clang-format on
 
#include "Parameters.h"
 
#include <memory>
#include <set>
 
namespace wmtk::components::triwild {
 
using VertexAttributes = wmtk::TriOptimizerMesh::VertexAttributes;
using EdgeAttributes = wmtk::TriOptimizerMesh::EdgeAttributes;
using FaceAttributes = wmtk::TriOptimizerMesh::FaceAttributes;
 
class TriWildMesh : public wmtk::TriOptimizerMesh
{
public:
    Parameters& m_tri_params;
 
    std::vector<Vector2d> m_V_envelope;
    std::vector<Vector2i> m_E_envelope;
 
    wmtk::InputEnvelopes m_input_envelopes;
 
    std::shared_ptr<Envelope> surface_envelope_for_edge(
        const std::array<size_t, 2>& vids,
        const EdgeAttributes& attr) const override
    {
        if (m_input_envelopes.empty() || !attr.m_is_surface_fs) return m_envelope;
        return m_input_envelopes.containment(attr.input_set());
    }
 
    std::shared_ptr<Envelope> smoothing_energy_envelope(const size_t vid) const override;
 
    // The curve network's 0-dimensional features are anchored by the base
    // (TriOptimizerMesh's feature-point anchors), turned on in the constructor with
    // m_feature_eps = the envelope eps. init_mesh fills m_feature_points from the
    // arrangement's constrained edges: a vertex whose valence in that edge set is neither 0
    // nor 2 is a feature -- valence 1 is an open polyline's endpoint, valence >= 3 a
    // junction -- plus the input free points. Reading it off the arrangement rather than the
    // raw input is deliberate: it is the network the optimizer actually starts from, so a
    // junction the simplification was allowed to merge (which it may, without
    // preserve_topology) is correctly absent, and no provenance or
    // position-matching plumbing is needed.
 
    TriWildMesh(Parameters& _m_params, double envelope_eps, int _num_threads = 0)
        : wmtk::TriOptimizerMesh(_m_params)
        , m_tri_params(_m_params)
    {
        // Registered unconditionally, as the ids always were: the driver exports and audits
        // the anchors whether or not preserve_feature_points turns the policy on.
        enable_feature_point_tracking(m_tri_params.preserve_feature_points);
        m_feature_eps = envelope_eps;
        m_envelope_eps = envelope_eps;
        NUM_THREADS = _num_threads;
 
        optimization::deactivate_opt_logger();
 
        double& wa = m_params.w_amips;
        double& we = m_params.w_envelope;
        we = 1 - wa;
        logger().info("w_envelope = {}", we);
    }
 
    ~TriWildMesh() {}
 
public:
    void init_mesh(
        const MatrixXd& V,
        const std::vector<Vector2r>& V_rational,
        const MatrixXi& F,
        const MatrixXi& E,
        const std::vector<std::string>& tag_names,
        const MatrixXd& V_env,
        const MatrixXi& E_env,
        const std::vector<int>* E_orientation = nullptr,
        const std::vector<size_t>& free_point_vids = {},
        const std::vector<int>* E_env_input = nullptr,
        const std::vector<InputSet>* E_input_set = nullptr);
 
    void init_surfaces_and_boundaries();
 
    void init_envelope(const MatrixXd& V, const MatrixXi& F);
 
    size_t refine_sizing_around_worst(double max_energy) override;
 
 
    void write_vtu(const std::string& path, MeshMap* output = nullptr) const;
 
public:
    void compute_winding_numbers(const std::vector<MatrixXd>& Vs, const std::vector<MatrixXi>& Es);
 
    void filter_with_input_winding_number();
 
    void compute_tracked_winding_number();
    void filter_with_tracked_winding_number();
    void filter_with_flood_fill();
 
    int flood_fill();
    bool m_has_parts = false;
 
protected:
    void write_smoothing_debug_output(const std::string& path) const override { write_vtu(path); }
};
 
 
} // namespace wmtk::components::triwild