Pipeline.hpp

Go to the documentation of this file.

#pragma once
 
// standard
#include <map>
#include <memory>
#include <unordered_set>
#include <vector>
 
// project
#include "AssetManager.hpp"
#include "Node.hpp"
#include "depthai/device/CalibrationHandler.hpp"
#include "depthai/device/Device.hpp"
#include "depthai/openvino/OpenVINO.hpp"
 
// shared
#include "depthai-shared/device/BoardConfig.hpp"
#include "depthai-shared/pipeline/PipelineSchema.hpp"
#include "depthai-shared/properties/GlobalProperties.hpp"
 
namespace dai {
 
class PipelineImpl {
    friend class Pipeline;
    friend class Node;
 
   public:
    PipelineImpl() = default;
    PipelineImpl(const PipelineImpl&) = default;
 
   private:
    // static functions
    static bool isSamePipeline(const Node::Output& out, const Node::Input& in);
    static bool canConnect(const Node::Output& out, const Node::Input& in);
 
    // Functions
    Node::Id getNextUniqueId();
    PipelineSchema getPipelineSchema(SerializationType type = DEFAULT_SERIALIZATION_TYPE) const;
    tl::optional<OpenVINO::Version> getPipelineOpenVINOVersion() const;
    bool isOpenVINOVersionCompatible(OpenVINO::Version version) const;
    Device::Config getDeviceConfig() const;
    void setCameraTuningBlobPath(const dai::Path& path);
    void setXLinkChunkSize(int sizeBytes);
    void setSippBufferSize(int sizeBytes);
    void setSippDmaBufferSize(int sizeBytes);
    void setBoardConfig(BoardConfig board);
    BoardConfig getBoardConfig() const;
 
    // Access to nodes
    std::vector<std::shared_ptr<const Node>> getAllNodes() const;
    std::vector<std::shared_ptr<Node>> getAllNodes();
    std::shared_ptr<const Node> getNode(Node::Id id) const;
    std::shared_ptr<Node> getNode(Node::Id id);
 
    void serialize(PipelineSchema& schema, Assets& assets, std::vector<std::uint8_t>& assetStorage, SerializationType type = DEFAULT_SERIALIZATION_TYPE) const;
    nlohmann::json serializeToJson() const;
    void remove(std::shared_ptr<Node> node);
 
    std::vector<Node::Connection> getConnections() const;
    void link(const Node::Output& out, const Node::Input& in);
    void unlink(const Node::Output& out, const Node::Input& in);
    void setCalibrationData(CalibrationHandler calibrationDataHandler);
    CalibrationHandler getCalibrationData() const;
 
    // Must be incremented and unique for each node
    Node::Id latestId = 0;
    // Pipeline asset manager
    AssetManager assetManager;
    // Optionally forced version
    tl::optional<OpenVINO::Version> forceRequiredOpenVINOVersion;
    // Global pipeline properties
    GlobalProperties globalProperties;
    // Optimized for adding, searching and removing connections
    using NodeMap = std::unordered_map<Node::Id, std::shared_ptr<Node>>;
    NodeMap nodeMap;
    using NodeConnectionMap = std::unordered_map<Node::Id, std::unordered_set<Node::Connection>>;
    // Connection map, NodeId represents id of node connected TO (input)
    NodeConnectionMap nodeConnectionMap;
    // Board configuration
    BoardConfig board;
 
    // Template create function
    template <class N>
    std::shared_ptr<N> create(const std::shared_ptr<PipelineImpl>& itself) {
        // Check that passed type 'N' is subclass of Node
        static_assert(std::is_base_of<Node, N>::value, "Specified class is not a subclass of Node");
        // Get unique id for this new node
        auto id = getNextUniqueId();
        // Create and store the node in the map
        auto node = std::make_shared<N>(itself, id);
        nodeMap[id] = node;
        // Return shared pointer to this node
        return node;
    }
};
 
class Pipeline {
    std::shared_ptr<PipelineImpl> pimpl;
    PipelineImpl* impl() {
        return pimpl.get();
    }
    const PipelineImpl* impl() const {
        return pimpl.get();
    }
 
   public:
    Pipeline();
    explicit Pipeline(const std::shared_ptr<PipelineImpl>& pimpl);
 
    Pipeline clone() const;
 
    GlobalProperties getGlobalProperties() const;
 
    PipelineSchema getPipelineSchema(SerializationType type = DEFAULT_SERIALIZATION_TYPE) const;
 
    // void loadAssets(AssetManager& assetManager);
    void serialize(PipelineSchema& schema, Assets& assets, std::vector<std::uint8_t>& assetStorage) const {
        impl()->serialize(schema, assets, assetStorage);
    }
 
    nlohmann::json serializeToJson() const {
        return impl()->serializeToJson();
    }
 
    template <class N>
    std::shared_ptr<N> create() {
        return impl()->create<N>(pimpl);
    }
 
    void remove(std::shared_ptr<Node> node) {
        impl()->remove(node);
    }
 
    std::vector<std::shared_ptr<const Node>> getAllNodes() const {
        return impl()->getAllNodes();
    }
    std::vector<std::shared_ptr<Node>> getAllNodes() {
        return impl()->getAllNodes();
    }
 
    std::shared_ptr<const Node> getNode(Node::Id id) const {
        return impl()->getNode(id);
    }
    std::shared_ptr<Node> getNode(Node::Id id) {
        return impl()->getNode(id);
    }
 
    std::vector<Node::Connection> getConnections() const {
        return impl()->getConnections();
    }
 
    using NodeConnectionMap = PipelineImpl::NodeConnectionMap;
    const NodeConnectionMap& getConnectionMap() const {
        return impl()->nodeConnectionMap;
    }
 
    using NodeMap = PipelineImpl::NodeMap;
    const NodeMap& getNodeMap() const {
        return impl()->nodeMap;
    }
 
    void link(const Node::Output& out, const Node::Input& in) {
        impl()->link(out, in);
    }
 
    void unlink(const Node::Output& out, const Node::Input& in) {
        impl()->unlink(out, in);
    }
 
    const AssetManager& getAssetManager() const {
        return impl()->assetManager;
    }
 
    AssetManager& getAssetManager() {
        return impl()->assetManager;
    }
 
    void setOpenVINOVersion(OpenVINO::Version version) {
        impl()->forceRequiredOpenVINOVersion = version;
    }
 
    void setCalibrationData(CalibrationHandler calibrationDataHandler) {
        impl()->setCalibrationData(calibrationDataHandler);
    }
 
    CalibrationHandler getCalibrationData() const {
        return impl()->getCalibrationData();
    }
 
    OpenVINO::Version getOpenVINOVersion() const {
        return impl()->getPipelineOpenVINOVersion().value_or(OpenVINO::DEFAULT_VERSION);
    }
 
    tl::optional<OpenVINO::Version> getRequiredOpenVINOVersion() const {
        return impl()->getPipelineOpenVINOVersion();
    }
 
    void setCameraTuningBlobPath(const dai::Path& path) {
        impl()->setCameraTuningBlobPath(path);
    }
 
    void setXLinkChunkSize(int sizeBytes) {
        impl()->setXLinkChunkSize(sizeBytes);
    }
 
    void setSippBufferSize(int sizeBytes) {
        impl()->setSippBufferSize(sizeBytes);
    }
 
    void setSippDmaBufferSize(int sizeBytes) {
        impl()->setSippDmaBufferSize(sizeBytes);
    }
 
    bool isOpenVINOVersionCompatible(OpenVINO::Version version) const {
        return impl()->isOpenVINOVersionCompatible(version);
    }
 
    void setBoardConfig(BoardConfig board) {
        impl()->setBoardConfig(board);
    }
 
    BoardConfig getBoardConfig() const {
        return impl()->getBoardConfig();
    }
 
    Device::Config getDeviceConfig() const {
        return impl()->getDeviceConfig();
    }
};
 
}  // namespace dai