hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/yaw_prediction/swift_app/Sources/DatasetRecorder.swift

@@ -0,0 +1,285 @@
+import Foundation
+#if os(iOS)
+import ImageIO
+import MobileCoreServices
+import simd
+import UniformTypeIdentifiers
+
+struct AttitudeGroundTruth {
+    let horizontalNorm: Double
+    let verticalNorm: Double
+    let horizontalDegrees: Double
+    let verticalDegrees: Double
+    let rollDegrees: Double
+}
+
+struct DatasetStatus {
+    let translationDriftMeters: Double
+    let lastCaptureAgeSeconds: Double?
+    let sampleCount: Int
+    let isTranslationAcceptable: Bool
+}
+
+final class DatasetRecorder {
+    struct SessionPaths {
+        let root: URL
+        let framesDirectory: URL
+        let metadata: URL
+        let summary: URL
+    }
+
+    private struct FrameRecord: Encodable {
+        let index: Int
+        let timestamp: Double
+        let image: String
+        let translationDriftMeters: Double
+        let translationFromSessionOrigin: [Double]
+        let worldTransform: [[Double]]
+    }
+
+    private struct SessionSummary: Encodable {
+        let createdAt: String
+        let imageSize: Int
+        let horizontalFOVDegrees: Double
+        let maxTranslationDriftMeters: Double
+        let minAngularSeparationDegrees: Double
+        let minSampleSpacingSeconds: Double
+        let framesDirectory: String
+        let metadata: String
+        let frameCount: Int
+    }
+
+    let imageSize: Int
+    let maxTranslationDriftMeters: Double
+    let minAngularSeparationDegrees: Double
+    let minSampleSpacingSeconds: Double
+
+    private(set) var sessionPaths: SessionPaths?
+    private(set) var sessionOriginTransform: simd_float4x4?
+    private(set) var sampleCount = 0
+
+    private var lastSavedTransform: simd_float4x4?
+    private var lastSavedTimestamp: TimeInterval?
+
+    init(
+        imageSize: Int,
+        maxTranslationDriftMeters: Double = 0.05,
+        minAngularSeparationDegrees: Double = 3.0,
+        minSampleSpacingSeconds: Double = 0.35
+    ) {
+        self.imageSize = imageSize
+        self.maxTranslationDriftMeters = maxTranslationDriftMeters
+        self.minAngularSeparationDegrees = minAngularSeparationDegrees
+        self.minSampleSpacingSeconds = minSampleSpacingSeconds
+    }
+
+    func start(frame: CapturedARFrame, horizontalFOVDegrees: Double) throws {
+        let fm = FileManager.default
+        let root = try Self.makeSessionRoot()
+        let frames = root.appendingPathComponent("frames", isDirectory: true)
+        try fm.createDirectory(at: root, withIntermediateDirectories: true)
+        try fm.createDirectory(at: frames, withIntermediateDirectories: true)
+
+        let metadata = root.appendingPathComponent("frames.jsonl")
+        fm.createFile(atPath: metadata.path, contents: nil)
+
+        sessionPaths = SessionPaths(
+            root: root,
+            framesDirectory: frames,
+            metadata: metadata,
+            summary: root.appendingPathComponent("session.json")
+        )
+        sessionOriginTransform = frame.transform
+        lastSavedTransform = nil
+        lastSavedTimestamp = nil
+        sampleCount = 0
+
+        _ = try saveFrame(frame, translationDriftMeters: 0.0, translationFromSessionOrigin: .zero)
+        try writeSummary(horizontalFOVDegrees: horizontalFOVDegrees)
+    }
+
+    func stop(horizontalFOVDegrees: Double) throws -> URL? {
+        guard let root = sessionPaths?.root else { return nil }
+        try writeSummary(horizontalFOVDegrees: horizontalFOVDegrees)
+        return root
+    }
+
+    func status(for frame: CapturedARFrame) -> DatasetStatus? {
+        guard let sessionOriginTransform else { return nil }
+        let rel = simd_inverse(sessionOriginTransform) * frame.transform
+        let translation = translationVector(rel)
+        let drift = simd_length(translation)
+        let age = lastSavedTimestamp.map { frame.timestamp - $0 }
+        return DatasetStatus(
+            translationDriftMeters: drift,
+            lastCaptureAgeSeconds: age,
+            sampleCount: sampleCount,
+            isTranslationAcceptable: drift <= maxTranslationDriftMeters
+        )
+    }
+
+    func considerSample(frame: CapturedARFrame, horizontalFOVDegrees: Double) throws -> Bool {
+        guard let sessionOriginTransform else { return false }
+        let rel = simd_inverse(sessionOriginTransform) * frame.transform
+        let translation = translationVector(rel)
+        let drift = simd_length(translation)
+        guard drift <= maxTranslationDriftMeters else { return false }
+
+        if let lastSavedTimestamp, frame.timestamp - lastSavedTimestamp < minSampleSpacingSeconds {
+            return false
+        }
+
+        if let lastSavedTransform {
+            let delta = simd_inverse(lastSavedTransform) * frame.transform
+            let angularSeparation = rotationAngleDegrees(delta)
+            guard angularSeparation >= minAngularSeparationDegrees else { return false }
+        }
+
+        _ = try saveFrame(frame, translationDriftMeters: drift, translationFromSessionOrigin: translation)
+        try writeSummary(horizontalFOVDegrees: horizontalFOVDegrees)
+        return true
+    }
+
+    private func writeSummary(horizontalFOVDegrees: Double) throws {
+        guard let paths = sessionPaths else { return }
+        let summary = SessionSummary(
+            createdAt: ISO8601DateFormatter().string(from: Date()),
+            imageSize: imageSize,
+            horizontalFOVDegrees: horizontalFOVDegrees,
+            maxTranslationDriftMeters: maxTranslationDriftMeters,
+            minAngularSeparationDegrees: minAngularSeparationDegrees,
+            minSampleSpacingSeconds: minSampleSpacingSeconds,
+            framesDirectory: paths.framesDirectory.lastPathComponent,
+            metadata: paths.metadata.lastPathComponent,
+            frameCount: sampleCount
+        )
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        let data = try encoder.encode(summary)
+        try data.write(to: paths.summary, options: .atomic)
+    }
+
+    private static func makeSessionRoot() throws -> URL {
+        let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd-HHmmss"
+        let name = "attitude-dataset-\(formatter.string(from: Date()))"
+        return docs.appendingPathComponent(name, isDirectory: true)
+    }
+
+    private static func appendJSONLine<T: Encodable>(_ value: T, to url: URL) throws {
+        let encoder = JSONEncoder()
+        let data = try encoder.encode(value)
+        guard let handle = try? FileHandle(forWritingTo: url) else {
+            throw CocoaError(.fileWriteUnknown)
+        }
+        defer { try? handle.close() }
+        try handle.seekToEnd()
+        try handle.write(contentsOf: data)
+        try handle.write(contentsOf: Data([0x0a]))
+    }
+
+    private static func writeJPEG(_ image: CGImage, to url: URL, quality: CGFloat) throws {
+        guard let destination = CGImageDestinationCreateWithURL(url as CFURL, UTType.jpeg.identifier as CFString, 1, nil) else {
+            throw CocoaError(.fileWriteUnknown)
+        }
+        let options: [CFString: Any] = [
+            kCGImageDestinationLossyCompressionQuality: quality
+        ]
+        CGImageDestinationAddImage(destination, image, options as CFDictionary)
+        if !CGImageDestinationFinalize(destination) {
+            throw CocoaError(.fileWriteUnknown)
+        }
+    }
+
+    private func saveFrame(
+        _ frame: CapturedARFrame,
+        translationDriftMeters: Double,
+        translationFromSessionOrigin: simd_double3
+    ) throws -> Int {
+        guard let paths = sessionPaths else { return sampleCount }
+        let index = sampleCount
+        let filename = String(format: "frame_%05d.jpg", index)
+        let imageURL = paths.framesDirectory.appendingPathComponent(filename)
+        try Self.writeJPEG(centerSquareCrop(frame.image), to: imageURL, quality: 0.9)
+
+        let record = FrameRecord(
+            index: index,
+            timestamp: frame.timestamp,
+            image: "frames/\(filename)",
+            translationDriftMeters: translationDriftMeters,
+            translationFromSessionOrigin: [translationFromSessionOrigin.x, translationFromSessionOrigin.y, translationFromSessionOrigin.z],
+            worldTransform: matrixRows(frame.transform)
+        )
+        try Self.appendJSONLine(record, to: paths.metadata)
+
+        sampleCount += 1
+        lastSavedTransform = frame.transform
+        lastSavedTimestamp = frame.timestamp
+        return index
+    }
+}
+
+private func centerSquareCrop(_ image: CGImage) -> CGImage {
+    let w = image.width
+    let h = image.height
+    let side = min(w, h)
+    let x = (w - side) / 2
+    let y = (h - side) / 2
+    return image.cropping(to: CGRect(x: x, y: y, width: side, height: side)) ?? image
+}
+
+func computeGroundTruthDegrees(
+    reference: simd_float4x4,
+    current: simd_float4x4,
+    horizontalFOVDegrees: Double
+) -> AttitudeGroundTruth? {
+    let rel = simd_inverse(reference) * current
+    let z2x = -rel.columns.2.x
+    let z2y = -rel.columns.2.y
+    let z2z = -rel.columns.2.z
+    guard abs(z2z) > 1e-6 else { return nil }
+    let hfov = horizontalFOVDegrees * .pi / 180.0
+    let tanHalfH = tan(hfov / 2.0)
+    let horizontalNorm = Double(-z2y / (z2z * Float(tanHalfH)))
+    let verticalNorm = Double(z2x / (z2z * Float(tanHalfH)))
+    let re00 = rel.columns.0.x
+    let re10 = rel.columns.1.x
+    let roll = Double(atan2(re10, re00)) * 180.0 / .pi
+    return AttitudeGroundTruth(
+        horizontalNorm: horizontalNorm,
+        verticalNorm: verticalNorm,
+        horizontalDegrees: normalizedDisplacementToDegrees(horizontalNorm, fovDegrees: horizontalFOVDegrees),
+        verticalDegrees: normalizedDisplacementToDegrees(verticalNorm, fovDegrees: horizontalFOVDegrees),
+        rollDegrees: -roll
+    )
+}
+
+func normalizedDisplacementToDegrees(_ value: Double, fovDegrees: Double) -> Double {
+    let halfFOVRadians = fovDegrees * .pi / 360.0
+    return atan(value * tan(halfFOVRadians)) * 180.0 / .pi
+}
+
+private func matrixRows(_ matrix: simd_float4x4) -> [[Double]] {
+    [
+        [Double(matrix.columns.0.x), Double(matrix.columns.1.x), Double(matrix.columns.2.x), Double(matrix.columns.3.x)],
+        [Double(matrix.columns.0.y), Double(matrix.columns.1.y), Double(matrix.columns.2.y), Double(matrix.columns.3.y)],
+        [Double(matrix.columns.0.z), Double(matrix.columns.1.z), Double(matrix.columns.2.z), Double(matrix.columns.3.z)],
+        [Double(matrix.columns.0.w), Double(matrix.columns.1.w), Double(matrix.columns.2.w), Double(matrix.columns.3.w)]
+    ]
+}
+
+private func translationVector(_ transform: simd_float4x4) -> simd_double3 {
+    simd_make_double3(
+        Double(transform.columns.3.x),
+        Double(transform.columns.3.y),
+        Double(transform.columns.3.z)
+    )
+}
+
+private func rotationAngleDegrees(_ transform: simd_float4x4) -> Double {
+    let rotation = simd_quatf(transform)
+    let clamped = max(-1.0, min(1.0, Double(rotation.real)))
+    return 2.0 * acos(clamped) * 180.0 / .pi
+}
+#endif

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/yaw_prediction/swift_app/Sources/YawPredictorApp.swift

@@ -0,0 +1,25 @@
+import SwiftUI
+
+@main
+struct YawPredictorApp: App {
+    #if os(macOS)
+    @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+    #endif
+
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+        }
+    }
+}
+
+#if os(macOS)
+import AppKit
+
+class AppDelegate: NSObject, NSApplicationDelegate {
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        NSApp.setActivationPolicy(.regular)
+        NSApp.activate(ignoringOtherApps: true)
+    }
+}
+#endif

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/yaw_prediction/swift_app/YawPredictor.entitlements

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.device.camera</key>
+    <true/>
+</dict>
+</plist>

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/yaw_prediction/swift_app/build.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../../../.." && pwd)"
+APP_NAME="YawPredictor"
+APP_BUNDLE="$SCRIPT_DIR/$APP_NAME.app"
+BUILD_TMP="$SCRIPT_DIR/.build"
+
+mkdir -p "$BUILD_TMP"
+
+# --- Find HDF5 ---
+HDF5_PREFIX="${HDF5_PREFIX:-$(brew --prefix hdf5 2>/dev/null || true)}"
+if [ -z "$HDF5_PREFIX" ] || [ ! -d "$HDF5_PREFIX/include" ]; then
+    echo "Error: HDF5 not found. Install with: brew install hdf5"
+    exit 1
+fi
+echo "HDF5: $HDF5_PREFIX"
+
+CXX_FLAGS="-std=c++20 -Ofast -I $REPO_ROOT/include -I $HDF5_PREFIX/include -DRL_TOOLS_ENABLE_HDF5"
+
+# --- Compile C++ inference library ---
+echo "Compiling inference.cpp..."
+clang++ $CXX_FLAGS -c "$SCRIPT_DIR/inference.cpp" -o "$BUILD_TMP/inference.o"
+ar rcs "$BUILD_TMP/libinference.a" "$BUILD_TMP/inference.o"
+echo "Built: $BUILD_TMP/libinference.a"
+
+# --- Build h5_to_tar converter ---
+echo "Compiling h5_to_tar..."
+clang++ $CXX_FLAGS "$SCRIPT_DIR/h5_to_tar.cpp" -L "$HDF5_PREFIX/lib" -lhdf5 -lc++ -o "$BUILD_TMP/h5_to_tar"
+echo "Built: $BUILD_TMP/h5_to_tar"
+
+# --- Create .app bundle ---
+rm -rf "$APP_BUNDLE"
+mkdir -p "$APP_BUNDLE/Contents/MacOS"
+cp "$SCRIPT_DIR/Info.plist" "$APP_BUNDLE/Contents/"
+
+# --- Compile Swift ---
+echo "Compiling Swift sources..."
+SWIFT_SOURCES=$(find "$SCRIPT_DIR/Sources" -name "*.swift")
+
+swiftc \
+    -O \
+    -import-objc-header "$SCRIPT_DIR/inference.h" \
+    $SWIFT_SOURCES \
+    "$BUILD_TMP/libinference.a" \
+    -L "$HDF5_PREFIX/lib" -lhdf5 \
+    -lc++ \
+    -framework SwiftUI \
+    -framework AVFoundation \
+    -framework CoreImage \
+    -framework AppKit \
+    -framework CoreVideo \
+    -o "$APP_BUNDLE/Contents/MacOS/$APP_NAME"
+
+# --- Sign with entitlements ---
+codesign --force --sign - --entitlements "$SCRIPT_DIR/YawPredictor.entitlements" "$APP_BUNDLE"
+
+echo ""
+echo "Built: $APP_BUNDLE"
+echo ""
+echo "To convert HDF5 to tar format (for iOS):"
+echo "  $BUILD_TMP/h5_to_tar <input.h5> <output.tar>"
+echo ""
+echo "Run:"
+echo "  open $APP_BUNDLE --args <model.h5 or model.tar>"

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/yaw_prediction/swift_app/build_ios.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../../../.." && pwd)"
+BUILD_TMP="$SCRIPT_DIR/.build"
+MODEL_BASENAME="yaw-predictor5-beta"
+MODEL_SOURCE="$REPO_ROOT/tests/data/${MODEL_BASENAME}.tar"
+
+mkdir -p "$BUILD_TMP"
+
+IOS_SDK=$(xcrun --sdk iphoneos --show-sdk-path)
+IOS_MIN="16.0"
+
+echo "iOS SDK: $IOS_SDK"
+
+# --- Compile C++ inference library for iOS (no HDF5, tar only) ---
+echo "Compiling inference.cpp for iOS..."
+xcrun clang++ -std=c++20 -O3 -c \
+    -target arm64-apple-ios${IOS_MIN} \
+    -isysroot "$IOS_SDK" \
+    -I "$REPO_ROOT/include" \
+    "$SCRIPT_DIR/inference.cpp" \
+    -o "$BUILD_TMP/inference_ios.o"
+
+ar rcs "$BUILD_TMP/libinference_ios.a" "$BUILD_TMP/inference_ios.o"
+echo "Built: $BUILD_TMP/libinference_ios.a"
+
+# --- Find signing identity / team ---
+TEAM_ID="${DEVELOPMENT_TEAM:-}"
+SIGNING_IDENTITY="${SIGNING_IDENTITY:-}"
+
+if [ -z "$SIGNING_IDENTITY" ]; then
+    SIGNING_IDENTITY=$(security find-identity -v -p codesigning 2>/dev/null | grep "Apple Development" | head -1 | awk '{print $2}' || true)
+fi
+if [ -z "$TEAM_ID" ] && [ -n "$SIGNING_IDENTITY" ]; then
+    TEAM_ID=$(security find-identity -v -p codesigning 2>/dev/null | grep "$SIGNING_IDENTITY" | sed -n 's/.*(\(.*\)).*/\1/p' | head -1 || true)
+fi
+
+if [ -z "$TEAM_ID" ]; then
+    echo "Error: No development team found. Set DEVELOPMENT_TEAM=<team_id>."
+    exit 1
+fi
+if [ -z "$SIGNING_IDENTITY" ]; then
+    echo "Error: No signing identity found. Set SIGNING_IDENTITY=<sha1 fingerprint>."
+    exit 1
+fi
+echo "Team: $TEAM_ID"
+echo "Signing identity: $SIGNING_IDENTITY"
+
+# --- Compile Swift for iOS ---
+echo "Compiling Swift sources for iOS..."
+SWIFT_SOURCES=$(find "$SCRIPT_DIR/Sources" -name "*.swift")
+
+xcrun swiftc \
+    -O \
+    -target arm64-apple-ios${IOS_MIN} \
+    -sdk "$IOS_SDK" \
+    -import-objc-header "$SCRIPT_DIR/inference.h" \
+    $SWIFT_SOURCES \
+    "$BUILD_TMP/libinference_ios.a" \
+    -lc++ \
+    -framework SwiftUI \
+    -framework AVFoundation \
+    -framework CoreImage \
+    -framework UIKit \
+    -framework CoreVideo \
+    -o "$BUILD_TMP/YawPredictor_ios"
+
+# --- Create .app bundle ---
+APP_BUNDLE="$BUILD_TMP/YawPredictor_ios.app"
+rm -rf "$APP_BUNDLE"
+mkdir -p "$APP_BUNDLE"
+
+cp "$BUILD_TMP/YawPredictor_ios" "$APP_BUNDLE/YawPredictor"
+if [ -f "$MODEL_SOURCE" ]; then
+    cp "$MODEL_SOURCE" "$APP_BUNDLE/${MODEL_BASENAME}.tar"
+else
+    echo "Warning: bundled model not found at $MODEL_SOURCE"
+fi
+cat > "$APP_BUNDLE/Info.plist" << 'PLIST'
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleIdentifier</key>
+    <string>com.rltools.yaw-predictor</string>
+    <key>CFBundleName</key>
+    <string>YawPredictor</string>
+    <key>CFBundleExecutable</key>
+    <string>YawPredictor</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>MinimumOSVersion</key>
+    <string>16.0</string>
+    <key>NSCameraUsageDescription</key>
+    <string>Camera access is needed to capture images for yaw angle prediction.</string>
+    <key>UIDeviceFamily</key>
+    <array>
+        <integer>1</integer>
+    </array>
+    <key>UISupportedInterfaceOrientations</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+    </array>
+    <key>UILaunchScreen</key>
+    <dict/>
+    <key>UIFileSharingEnabled</key>
+    <true/>
+    <key>LSSupportsOpeningDocumentsInPlace</key>
+    <true/>
+</dict>
+</plist>
+PLIST
+
+# --- Sign ---
+codesign --force --sign "$SIGNING_IDENTITY" --entitlements "$SCRIPT_DIR/YawPredictor.entitlements" "$APP_BUNDLE"
+
+echo ""
+echo "Built: $APP_BUNDLE"
+echo ""
+
+# --- Install on device ---
+echo "Installing on device..."
+xcrun devicectl device install app --device "iPhone von Jonas" "$APP_BUNDLE" 2>&1 || {
+    echo ""
+    echo "Auto-install failed. Try:"
+    echo "  xcrun devicectl device install app --device 'iPhone von Jonas' $APP_BUNDLE"
+}

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/yaw_prediction/swift_app/generate.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+xcodegen generate --spec "$SCRIPT_DIR/project.yml" --project "$SCRIPT_DIR"

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/yaw_prediction/swift_app/h5_to_tar.cpp

@@ -0,0 +1,82 @@
+#include <rl_tools/operations/cpu_mux.h>
+
+#include <rl_tools/nn/layers/dense/operations_generic.h>
+#include <rl_tools/nn/layers/conv2d/operations_generic.h>
+#include <rl_tools/nn/layers/avg_pool2d/operations_generic.h>
+#include <rl_tools/nn_models/sequential/operations_generic.h>
+#include <rl_tools/nn_models/parallel/operations_generic.h>
+#include <rl_tools/nn_models/operations_generic.h>
+
+#include <rl_tools/containers/tensor/operations_generic.h>
+#include <rl_tools/containers/tensor/operations_cpu.h>
+
+#include <rl_tools/persist/backends/hdf5/operations_cpu.h>
+#include <rl_tools/persist/backends/tar/operations_cpu.h>
+
+#include <rl_tools/nn/parameters/persist.h>
+#include <rl_tools/nn/layers/dense/persist.h>
+#include <rl_tools/nn/layers/conv2d/persist.h>
+#include <rl_tools/nn/layers/avg_pool2d/persist.h>
+#include <rl_tools/nn_models/sequential/persist.h>
+#include <rl_tools/nn_models/parallel/persist.h>
+
+#include "../model.h"
+
+#include <iostream>
+#include <fstream>
+
+namespace rlt = rl_tools;
+
+using T = float;
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+using TI = DEVICE::index_t;
+using TYPE_POLICY = rlt::numeric_types::Policy<T>;
+
+static constexpr TI BATCH_SIZE = 1;
+using CAPABILITY = rlt::nn::capability::Forward<>;
+using MODEL = rlt::rendering::raytracing::yaw_prediction::MODEL<CAPABILITY, TYPE_POLICY, TI, BATCH_SIZE>;
+
+int main(int argc, char* argv[]) {
+    if (argc != 3) {
+        std::cerr << "Usage: " << argv[0] << " <input.h5> <output.tar>" << std::endl;
+        return 1;
+    }
+
+    DEVICE device;
+    rlt::init(device);
+
+    MODEL model;
+    rlt::malloc(device, model);
+
+    try {
+        auto file = rl_tools::persist::backends::hdf5::File(std::string(argv[1]), rl_tools::persist::backends::hdf5::Mode::READ);
+        auto model_group = rlt::get_group(device, file, "model");
+        if (!rlt::load(device, model, model_group)) {
+            std::cerr << "Failed to load model from " << argv[1] << std::endl;
+            return 1;
+        }
+    } catch (const std::exception& e) {
+        std::cerr << "Error loading HDF5: " << e.what() << std::endl;
+        return 1;
+    }
+
+    std::cout << "Model loaded from " << argv[1] << std::endl;
+
+    rlt::persist::backends::tar::Writer writer;
+    using WRITER_GROUP_SPEC = rlt::persist::backends::tar::WriterGroupSpecification<TI, decltype(writer)>;
+    rlt::persist::backends::tar::WriterGroup<WRITER_GROUP_SPEC> writer_group;
+    writer_group.writer = &writer;
+
+    auto model_group = rlt::create_group(device, writer_group, "model");
+    rlt::save(device, model, model_group);
+    rlt::persist::backends::tar::finalize(device, writer);
+
+    std::ofstream out(argv[2], std::ios::binary);
+    out.write(writer.buffer.data(), writer.buffer.size());
+    out.close();
+
+    std::cout << "Model saved to " << argv[2] << " (" << writer.buffer.size() << " bytes)" << std::endl;
+
+    rlt::free(device, model);
+    return 0;
+}