PerPixelMap.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <memory>
 
#include <opencv2/core.hpp>
 
#include "vc/core/filesystem.hpp"
#include "vc/core/types/OrderedPointSet.hpp"
#include "vc/core/types/UVMap.hpp"
 
namespace volcart
{
class PerPixelMap
{
    struct Coord2D {
        Coord2D() = default;
        Coord2D(std::size_t y, std::size_t x) : y{y}, x{x} {}
        std::size_t y;
        std::size_t x;
    };
 
    struct PixelMap : public Coord2D {
        PixelMap() = default;
 
        PixelMap(std::size_t y, std::size_t x, cv::Vec6d value)
            : Coord2D{y, x}
            , pos{value[0], value[1], value[2]}
            , normal{value[3], value[4], value[5]}
        {
        }
 
        cv::Vec3d pos;
        cv::Vec3d normal;
    };
 
public:
    using Pointer = std::shared_ptr<PerPixelMap>;
 
    PerPixelMap() = default;
 
    PerPixelMap(std::size_t height, std::size_t width);
 
    template <typename... Args>
    static auto New(Args... args) -> Pointer
    {
        return std::make_shared<PerPixelMap>(std::forward<Args>(args)...);
    }
 
    [[nodiscard]] auto initialized() const -> bool;
    auto operator()(std::size_t y, std::size_t x) const -> const cv::Vec6d&;
 
    auto operator()(std::size_t y, std::size_t x) -> cv::Vec6d&;
 
    [[nodiscard]] auto getMapping(std::size_t y, std::size_t x) const
        -> const cv::Vec6d&;
 
    auto getMapping(std::size_t y, std::size_t x) -> cv::Vec6d&;
 
    [[nodiscard]] auto hasMapping(std::size_t y, std::size_t x) const -> bool;
 
    auto getAsPixelMap(std::size_t y, std::size_t x) -> PixelMap;
 
    [[nodiscard]] auto getMappings() const -> std::vector<PixelMap>;
 
    [[nodiscard]] auto getMappingCoords() const -> std::vector<Coord2D>;
 
    [[nodiscard]] auto numMappings() const -> std::size_t;
    void setDimensions(std::size_t h, std::size_t w);
 
    void setWidth(std::size_t w);
 
    void setHeight(std::size_t h);
 
    [[nodiscard]] auto width() const -> std::size_t;
 
    [[nodiscard]] auto height() const -> std::size_t;
    [[nodiscard]] auto mask() const -> cv::Mat;
 
    void setMask(const cv::Mat& m);
 
    [[nodiscard]] auto cellMap() const -> cv::Mat;
 
    void setCellMap(const cv::Mat& m);
    static void WritePPM(const filesystem::path& path, const PerPixelMap& map);
 
    static auto ReadPPM(const filesystem::path& path) -> PerPixelMap;
    static auto Crop(
        const PerPixelMap& map,
        std::size_t originY,
        std::size_t originX,
        std::size_t height,
        std::size_t width) -> PerPixelMap;
 
private:
    void initialize_map_();
 
    std::size_t height_{0};
    std::size_t width_{0};
    OrderedPointSet<cv::Vec6d> map_;
 
    cv::Mat mask_;
 
    cv::Mat cellMap_;
};
}  // namespace volcart