hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/datasets/operations_cpu.h

@@ -0,0 +1,96 @@
+#include "../../version.h"
+#include "../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_DATASETS_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_DATASETS_OPERATIONS_CPU_H
+
+#include "../scene.h"
+#include "../camera.h"
+#include "../transforms.h"
+
+#include <conta/conta.h>
+
+#include <string>
+#include <limits>
+#include <algorithm>
+#include <iostream>
+
+#define RL_TOOLS_RENDERING_DATASETS_LOG(message) do { std::cout << "\033[0;34m" << "#rl_tools::rendering::datasets: " << message << "\033[0m" << std::endl; } while(false)
+#define RL_TOOLS_RENDERING_DATASETS_LOG_ERR(message) do { std::cerr << "\033[0;31m" << "#rl_tools::rendering::datasets: " << message << "\033[0m" << std::endl; } while(false)
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace rendering::datasets{
+        // every path-valued dataset field accepts either a filesystem path or a "conta:HASH"
+        // reference; this is the single choke point that turns references into local files
+        template <typename DEVICE>
+        bool resolve_reference(DEVICE& device, const std::string& reference, std::string& path){
+            constexpr const char PREFIX[] = "conta:";
+            if(reference.rfind(PREFIX, 0) == 0){
+                std::string error;
+                if(!conta::resolve(reference.substr(sizeof(PREFIX) - 1), path, error)){
+                    RL_TOOLS_RENDERING_DATASETS_LOG_ERR(error);
+                    return false;
+                }
+                return true;
+            }
+            path = reference;
+            return true;
+        }
+
+        // SHA-1 hex over the file bytes: the conta identity, used verbatim as the AssetLibrary
+        // deduplication key and the per-episode scene provenance
+        template <typename DEVICE>
+        bool content_hash(DEVICE& device, const std::string& path, std::string& hex){
+            return conta::detail::sha1_file(path, hex);
+        }
+
+        template <typename DEVICE, typename T>
+        void compute_bounds(DEVICE& device, const rendering::Scene& scene, rendering::SceneMetadata<T>& metadata){
+            float bbox_min[3] = {std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max()};
+            float bbox_max[3] = {std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest()};
+            for(const auto& instance : scene.instances){
+                for(const auto& mesh : scene.objects[instance.object].meshes){
+                    for(size_t vertex_i = 0; vertex_i + 2 < mesh.vertices.size(); vertex_i += 3){
+                        float world[3] = {mesh.vertices[vertex_i], mesh.vertices[vertex_i + 1], mesh.vertices[vertex_i + 2]};
+                        if(!instance.identity){
+                            const float local[3] = {world[0], world[1], world[2]};
+                            rendering::transform_point(instance.transform, local, world);
+                        }
+                        for(int d = 0; d < 3; d++){
+                            bbox_min[d] = std::min(bbox_min[d], world[d]);
+                            bbox_max[d] = std::max(bbox_max[d], world[d]);
+                        }
+                    }
+                }
+            }
+            RL_TOOLS_RENDERING_DATASETS_LOG("Bounding box: [" << bbox_min[0] << "," << bbox_min[1] << "," << bbox_min[2] << "] - ["
+                  << bbox_max[0] << "," << bbox_max[1] << "," << bbox_max[2] << "]");
+
+            float center[3], size[3];
+            for(int d = 0; d < 3; d++){
+                center[d] = 0.5f * (bbox_min[d] + bbox_max[d]);
+                size[d] = bbox_max[d] - bbox_min[d];
+            }
+            float max_dim = std::max({size[0], size[1], size[2]});
+            // the default max ray length is the round trip to a diagonal whole-scene viewpoint —
+            // datasets with their own far-plane semantics (e.g. outdoor) overwrite it after load
+            float look_from[3] = {center[0] + max_dim * 1.5f, center[1] + max_dim * 1.5f, center[2] + max_dim * 0.8f};
+            float look_offset[3];
+            rendering::vec3::sub(look_from, center, look_offset);
+            for(int d = 0; d < 3; d++){
+                metadata.center[d] = center[d];
+                metadata.half_extent[d] = size[d] * 0.5f;
+            }
+            metadata.max_ray_length = rendering::vec3::length(look_offset) * 2.0f;
+        }
+
+        template <typename DEVICE, typename T>
+        void compute_bounds(DEVICE& device, rendering::Bundle<T>& bundle){
+            compute_bounds(device, bundle.scene, bundle.metadata);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/datasets/procthor/conversion.h

@@ -0,0 +1,33 @@
+#include "../../../version.h"
+#include "../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_DATASETS_PROCTHOR_CONVERSION_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_DATASETS_PROCTHOR_CONVERSION_H
+
+#include <string>
+
+// scene_instance.json (ai2thor-hab / HSSD) → self-contained GLB conversion. Declaration-only:
+// the implementation is the rl_tools_procthor_conversion library (src/rendering/procthor2glb/)
+// with its heavy dependencies (tinygltf, basisu, stb) — targets using the AI2ThorHab dataset
+// source (or the procthor2glb CLI) link it.
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::datasets::procthor::conversion {
+    // part of the loader's conversion-cache key: bump on any change to the conversion output
+    inline constexpr int VERSION = 6;
+
+    enum class Dataset { AI2THOR_HAB, HSSD };
+
+    struct Options {
+        std::string scene_instance_path;
+        std::string output_glb_path;          // empty: <scene_name>.glb next to the working directory
+        bool normalize = false;               // decode KTX2, dequantize meshes, bake texture transforms
+        Dataset dataset = Dataset::AI2THOR_HAB;
+        std::string hssd_lighting_path;       // explicit HSSD lighting JSON instead of scene default_lighting
+    };
+
+    bool semantic_source(const Options& options, std::string& source, std::string& error);
+    bool scene_instance_to_glb(const Options& options, std::string& error);
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/datasets/procthor/operations_cpu.h

@@ -0,0 +1,141 @@
+#include "../../../version.h"
+#include "../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_DATASETS_PROCTHOR_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_DATASETS_PROCTHOR_OPERATIONS_CPU_H
+
+#include "procthor.h"
+#include "conversion.h"
+#include "../operations_cpu.h"
+#include "../glb/operations_cpu.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+#if !defined(_WIN32)
+#include <unistd.h>
+#endif
+#include <filesystem>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::datasets::procthor {
+    // natural (version) order: digit runs compare numerically, mirroring the sort -V corpus
+    // conventions — the deterministic enumeration order is part of the dataset contract
+    inline bool natural_less(const std::string& a, const std::string& b) {
+        size_t i = 0, j = 0;
+        while(i < a.size() && j < b.size()){
+            if(std::isdigit((unsigned char)a[i]) && std::isdigit((unsigned char)b[j])){
+                size_t i_end = i, j_end = j;
+                while(i_end < a.size() && std::isdigit((unsigned char)a[i_end])) i_end++;
+                while(j_end < b.size() && std::isdigit((unsigned char)b[j_end])) j_end++;
+                size_t i_num = i, j_num = j;
+                while(i_num < i_end - 1 && a[i_num] == '0') i_num++;
+                while(j_num < j_end - 1 && b[j_num] == '0') j_num++;
+                const size_t i_len = i_end - i_num, j_len = j_end - j_num;
+                if(i_len != j_len) return i_len < j_len;
+                const int order = a.compare(i_num, i_len, b, j_num, j_len);
+                if(order != 0) return order < 0;
+                i = i_end; j = j_end;
+            }
+            else{
+                if(a[i] != b[j]) return (unsigned char)a[i] < (unsigned char)b[j];
+                i++; j++;
+            }
+        }
+        return a.size() - i < b.size() - j;
+    }
+
+    template <typename DEVICE>
+    void enumerate(DEVICE& device, const GLB& dataset, Corpus& corpus) {
+        corpus.references.clear();
+        if(!dataset.references.empty()){
+            corpus.references = dataset.references;
+            return;
+        }
+        for (const auto& entry : std::filesystem::directory_iterator(dataset.directory)) {
+            if (entry.is_regular_file() && entry.path().extension() == ".glb") {
+                corpus.references.push_back(entry.path().string());
+            }
+        }
+        std::sort(corpus.references.begin(), corpus.references.end(), natural_less);
+        utils::assert_exit(device, !corpus.references.empty(), "datasets::procthor::GLB: no .glb scenes found in directory");
+    }
+
+    template <typename SHADING = rendering::VeryHigh, bool HAS_RGB = true, typename DEVICE, typename T, typename MODE = mode::Default<>>
+    bool load(DEVICE& device, const GLB& dataset, const Corpus& corpus, size_t index, rendering::Bundle<T>& bundle, const Mode<MODE>& mode = Mode<MODE>{}) {
+        utils::assert_exit(device, index < corpus.references.size(), "datasets::procthor: corpus index out of range");
+        using rl_tools::load;
+        return load<SHADING, HAS_RGB>(device, bundle, corpus.references[index], mode);
+    }
+
+
+    template <typename DEVICE>
+    void enumerate(DEVICE& device, const AI2ThorHab& dataset, Corpus& corpus) {
+        corpus.references.clear();
+        const std::string prefix = "ProcTHOR-" + dataset.split + "-";
+        const std::string suffix = ".scene_instance.json";
+        const std::filesystem::path scenes_root = std::filesystem::path(dataset.root) / "configs" / "scenes" / "ProcTHOR";
+        utils::assert_exit(device, std::filesystem::is_directory(scenes_root), "datasets::procthor::AI2ThorHab: configs/scenes/ProcTHOR not found under root");
+        for (const auto& entry : std::filesystem::recursive_directory_iterator(scenes_root)) {
+            if (!entry.is_regular_file()) {
+                continue;
+            }
+            const std::string filename = entry.path().filename().string();
+            if (filename.rfind(prefix, 0) == 0 && filename.size() > suffix.size() && filename.compare(filename.size() - suffix.size(), suffix.size(), suffix) == 0) {
+                corpus.references.push_back(entry.path().string());
+            }
+        }
+        std::sort(corpus.references.begin(), corpus.references.end(), natural_less);
+        utils::assert_exit(device, !corpus.references.empty(), "datasets::procthor::AI2ThorHab: no scene_instance.json files found for split");
+    }
+
+    template <typename SHADING = rendering::VeryHigh, bool HAS_RGB = true, typename DEVICE, typename T, typename MODE = mode::Default<>>
+    bool load(DEVICE& device, const AI2ThorHab& dataset, const Corpus& corpus, size_t index, rendering::Bundle<T>& bundle, const Mode<MODE>& mode = Mode<MODE>{}) {
+        utils::assert_exit(device, index < corpus.references.size(), "datasets::procthor: corpus index out of range");
+        const std::string& source = corpus.references[index];
+        std::string source_hash;
+        utils::assert_exit(device, rendering::datasets::content_hash(device, source, source_hash), "datasets::procthor::AI2ThorHab: failed to hash scene_instance");
+        conversion::Options semantic_options;
+        semantic_options.scene_instance_path = source;
+        std::string semantic_source, semantic_error;
+        if(!conversion::semantic_source(semantic_options, semantic_source, semantic_error)){
+            RL_TOOLS_RENDERING_DATASETS_LOG_ERR(semantic_error);
+            return false;
+        }
+        conta::detail::Sha1 fingerprint;
+        fingerprint.update(reinterpret_cast<const unsigned char*>(source_hash.data()), source_hash.size());
+        fingerprint.update(reinterpret_cast<const unsigned char*>(semantic_source.data()), semantic_source.size());
+        source_hash = fingerprint.finalize();
+        std::string cache_directory = dataset.cache_directory;
+        if (cache_directory.empty()) {
+            const char* home = std::getenv("HOME");
+            cache_directory = (home != nullptr ? std::string(home) + "/.cache" : std::string(".")) + "/rl_tools/procthor_glb";
+        }
+        std::filesystem::create_directories(cache_directory);
+        std::string scene_name = std::filesystem::path(source).stem().string();
+        const std::string scene_instance_suffix = ".scene_instance";
+        if(scene_name.size() > scene_instance_suffix.size() && scene_name.compare(scene_name.size() - scene_instance_suffix.size(), scene_instance_suffix.size(), scene_instance_suffix) == 0){
+            scene_name = scene_name.substr(0, scene_name.size() - scene_instance_suffix.size());
+        }
+        const std::string cache_path = cache_directory + "/" + scene_name + "-" + source_hash + "-v" + std::to_string(conversion::VERSION) + (dataset.normalize ? "" : "-raw") + ".glb";
+        if (!std::filesystem::exists(cache_path)) {
+            RL_TOOLS_RENDERING_DATASETS_LOG("procthor::AI2ThorHab: converting " << scene_name << " -> " << cache_path);
+            conversion::Options options;
+            options.scene_instance_path = source;
+            options.output_glb_path = cache_path + ".part." + std::to_string(::getpid()); // pid-unique: concurrent loaders converting the same scene must not share a temp file
+            options.normalize = dataset.normalize;
+            std::string error;
+            const bool converted = conversion::scene_instance_to_glb(options, error);
+            if (!converted) {
+                RL_TOOLS_RENDERING_DATASETS_LOG_ERR("procthor::AI2ThorHab: conversion failed: " << error);
+                return false;
+            }
+            std::filesystem::rename(options.output_glb_path, cache_path);
+        }
+        using rl_tools::load;
+        return load<SHADING, HAS_RGB>(device, bundle, cache_path, mode);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/datasets/procthor/procthor.h

@@ -0,0 +1,40 @@
+#include "../../../version.h"
+#include "../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_DATASETS_PROCTHOR_PROCTHOR_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_DATASETS_PROCTHOR_PROCTHOR_H
+
+#include <string>
+#include <vector>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::datasets::procthor {
+    // pre-converted corpus: bare welded GLBs. Sources are references (paths or conta:HASH);
+    // an explicit reference list wins, otherwise the directory is enumerated as a
+    // lexicographically sorted .glb walk so the corpus is filesystem-order independent.
+    struct Corpus {
+        std::vector<std::string> references;
+    };
+
+    struct GLB {
+        using Corpus = procthor::Corpus;
+        std::string directory;
+        std::vector<std::string> references;
+    };
+
+    // ProcTHOR proper: the raw ai2thor-hab checkout. Scenes are converted through the
+    // rl_tools_procthor_conversion library on first load and cached as GLBs (keyed by source
+    // content hash + converter version, laid out as conta-addressable blobs) — targets using
+    // this source must link rl_tools_procthor_conversion.
+    struct AI2ThorHab {
+        using Corpus = procthor::Corpus;
+        std::string root;               // the directory containing configs/ (e.g. .../ai2thor-hab/ai2thor-hab)
+        std::string split = "Train";    // filename filter: ProcTHOR-<split>-*.scene_instance.json
+        std::string cache_directory;    // converted-GLB cache; default: ~/.cache/rl_tools/procthor_glb (dataset roots are often read-only mounts)
+        bool normalize = true;          // the pre-converted corpora were produced with --normalize
+    };
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif