refactor ZED capture into modular camera class with env config

Extract camera lifecycle (open, warmup, grab, close) and
environment-based configuration into src/zed/camera.{h,cc}.
Thin main.cc now only handles the dora event loop.

Closes #2

src/main.cc

@@ -0,0 +1,151 @@
+#include "zed/camera.h"
+
+#include <dora-node-api.h>
+#include <opencv2/opencv.hpp>
+
+#include <chrono>
+#include <initializer_list>
+#include <iostream>
+#include <string>
+
+namespace {
+
+rust::Vec<int64_t> make_shape(int height, int width, int channels) {
+    rust::Vec<int64_t> shape;
+    shape.push_back(height);
+    shape.push_back(width);
+    shape.push_back(channels);
+    return shape;
+}
+
+rust::Vec<double> make_distortion(const std::vector<double>& distortion) {
+    rust::Vec<double> values;
+    for (double v : distortion) {
+        values.push_back(v);
+    }
+    return values;
+}
+
+rust::Vec<int64_t> make_vector_int(std::initializer_list<int64_t> values) {
+    rust::Vec<int64_t> out;
+    for (int64_t v : values) {
+        out.push_back(v);
+    }
+    return out;
+}
+
+} // namespace
+
+int main() {
+    auto dora_node = init_dora_node();
+
+    auto config = zed::Config::from_env();
+    zed::Camera camera(config);
+    camera.open();
+    camera.warmup();
+    auto calib = camera.calibration();
+
+    int64_t frame_id = 0;
+    while (true) {
+        auto event = dora_node.events->next();
+        auto type = event_type(event);
+
+        if (type == DoraEventType::Stop || type == DoraEventType::AllInputsClosed) {
+            break;
+        }
+
+        if (type != DoraEventType::Input) {
+            continue;
+        }
+
+        auto input = event_as_input(std::move(event));
+        (void)input;
+
+        if (!camera.grab()) {
+            std::cerr << "Grab failed; attempting to reconnect..." << std::endl;
+            camera.close();
+            camera.open();
+            calib = camera.calibration();
+            continue;
+        }
+
+        sl::Mat& image_mat = camera.image();
+        sl::Mat& point_cloud_mat = camera.point_cloud();
+
+        int width = image_mat.getWidth();
+        int height = image_mat.getHeight();
+
+        cv::Mat image_rgba(height, width, CV_8UC4, image_mat.getPtr<sl::uchar1>());
+        cv::Mat image_bgr;
+        cv::cvtColor(image_rgba, image_bgr, cv::COLOR_BGRA2BGR);
+
+        const auto image_size = static_cast<size_t>(image_bgr.total() * image_bgr.elemSize());
+        rust::Slice<const uint8_t> image_slice{
+            reinterpret_cast<const uint8_t*>(image_bgr.data), image_size};
+
+        auto image_metadata = new_metadata();
+        image_metadata->set_string("dtype", "uint8");
+        image_metadata->set_string("encoding", "bgr8");
+        image_metadata->set_string("layout", "HWC");
+        image_metadata->set_list_int("shape", make_shape(height, width, 3));
+        image_metadata->set_float("fx", calib.fx);
+        image_metadata->set_float("fy", calib.fy);
+        image_metadata->set_float("cx", calib.cx);
+        image_metadata->set_float("cy", calib.cy);
+        image_metadata->set_list_float("distortion", make_distortion(calib.distortion));
+        image_metadata->set_int("frame_id", frame_id++);
+        image_metadata->set_int("timestamp_ns", static_cast<int64_t>(
+            std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::steady_clock::now().time_since_epoch()
+            ).count()
+        ));
+
+        auto image_result = send_output_with_metadata(
+            dora_node.send_output, "image_bgr", image_slice, std::move(image_metadata));
+        if (!std::string(image_result.error).empty()) {
+            std::cerr << "Error sending image_bgr: " << std::string(image_result.error) << std::endl;
+        }
+
+        int pc_width = point_cloud_mat.getWidth();
+        int pc_height = point_cloud_mat.getHeight();
+        const size_t pc_size = static_cast<size_t>(pc_width * pc_height * sizeof(sl::float4));
+        const auto* pc_ptr = reinterpret_cast<const uint8_t*>(point_cloud_mat.getPtr<sl::float4>());
+        rust::Slice<const uint8_t> pc_slice{pc_ptr, pc_size};
+
+        auto pc_metadata = new_metadata();
+        pc_metadata->set_string("dtype", "float32");
+        pc_metadata->set_string("layout", "HWC");
+        pc_metadata->set_string("channels", "XYZRGBA");
+        pc_metadata->set_string("units", "mm");
+        pc_metadata->set_list_int("shape", make_shape(pc_height, pc_width, 4));
+        pc_metadata->set_float("fx", calib.fx);
+        pc_metadata->set_float("fy", calib.fy);
+        pc_metadata->set_float("cx", calib.cx);
+        pc_metadata->set_float("cy", calib.cy);
+        pc_metadata->set_list_float("distortion", make_distortion(calib.distortion));
+
+        auto pc_result = send_output_with_metadata(
+            dora_node.send_output, "point_cloud", pc_slice, std::move(pc_metadata));
+        if (!std::string(pc_result.error).empty()) {
+            std::cerr << "Error sending point_cloud: " << std::string(pc_result.error) << std::endl;
+        }
+
+        float camera_data[4] = {calib.fx, calib.fy, calib.cx, calib.cy};
+        rust::Slice<const uint8_t> cam_slice{
+            reinterpret_cast<const uint8_t*>(camera_data), sizeof(camera_data)};
+
+        auto cam_metadata = new_metadata();
+        cam_metadata->set_string("dtype", "float32");
+        cam_metadata->set_string("layout", "C");
+        cam_metadata->set_list_int("shape", make_vector_int({4}));
+        cam_metadata->set_list_float("distortion", make_distortion(calib.distortion));
+
+        auto cam_result = send_output_with_metadata(
+            dora_node.send_output, "camera_info", cam_slice, std::move(cam_metadata));
+        if (!std::string(cam_result.error).empty()) {
+            std::cerr << "Error sending camera_info: " << std::string(cam_result.error) << std::endl;
+        }
+    }
+
+    return 0;
+}