Parameters.h

#pragma once
 
#include <wmtk/OptimizerParameters.h>
 
#include <nlohmann/json.hpp>
 
namespace wmtk::components::triwild {
struct Parameters : public wmtk::OptimizerParameters
{
    Vector2d box_min = Vector2d::Zero();
    Vector2d box_max = Vector2d::Ones();
 
    bool preserve_feature_points = true;
 
    bool allow_junction_cleanup = true;
 
    bool check_envelope_at_init = false;
 
    bool use_sample_envelope = false;
 
    Parameters() = default;
 
    Parameters(const nlohmann::json& json_params)
    {
        epsr = json_params["eps_rel"];
        lr = json_params["length_rel"];
        stop_energy = json_params["stop_energy"];
        preserve_topology = json_params["preserve_topology"];
        optimize_envelope_around_simplified = json_params["optimize_envelope_around_simplified"];
        preserve_feature_points = json_params["preserve_feature_points"];
        allow_junction_cleanup = json_params["allow_junction_cleanup"];
 
        debug_output = json_params["DEBUG_output"];
        perform_sanity_checks = json_params["DEBUG_sanity_checks"];
        check_envelope_at_init = json_params["DEBUG_envelope_sanity_check"];
        use_sample_envelope = json_params["use_sample_envelope"];
 
        split_high_valence_threshold = json_params["split_high_valence_threshold"];
        w_amips = json_params["w_amips"];
        smoothing_mode = json_params["smoothing_mode"];
        project_line_search_steps = json_params["project_line_search_steps"];
        project_line_search_nested_steps = json_params["project_line_search_nested_steps"];
        num_smoothing_passes = json_params["num_smoothing_passes"];
        interleaved_smoothing = json_params["interleaved_smoothing"];
        interleaved_smoothing_passes = json_params["interleaved_smoothing_passes"];
 
        // Coarsening pass.
        coarsen_pass = json_params["coarsen_pass"];
        coarsen_unbounded = json_params["coarsen_unbounded"];
        coarsen_local_smoothing_passes = json_params["coarsen_local_smoothing_passes"];
        coarsen_smooth_ring = json_params["coarsen_smooth_ring"];
        coarsen_global_smoothing_passes = json_params["coarsen_global_smoothing_passes"];
        coarsen_max_rounds = json_params["coarsen_max_rounds"];
        coarsen_max_inner_passes = json_params["coarsen_max_inner_passes"];
 
        // Stuck-element sizing refinement.
        stuck_refine_stall_eps = json_params["stuck_refine_stall_eps"];
        stuck_refine_cooldown = json_params["stuck_refine_cooldown"];
        stuck_refine_num_worst = json_params["stuck_refine_num_worst"];
        stuck_refine_rings = json_params["stuck_refine_rings"];
        stuck_refine_factor = json_params["stuck_refine_factor"];
        stuck_refine_min_scalar = json_params["stuck_refine_min_scalar"];
        stuck_refine_gradation = json_params["stuck_refine_gradation"];
        stuck_refine_force_split = json_params["stuck_refine_force_split"];
 
        // Skip good regions.
        skip_good_regions = json_params["skip_good_regions"];
        skip_good_regions_margin = json_params["skip_good_regions_margin"];
    }
 
    void init(const Vector2d& min_, const Vector2d& max_)
    {
        box_min = min_;
        box_max = max_;
        init_lengths_from_diagonal((box_max - box_min).norm());
        l_min = eps;
    }
    void init(
        const std::vector<Vector2d>& vertices,
        const std::vector<std::array<size_t, 3>>& faces)
    {
        Vector2d min_, max_;
        for (size_t i = 0; i < vertices.size(); i++) {
            if (i == 0) {
                min_ = vertices[i];
                max_ = vertices[i];
                continue;
            }
            for (int j = 0; j < 2; j++) {
                if (vertices[i][j] < min_[j]) {
                    min_[j] = vertices[i][j];
                }
                if (vertices[i][j] > max_[j]) {
                    max_[j] = vertices[i][j];
                }
            }
        }
 
        init(min_, max_);
    }
};
} // namespace wmtk::components::triwild