Add load && save method to ImgFrame

bindings/python/src/pipeline/datatype/EncodedFrameBindings.cpp

@@ -120,6 +120,10 @@ void bind_encodedframe(pybind11::module& m, void* pCallstack) {
         .def("setLossless", &EncodedFrame::setLossless, DOC(dai, EncodedFrame, getLossless))
         .def("setProfile", &EncodedFrame::setProfile, DOC(dai, EncodedFrame, getProfile))
         .def("setTransformation", [](EncodedFrame& msg, const ImgTransformation& transformation) { msg.transformation = transformation; });
+#ifdef DEPTHAI_ENABLE_PROTOBUF
+    encodedFrame.def("save", &EncodedFrame::save, py::arg("path"), py::arg("metadataOnly") = false)
+        .def("load", &EncodedFrame::load, py::arg("path"), py::arg("metadataOnly") = false);
+#endif
     //   // add aliases dai.ImgFrame.Type and dai.ImgFrame.Specs
     //   m.attr("EncodedFrame").attr("FrameType") =
     //       m.attr("RawEncodedFrame").attr("FrameType");

bindings/python/src/pipeline/datatype/IMUDataBindings.cpp

@@ -156,4 +156,8 @@ void bind_imudata(pybind11::module& m, void* pCallstack) {
             [](IMUData& imuDta) -> std::vector<IMUPacket>& { return imuDta.packets; },
             [](IMUData& imuDta, std::vector<IMUPacket>& val) { imuDta.packets = val; },
             DOC(dai, IMUData, packets));
+#ifdef DEPTHAI_ENABLE_PROTOBUF
+    imuData.def("save", &IMUData::save, py::arg("path"), py::arg("metadataOnly") = false)
+        .def("load", &IMUData::load, py::arg("path"), py::arg("metadataOnly") = false);
+#endif
 }

bindings/python/src/pipeline/datatype/ImgFrameBindings.cpp

@@ -326,6 +326,21 @@ void bind_imgframe(pybind11::module& m, void* pCallstack) {
         .def("setTransformation", &ImgFrame::setTransformation, py::arg("transformation"), DOC(dai, ImgFrame, setTransformation))
         // .def("set", &ImgFrame::set, py::arg("type"), DOC(dai, ImgFrame, set))
         ;
+
+#ifdef DEPTHAI_ENABLE_PROTOBUF
+    imgFrame
+        .def(
+            "save",
+            &ImgFrame::save,
+            py::arg("path"),
+            py::arg("metadataOnly") = false)
+        .def(
+            "load",
+            &ImgFrame::load,
+            py::arg("path"),
+            py::arg("metadataOnly") = false);
+#endif
+
     // add aliases dai.ImgFrame.Type and dai.ImgFrame.Specs
     // m.attr("ImgFrame").attr("Type") = m.attr("RawImgFrame").attr("Type");
     // m.attr("ImgFrame").attr("Specs") = m.attr("RawImgFrame").attr("Specs");

bindings/python/src/pipeline/datatype/PointCloudDataBindings.cpp

@@ -183,4 +183,8 @@ void bind_pointclouddata(pybind11::module& m, void* pCallstack) {
         .def("updateBoundingBox", &PointCloudData::updateBoundingBox, DOC(dai, PointCloudData, updateBoundingBox))
         .def("getTransformation", &PointCloudData::getTransformation, py::return_value_policy::reference_internal)
         .def("setTransformation", &PointCloudData::setTransformation, py::arg("transformation"));
+#ifdef DEPTHAI_ENABLE_PROTOBUF
+    pointCloudData.def("save", &PointCloudData::save, py::arg("path"), py::arg("metadataOnly") = false)
+        .def("load", &PointCloudData::load, py::arg("path"), py::arg("metadataOnly") = false);
+#endif
 }

bindings/python/src/pipeline/datatype/RGBDDataBindings.cpp

@@ -36,4 +36,8 @@ void bind_rgbddata(pybind11::module& m, void* pCallstack) {
         .def("getDepthFrame", &RGBDData::getDepthFrame, DOC(dai, RGBDData, getDepthFrame))
         .def("setRGBFrame", &RGBDData::setRGBFrame, py::arg("frame"), DOC(dai, RGBDData, setRGBFrame))
         .def("setDepthFrame", &RGBDData::setDepthFrame, py::arg("frame"), DOC(dai, RGBDData, setDepthFrame));
+#ifdef DEPTHAI_ENABLE_PROTOBUF
+    rgbdData.def("save", &RGBDData::save, py::arg("path"), py::arg("metadataOnly") = false)
+        .def("load", &RGBDData::load, py::arg("path"), py::arg("metadataOnly") = false);
+#endif
 }

bindings/python/tests/imgframe_test.py

@@ -3,6 +3,7 @@
 import numpy as np
 import pytest
 import numpy.typing as npt
+from pathlib import Path
 
 DEBUG = False
 
@@ -44,6 +45,38 @@ def assert_images_close(expected, recovered, tolerance, msg):
     assert max_diff <= tolerance, f"{msg} max abs diff too high: {max_diff} > {tolerance}"
 
 
+def make_test_frame():
+    image = generate_color_image()
+    frame = dai.ImgFrame()
+    frame.setCvFrame(image, dai.ImgFrame.Type.BGR888i)
+    frame.setTimestamp(frame.getTimestamp())
+    frame.setTimestampDevice(frame.getTimestampDevice())
+    frame.setSequenceNum(123)
+    frame.setInstanceNum(7)
+    frame.setCategory(11)
+
+    transformation = dai.ImgTransformation(160, 120, image.shape[1], image.shape[0])
+    transformation.addCrop(8, 6, image.shape[1] - 12, image.shape[0] - 10)
+    frame.setTransformation(transformation)
+
+    return frame, image
+
+
+def assert_frame_metadata_equal(expected, actual):
+    assert actual.getSequenceNum() == expected.getSequenceNum()
+    assert actual.getInstanceNum() == expected.getInstanceNum()
+    assert actual.getCategory() == expected.getCategory()
+    assert actual.getWidth() == expected.getWidth()
+    assert actual.getHeight() == expected.getHeight()
+    assert actual.getType() == expected.getType()
+    assert actual.getTimestamp() == expected.getTimestamp()
+    assert actual.getTimestampDevice() == expected.getTimestampDevice()
+
+    expected_transform = np.array(expected.getTransformation().getTransformationMatrix())
+    actual_transform = np.array(actual.getTransformation().getTransformationMatrix())
+    np.testing.assert_allclose(actual_transform, expected_transform)
+
+
 
 COLOR_TYPES = [
     pytest.param(dai.ImgFrame.Type.BGR888p, 0.5, id="BGR888p"),
@@ -127,3 +160,55 @@ def test_setcvframe_raw32():
     assert recovered.shape == image.shape
     assert recovered.dtype == np.int32
     assert_images_close(image, recovered, tolerance=0.0, msg="RAW32")
+
+
+def test_imgframe_file_roundtrip(tmp_path: Path):
+    frame, image = make_test_frame()
+    path = tmp_path / "frame.pb"
+
+    frame.save(path)
+    recovered = dai.ImgFrame()
+    recovered.load(path)
+
+    assert_frame_metadata_equal(frame, recovered)
+    assert np.array_equal(np.asarray(recovered.getData()), np.asarray(frame.getData()))
+    assert_images_close(image, recovered.getCvFrame(), tolerance=0.5, msg="imgframe file roundtrip")
+
+
+def test_imgframe_metadata_only_roundtrip(tmp_path: Path):
+    frame, _ = make_test_frame()
+    path = tmp_path / "frame-metadata.pb"
+
+    frame.save(path, metadataOnly=True)
+    recovered = dai.ImgFrame()
+    recovered.load(path, metadataOnly=True)
+
+    assert_frame_metadata_equal(frame, recovered)
+    assert recovered.getData().size == 0
+
+
+def test_encodedframe_file_roundtrip(tmp_path: Path):
+    frame = dai.EncodedFrame()
+    frame.setWidth(320)
+    frame.setHeight(180)
+    frame.setQuality(90)
+    frame.setBitrate(1_000_000)
+    frame.setProfile(dai.EncodedFrame.Profile.JPEG)
+    frame.setFrameType(dai.EncodedFrame.FrameType.I)
+    frame.setLossless(False)
+    frame.setData(np.arange(64, dtype=np.uint8))
+
+    path = tmp_path / "encoded-frame.pb"
+    frame.save(path)
+
+    recovered = dai.EncodedFrame()
+    recovered.load(path)
+
+    assert recovered.getWidth() == frame.getWidth()
+    assert recovered.getHeight() == frame.getHeight()
+    assert recovered.getQuality() == frame.getQuality()
+    assert recovered.getBitrate() == frame.getBitrate()
+    assert recovered.getProfile() == frame.getProfile()
+    assert recovered.getFrameType() == frame.getFrameType()
+    assert recovered.getLossless() == frame.getLossless()
+    assert np.array_equal(np.asarray(recovered.getData()), np.asarray(frame.getData()))

include/depthai/pipeline/datatype/EncodedFrame.hpp

@@ -215,6 +215,11 @@ class EncodedFrame : public Buffer, public ProtoSerializable {
      * @returns serialized schema
      */
     ProtoSerializable::SchemaPair serializeSchema() const override;
+
+   protected:
+    void deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) override;
+
+   public:
 #endif
 
     DEPTHAI_SERIALIZE(EncodedFrame,

include/depthai/pipeline/datatype/IMUData.hpp

@@ -257,6 +257,11 @@ class IMUData : public Buffer, public ProtoSerializable {
      * @returns serialized schema
      */
     ProtoSerializable::SchemaPair serializeSchema() const override;
+
+   protected:
+    void deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) override;
+
+   public:
 #endif
 
     DEPTHAI_SERIALIZE(IMUData, Buffer::ts, Buffer::tsDevice, Buffer::tsSystem, Buffer::sequenceNum, packets);

include/depthai/pipeline/datatype/ImgFrame.hpp

@@ -101,8 +101,12 @@ class ImgFrame : public Buffer, public ProtoSerializable {
      * @returns serialized schema
      */
     ProtoSerializable::SchemaPair serializeSchema() const override;
-#endif
 
+   protected:
+    void deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) override;
+
+   public:
+#endif
     // getters
     /**
      * Retrieves image timestamp (at the specified offset of exposure) related to dai::Clock::now()
@@ -768,7 +772,6 @@ class ImgFrame : public Buffer, public ProtoSerializable {
     dai::FrameEvent event = dai::FrameEvent::NONE;
     ImgTransformation transformation;
 
-   public:
     DEPTHAI_SERIALIZE(ImgFrame, Buffer::ts, Buffer::tsDevice, Buffer::tsSystem, Buffer::sequenceNum, fb, sourceFb, cam, category, instanceNum, transformation);
 };
 

include/depthai/pipeline/datatype/PointCloudData.hpp

@@ -266,6 +266,11 @@ class PointCloudData : public Buffer, public ProtoSerializable, public Transform
      * @returns serialized schema
      */
     ProtoSerializable::SchemaPair serializeSchema() const override;
+
+   protected:
+    void deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) override;
+
+   public:
 #endif
 
 #ifdef DEPTHAI_HAVE_PCL_SUPPORT

include/depthai/pipeline/datatype/RGBDData.hpp

@@ -61,6 +61,11 @@ class RGBDData : public Buffer, public ProtoSerializable {
      * @returns serialized schema
      */
     ProtoSerializable::SchemaPair serializeSchema() const override;
+
+   protected:
+    void deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) override;
+
+   public:
 #endif
 
     DEPTHAI_SERIALIZE(RGBDData, colorFrame, depthFrame, Buffer::ts, Buffer::tsDevice, Buffer::tsSystem, Buffer::sequenceNum);

include/depthai/utility/ProtoSerializable.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <filesystem>
 #include <string>
 #include <vector>
 
@@ -16,6 +17,20 @@ class ProtoSerializable {
     virtual ~ProtoSerializable();
 
 #ifdef DEPTHAI_ENABLE_PROTOBUF
+    /**
+     * @brief Serialize this object and write it to disk
+     * @param path Output path. If it has no extension, the final on-disk filename is resolved to `<path>.dai`.
+     * @param metadataOnly If true, serialize only metadata and omit payload data where supported by the concrete type.
+     */
+    void save(const std::filesystem::path& path, bool metadataOnly = false) const;
+
+    /**
+     * @brief Load this object from a serialized protobuf file on disk
+     * @param path Input path. If it has no extension, the file is resolved as `<path>.dai`.
+     * @param metadataOnly If true, load only metadata and omit payload data where supported by the concrete type.
+     */
+    void load(const std::filesystem::path& path, bool metadataOnly = false);
+
     /**
      * @brief Serialize the protobuf message of this object
      * @return serialized protobuf message
@@ -28,6 +43,9 @@ class ProtoSerializable {
      */
     virtual SchemaPair serializeSchema() const = 0;
 
+   protected:
+    virtual void deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly);
+
 #else
     // Helper struct for compile-time check
     template <typename... T>

src/opencv/ImgFrame.cpp

@@ -10,6 +10,7 @@
 // #include "spdlog/spdlog.h"
 
 namespace dai {
+
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch-enum"
 ImgFrame& ImgFrame::setFrame(cv::Mat frame) {

src/pipeline/datatype/EncodedFrame.cpp

@@ -1,6 +1,7 @@
 #include "depthai/pipeline/datatype/EncodedFrame.hpp"
 #ifdef DEPTHAI_ENABLE_PROTOBUF
     #include "depthai/schemas/EncodedFrame.pb.h"
+    #include "utility/ProtoFileIO.hpp"
     #include "utility/ProtoSerialize.hpp"
 #endif
 
@@ -161,6 +162,10 @@ ImgFrame EncodedFrame::getImgFrameMeta() const {
 }
 
 #ifdef DEPTHAI_ENABLE_PROTOBUF
+void EncodedFrame::deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) {
+    utility::loadProtoMessageFromBytes(*this, bytes, metadataOnly);
+}
+
 ProtoSerializable::SchemaPair EncodedFrame::serializeSchema() const {
     return utility::serializeSchema(utility::getProtoMessage(this));
 }

src/pipeline/datatype/IMUData.cpp

@@ -3,6 +3,7 @@
 #if DEPTHAI_ENABLE_PROTOBUF
     #include "depthai/schemas/IMUData.pb.h"
     #include "depthai/schemas/common.pb.h"
+    #include "utility/ProtoFileIO.hpp"
     #include "utility/ProtoSerialize.hpp"
 #endif
 
@@ -16,6 +17,9 @@ void IMUData::serialize(std::vector<std::uint8_t>& metadata, DatatypeEnum& datat
 }
 
 #ifdef DEPTHAI_ENABLE_PROTOBUF
+void IMUData::deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) {
+    utility::loadProtoMessageFromBytes(*this, bytes, metadataOnly);
+}
 
 ProtoSerializable::SchemaPair IMUData::serializeSchema() const {
     return utility::serializeSchema(utility::getProtoMessage(this));

src/pipeline/datatype/ImgFrame.cpp

@@ -6,6 +6,7 @@
 #include "depthai/utility/SharedMemory.hpp"
 #ifdef DEPTHAI_ENABLE_PROTOBUF
     #include "depthai/schemas/ImgFrame.pb.h"
+    #include "utility/ProtoFileIO.hpp"
     #include "utility/ProtoSerialize.hpp"
 #endif
 namespace dai {
@@ -361,6 +362,10 @@ Rect ImgFrame::remapRectBetweenFrames(const Rect& originRect, const ImgFrame& or
 }
 
 #ifdef DEPTHAI_ENABLE_PROTOBUF
+void ImgFrame::deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) {
+    utility::loadProtoMessageFromBytes(*this, bytes, metadataOnly);
+}
+
 ProtoSerializable::SchemaPair ImgFrame::serializeSchema() const {
     return utility::serializeSchema(utility::getProtoMessage(this));
 }

src/pipeline/datatype/PointCloudData.cpp

@@ -7,6 +7,7 @@
 #include "depthai/common/Point3f.hpp"
 #ifdef DEPTHAI_ENABLE_PROTOBUF
     #include "depthai/schemas/PointCloudData.pb.h"
+    #include "utility/ProtoFileIO.hpp"
     #include "utility/ProtoSerialize.hpp"
 #endif
 namespace dai {
@@ -244,6 +245,10 @@ PointCloudData& PointCloudData::setColor(bool val) {
 }
 
 #ifdef DEPTHAI_ENABLE_PROTOBUF
+void PointCloudData::deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) {
+    utility::loadProtoMessageFromBytes(*this, bytes, metadataOnly);
+}
+
 std::vector<std::uint8_t> PointCloudData::serializeProto(bool metadataOnly) const {
     return utility::serializeProto(utility::getProtoMessage(this, metadataOnly));
 }

src/pipeline/datatype/RGBDData.cpp

@@ -2,6 +2,7 @@
 
 #ifdef DEPTHAI_ENABLE_PROTOBUF
     #include "depthai/schemas/RGBDData.pb.h"
+    #include "utility/ProtoFileIO.hpp"
     #include "utility/ProtoSerialize.hpp"
 #endif
 
@@ -62,6 +63,10 @@ std::optional<RGBDData::FrameVariant> RGBDData::getDepthFrame() const {
 }
 
 #ifdef DEPTHAI_ENABLE_PROTOBUF
+void RGBDData::deserializeProtoMessage(const std::vector<std::uint8_t>& bytes, bool metadataOnly) {
+    utility::loadProtoMessageFromBytes(*this, bytes, metadataOnly);
+}
+
 std::vector<std::uint8_t> RGBDData::serializeProto(bool metadataOnly) const {
     return utility::serializeProto(utility::getProtoMessage(this, metadataOnly));
 }