awe/radar_system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added GPR

Browse Source
This commit is contained in:
Ayzen
2026-03-19 19:29:08 +03:00
parent bdefe3f581
commit 9581730e41
39 changed files with 3830 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files
data_acq_and_processing/common_cpp/ipc/include/shared_types.hpp
+10
View File
@@ -49,6 +49,8 @@ using PreprocessedCollection = RawSweepCollection;
enum class ResultKind : std::uint8_t {
TraceComplex = 1,
ScalarF32 = 2,
ImageF32 = 3,
TableF32 = 4,
};
struct ResultPayload {
@@ -60,6 +62,13 @@ struct ResultPayload {
std::vector<Complex32> trace{};
// Valid for ScalarF32 payloads.
float scalar_value = 0.0F;
// Valid for ImageF32 payloads.
std::vector<float> image_x_axis{};
std::vector<float> image_y_axis{};
std::vector<float> image_values{};
// Valid for TableF32 payloads.
std::uint32_t table_columns = 0;
std::vector<float> table_values{};
};
struct ResultBlock {
@@ -70,6 +79,7 @@ struct ResultBlock {
struct ResultCollection {
std::uint64_t collection_id = 0;
std::uint64_t monotonic_ns = 0;
std::vector<ResultPayload> collection_payloads{};
std::vector<ResultBlock> blocks{};
};
data_acq_and_processing/common_cpp/ipc/src/shared_types.cpp
+91
View File
@@ -200,6 +200,75 @@ auto read_trace_result_payload(BinaryReader& reader, ResultPayload* payload) ->
}
}
void write_image_result_payload(BinaryWriter& writer, const ResultPayload& payload) {
const auto x_count = checked_count_to_u32(payload.image_x_axis.size(), "Result image x axis point count");
const auto y_count = checked_count_to_u32(payload.image_y_axis.size(), "Result image y axis point count");
const std::size_t expected_value_count = static_cast<std::size_t>(x_count) * static_cast<std::size_t>(y_count);
if (payload.image_values.size() != expected_value_count) {
throw std::runtime_error("Result image payload has inconsistent axis/value sizes");
}
writer.write(x_count);
writer.write(y_count);
for (const auto value : payload.image_x_axis) {
writer.write(value);
}
for (const auto value : payload.image_y_axis) {
writer.write(value);
}
for (const auto value : payload.image_values) {
writer.write(value);
}
}
auto read_image_result_payload(BinaryReader& reader, ResultPayload* payload) -> void {
const auto x_count = reader.read<std::uint32_t>();
const auto y_count = reader.read<std::uint32_t>();
payload->image_x_axis.reserve(x_count);
payload->image_y_axis.reserve(y_count);
payload->image_values.reserve(static_cast<std::size_t>(x_count) * static_cast<std::size_t>(y_count));
for (std::uint32_t index = 0; index < x_count; ++index) {
payload->image_x_axis.push_back(reader.read<float>());
}
for (std::uint32_t index = 0; index < y_count; ++index) {
payload->image_y_axis.push_back(reader.read<float>());
}
for (std::size_t index = 0; index < static_cast<std::size_t>(x_count) * static_cast<std::size_t>(y_count); ++index) {
payload->image_values.push_back(reader.read<float>());
}
}
void write_table_result_payload(BinaryWriter& writer, const ResultPayload& payload) {
const auto column_count = payload.table_columns;
if (column_count == 0U && !payload.table_values.empty()) {
throw std::runtime_error("Result table payload must declare table_columns when values are present");
}
if (column_count != 0U && (payload.table_values.size() % column_count) != 0U) {
throw std::runtime_error("Result table payload has inconsistent column/value sizes");
}
const std::uint32_t row_count =
column_count == 0U ? 0U : checked_count_to_u32(payload.table_values.size() / column_count, "Result table row count");
writer.write(column_count);
writer.write(row_count);
for (const auto value : payload.table_values) {
writer.write(value);
}
}
auto read_table_result_payload(BinaryReader& reader, ResultPayload* payload) -> void {
const auto column_count = reader.read<std::uint32_t>();
const auto row_count = reader.read<std::uint32_t>();
payload->table_columns = column_count;
payload->table_values.reserve(static_cast<std::size_t>(column_count) * static_cast<std::size_t>(row_count));
for (std::size_t index = 0; index < static_cast<std::size_t>(column_count) * static_cast<std::size_t>(row_count); ++index) {
payload->table_values.push_back(reader.read<float>());
}
}
void write_result_payload(BinaryWriter& writer, const ResultPayload& payload) {
writer.write(static_cast<std::uint8_t>(payload.kind));
writer.write_string(payload.processing_name);
@@ -211,6 +280,12 @@ void write_result_payload(BinaryWriter& writer, const ResultPayload& payload) {
case ResultKind::ScalarF32:
writer.write(payload.scalar_value);
return;
case ResultKind::ImageF32:
write_image_result_payload(writer, payload);
return;
case ResultKind::TableF32:
write_table_result_payload(writer, payload);
return;
default:
throw std::runtime_error("Unsupported result payload kind");
}
@@ -228,6 +303,12 @@ void write_result_payload(BinaryWriter& writer, const ResultPayload& payload) {
case ResultKind::ScalarF32:
payload.scalar_value = reader.read<float>();
return payload;
case ResultKind::ImageF32:
read_image_result_payload(reader, &payload);
return payload;
case ResultKind::TableF32:
read_table_result_payload(reader, &payload);
return payload;
default:
throw std::runtime_error("Unsupported result payload kind in stream");
}
@@ -296,8 +377,12 @@ auto serialize_result_collection(const ResultCollection& collection) -> std::vec
writer.write(kResultCollectionMagic);
writer.write(collection.collection_id);
writer.write(collection.monotonic_ns);
writer.write(checked_count_to_u32(collection.collection_payloads.size(), "Collection payload count"));
writer.write(checked_count_to_u32(collection.blocks.size(), "Result block count"));
for (const auto& payload : collection.collection_payloads) {
write_result_payload(writer, payload);
}
for (const auto& block : collection.blocks) {
write_result_block(writer, block);
}
@@ -317,7 +402,13 @@ auto deserialize_result_collection(std::span<const std::uint8_t> bytes) -> Resul
collection.collection_id = reader.read<std::uint64_t>();
collection.monotonic_ns = reader.read<std::uint64_t>();
const auto collection_payload_count = reader.read<std::uint32_t>();
const auto block_count = reader.read<std::uint32_t>();
collection.collection_payloads.reserve(collection_payload_count);
for (std::uint32_t index = 0; index < collection_payload_count; ++index) {
collection.collection_payloads.push_back(read_result_payload(reader));
}
collection.blocks.reserve(block_count);
for (std::uint32_t index = 0; index < block_count; ++index) {
collection.blocks.push_back(read_result_block(reader));