openvino_blob_test.cpp
Go to the documentation of this file.
1 #include <catch2/catch_all.hpp>
2 
3 // std
4 #include <atomic>
5 #include <fstream>
6 #include <iostream>
7 
8 // Include depthai library
9 #include <depthai/depthai.hpp>
10 
11 // setBlob
12 
13 void checkBlob(dai::OpenVINO::Blob& blob) {
14  printf("Blob: ");
15  for(const auto& in : blob.networkInputs) {
16  std::string name = in.first;
17  auto tensor = in.second;
18  printf("'%s - dims: %d - order: %04x - type: %d' ", name.c_str(), tensor.numDimensions, tensor.order, tensor.dataType);
19  }
20  for(const auto& out : blob.networkOutputs) {
21  std::string name = out.first;
22  auto tensor = out.second;
23  printf("'%s - dims: %d - order: %04x - type: %d' ", name.c_str(), tensor.numDimensions, tensor.order, tensor.dataType);
24  }
25  printf("(%u %u %u %u)\n", blob.stageCount, blob.numShaves, blob.numSlices, blob.version);
26 
27  REQUIRE(blob.networkInputs.size() == 1);
28  REQUIRE(blob.networkInputs.at("0").numDimensions == 4);
29  REQUIRE(blob.networkInputs.at("0").order == dai::TensorInfo::StorageOrder::NCHW);
30  // REQUIRE(blob.networkInputs.at("0").dataType == dai::TensorInfo::DataType::U8F);
31 
32  REQUIRE(blob.networkOutputs.size() == 1);
33  REQUIRE(blob.networkOutputs.at("14").numDimensions == 4);
34  REQUIRE(blob.networkOutputs.at("14").order == dai::TensorInfo::StorageOrder::NCHW);
35  REQUIRE(blob.networkOutputs.at("14").dataType == dai::TensorInfo::DataType::FP16);
36 }
37 
38 TEST_CASE("OpenVINO 2020.3 setBlob") {
39  dai::Pipeline p;
40  auto nn = p.create<dai::node::NeuralNetwork>();
41 
42  dai::OpenVINO::Blob blob(OPENVINO_2020_3_BLOB_PATH);
43  REQUIRE(blob.version == dai::OpenVINO::VERSION_2020_3);
44  checkBlob(blob);
45  nn->setBlob(std::move(blob));
46 
47  auto networkOpenvinoVersion = p.getOpenVINOVersion();
48  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2020_3);
49  REQUIRE_THROWS_AS(dai::Device(p), std::runtime_error);
50 }
51 
52 TEST_CASE("OpenVINO 2020.4 setBlob") {
53  dai::Pipeline p;
54  auto nn = p.create<dai::node::NeuralNetwork>();
55 
56  dai::OpenVINO::Blob blob(OPENVINO_2020_4_BLOB_PATH);
57  REQUIRE(blob.version == dai::OpenVINO::VERSION_2020_4);
58  checkBlob(blob);
59  nn->setBlob(std::move(blob));
60 
61  auto networkOpenvinoVersion = p.getOpenVINOVersion();
62  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2020_4);
63  dai::Device d(p);
64 }
65 
66 TEST_CASE("OpenVINO 2021.1 setBlob") {
67  dai::Pipeline p;
68  auto nn = p.create<dai::node::NeuralNetwork>();
69 
70  dai::OpenVINO::Blob blob(OPENVINO_2021_1_BLOB_PATH);
71  REQUIRE(blob.version == dai::OpenVINO::VERSION_2021_1);
72  checkBlob(blob);
73  nn->setBlob(std::move(blob));
74 
75  auto networkOpenvinoVersion = p.getOpenVINOVersion();
76  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_1);
77  dai::Device d(p);
78 }
79 
80 TEST_CASE("OpenVINO 2021.2 setBlob") {
81  dai::Pipeline p;
82  auto nn = p.create<dai::node::NeuralNetwork>();
83 
84  dai::OpenVINO::Blob blob(OPENVINO_2021_2_BLOB_PATH);
85  REQUIRE(blob.version == dai::OpenVINO::VERSION_2021_2);
86  checkBlob(blob);
87  nn->setBlob(std::move(blob));
88 
89  auto networkOpenvinoVersion = p.getOpenVINOVersion();
90  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_2);
91  dai::Device d(p);
92 }
93 
94 TEST_CASE("OpenVINO 2021.3 setBlob") {
95  dai::Pipeline p;
96  auto nn = p.create<dai::node::NeuralNetwork>();
97 
98  dai::OpenVINO::Blob blob(OPENVINO_2021_3_BLOB_PATH);
99  REQUIRE(blob.version == dai::OpenVINO::VERSION_2021_3);
100  checkBlob(blob);
101  nn->setBlob(std::move(blob));
102 
103  auto networkOpenvinoVersion = p.getOpenVINOVersion();
104  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_3);
105  dai::Device d(p);
106 }
107 
108 TEST_CASE("OpenVINO 2021.4 setBlob") {
109  dai::Pipeline p;
110  auto nn = p.create<dai::node::NeuralNetwork>();
111 
112  dai::OpenVINO::Blob blob(OPENVINO_2021_4_BLOB_PATH);
113  REQUIRE(blob.version == dai::OpenVINO::VERSION_2021_4);
114  checkBlob(blob);
115  nn->setBlob(std::move(blob));
116 
117  auto networkOpenvinoVersion = p.getOpenVINOVersion();
118  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_4);
119  dai::Device d(p);
120 }
121 
122 TEST_CASE("OpenVINO 2022.1 setBlob") {
123  dai::Pipeline p;
124  auto nn = p.create<dai::node::NeuralNetwork>();
125 
126  dai::OpenVINO::Blob blob(OPENVINO_2022_1_BLOB_PATH);
127  REQUIRE(blob.version == dai::OpenVINO::VERSION_2022_1);
128  checkBlob(blob);
129  nn->setBlob(std::move(blob));
130 
131  auto networkOpenvinoVersion = p.getOpenVINOVersion();
132  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2022_1);
133  dai::Device d(p);
134 }
135 
136 // setBlobPath
137 
138 TEST_CASE("OpenVINO 2020.3 blob") {
139  dai::Pipeline p;
140  auto nn = p.create<dai::node::NeuralNetwork>();
141  nn->setBlobPath(OPENVINO_2020_3_BLOB_PATH);
142  auto networkOpenvinoVersion = p.getOpenVINOVersion();
143  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2020_3);
144  REQUIRE_THROWS_AS(dai::Device(p), std::runtime_error);
145 }
146 
147 TEST_CASE("OpenVINO 2020.4 blob") {
148  dai::Pipeline p;
149  auto nn = p.create<dai::node::NeuralNetwork>();
150  nn->setBlobPath(OPENVINO_2020_4_BLOB_PATH);
151  auto networkOpenvinoVersion = p.getOpenVINOVersion();
152  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2020_4);
153  dai::Device d(p);
154 }
155 
156 TEST_CASE("OpenVINO 2021.1 blob") {
157  dai::Pipeline p;
158  auto nn = p.create<dai::node::NeuralNetwork>();
159  nn->setBlobPath(OPENVINO_2021_1_BLOB_PATH);
160  auto networkOpenvinoVersion = p.getOpenVINOVersion();
161  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_1);
162  dai::Device d(p);
163 }
164 
165 TEST_CASE("OpenVINO 2021.2 blob") {
166  dai::Pipeline p;
167  auto nn = p.create<dai::node::NeuralNetwork>();
168  nn->setBlobPath(OPENVINO_2021_2_BLOB_PATH);
169  auto networkOpenvinoVersion = p.getOpenVINOVersion();
170  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_2);
171  dai::Device d(p);
172 }
173 
174 TEST_CASE("OpenVINO 2021.3 blob") {
175  dai::Pipeline p;
176  auto nn = p.create<dai::node::NeuralNetwork>();
177  nn->setBlobPath(OPENVINO_2021_3_BLOB_PATH);
178  auto networkOpenvinoVersion = p.getOpenVINOVersion();
179  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_3);
180  dai::Device d(p);
181 }
182 
183 TEST_CASE("OpenVINO 2021.4 blob") {
184  dai::Pipeline p;
185  auto nn = p.create<dai::node::NeuralNetwork>();
186  nn->setBlobPath(OPENVINO_2021_4_BLOB_PATH);
187  auto networkOpenvinoVersion = p.getOpenVINOVersion();
188  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_4);
189  dai::Device d(p);
190 }
191 
192 TEST_CASE("OpenVINO 2022.1 blob") {
193  dai::Pipeline p;
194  auto nn = p.create<dai::node::NeuralNetwork>();
195  nn->setBlobPath(OPENVINO_2022_1_BLOB_PATH);
196  auto networkOpenvinoVersion = p.getOpenVINOVersion();
197  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2022_1);
198  dai::Device d(p);
199 }
200 
201 // Check if an exception is thrown if blob is corrupted
202 TEST_CASE("OpenVINO corrupted blob") {
203  std::ifstream stream(OPENVINO_2021_4_BLOB_PATH, std::ios::in | std::ios::binary);
204  std::vector<std::uint8_t> blobData(std::istreambuf_iterator<char>(stream), {});
205 
206  // Corrupt blob by removing half the file size
207  blobData.resize(blobData.size() / 2);
208 
209  REQUIRE_THROWS(dai::OpenVINO::Blob(blobData));
210 }
211 
212 // TEST UNIVERSAL FW
213 
214 TEST_CASE("OpenVINO 2020.4 blob, test with universal FW") {
215  dai::Pipeline p;
216  auto nn = p.create<dai::node::NeuralNetwork>();
217  nn->setBlobPath(OPENVINO_2020_4_BLOB_PATH);
218  auto networkOpenvinoVersion = p.getOpenVINOVersion();
219  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2020_4);
220  p.setOpenVINOVersion(dai::OpenVINO::VERSION_UNIVERSAL);
221  dai::Device d(p);
222 }
223 
224 TEST_CASE("OpenVINO 2021.1 blob, test with universal FW") {
225  dai::Pipeline p;
226  auto nn = p.create<dai::node::NeuralNetwork>();
227  nn->setBlobPath(OPENVINO_2021_1_BLOB_PATH);
228  auto networkOpenvinoVersion = p.getOpenVINOVersion();
229  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_1);
230  p.setOpenVINOVersion(dai::OpenVINO::VERSION_UNIVERSAL);
231  dai::Device d(p);
232 }
233 
234 TEST_CASE("OpenVINO 2021.2 blob, test with universal FW") {
235  dai::Pipeline p;
236  auto nn = p.create<dai::node::NeuralNetwork>();
237  nn->setBlobPath(OPENVINO_2021_2_BLOB_PATH);
238  auto networkOpenvinoVersion = p.getOpenVINOVersion();
239  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_2);
240  p.setOpenVINOVersion(dai::OpenVINO::VERSION_UNIVERSAL);
241  dai::Device d(p);
242 }
243 
244 TEST_CASE("OpenVINO 2021.3 blob, test with universal FW") {
245  dai::Pipeline p;
246  auto nn = p.create<dai::node::NeuralNetwork>();
247  nn->setBlobPath(OPENVINO_2021_3_BLOB_PATH);
248  auto networkOpenvinoVersion = p.getOpenVINOVersion();
249  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_3);
250  p.setOpenVINOVersion(dai::OpenVINO::VERSION_UNIVERSAL);
251  dai::Device d(p);
252 }
253 
254 TEST_CASE("OpenVINO 2021.4 blob, test with universal FW") {
255  dai::Pipeline p;
256  auto nn = p.create<dai::node::NeuralNetwork>();
257  nn->setBlobPath(OPENVINO_2021_4_BLOB_PATH);
258  auto networkOpenvinoVersion = p.getOpenVINOVersion();
259  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2021_4);
260  p.setOpenVINOVersion(dai::OpenVINO::VERSION_UNIVERSAL);
261  dai::Device d(p);
262 }
263 
264 TEST_CASE("OpenVINO 2022.1 blob, test with universal FW") {
265  dai::Pipeline p;
266  auto nn = p.create<dai::node::NeuralNetwork>();
267  nn->setBlobPath(OPENVINO_2022_1_BLOB_PATH);
268  auto networkOpenvinoVersion = p.getOpenVINOVersion();
269  REQUIRE(networkOpenvinoVersion == dai::OpenVINO::VERSION_2022_1);
270  p.setOpenVINOVersion(dai::OpenVINO::VERSION_UNIVERSAL);
271  dai::Device d(p);
272 }
dai::OpenVINO::Blob::version
Version version
OpenVINO version.
Definition: OpenVINO.hpp:38
dai::Pipeline
Represents the pipeline, set of nodes and connections between them.
Definition: Pipeline.hpp:100
dai::OpenVINO::Blob
OpenVINO Blob.
Definition: OpenVINO.hpp:23
dai::OpenVINO::Blob::stageCount
uint32_t stageCount
Number of network stages.
Definition: OpenVINO.hpp:44
dai::OpenVINO::VERSION_2020_4
@ VERSION_2020_4
Definition: OpenVINO.hpp:20
dai::TensorInfo::DataType::FP16
@ FP16
dai::node::NeuralNetwork
NeuralNetwork node. Runs a neural inference on input data.
Definition: NeuralNetwork.hpp:18
TEST_CASE
TEST_CASE("OpenVINO 2020.3 setBlob")
Definition: openvino_blob_test.cpp:38
checkBlob
void checkBlob(dai::OpenVINO::Blob &blob)
Definition: openvino_blob_test.cpp:13
dai::Pipeline::getOpenVINOVersion
OpenVINO::Version getOpenVINOVersion() const
Get possible OpenVINO version to run this pipeline.
Definition: Pipeline.hpp:247
dai::Pipeline::setOpenVINOVersion
void setOpenVINOVersion(OpenVINO::Version version)
Set a specific OpenVINO version to use with this pipeline.
Definition: Pipeline.hpp:224
depthai.hpp
dai::OpenVINO::Blob::numShaves
uint32_t numShaves
Number of shaves the blob was compiled for.
Definition: OpenVINO.hpp:46
dai::OpenVINO::Blob::numSlices
uint32_t numSlices
Number of CMX slices the blob was compiled for.
Definition: OpenVINO.hpp:48
dai::Pipeline::create
std::shared_ptr< N > create()
Definition: Pipeline.hpp:145
dai::node::NeuralNetwork::setBlobPath
void setBlobPath(const dai::Path &path)
Definition: NeuralNetwork.cpp:26
dai::TensorInfo::StorageOrder::NCHW
@ NCHW
dai::OpenVINO::VERSION_2020_3
@ VERSION_2020_3
Definition: OpenVINO.hpp:20
dai::OpenVINO::VERSION_2021_4
@ VERSION_2021_4
Definition: OpenVINO.hpp:20
dai::OpenVINO::VERSION_2022_1
@ VERSION_2022_1
Definition: OpenVINO.hpp:20
dai::OpenVINO::VERSION_UNIVERSAL
@ VERSION_UNIVERSAL
Definition: OpenVINO.hpp:20
dai::OpenVINO::VERSION_2021_1
@ VERSION_2021_1
Definition: OpenVINO.hpp:20
dai::OpenVINO::Blob::networkOutputs
std::unordered_map< std::string, TensorInfo > networkOutputs
Map of output names to additional information.
Definition: OpenVINO.hpp:42
dai::Device
Definition: Device.hpp:21
dai::OpenVINO::VERSION_2021_2
@ VERSION_2021_2
Definition: OpenVINO.hpp:20
dai::OpenVINO::Blob::networkInputs
std::unordered_map< std::string, TensorInfo > networkInputs
Map of input names to additional information.
Definition: OpenVINO.hpp:40
dai::OpenVINO::VERSION_2021_3
@ VERSION_2021_3
Definition: OpenVINO.hpp:20

depthai
Author(s): Martin Peterlin
autogenerated on Sat Mar 22 2025 02:58:19