Volume.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <mutex>
#include <optional>
#include <utility>
 
#include "vc/core/filesystem.hpp"
#include "vc/core/types/BoundingBox.hpp"
#include "vc/core/types/Cache.hpp"
#include "vc/core/types/DiskBasedObjectBaseClass.hpp"
#include "vc/core/types/LRUCache.hpp"
#include "vc/core/types/Reslice.hpp"
#include "vc/core/util/MemMap.hpp"
 
namespace volcart
{
// shared_from_this used in Python bindings
// https://en.cppreference.com/w/cpp/memory/enable_shared_from_this
class Volume : public DiskBasedObjectBaseClass,
               public std::enable_shared_from_this<Volume>
{
public:
    using Bounds = BoundingBox<double, 3>;
 
    using Pointer = std::shared_ptr<Volume>;
 
    using SliceItem = std::pair<cv::Mat, std::optional<mmap_info>>;
 
    using SliceCache = Cache<int, SliceItem>;
 
    using DefaultCache = LRUCache<int, SliceItem, NoOpMutex>;
 
    static constexpr std::size_t DEFAULT_CAPACITY = 200;
 
    Volume() = delete;
 
    explicit Volume(filesystem::path path);
 
    Volume(filesystem::path path, Identifier uuid, std::string name);
 
    static auto New(const filesystem::path& path) -> Pointer;
 
    static auto New(
        const filesystem::path& path,
        const Identifier& uuid,
        const std::string& name) -> Pointer;
    auto sliceWidth() const -> int;
    auto sliceHeight() const -> int;
    auto numSlices() const -> int;
    auto voxelSize() const -> double;
    auto min() const -> double;
    auto max() const -> double;
    void setSliceWidth(int w);
    void setSliceHeight(int h);
    void setNumberOfSlices(std::size_t numSlices);
    void setVoxelSize(double s);
    void setMin(double m);
    void setMax(double m);
    auto bounds() const -> Bounds;
    auto isInBounds(double x, double y, double z) const -> bool;
    auto isInBounds(const cv::Vec3d& v) const -> bool;
    void setMemoryMapSlices(bool b);
 
    auto getSliceData(int index) const -> cv::Mat;
 
    auto getSliceDataCopy(int index) const -> cv::Mat;
 
    void setSliceData(
        int index, const cv::Mat& slice, bool compress = true) const;
 
    auto getSlicePath(int index) const -> filesystem::path;
    auto intensityAt(int x, int y, int z) const -> std::uint16_t;
 
    auto intensityAt(const cv::Vec3d& v) const -> std::uint16_t;
 
    auto interpolateAt(double x, double y, double z) const -> std::uint16_t;
 
    auto interpolateAt(const cv::Vec3d& v) const -> std::uint16_t;
 
    auto reslice(
        const cv::Vec3d& center,
        const cv::Vec3d& xvec,
        const cv::Vec3d& yvec,
        int width = 64,
        int height = 64) const -> Reslice;
    void setCacheSlices(bool b);
 
    void setCache(SliceCache::Pointer c) const;
 
    void setCacheCapacity(std::size_t newCacheCapacity) const;
 
    void setCacheMemoryInBytes(std::size_t nbytes) const;
 
    auto getCacheCapacity() const -> std::size_t;
 
    auto getCacheSize() const -> std::size_t;
 
    void cachePurge() const;
protected:
    int width_{0};
    int height_{0};
    int slices_{0};
    int numSliceCharacters_{0};
 
    bool cacheSlices_{true};
    mutable SliceCache::Pointer cache_{DefaultCache::New(DEFAULT_CAPACITY)};
    mutable std::shared_mutex cacheMutex_;
    // TODO: This seems excessive but I'll leave it until it can be tested
    mutable std::vector<std::mutex> sliceMutexes_;
 
    bool memmap_{true};
    cv::Mat load_slice_(int index, mmap_info* mmap_info = nullptr) const;
    cv::Mat cache_slice_(int index) const;
};
}  // namespace volcart