Loading...
Searching...
No Matches
dipla_planner.cpp
Go to the documentation of this file.
100 return std::isfinite(east) && std::isfinite(north) && east >= 0 && east <= DIPLA_FIELD_EXTENT_M &&
104std::size_t cell_index(std::size_t row, std::size_t column) { return row * DIPLA_GRID_SIDE + column; }
224 const std::array<std::string_view, 3> keys{{"source_sha256", "encoder_descriptor_sha256", "denoiser_descriptor_sha256"}};
240 const std::array<std::filesystem::path, 3> identified{{source, root / "encoder.ini", root / "denoiser.ini"}};
243 if (!inference_file_sha256(identified[index].c_str(), digest.data()) || digest.data() != identities.hashes[index])
246 if (!inference_model_read(&encoder_model, (root / "encoder.ini").c_str(), (root / "encoder.onnx").c_str(), error.data(), error.size()) ||
247 !inference_model_read(&denoiser_model, (root / "denoiser.ini").c_str(), (root / "denoiser.onnx").c_str(), error.data(), error.size()))
250 std::string(denoiser_model.adapter) != "dipla_ddim_cache_v1" || encoder_model.input_count != 3 ||
252 denoiser_model.input_count != encoder_model.output_count + 2 || denoiser_model.output_count != 1)
285 if (std::string(target.name) == encoder_model.outputs[candidate].name) actual = &encoder_model.outputs[candidate];
292 if (!onnx_session_open(&encoder, (root / "encoder.onnx").c_str(), encoder_model.inputs, encoder_model.input_count,
295 if (!onnx_session_open(&denoiser, (root / "denoiser.onnx").c_str(), denoiser_model.inputs, denoiser_model.input_count,
365 if (!tree) throw std::runtime_error("Invalid metadata JSON at byte " + std::to_string(parsed.pos));
372 if (metadata_integer(world, "grid") != DIPLA_GRID_SIDE || finite_number(world, "xy_scale_m") != DIPLA_FIELD_EXTENT_M ||
373 finite_number(world, "z_min_m") != DIPLA_MODEL_Z_MIN_M || finite_number(world, "z_max_m") != DIPLA_MODEL_Z_MAX_M ||
374 metadata_integer(diffusion, "T") != DIPLA_DIFFUSION_STEPS || metadata_integer(diffusion, "num_waypoints") != points)
393 if (schedule_node.type != JSONBOURNE_TYPE_ARR) throw std::runtime_error("Expected diffusion schedule array");
414 {"meanvarmarker_map", ONNX_FLOAT32, 4, {1,DIPLA_MAP_CHANNEL_COUNT,DIPLA_GRID_SIDE,DIPLA_GRID_SIDE}, maps.data(), sizeof(maps)},
415 {"current_position", ONNX_FLOAT32, 2, {1,DIPLA_COORDINATE_COUNT}, position.data(), sizeof(position)},
419 {"noise_pred", ONNX_FLOAT32, 3, {1,DIPLA_COORDINATE_COUNT,points}, predicted.data(), sizeof(predicted)}
428 if (!inference_model_read(&bundle, policy.descriptor.c_str(), model.c_str(), error.data(), error.size()))
430 if (std::string(bundle.adapter) != "dipla_ddim_v1" || bundle.input_count != std::size(inputs) || bundle.output_count != std::size(outputs))
440 if (!matches(bundle.inputs[index], inputs[index])) throw std::runtime_error("Diplacam descriptor input mismatch");
441 if (!matches(bundle.outputs[0], outputs[0])) throw std::runtime_error("Diplacam descriptor output mismatch");
445 conditioning_cache = std::make_unique<ConditioningCache>(policy.conditioning_cache, model, inputs, outputs, options);
446 } else if (!onnx_session_open(&session, model.c_str(), inputs, std::size(inputs), outputs, std::size(outputs), &options,
465Network::Network(const std::string& model, const std::string& metadata, const NetworkOptions& options)
467/** @details Destroy State through its owner so the session closes before its buffers disappear. */
486Waypoints Network::sample(const Belief& belief, const std::array<double, 3>& position, const Noise& noise) {
490 const std::uint64_t deadline = state.timeout_ms ? onnx_monotonic_us() + std::uint64_t(state.timeout_ms) * 1000 : 0;
491 for (double value : position) if (!std::isfinite(value)) throw std::runtime_error("Nonfinite position");
502 if (!std::isfinite(belief.mean[cell]) || !std::isfinite(belief.variance[cell]) || belief.variance[cell] < 0)
504 state.maps[cell] = (static_cast<float>(belief.mean[cell]) - static_cast<float>(state.mean_normalization.center)) /
506 state.maps[cells + cell] = (static_cast<float>(belief.variance[cell]) - static_cast<float>(state.variance_normalization.center)) /
515 const auto column = static_cast<std::size_t>(std::clamp(std::nearbyint(position[0] / DIPLA_GRID_STEP_M), 0.0, double(DIPLA_GRID_SIDE - 1U)));
516 const auto row = static_cast<std::size_t>(std::clamp(std::nearbyint(position[1] / DIPLA_GRID_STEP_M), 0.0, double(DIPLA_GRID_SIDE - 1U)));
523 state.position = {{static_cast<float>(position[0] / xy_half_extent_m - 1.0), static_cast<float>(position[1] / xy_half_extent_m - 1.0),
525 state.total[0] = static_cast<float>((std::log1p(total) - state.total_normalization.center) / state.total_normalization.scale);
526 if (!std::isfinite(state.total[0])) throw std::runtime_error("Variance normalization overflow");
529 if (!onnx_session_run(&state.conditioning_cache->encoder, deadline, error.data(), error.size()))
533 for (double value : current) if (!std::isfinite(value)) throw std::runtime_error("Nonfinite noise");
546 auto* session = state.conditioning_cache ? &state.conditioning_cache->denoiser : &state.session;
578 !std::isfinite(gp_prior_mean) || !std::isfinite(gp_kernel_variance) || gp_kernel_variance <= 0 ||
600 if (margin_cells * 2ULL >= DIPLA_GRID_SIDE - 1U) throw std::runtime_error("Invalid flight margin");
651 if (std::filesystem::file_size(path) > field_byte_limit) throw std::runtime_error("Field CSV too large");
688 if (!input.eof() || rows != cells) throw std::runtime_error("Field must cover all 2601 grid cells");
689 covariance = aipp::initialize_covariance(grid, options.gp_kernel_variance, options.gp_lengthscale_m);
701/** @details Release private truth and the dense posterior together through their owning State. */
722 if (!inside_field(east, north) || !std::isfinite(height) || height <= 0 || height > DIPLA_MODEL_Z_MAX_M)
761 for (double value : position) if (!std::isfinite(value)) throw std::runtime_error("Nonfinite comparison position");
768 const auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(comparison.budget_ms);
Allocation-free flat key=value mechanics; callers own schemas and storage.
static bool ini_read_file(const char *filename, char *buffer, size_t capacity, size_t *length)
Read a nonempty regular file smaller than capacity and append NUL.
Definition bounded_ini.h:98
static bool ini_parse(char *buffer, size_t length, ini_field_handler handler, void *context)
Destructively parse flat fields with blank lines and #/; comment lines.
Definition bounded_ini.h:132
Network(const std::string &model, const std::string &metadata, const NetworkOptions &options={})
Load and validate a deployment model.
Definition dipla_planner.cpp:465
Waypoints sample(const Belief &belief, const std::array< double, 3 > &position, const Noise &noise)
Run the complete deterministic DDIM sampler for a supplied noise vector.
Definition dipla_planner.cpp:486
Belief belief() const
Copy the current GP marginal mean and variance into fixed-size storage.
Definition dipla_planner.cpp:808
double total_variance() const
Return the sum of posterior marginal variances.
Definition dipla_planner.cpp:825
std::uint64_t field_digest() const
Return the FNV-1a digest of the input CSV bytes.
Definition dipla_planner.cpp:832
bool observe(double east, double north, std::uint32_t number, double height=DIPLA_DEMO_HEIGHT_MM/DIPLA_MM_PER_M)
Assimilate one synthetic observation at a local pose.
Definition dipla_planner.cpp:715
Survey(const std::string &field, const ExperimentOptions &options={})
Load the complete finite-grid synthetic field.
Definition dipla_planner.cpp:699
std::optional< Waypoints > compare(const std::array< double, 3 > &position, const CmaesOptions &options={}, const std::function< bool()> &cancelled={}) const
Run the explicitly requested native CMA-ES comparison planner.
Definition dipla_planner.cpp:758
Native finite-grid GP sensor model and trajectory-planning API.
Public planning, synthetic-survey, and comparison APIs for Diplacam.
struct jsonbourne_val jsonbourne_val
Forward name for values referenced by recursive container entries.
Definition jsonbourne.h:214
struct jsonbourne_num jsonbourne_num
Original number spelling, retained so reading never rounds through a double.
struct jsonbourne_obj jsonbourne_obj
Ordered object members; len must exactly match the linked-list length.
@ JSONBOURNE_READ_ERROR_MEMORY_ALLOCATION
Definition jsonbourne.h:279
jsonbourne_val * jsonbourne_read_buf(const void *src, size_t len, jsonbourne_read_flag flg, const jsonbourne_read_limits *limits, void *buf, size_t cap, size_t *required, jsonbourne_read_err *err)
Read a DOM into aligned caller storage without heap allocation.
Definition jsonbourne.c:1123
bool inference_file_sha256(const char *filename, char digest[65])
Hash a stable nonempty regular file using bounded streaming scratch.
Definition inference_model.c:41
bool inference_model_read(struct inference_model *model, const char *descriptor, const char *graph, char *error, size_t capacity)
Load a bounded descriptor and verify its exact graph digest; hashes are not authentication.
Definition inference_model.c:258
Integrity-checked model contracts and independently owned tensor workspaces.
JSON reader, writer and DOM utilities for Linux C11 with a C++11-compatible API.
std::vector< Point > plan(const Grid &grid, const Vector &mean, const Matrix &covariance, const Point &start, const PlannerOptions &options)
Run greedy route selection followed by optional CMA-ES refinement.
Definition cmaes_optimizer.cpp:114
Matrix initialize_covariance(const Grid &grid, double sigma2, double lengthscale)
Initialize a dense Matérn-3/2 GP covariance matrix.
Definition dipla_gp_belief_planner.cpp:262
Vector sample_sensor_noise(const Sensor &sensor, std::mt19937_64 &generator)
Draw independent zero-mean noise using each sensor row's variance.
Definition dipla_gp_belief_planner.cpp:398
Sensor build_sensor(const Grid &grid, const Point &pose, double angle, double observation_variance)
Build one block-averaged sensor footprint at a pose.
Definition dipla_gp_belief_planner.cpp:296
void condition(Matrix &covariance, Vector *mean, const Sensor &sensor, const Vector *measurement)
Apply a Gaussian linear-observation update in place.
Definition dipla_gp_belief_planner.cpp:473
Vector observe(const Sensor &sensor, const Vector &field)
Apply the sensor's block averages to a full-grid field.
Definition dipla_gp_belief_planner.cpp:379
Definition aigenlib.cpp:42
void apply_flight_margin(Waypoints &route, unsigned margin_cells)
Apply the configured horizontal flight margin.
Definition dipla_planner.cpp:599
void initialize_runtime(const std::string &onnx_lib_path)
Load the ONNX Runtime C API before constructing an inference session.
Definition dipla_planner.cpp:75
std::array< double, DIPLA_COORDINATE_COUNT *points > Noise
Definition dipla_planner.hpp:48
std::array< std::array< double, DIPLA_COORDINATE_COUNT >, points > Waypoints
Definition dipla_planner.hpp:50
double number(const std::string &text, const std::string &name)
Read a complete finite numeric route field.
Definition route.h:141
bool onnx_runtime_open(const char *library_directory, char *error, size_t capacity)
Initialize one process-lifetime runtime/environment using explicit local search roots.
Definition onnx_runtime.c:38
Process-wide runtime ownership shared by independent model sessions.
bool onnx_session_run(struct onnx_session *session, uint64_t deadline_us, char *error, size_t capacity)
Run once; deadline is absolute CLOCK_MONOTONIC microseconds, or zero for none.
Definition onnx_session.c:251
bool onnx_session_open(struct onnx_session *session, const char *model, const struct onnx_tensor *inputs, size_t input_count, const struct onnx_tensor *outputs, size_t output_count, const struct onnx_session_options *options, char *error, size_t capacity)
Validate graph contracts and bind reusable caller buffers; failure releases acquired resources.
Definition onnx_session.c:187
uint64_t onnx_monotonic_us(void)
Read the clock used by inference deadlines.
Definition onnx_session.c:40
void onnx_session_close(struct onnx_session *session)
Cancel/wait for an active run and release resources; repeated closes are harmless.
Definition onnx_session.c:337
Bounded tensor bindings and cooperative execution policy, independent of CAM semantics.
Search, utility, and optimizer controls for the reference planner.
Definition dipla_gp_belief_planner.hpp:131
Fixed-shape posterior summary consumed by the diffusion model.
Definition dipla_planner.hpp:105
Bounded parameters for the comparison-only CMA-ES planner.
Definition dipla_planner.hpp:117
void validate() const
Validate the complete comparison policy before planning.
Definition dipla_planner.cpp:585
static constexpr int max_evaluations
Definition dipla_planner.hpp:123
static constexpr int max_budget_ms
Definition dipla_planner.hpp:121
static constexpr int population_size
Definition dipla_planner.hpp:119
Startup-only synthetic experiment settings shared by both planners.
Definition dipla_planner.hpp:53
unsigned flight_margin_cells
Definition dipla_planner.hpp:61
double gp_kernel_variance
Definition dipla_planner.hpp:65
void validate() const
Reject nonfinite values and incompatible margins before allocation.
Definition dipla_planner.cpp:576
double sensor_noise_variance
Definition dipla_planner.hpp:71
Model identity and execution limits for a diffusion network.
Definition dipla_planner.hpp:144
std::string conditioning_cache
Definition dipla_planner.hpp:152
onnx_session encoder
Definition dipla_planner.cpp:200
onnx_session denoiser
Definition dipla_planner.cpp:200
std::array< std::vector< float >, ONNX_TENSOR_LIMIT > values
Definition dipla_planner.cpp:202
inference_model encoder_model
Definition dipla_planner.cpp:201
inference_model denoiser_model
Definition dipla_planner.cpp:201
ConditioningCache(const std::string &directory, const std::string &source, const onnx_tensor *inputs, const onnx_tensor *outputs, const onnx_session_options &options)
Validate the split model contract and open both runtime sessions.
Definition dipla_planner.cpp:213
~ConditioningCache()
Release sessions before their borrowed tensor storage is destroyed.
Definition dipla_planner.cpp:303
Runtime-owned ONNX session and reusable input/output storage.
Definition dipla_planner.cpp:197
~State()
Close the session while every borrowed member buffer is still alive.
Definition dipla_planner.cpp:455
std::array< float, DIPLA_COORDINATE_COUNT *points > predicted
Definition dipla_planner.cpp:316
Normalization total_normalization
Definition dipla_planner.cpp:328
std::array< double, DIPLA_DIFFUSION_STEPS > alpha
Definition dipla_planner.cpp:326
std::array< float, DIPLA_COORDINATE_COUNT *points > candidate
Definition dipla_planner.cpp:314
Normalization variance_normalization
Definition dipla_planner.cpp:328
Normalization mean_normalization
Definition dipla_planner.cpp:328
std::array< float, DIPLA_MAP_CHANNEL_COUNT *cells > maps
Definition dipla_planner.cpp:318
State(const std::string &model, const std::string &metadata, const NetworkOptions &policy)
Validate the export contract before binding a reusable ONNX session.
Definition dipla_planner.cpp:343
std::unique_ptr< ConditioningCache > conditioning_cache
Definition dipla_planner.cpp:308
Private storage for the synthetic field and its GP posterior.
Definition dipla_planner.cpp:620
std::mt19937_64 sensor_generator
Definition dipla_planner.cpp:634
State(const std::string &path, const ExperimentOptions &experiment)
Load the complete synthetic lattice without inventing missing truth.
Definition dipla_planner.cpp:648
Parsed descriptor with self-referencing tensor-name pointers; do not copy after parsing.
Definition inference_model.h:31
struct onnx_tensor outputs[ONNX_TENSOR_LIMIT]
Definition inference_model.h:36
Ordered array elements; explicit length supports bounded traversal.
Definition jsonbourne.h:240
Optional read result; coordinates describe the parser's failure cursor.
Definition jsonbourne.h:290
Explicit execution limits so each model cannot create an unbounded CPU pool.
Definition onnx_session.h:54
Noncopyable caller-owned session; zero-initialize and serialize open/run/close ownership.
Definition onnx_session.h:64
Named concrete tensor view; its aligned backing storage must outlive the session.
Definition onnx_session.h:44
One timestamped geographic position for a replay annotation.
Definition ear_heatmap_overlay.c:79