.. _program_listing_file_include_depthai_pipeline_Pipeline.hpp:

Program Listing for File Pipeline.hpp
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_depthai_pipeline_Pipeline.hpp>` (``include/depthai/pipeline/Pipeline.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #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