From 88047ce74050c8d08aabb9b3717eb7ddca1d75ce Mon Sep 17 00:00:00 2001 From: Georg Hagen Date: Wed, 4 Dec 2024 21:35:49 +0100 Subject: [PATCH] Support yaml for ArFrameMetadata --- openVulkanoCpp/AR/ArFrameMetadata.cpp | 112 +++++++++++++----- .../Extensions/YamlCppConverters.hpp | 46 +++++-- openVulkanoCpp/Math/CameraIntrinsic.hpp | 9 +- 3 files changed, 126 insertions(+), 41 deletions(-) diff --git a/openVulkanoCpp/AR/ArFrameMetadata.cpp b/openVulkanoCpp/AR/ArFrameMetadata.cpp index 82c27df..7d6e996 100644 --- a/openVulkanoCpp/AR/ArFrameMetadata.cpp +++ b/openVulkanoCpp/AR/ArFrameMetadata.cpp @@ -5,8 +5,9 @@ */ #include "ArFrameMetadata.hpp" +#include "Extensions/RymlConverters.hpp" +#include #include -#include #include namespace OpenVulkano::AR @@ -45,18 +46,21 @@ namespace OpenVulkano::AR } } - template - void MatToYaml(const glm::mat& mat, std::ostream& stream, const std::string& nl = "\n") + template + void ReadMat(const ryml::NodeRef& node, T& mat) { - for(int r = 0 ; r < SIZE; r++) + if (!node.is_seq()) return; + int row = 0; + for(auto iter = node.begin(); iter != node.end() && row < S; ++iter) { - stream << nl << "- ["; - for (int c = 0; c < SIZE; c++) + const auto rowNode = *iter; + int col = 0; + for(auto colIter = rowNode.begin(); colIter != rowNode.end() && col < S; ++colIter) { - if (c) stream << ','; - stream << ' ' << mat[c][r]; + (*colIter) >> mat[col][row]; + col++; } - stream << " ]"; + row++; } } } @@ -89,32 +93,82 @@ namespace OpenVulkano::AR return frameData; } - ArFrameMetadata ArFrameMetadata::FromYaml(const char* xml, size_t length) + ArFrameMetadata ArFrameMetadata::FromYaml(const char* yaml, size_t length) { ArFrameMetadata frameData; - //TODO + ryml::Tree tree; + ryml::parse_in_arena(c4::csubstr(yaml, length), &tree); + ryml::NodeRef root = tree.rootref(); + ryml::NodeRef camNode = root["Camera"]; + ReadMat(camNode["Transform"], frameData.transformation); + ReadMat(camNode["Projection"], frameData.projection); + Math::Matrix3f intrinsic; + Math::Vector2i res; + camNode["Resolution"] >> res; + ReadMat(camNode["Intrinsics"], intrinsic); + frameData.intrinsic = {intrinsic, res}; + camNode["ExposureDuration"] >> frameData.exposureTime; + camNode["ExposureOffset"] >> frameData.exposureOffset; + uint64_t nanos; + root["Timestamp"] >> nanos; + frameData.timestamp = nanos; + root["TimestampDepth"] >> nanos; + frameData.timestampDepth = nanos; + std::string tracking; + ryml::NodeRef trackingNode = root["TrackingState"]; + trackingNode["Camera"] >> tracking; + frameData.trackingState = ArTrackingState::GetFromName(tracking); + ryml::NodeRef lightNode = root["Light"]; + lightNode["Intensity"] >> frameData.lightIntensity; + lightNode["ColorTemp"] >> frameData.lightColorTemp; return frameData; } std::string ArFrameMetadata::ToYaml() const { - std::stringstream meta; - meta << std::setprecision(std::numeric_limits::digits10); - - meta << "camera:\n transform: "; - MatToYaml(transformation, meta, "\n "); - meta << "\n projection"; - MatToYaml(projection, meta, "\n "); - meta << "\n resolution:\n width: " << intrinsic.GetResolution().x << "\n height: " << intrinsic.GetResolution().y; - meta << "\n intrinsics: "; - MatToYaml(intrinsic.cameraMatrix, meta, "\n "); - meta << "\n exposureDuration: " << exposureTime << "\n exposureOffset: " << exposureOffset; - meta << "\ntimestamp: " << timestamp.GetSeconds(); - meta << "\ntimestampDepth: " << timestampDepth.GetNanos(); - meta << "\ntrackingState: \n camera: " << trackingState.GetName(); - meta << "\nlight:\n intensity: " << lightIntensity << "\n colorTemp: " << lightColorTemp; - - return meta.str(); + const auto& camMat = intrinsic.GetMatrix(); + std::string meta = fmt::format(R"(Camera: + Transform: + - [ {}, {}, {}, {} ] + - [ {}, {}, {}, {} ] + - [ {}, {}, {}, {} ] + - [ {}, {}, {}, {} ] + Projection: + - [ {}, {}, {}, {} ] + - [ {}, {}, {}, {} ] + - [ {}, {}, {}, {} ] + - [ {}, {}, {}, {} ] + Resolution: '({},{})' + Intrinsics: + - [ {}, {}, {} ] + - [ {}, {}, {} ] + - [ {}, {}, {} ] + ExposureDuration: {} + ExposureOffset: {} +Timestamp: {} +TimestampDepth: {} +TrackingState: + Camera: {} +Light: + Intensity: {} + ColorTemp: {} +)", + transformation[0][0], transformation[1][0], transformation[2][0], transformation[3][0], + transformation[0][1], transformation[1][1], transformation[2][1], transformation[3][1], + transformation[0][2], transformation[1][2], transformation[2][2], transformation[3][2], + transformation[0][3], transformation[1][3], transformation[2][3], transformation[3][3], + projection[0][0], projection[1][0], projection[2][0], projection[3][0], + projection[0][1], projection[1][1], projection[2][1], projection[3][1], + projection[0][2], projection[1][2], projection[2][2], projection[3][2], + projection[0][3], projection[1][3], projection[2][3], projection[3][3], + intrinsic.GetResolution().x, intrinsic.GetResolution().y, + camMat[0][0], camMat[1][0], camMat[2][0], + camMat[0][1], camMat[1][1], camMat[2][1], + camMat[0][2], camMat[1][2], camMat[2][2], + exposureTime, exposureOffset, timestamp.GetNanos(), timestampDepth.GetNanos(), + trackingState.GetName(), lightIntensity, lightColorTemp +); + return meta; } std::string ArFrameMetadata::ToXML() const @@ -128,7 +182,7 @@ namespace OpenVulkano::AR MatToXML(projection, meta, "\n\t\t\t"); meta << "\n\t\t\n\t\t\n\t\t\t" << intrinsic.GetResolution().x << "\n\t\t\t"; meta << "" << intrinsic.GetResolution().y << "\n\t\t\n\t\t"; - MatToXML(intrinsic.cameraMatrix, meta, "\n\t\t\t"); + MatToXML(intrinsic.GetMatrix(), meta, "\n\t\t\t"); meta << "\n\t\t" << exposureTime << "\n\t\t" << exposureOffset; meta << "\n\t\n\t"; meta << "" << timestamp.GetSeconds() << "\n\t"; diff --git a/openVulkanoCpp/Extensions/YamlCppConverters.hpp b/openVulkanoCpp/Extensions/YamlCppConverters.hpp index 58ffbd9..3586dac 100644 --- a/openVulkanoCpp/Extensions/YamlCppConverters.hpp +++ b/openVulkanoCpp/Extensions/YamlCppConverters.hpp @@ -79,6 +79,20 @@ namespace YAML } }; + template + bool ReadSequence(const Node& node, const int count, T* array) + { + if (!node.IsSequence()) return false; + int readCount = 0; + YAML::const_iterator iter = node.begin(); + for(int i = 0; i < count && iter != node.end(); i++, iter++) + { + array[i] = iter->as(); + readCount++; + } + return readCount == count; + } + template struct convert> { @@ -94,7 +108,7 @@ namespace YAML size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{})", v.x, v.y); return ret != c4::csubstr::npos; } - return false; + return ReadSequence(node, 2, &v.x); } }; @@ -113,7 +127,7 @@ namespace YAML size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{})", v.x, v.y, v.z); return ret != c4::csubstr::npos; } - return false; + return ReadSequence(node, 3, &v.x); } }; @@ -132,7 +146,7 @@ namespace YAML size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{},{})", v.x, v.y, v.z, v.w); return ret != c4::csubstr::npos; } - return false; + return ReadSequence(node, 4, &v.x); } }; @@ -151,7 +165,7 @@ namespace YAML size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{})", v.x, v.y); return ret != c4::csubstr::npos; } - return false; + return ReadSequence(node, 2, &v.x); } }; @@ -170,10 +184,26 @@ namespace YAML size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{})", v.x, v.y, v.z); return ret != c4::csubstr::npos; } - return false; + return ReadSequence(node, 3, &v.x); } }; + template + bool ReadSequenceMat(const Node& node, const int size, MAT& data) + { + if (!node.IsSequence()) return false; + int readCount = 0; + MAT tmp; + YAML::const_iterator iter = node.begin(); + for(int i = 0; i < size && iter != node.end(); i++, iter++) + { + if (!iter->IsSequence()) return false; + if (ReadSequence(*iter, size, &tmp[i][0])) readCount++; + } + data = glm::transpose(tmp); + return readCount == size; + } + template struct convert> { @@ -196,7 +226,7 @@ namespace YAML mat[2][0], mat[2][1], mat[2][2]); return ret != c4::csubstr::npos; } - return false; + return ReadSequenceMat(node, 3, mat); } }; @@ -222,7 +252,7 @@ namespace YAML mat[2][0], mat[2][1], mat[2][2]); return ret != c4::csubstr::npos; } - return false; + return ReadSequenceMat(node, 3, mat); } }; @@ -250,7 +280,7 @@ namespace YAML mat[3][0], mat[3][1], mat[3][2], mat[3][3]); return ret != c4::csubstr::npos; } - return false; + return ReadSequenceMat(node, 4, mat); } }; diff --git a/openVulkanoCpp/Math/CameraIntrinsic.hpp b/openVulkanoCpp/Math/CameraIntrinsic.hpp index ef914ee..83e8542 100644 --- a/openVulkanoCpp/Math/CameraIntrinsic.hpp +++ b/openVulkanoCpp/Math/CameraIntrinsic.hpp @@ -12,9 +12,8 @@ namespace OpenVulkano::Math { class CameraIntrinsic { - public: Math::Matrix3f_SIMD cameraMatrix; - + public: CameraIntrinsic() : CameraIntrinsic(Math::Matrix3f(0)) {} CameraIntrinsic(const Math::Matrix3f& camMat) : cameraMatrix(camMat) @@ -103,15 +102,17 @@ namespace OpenVulkano::Math }; } - CameraIntrinsic operator * (const float scale) const + [[nodiscard]] CameraIntrinsic operator * (const float scale) const { return Scale(scale); } - CameraIntrinsic operator * (const Math::Vector2f& scale) const + [[nodiscard]] CameraIntrinsic operator * (const Math::Vector2f& scale) const { return Scale(scale); } + + [[nodiscard]] const Matrix3f_SIMD& GetMatrix() const { return cameraMatrix; } }; class CameraIntrinsicWithResolution : public CameraIntrinsic