Transforms.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <iostream>
#include <list>
#include <memory>
#include <string>
#include <vector>
 
#include <nlohmann/json.hpp>
#include <opencv2/core.hpp>
 
#include "vc/core/filesystem.hpp"
#include "vc/core/types/ITKMesh.hpp"
#include "vc/core/types/PerPixelMap.hpp"
 
namespace volcart
{
 
class Transform3D
{
public:
    static constexpr std::string_view TYPE{"Transform3D"};
 
    using Pointer = std::shared_ptr<Transform3D>;
 
    using Identifier = std::string;
 
    virtual ~Transform3D() = default;
    Transform3D(Transform3D&&) = delete;
    auto operator=(Transform3D&& other) -> Transform3D& = delete;
 
    [[nodiscard]] virtual auto type() const -> std::string_view = 0;
    [[nodiscard]] virtual auto clone() const -> Pointer = 0;
 
    [[nodiscard]] virtual auto invertible() const -> bool;
    [[nodiscard]] virtual auto invert() const -> Pointer;
    [[nodiscard]] virtual auto composable() const -> bool;
 
    virtual void reset() = 0;
    void clear();
 
    void source(const std::string& src);
    [[nodiscard]] auto source() const -> std::string;
    void target(const std::string& tgt);
    [[nodiscard]] auto target() const -> std::string;
 
    [[nodiscard]] virtual auto applyPoint(const cv::Vec3d& point) const
        -> cv::Vec3d = 0;
    [[nodiscard]] virtual auto applyVector(const cv::Vec3d& vector) const
        -> cv::Vec3d = 0;
    [[nodiscard]] auto applyUnitVector(const cv::Vec3d& vector) const
        -> cv::Vec3d;
    [[nodiscard]] auto applyPointAndNormal(
        const cv::Vec6d& ptN, bool normalize = true) const -> cv::Vec6d;
 
    static auto Compose(const Pointer& lhs, const Pointer& rhs)
        -> std::pair<Pointer, Pointer>;
 
    static void Save(const filesystem::path& path, const Pointer& transform);
    static auto Load(const filesystem::path& path) -> Pointer;
 
protected:
    Transform3D() = default;
    Transform3D(const Transform3D&) = default;
    auto operator=(const Transform3D& other) -> Transform3D& = default;
 
    [[nodiscard]] virtual auto compose_(const Pointer& rhs) const -> Pointer;
 
    using Metadata = nlohmann::ordered_json;
    static auto Serialize(const Pointer& transform) -> Metadata;
    static auto Deserialize(const Metadata& meta) -> Pointer;
    virtual void to_meta_(Metadata& meta) = 0;
    virtual void from_meta_(const Metadata& meta) = 0;
 
private:
    std::string src_;
    std::string tgt_;
};
 
auto operator*(const Transform3D::Pointer& lhs, const Transform3D::Pointer& rhs)
    -> Transform3D::Pointer;
 
class AffineTransform : public Transform3D
{
public:
    static constexpr std::string_view TYPE{"AffineTransform"};
 
    using Parameters = cv::Matx<double, 4, 4>;
 
    using Pointer = std::shared_ptr<AffineTransform>;
 
    static auto New() -> Pointer;
 
    [[nodiscard]] auto type() const -> std::string_view final;
    [[nodiscard]] auto clone() const -> Transform3D::Pointer final;
    [[nodiscard]] auto invertible() const -> bool final;
    [[nodiscard]] auto invert() const -> Transform3D::Pointer final;
    [[nodiscard]] auto composable() const -> bool final;
    void reset() final;
 
    [[nodiscard]] auto applyPoint(const cv::Vec3d& point) const
        -> cv::Vec3d final;
    [[nodiscard]] auto applyVector(const cv::Vec3d& vector) const
        -> cv::Vec3d final;
 
    [[nodiscard]] auto params() const -> Parameters;
    void params(const Parameters& params);
 
    void translate(double x, double y, double z);
 
    template <typename Tp, int Cn>
    void translate(const cv::Vec<Tp, Cn>& translation)
    {
        static_assert(Cn >= 3, "cv::Vec must have >= 3 values");
        translate(translation[0], translation[1], translation[2]);
    }
 
    void rotate(double angle, double ax, double ay, double az);
 
    template <typename Tp, int Cn>
    void rotate(const double angle, cv::Vec<Tp, Cn> axis)
    {
        static_assert(Cn >= 3, "cv::Vec must have >= 3 values");
        rotate(angle, axis[0], axis[1], axis[2]);
    }
 
    void scale(double sx, double sy, double sz);
 
    void scale(double s);
 
private:
    AffineTransform() = default;
    Parameters params_{Parameters::eye()};
    [[nodiscard]] auto compose_(const Transform3D::Pointer& rhs) const
        -> Transform3D::Pointer final;
    void to_meta_(Metadata& meta) final;
    void from_meta_(const Metadata& meta) final;
};
 
class IdentityTransform : public Transform3D
{
public:
    static constexpr std::string_view TYPE{"IdentityTransform"};
 
    using Pointer = std::shared_ptr<IdentityTransform>;
 
    static auto New() -> Pointer;
 
    [[nodiscard]] auto type() const -> std::string_view final;
    [[nodiscard]] auto clone() const -> Transform3D::Pointer final;
    [[nodiscard]] auto invertible() const -> bool final;
    [[nodiscard]] auto invert() const -> Transform3D::Pointer final;
    [[nodiscard]] auto composable() const -> bool final;
    void reset() final;
 
    [[nodiscard]] auto applyPoint(const cv::Vec3d& point) const
        -> cv::Vec3d final;
    [[nodiscard]] auto applyVector(const cv::Vec3d& vector) const
        -> cv::Vec3d final;
 
private:
    IdentityTransform() = default;
    [[nodiscard]] auto compose_(const Transform3D::Pointer& rhs) const
        -> Transform3D::Pointer final;
    void to_meta_(Metadata& meta) final;
    void from_meta_(const Metadata& meta) final;
};
 
class CompositeTransform : public Transform3D
{
public:
    static constexpr std::string_view TYPE{"CompositeTransform"};
 
    using Pointer = std::shared_ptr<CompositeTransform>;
 
    static auto New() -> Pointer;
 
    [[nodiscard]] auto type() const -> std::string_view final;
    [[nodiscard]] auto clone() const -> Transform3D::Pointer final;
    void reset() final;
 
    [[nodiscard]] auto applyPoint(const cv::Vec3d& point) const
        -> cv::Vec3d final;
    [[nodiscard]] auto applyVector(const cv::Vec3d& vector) const
        -> cv::Vec3d final;
 
    void push_front(const Transform3D::Pointer& t);
 
    void push_back(const Transform3D::Pointer& t);
 
    [[nodiscard]] auto size() const noexcept -> std::size_t;
 
    void simplify();
 
    [[nodiscard]] auto transforms() const -> std::vector<Transform3D::Pointer>;
 
private:
    CompositeTransform() = default;
    std::list<Transform3D::Pointer> tfms_;
    void to_meta_(Metadata& meta) final;
    void from_meta_(const Metadata& meta) final;
};
 
auto ApplyTransform(
    const ITKMesh::Pointer& mesh,
    const Transform3D::Pointer& transform,
    bool normalize = true) -> ITKMesh::Pointer;
 
auto ApplyTransform(
    const PerPixelMap& ppm,
    const Transform3D::Pointer& transform,
    bool normalize = true) -> PerPixelMap;
 
auto ApplyTransform(
    const PerPixelMap::Pointer& ppm,
    const Transform3D::Pointer& transform,
    bool normalize = true) -> PerPixelMap::Pointer;
 
template <class PointSetT>
auto ApplyTransform(const PointSetT& ps, const Transform3D::Pointer& transform)
    -> PointSetT;
 
}  // namespace volcart
 
#include "vc/core/types/TransformsImpl.hpp"