GeorgH93/OpenVulkano
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Support yaml for ArFrameMetadata

Browse Source
This commit is contained in:
Georg Hagen
2024-12-04 21:35:49 +01:00
parent 007eefc688
commit 88047ce740
3 changed files with 126 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
openVulkanoCpp/AR/ArFrameMetadata.cpp
View File

@@ -5,8 +5,9 @@
*/
#include "ArFrameMetadata.hpp"
#include "Extensions/RymlConverters.hpp"
#include <fmt/format.h>
#include <pugixml.hpp>
#include <yaml-cpp/yaml.h>
#include <sstream>
namespace OpenVulkano::AR
@@ -45,18 +46,21 @@ namespace OpenVulkano::AR
}
}
template<glm::length_t SIZE, typename T, glm::qualifier Q>
void MatToYaml(const glm::mat<SIZE, SIZE, T, Q>& mat, std::ostream& stream, const std::string& nl = "\n")
template<typename T, int S>
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<Math::Matrix4f, 4>(camNode["Transform"], frameData.transformation);
ReadMat<Math::Matrix4f, 4>(camNode["Projection"], frameData.projection);
Math::Matrix3f intrinsic;
Math::Vector2i res;
camNode["Resolution"] >> res;
ReadMat<Math::Matrix3f, 3>(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<double>::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</projection>\n\t\t<resolution>\n\t\t\t<width>" << intrinsic.GetResolution().x << "</width>\n\t\t\t";
meta << "<height>" << intrinsic.GetResolution().y << "</height>\n\t\t</resolution>\n\t\t<intrinsics>";
MatToXML(intrinsic.cameraMatrix, meta, "\n\t\t\t");
MatToXML(intrinsic.GetMatrix(), meta, "\n\t\t\t");
meta << "</intrinsics>\n\t\t<exposureDuration>" << exposureTime << "</exposureDuration>\n\t\t<exposureOffset>" << exposureOffset;
meta << "</exposureOffset>\n\t</camera>\n\t";
meta << "<timestamp>" << timestamp.GetSeconds() << "</timestamp>\n\t";

46
openVulkanoCpp/Extensions/YamlCppConverters.hpp
View File

@@ -79,6 +79,20 @@ namespace YAML
}
};
template<typename T>
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<T>();
readCount++;
}
return readCount == count;
}
template<typename T>
struct convert<OpenVulkano::Math::Vector2<T>>
{
@@ -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<typename MAT>
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<typename T>
struct convert<OpenVulkano::Math::Matrix3<T>>
{
@@ -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);
}
};

9
openVulkanoCpp/Math/CameraIntrinsic.hpp
View File

@@ -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