Solidifier.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 Povl Filip Sonne-Frederiksen
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
#include "reusex/reconstruction/CellComplex.hpp"
 
#include <functional>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace reusex::geometry {

enum class SolveStatus {
  not_solved,
  optimal,
  feasible,
  infeasible,
  unbounded,
  time_limit,
  iteration_limit,
  numerical_error,
  error
};

const char *to_string(SolveStatus status);

enum class SolverChoice { automatic, cuopt, highs };

SolverChoice parse_solver_choice(const std::string &s);
 
struct SolidifierOptions {
  double time_limit_seconds = 120.0;

  double alpha = 0.04;

  double mip_gap = -1.0;

  bool sectioned = true;

  size_t sectioned_threshold = 2000;

  SolverChoice solver = SolverChoice::automatic;
};

struct SectionSolveStats {
  int section = -1;       
  size_t cells = 0;       
  size_t variables = 0;   
  size_t constraints = 0; 
  double seconds = 0.0;   
  SolveStatus status = SolveStatus::not_solved; 
  bool used_highs_fallback = false; 
};

class Solidifier {
    public:
  using Fd = CellComplex::Vertex;
  using Cd = CellComplex::Vertex;
 
  Solidifier() = delete;
  explicit Solidifier(std::shared_ptr<const CellComplex> cc,
                      SolidifierOptions options = SolidifierOptions{});
  ~Solidifier();
 
  // Delete copy (contains unique_ptr to incomplete type)
  Solidifier(const Solidifier &) = delete;
  Solidifier &operator=(const Solidifier &) = delete;
 
  // Delete move (simpler, could be implemented if needed)
  Solidifier(Solidifier &&) = delete;
  Solidifier &operator=(Solidifier &&) = delete;

  std::optional<std::pair<std::unordered_map<Cd, int>,
                          std::unordered_map<Cd, std::set<int>>>>
  solve();

  SolveStatus last_solve_status() const;

  const std::vector<SectionSolveStats> &section_stats() const;

  std::pair<Eigen::MatrixXd, Eigen::MatrixXi>
  toMesh(std::function<bool(const Cd)> filter);
 
    protected:
  // Internal accessor for implementations in separate compilation units
  std::shared_ptr<const CellComplex> get_cell_complex() const;
 
    private:
  class Impl;
  std::unique_ptr<Impl> pimpl_;
};
 
} // namespace reusex::geometry