MeshFitter.h

#pragma once

#include "MeasurementModel.h"
#include "Mesh.h"
#include "VoxelVolume.h"

#include "Optional.h"
#include "propagate_const.h"

#include <array>
#include <memory>
#include <variant>

namespace CortidQCT {

namespace Internal {
struct PrivateStateAccessor;
}

struct Coordinate3D {
  enum class Type { absolute, relative };

  std::array<float, 3> xyz{{0, 0, 0}};
  Type type{Type::absolute};
};

class MeshFitter {
  class Impl;

public:
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"

  struct Configuration {
    enum class OriginType { untouched, centered };
    using Origin = std::variant<OriginType, Coordinate3D>;
    using ScaleVector = std::array<float, 3>;

    using RotationVector = std::array<float, 3>;

    MeasurementModel model;
    Mesh<float> referenceMesh;
    double sigmaE = 5.4;
    double sigmaS = 2.0;
    std::size_t maxIterations = 100;
    std::size_t minNonDecreasing = 10;
    float decay = 0.9f;
    bool ignoreExteriorSamples = false;

    Origin referenceMeshOrigin = OriginType::untouched;

    ScaleVector referenceMeshScale = {{1.f, 1.f, 1.f}};

    RotationVector referenceMeshRotation = {{0.f, 0.f, 0.f}};

    Configuration &loadFromFile(std::string const &filename);

    inline static Configuration fromFile(std::string const &filename) {
      return Configuration{}.loadFromFile(filename);
    }

    std::array<float, 3> meshTranslation(VoxelVolume const &volume) const;
  };
#pragma clang diagnostic pop

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"

  struct Result {
    Mesh<float> referenceMesh;
    Mesh<float> deformedMesh;
    std::vector<float> displacementVector;
    std::vector<float> weights;
    std::vector<std::array<float, 3>> vertexNormals;
    std::vector<std::array<float, 3>> volumeSamplingPositions;
    std::vector<float> volumeSamples;
    float minDisNorm = std::numeric_limits<float>::max();
    float logLikelihood = -std::numeric_limits<float>::max();
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation-deprecated-sync"
    // in `deformedMesh` instead. Will be removed in version 2.0.
    std::vector<float> perVertexLogLikelihood;
#pragma clang diagnostic pop
    float effectiveSigmaS = .0f;
    std::size_t iteration = 1;
    bool converged = false;
    bool success = false;
    std::size_t nonDecreasing = 0;
  };

  struct State : public Result {
    State() = default;
    State(State const &);
    State(State &&) = default;
    State(Result const &);
    State(Result &&);
    ~State();
    State &operator=(State const &);
    State &operator=(State &&) = default;

  private:
    friend class Impl;
    friend struct Internal::PrivateStateAccessor;
    struct HiddenState;
    using HiddenStatePtr = std::unique_ptr<HiddenState>;

    HiddenStatePtr hiddenState_;
  };

#pragma clang diagnostic pop

  Configuration configuration;


  MeshFitter(Configuration config);

  ~MeshFitter();
  MeshFitter(MeshFitter const &);
  MeshFitter(MeshFitter &&) noexcept;
  MeshFitter &operator=(MeshFitter const &);
  MeshFitter &operator=(MeshFitter &&) noexcept;

  void swap(MeshFitter &rhs) noexcept;

  inline MeshFitter(std::string const &configFilename)
      : MeshFitter(Configuration::fromFile(configFilename)) {}

  Result fit(VoxelVolume const &volume) const;

  State init(VoxelVolume const &volume) const;

  void fitOneIteration(State &state) const;

  void volumeSamplingStep(State &state) const;

  void optimalDisplacementStep(State &state) const;

  void optimalDeformationStep(State &state) const;

  void logLikelihoodStep(State &state) const;

  void convergenceTestStep(State &state) const;

private:
#ifndef CORTIDQCT_NO_PROPAGATE_CONST
  std::propagate_const<std::unique_ptr<Impl>> pImpl_;
#else
  std::unique_ptr<Impl> pImpl_;
#endif
};

} // namespace CortidQCT