hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/fixed_pose.cpp

@@ -0,0 +1,221 @@
+#define RL_TOOLS_RENDERING_RAYTRACING_DISABLE_PROBE_RAYS 1
+
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_SHADING
+#define RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_SHADING 3
+#endif
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_OUTPUT_MODE
+#define RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_OUTPUT_MODE 0
+#endif
+
+#include <rl_tools/operations/cpu_mux.h>
+#include <rl_tools/rendering/raytracing/operations_cpu_mux.h>
+#include <rl_tools/rendering/datasets/glb/operations_cpu.h>
+#include <rl_tools/rendering/raytracing/save_cpu.h>
+
+#include <conta/conta.h>
+
+
+#include <cmath>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+namespace rlt = rl_tools;
+
+using T = float;
+static constexpr T FOV = 80;
+using TI = typename rlt::devices::DEVICE_FACTORY<>::index_t;
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+
+static constexpr TI CAM_WIDTH = 2048;
+static constexpr TI CAM_HEIGHT = 1024;
+static constexpr TI NUM_CAMERAS = 1;
+static constexpr TI NUM_PROBES = 1;
+
+#if RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_SHADING == 0
+using SHADING = rlt::rendering::raytracing::Low;
+#elif RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_SHADING == 1
+using SHADING = rlt::rendering::raytracing::Medium;
+#elif RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_SHADING == 2
+using SHADING = rlt::rendering::raytracing::High;
+#else
+using SHADING = rlt::rendering::raytracing::VeryHigh;
+#endif
+
+static constexpr bool OUTPUT_RGB = RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_OUTPUT_MODE != 2;
+static constexpr bool OUTPUT_DEPTH = RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_OUTPUT_MODE != 0;
+
+struct CONFIG: rlt::rendering::raytracing::config::Default<T, TI>{
+    static constexpr TI CAM_WIDTH = ::CAM_WIDTH, CAM_HEIGHT = ::CAM_HEIGHT, NUM_CAMERAS = ::NUM_CAMERAS, NUM_PROBES = ::NUM_PROBES;
+    using SHADING = ::SHADING;
+    static constexpr bool OUTPUT_RGB = ::OUTPUT_RGB;
+    static constexpr bool OUTPUT_DEPTH = ::OUTPUT_DEPTH;
+    static constexpr bool ENABLE_ANTI_ALIASING = true;
+    static constexpr TI ANTI_ALIASING_GRID_SIZE = 2;
+};
+using SPEC = rlt::rendering::raytracing::Specification<CONFIG>;
+using Renderer = rlt::rendering::raytracing::Renderer<SPEC>;
+
+static constexpr char DEFAULT_SCENE_PATH[] = "/home/jonas/git/hssd-hab/glb/102343992.glb";
+
+struct Options {
+    std::string scene_path;
+    std::string output_path = "rendering_raytracing_fixed_pose.png";
+    T position[3] = {static_cast<T>(12.08), static_cast<T>(7.23), static_cast<T>(2.26)};
+    T orientation_wxyz[4] = {static_cast<T>(0.656), static_cast<T>(0.117), static_cast<T>(0.104), static_cast<T>(-0.738)};
+};
+
+static void print_usage(const char* argv0) {
+    std::cout
+        << "Usage: " << argv0 << " [--scene path.glb|conta:HASH] [--output path.png] [--position x,y,z] [--orientation w,x,y,z]\n"
+        << "Default scene: " << DEFAULT_SCENE_PATH << "\n";
+}
+
+static std::string resolve_scene_arg(const std::string& scene_arg) {
+    if(scene_arg.empty()) {
+        return DEFAULT_SCENE_PATH;
+    }
+    if(scene_arg.compare(0, 6, "conta:") == 0) {
+        std::string path, error;
+        if(!conta::resolve(scene_arg.substr(6), path, error)) {
+            std::cerr << error << std::endl;
+            return "";
+        }
+        return path;
+    }
+    return scene_arg;
+}
+
+static bool parse_options(int argc, char** argv, Options& options) {
+    std::string scene_arg;
+    for(int i = 1; i < argc; i++) {
+        const std::string arg = argv[i];
+        if(arg == "-h" || arg == "--help") {
+            print_usage(argv[0]);
+            std::exit(0);
+        }
+        if(arg == "--scene" || arg == "-s") {
+            if(i + 1 >= argc) {
+                std::cerr << "Missing value for " << arg << std::endl;
+                return false;
+            }
+            scene_arg = argv[++i];
+        }
+        else if(arg == "--output" || arg == "-o") {
+            if(i + 1 >= argc) {
+                std::cerr << "Missing value for " << arg << std::endl;
+                return false;
+            }
+            options.output_path = argv[++i];
+        }
+        else if(arg == "--position" || arg == "-p") {
+            if(i + 1 >= argc || std::sscanf(argv[++i], "%f,%f,%f", &options.position[0], &options.position[1], &options.position[2]) != 3) {
+                std::cerr << "Invalid value for " << arg << " (expected x,y,z)" << std::endl;
+                return false;
+            }
+        }
+        else if(arg == "--orientation" || arg == "-q") {
+            if(i + 1 >= argc || std::sscanf(argv[++i], "%f,%f,%f,%f", &options.orientation_wxyz[0], &options.orientation_wxyz[1], &options.orientation_wxyz[2], &options.orientation_wxyz[3]) != 4) {
+                std::cerr << "Invalid value for " << arg << " (expected w,x,y,z)" << std::endl;
+                return false;
+            }
+        }
+        else if(!arg.empty() && arg[0] == '-') {
+            std::cerr << "Unknown argument: " << arg << std::endl;
+            return false;
+        }
+        else if(scene_arg.empty()) {
+            scene_arg = arg;
+        }
+        else {
+            std::cerr << "Multiple scene paths provided" << std::endl;
+            return false;
+        }
+    }
+    options.scene_path = resolve_scene_arg(scene_arg);
+    if(options.scene_path.empty()) {
+        return false;
+    }
+    return true;
+}
+
+static void rotate_vector_by_quaternion(const T q[4], const T v[3], T out[3]) {
+    const T uv[3] = {
+        q[2] * v[2] - q[3] * v[1],
+        q[3] * v[0] - q[1] * v[2],
+        q[1] * v[1] - q[2] * v[0]
+    };
+    const T uuv[3] = {
+        q[2] * uv[2] - q[3] * uv[1],
+        q[3] * uv[0] - q[1] * uv[2],
+        q[1] * uv[1] - q[2] * uv[0]
+    };
+    out[0] = v[0] + static_cast<T>(2) * (q[0] * uv[0] + uuv[0]);
+    out[1] = v[1] + static_cast<T>(2) * (q[0] * uv[1] + uuv[1]);
+    out[2] = v[2] + static_cast<T>(2) * (q[0] * uv[2] + uuv[2]);
+}
+
+int main(int argc, char** argv) {
+    Options options;
+    if(!parse_options(argc, argv, options)) {
+        print_usage(argv[0]);
+        return 1;
+    }
+
+    DEVICE device;
+    rlt::init(device);
+
+    Renderer renderer;
+    rlt::malloc(device, renderer);
+
+    rlt::rendering::Bundle<T> bundle;
+    if(!rlt::load<typename SPEC::SHADING, SPEC::HAS_RGB>(device, bundle, options.scene_path)) {
+        std::cerr << "Failed to load scene: " << options.scene_path << std::endl;
+        rlt::free(device, renderer);
+        return 1;
+    }
+
+    rlt::init(device, renderer, bundle);
+
+    constexpr T forward_body[3] = {static_cast<T>(1), static_cast<T>(0), static_cast<T>(0)};
+    constexpr T up_body[3] = {static_cast<T>(0), static_cast<T>(0), static_cast<T>(1)};
+    T forward[3];
+    T up[3];
+    rotate_vector_by_quaternion(options.orientation_wxyz, forward_body, forward);
+    rotate_vector_by_quaternion(options.orientation_wxyz, up_body, up);
+
+    const T look_at[3] = {
+        options.position[0] + forward[0],
+        options.position[1] + forward[1],
+        options.position[2] + forward[2]
+    };
+    const T aspect = static_cast<T>(CAM_WIDTH) / static_cast<T>(CAM_HEIGHT);
+
+    auto camera = rlt::make_camera_data(options.position, look_at, up, FOV, aspect);
+    rlt::Tensor<typename decltype(renderer.cameras)::SPEC> camera_alias;
+    camera_alias._data = &camera;
+    rlt::copy(device, renderer.device, camera_alias, rlt::cameras(device, renderer));
+#if RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_OUTPUT_MODE == 2
+    rlt::render(device, renderer);
+    rlt::synchronize(device, renderer);
+    rlt::save_depth_image(device, renderer, options.output_path.c_str());
+    rlt::save_depth(device, renderer, (options.output_path + ".bin").c_str());
+#elif RL_TOOLS_RENDERING_RAYTRACING_FIXED_POSE_OUTPUT_MODE == 1
+    rlt::render(device, renderer);
+    rlt::synchronize(device, renderer);
+    rlt::save_image(device, renderer, options.output_path.c_str());
+    rlt::save_depth_image(device, renderer, (options.output_path + ".depth.png").c_str());
+    rlt::save_depth(device, renderer, (options.output_path + ".depth.bin").c_str());
+#else
+    rlt::render(device, renderer);
+    rlt::synchronize(device, renderer);
+    rlt::save_image(device, renderer, options.output_path.c_str());
+#endif
+
+    std::cout << "Wrote " << options.output_path << std::endl;
+
+    rlt::free(device, renderer);
+    return 0;
+}

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/flow.cpp

@@ -0,0 +1,120 @@
+// Two-instant optical flow: a cube (overlay) translates across the living room of the default
+// scene while the camera strafes. Frame 0 establishes the state, then one steady-state step
+// (advance_flow -> move -> update -> render) produces backward flow on the current frame,
+// forward flow on the previous frame, and the FlowStatus buffers that mask both.
+#include <rl_tools/operations/cpu_mux.h>
+#include <rl_tools/rendering/raytracing/operations_cpu_mux.h>
+#include <rl_tools/rendering/datasets/glb/operations_cpu.h>
+#include <rl_tools/rendering/raytracing/save_cpu.h>
+
+#include <iostream>
+#include <string>
+
+namespace rlt = rl_tools;
+
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+using T = float;
+static constexpr T FOV = 80;
+using TI = typename DEVICE::index_t;
+
+struct CONFIG: rlt::rendering::raytracing::config::Default<T, TI>{
+    static constexpr TI CAM_WIDTH = 256, CAM_HEIGHT = 256, NUM_CAMERAS = 1, NUM_PROBES = 1;
+    using SHADING = rlt::rendering::raytracing::Low;
+    static constexpr bool OUTPUT_FLOW = true;
+    static constexpr bool OUTPUT_FLOW_FORWARD = true;
+    static constexpr TI NUM_OVERLAYS = 1;
+    static constexpr TI MAX_OVERLAY_INSTANCES = 1;
+    static constexpr TI MAX_OVERLAYS_PER_CAMERA = 1;
+};
+using SPEC = rlt::rendering::raytracing::Specification<CONFIG>;
+using Renderer = rlt::rendering::raytracing::Renderer<SPEC>;
+
+static constexpr T CUBE_HALF_EXTENT = 0.3;
+static constexpr T CUBE_POSITION_PREVIOUS[3] = {-5.2, -5.0, 1.4};
+static constexpr T CUBE_POSITION_CURRENT[3] = {-4.9, -4.5, 1.5};
+static constexpr T CAMERA_POSITION_PREVIOUS[3] = {-6.5, -4.2, 1.6};
+static constexpr T CAMERA_POSITION_CURRENT[3] = {-6.4, -4.4, 1.6};
+static constexpr T CAMERA_LOOK_AT[3] = {-4.5, -5.0, 1.3};
+
+rlt::rendering::raytracing::Mesh make_cube(){
+    using namespace rlt::rendering::raytracing::constants;
+    rlt::rendering::raytracing::Mesh mesh;
+    mesh.color[0] = 0.85f;
+    mesh.color[1] = 0.3f;
+    mesh.color[2] = 0.1f;
+    for(TI vertex_i = 0; vertex_i < (TI)NUM_VERTICES; vertex_i++){
+        for(TI dim_i = 0; dim_i < 3; dim_i++){
+            mesh.vertices.push_back(default_vertices[vertex_i][dim_i] * static_cast<float>(CUBE_HALF_EXTENT));
+        }
+    }
+    for(TI triangle_i = 0; triangle_i < (TI)NUM_INDICES; triangle_i++){
+        for(TI corner_i = 0; corner_i < 3; corner_i++){
+            mesh.indices.push_back(default_indices[triangle_i][corner_i]);
+        }
+    }
+    return mesh;
+}
+
+void translation(const T position[3], float transform[12]){
+    const float quaternion_wxyz[4] = {1, 0, 0, 0};
+    const float position_float[3] = {static_cast<float>(position[0]), static_cast<float>(position[1]), static_cast<float>(position[2])};
+    rlt::make_transform(position_float, quaternion_wxyz, transform);
+}
+
+void set_camera(DEVICE& device, Renderer& renderer, const T position[3]){
+    constexpr T aspect = static_cast<T>(SPEC::CAM_WIDTH) / static_cast<T>(SPEC::CAM_HEIGHT);
+    const T up[3] = {0, 0, 1};
+    rlt::Tensor<typename Renderer::CAMERA_TENSOR_SPEC> camera_staging;
+    rlt::malloc(device, camera_staging);
+    rlt::set(device, camera_staging, rlt::make_camera_data(position, CAMERA_LOOK_AT, up, FOV, aspect), 0);
+    rlt::copy(device, renderer.device, camera_staging, rlt::cameras(device, renderer));
+    rlt::free(device, camera_staging);
+}
+
+int main(int argc, char** argv){
+    const std::string scene_path = argc > 1 ? argv[1] : "tests/data/ProcTHOR-Train-1.glb";
+    const std::string output_prefix = argc > 2 ? argv[2] : "flow";
+
+    DEVICE device;
+    rlt::init(device);
+
+    Renderer renderer;
+    rlt::malloc(device, renderer);
+
+    rlt::rendering::Bundle<T> bundle;
+    if(!rlt::load<typename SPEC::SHADING, SPEC::HAS_RGB>(device, bundle, scene_path)){
+        std::cerr << "Failed to load scene: " << scene_path << std::endl;
+        rlt::free(device, renderer);
+        return 1;
+    }
+    rlt::rendering::raytracing::AssetPool pool;
+    const auto cube = rlt::add(device, pool, make_cube());
+    rlt::init(device, renderer, bundle, pool);
+    rlt::attach(device, renderer, 0, rlt::rendering::raytracing::OverlayIndex{0});
+
+    // frame 0: spawn initialises the previous instant equal to the current one
+    float transform[12];
+    translation(CUBE_POSITION_PREVIOUS, transform);
+    const auto placement = rlt::spawn(device, renderer, rlt::rendering::raytracing::OverlayIndex{0}, cube, transform);
+    set_camera(device, renderer, CAMERA_POSITION_PREVIOUS);
+    rlt::update(device, renderer);
+    rlt::render(device, renderer);
+
+    // steady-state step: publish frame 0 as the previous instant, move camera and object, republish
+    rlt::advance_flow(device, renderer);
+    set_camera(device, renderer, CAMERA_POSITION_CURRENT);
+    translation(CUBE_POSITION_CURRENT, transform);
+    rlt::set_transform(device, renderer, rlt::rendering::raytracing::OverlayIndex{0}, placement, transform);
+    rlt::update(device, renderer);
+    rlt::render(device, renderer);
+
+    rlt::save_image(device, renderer, (output_prefix + "_rgb.png").c_str());
+    rlt::save_flow_image(device, renderer, (output_prefix + "_backward.png").c_str());
+    rlt::save_flow_status_image(device, renderer, (output_prefix + "_backward_status.png").c_str());
+    rlt::save_flow_forward_image(device, renderer, (output_prefix + "_forward.png").c_str());
+    rlt::save_flow_forward_status_image(device, renderer, (output_prefix + "_forward_status.png").c_str());
+    std::cout << "Wrote " << output_prefix << "_{rgb,backward,backward_status,forward,forward_status}.png" << std::endl;
+
+    rlt::free(device, renderer);
+    return 0;
+}