fy59/lardon3d
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
lardon3d/tests/test_track_builder_project.cpp

688 lines
30 KiB
C++
Raw Blame History

#include <cassert>
#include <cstdio>
#include <cstring>
#include <chrono>
#include <fcntl.h>
#include <openssl/evp.h>
#include <sqlite3.h>
#include <string>
#include <sys/stat.h>
#include <sys/resource.h>
#include <unistd.h>
#include <vector>
extern "C" {
#include <lardon3d/match_file.h>
#include <lardon3d/project_db.h>
#include <lardon3d/track_builder_project.h>
}
namespace {
constexpr Lardon3DGeometricVerifierKind kVerifier = LARDON3D_GEOMETRIC_VERIFIER_FUNDAMENTAL;
constexpr uint32_t kVersion = 1;
unsigned char g_verifier[32];
std::string g_delete_db;
uint64_t g_delete_id = 0;
bool g_delete_before_revalidation = false;
std::string g_insert_db;
uint64_t g_insert_match_id = 0;
bool g_insert_during_build = false;
void check(bool value, const char *expression, int line) {
if (!value) {
std::fprintf(stderr, "track-builder-project:%d: %s\n", line, expression);
std::abort();
}
}
#define CHECK(value) check((value), #value, __LINE__)
std::string asset_path(const unsigned char hash[32], const char *kind) {
static constexpr char digits[] = "0123456789abcdef";
std::string hex(64, '0');
for (size_t i = 0; i < 32; ++i) {
hex[2 * i] = digits[hash[i] >> 4];
hex[2 * i + 1] = digits[hash[i] & 0x0fU];
}
return std::string("assets/") + kind + "/" + hex.substr(0, 2) + "/" + hex;
}
void digest_file(const std::string &path, unsigned char hash[32], uint64_t *size) {
FILE *file = std::fopen(path.c_str(), "rb");
CHECK(file != nullptr);
EVP_MD_CTX *context = EVP_MD_CTX_new();
CHECK(context != nullptr && EVP_DigestInit_ex(context, EVP_sha256(), nullptr) == 1);
unsigned char buffer[4096];
*size = 0;
size_t read = 0;
while ((read = std::fread(buffer, 1, sizeof(buffer), file)) != 0) {
CHECK(EVP_DigestUpdate(context, buffer, read) == 1);
*size += read;
}
unsigned int length = 0;
CHECK(EVP_DigestFinal_ex(context, hash, &length) == 1 && length == 32);
EVP_MD_CTX_free(context);
std::fclose(file);
}
struct Fixture {
std::string directory;
std::string db_path;
Lardon3DProjectDb *db = nullptr;
uint64_t image[3]{};
uint64_t feature[3]{};
uint64_t next_asset = 1;
uint64_t next_file = 1;
explicit Fixture(uint32_t feature_count = 32) {
char name[] = "/tmp/lardon3d-track-c-XXXXXX";
CHECK(mkdtemp(name) != nullptr);
directory = name;
db_path = directory + "/project.db";
char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY]{};
CHECK(lardon3d_project_db_open(db_path.c_str(), &db, error) == LARDON3D_PROJECT_DB_OK);
Lardon3DProjectDbScanSet scanset{};
CHECK(lardon3d_project_db_create_scanset(db, "SPECIMEN", &scanset) ==
LARDON3D_PROJECT_DB_OK);
for (size_t i = 0; i < 3; ++i) {
unsigned char hash[32]{};
hash[0] = static_cast<unsigned char>(i + 1);
std::string path = asset_path(hash, "images");
Lardon3DProjectDbImageRegisterStatus status;
Lardon3DProjectDbImage created{};
char original_name[32];
std::snprintf(original_name, sizeof(original_name), "image-%zu.jpg", i + 1);
Lardon3DProjectDbResult image_result = lardon3d_project_db_register_image(
db, scanset.scanset_id, hash, path.c_str(), 1, original_name, path.c_str(), 0,
static_cast<int64_t>(i + 1), &status, &created);
CHECK(image_result == LARDON3D_PROJECT_DB_OK);
image[i] = created.image_id;
unsigned char parameter[32]{0x5a};
unsigned char source[32]{};
source[0] = static_cast<unsigned char>(i + 1);
unsigned char asset[32]{static_cast<unsigned char>(0x70U + i)};
Lardon3DProjectDbFeatureSet set{};
CHECK(lardon3d_project_db_register_feature_set(
db, image[i], "orb", 1, parameter, source, feature_count, 1, 32, asset,
asset_path(asset, "features").c_str(), 1, LARDON3D_DB_FEATURE_ASSET_DURABLE, 0,
static_cast<int64_t>(i + 10), &set) == LARDON3D_PROJECT_DB_OK);
feature[i] = set.feature_set_id;
}
std::memset(g_verifier, 0x42, sizeof(g_verifier));
}
~Fixture() {
if (db) lardon3d_project_db_close(db);
}
uint64_t add_feature_set(size_t image_index, unsigned char parameter_byte,
const char *extractor = "orb", uint32_t descriptor_type = 1) {
unsigned char parameter[32]{parameter_byte};
unsigned char source[32]{};
source[0] = static_cast<unsigned char>(image_index + 1);
unsigned char asset[32]{static_cast<unsigned char>(0x90U + parameter_byte)};
Lardon3DProjectDbFeatureSet set{};
CHECK(lardon3d_project_db_register_feature_set(
db, image[image_index], extractor, 1, parameter, source, 32,
descriptor_type, 32, asset, asset_path(asset, "features").c_str(), 1,
LARDON3D_DB_FEATURE_ASSET_DURABLE, 0, 100, &set) == LARDON3D_PROJECT_DB_OK);
return set.feature_set_id;
}
uint64_t add_gvr(size_t first, size_t second,
const std::vector<Lardon3DMatchFileEntry> &entries,
const std::vector<unsigned char> &mask,
Lardon3DGeometricVerificationStatus status = LARDON3D_GEOMETRIC_VERIFIED,
uint64_t feature_a = 0, uint64_t feature_b = 0,
const char *matcher_kind = "matcher-a", uint32_t matcher_version = 1) {
if (feature_a == 0) feature_a = feature[first];
if (feature_b == 0) feature_b = feature[second];
Lardon3DProjectDbCandidatePair pair{};
Lardon3DProjectDbResult pair_result = lardon3d_project_db_find_candidate_pair(
db, image[first], image[second], &pair);
if (pair_result == LARDON3D_PROJECT_DB_NOT_FOUND) {
pair_result = lardon3d_project_db_create_candidate_pair(
db, image[first], image[second], static_cast<int64_t>(next_file), &pair);
}
CHECK(pair_result == LARDON3D_PROJECT_DB_OK);
std::string path = directory + "/match-" + std::to_string(next_file++) + ".bin";
int fd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0600);
CHECK(fd >= 0);
CHECK(lardon3d_match_file_write(fd, 1, 32, feature_a, feature_b,
entries.data(), static_cast<uint32_t>(entries.size())) ==
LARDON3D_MATCH_FILE_OK);
CHECK(close(fd) == 0);
unsigned char hash[32]{};
uint64_t size = 0;
digest_file(path, hash, &size);
unsigned char matcher_fingerprint[32]{};
matcher_fingerprint[0] = static_cast<unsigned char>(next_file);
Lardon3DProjectDbMatchResult match{};
CHECK(lardon3d_project_db_create_match_result(
db, pair.candidate_pair_id, feature_a, feature_b, matcher_kind, matcher_version,
matcher_fingerprint, LARDON3D_MATCH_RESULT_STATUS_MATCHED,
static_cast<uint32_t>(entries.size()), hash,
path.substr(directory.size() + 1).c_str(), size, static_cast<int64_t>(next_file),
&match) == LARDON3D_PROJECT_DB_OK);
Lardon3DProjectDbGeometricVerificationResult gvr{};
double model[9]{};
Lardon3DProjectDbResult gvr_result = lardon3d_project_db_create_geometric_verification_result(
db, match.match_result_id, kVerifier, kVersion, g_verifier, status,
popcount(mask),
mask.data(), mask.size(),
status == LARDON3D_GEOMETRIC_VERIFIED ? model : nullptr,
static_cast<int64_t>(next_file), &gvr);
CHECK(gvr_result == LARDON3D_PROJECT_DB_OK);
return gvr.geometric_verification_result_id;
}
Lardon3DTrackBuilderProjectRequest request(const uint64_t *ids, size_t count) const {
return {directory.c_str(), db, kVerifier, kVersion, g_verifier, ids, count};
}
static uint32_t popcount(const std::vector<unsigned char> &mask) {
uint32_t count = 0;
for (unsigned char byte : mask) {
for (unsigned bit = 0; bit < 8; ++bit) count += (byte >> bit) & 1U;
}
return count;
}
};
void assert_track(Lardon3DProjectDb *db, uint64_t set_id, uint64_t a, uint64_t b,
uint64_t c) {
Lardon3DProjectDbTrack track{};
CHECK(lardon3d_project_db_find_track_by_observation(db, set_id, a, 0, &track) ==
LARDON3D_PROJECT_DB_OK);
CHECK(track.observation_count == 3 && track.observations[0].feature_set_id == a &&
track.observations[0].position_in_track == 0 && track.observations[1].feature_set_id == b &&
track.observations[1].position_in_track == 1 && track.observations[2].feature_set_id == c &&
track.observations[2].position_in_track == 2);
lardon3d_project_db_free_track(&track);
}
void assert_two_observation_track(Lardon3DProjectDb *db, uint64_t set_id, uint64_t a, uint64_t b) {
Lardon3DProjectDbTrack track{};
CHECK(lardon3d_project_db_find_track_by_observation(db, set_id, a, 0, &track) ==
LARDON3D_PROJECT_DB_OK && track.observation_count == 2 &&
track.observations[0].feature_set_id == a &&
track.observations[0].position_in_track == 0 &&
track.observations[1].feature_set_id == b &&
track.observations[1].position_in_track == 1);
lardon3d_project_db_free_track(&track);
}
uint64_t track_set_count(const std::string &path) {
sqlite3 *db = nullptr;
sqlite3_stmt *statement = nullptr;
CHECK(sqlite3_open_v2(path.c_str(), &db, SQLITE_OPEN_READONLY, nullptr) == SQLITE_OK);
CHECK(sqlite3_prepare_v2(db, "SELECT count(*) FROM track_sets", -1, &statement, nullptr) ==
SQLITE_OK);
CHECK(sqlite3_step(statement) == SQLITE_ROW);
uint64_t result = static_cast<uint64_t>(sqlite3_column_int64(statement, 0));
sqlite3_finalize(statement);
sqlite3_close(db);
return result;
}
uint64_t table_count(const std::string &path, const char *table) {
char sql[128];
std::snprintf(sql, sizeof(sql), "SELECT count(*) FROM %s", table);
sqlite3 *db = nullptr;
sqlite3_stmt *statement = nullptr;
CHECK(sqlite3_open_v2(path.c_str(), &db, SQLITE_OPEN_READONLY, nullptr) == SQLITE_OK);
CHECK(sqlite3_prepare_v2(db, sql, -1, &statement, nullptr) == SQLITE_OK);
CHECK(sqlite3_step(statement) == SQLITE_ROW);
uint64_t result = static_cast<uint64_t>(sqlite3_column_int64(statement, 0));
CHECK(sqlite3_finalize(statement) == SQLITE_OK && sqlite3_close(db) == SQLITE_OK);
return result;
}
void execute_sql(const std::string &path, const char *sql) {
sqlite3 *db = nullptr;
CHECK(sqlite3_open(path.c_str(), &db) == SQLITE_OK);
CHECK(sqlite3_exec(db, sql, nullptr, nullptr, nullptr) == SQLITE_OK);
CHECK(sqlite3_close(db) == SQLITE_OK);
}
void independent_scope_digest(const uint64_t *ids, size_t count, unsigned char output[32]) {
std::vector<unsigned char> bytes(8 + count * 8);
const char domain[] = "L3DTSIS1";
std::memcpy(bytes.data(), domain, 8);
for (size_t i = 0; i < count; ++i) {
uint64_t value = ids[i];
for (size_t byte = 0; byte < 8; ++byte) {
bytes[8 + i * 8 + byte] = static_cast<unsigned char>(value & 0xffU);
value >>= 8;
}
}
unsigned int length = 0;
EVP_MD_CTX *context = EVP_MD_CTX_new();
CHECK(context != nullptr && EVP_DigestInit_ex(context, EVP_sha256(), nullptr) == 1 &&
EVP_DigestUpdate(context, bytes.data(), bytes.size()) == 1 &&
EVP_DigestFinal_ex(context, output, &length) == 1 && length == 32);
EVP_MD_CTX_free(context);
}
void run_basic_and_reuse() {
Fixture fixture;
auto ab = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
auto bc = fixture.add_gvr(1, 2, {{0, 0, 0.1F}}, {0x01});
uint64_t ids[] = {ab, bc};
auto request = fixture.request(ids, 2);
Lardon3DTrackBuilderProjectResult first{};
auto first_status = lardon3d_track_builder_build_project(&request, &first);
CHECK(first_status == LARDON3D_TRACK_BUILDER_PROJECT_OK && !first.reused &&
first.track_count == 1);
assert_track(fixture.db, first.track_set_id, fixture.feature[0], fixture.feature[1],
fixture.feature[2]);
uint64_t before = track_set_count(fixture.db_path);
Lardon3DTrackBuilderProjectResult second{};
CHECK(lardon3d_track_builder_build_project(&request, &second) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && second.reused && second.track_set_id == first.track_set_id);
CHECK(track_set_count(fixture.db_path) == before);
std::puts("C01/C20: PASS");
}
void run_mask_cases() {
Fixture fixture;
std::vector<Lardon3DMatchFileEntry> entries;
for (uint32_t i = 0; i < 14; ++i) entries.push_back({i, i, 0.1F});
auto gvr = fixture.add_gvr(0, 1, entries, {0x85, 0x21});
uint64_t ids[] = {gvr};
auto request = fixture.request(ids, 1);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && result.raw_inlier_edge_count == 5 &&
result.track_count == 5);
std::puts("C02/C03: PASS (outlier exclusion, asymmetric LSB-first mask)");
}
void run_rejection_cases() {
Fixture fixture;
auto gvr = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01}, LARDON3D_GEOMETRIC_REJECTED);
uint64_t ids[] = {gvr};
auto request = fixture.request(ids, 1);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK &&
track_set_count(fixture.db_path) == 0);
request.verifier_kind = 99;
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK);
CHECK(fixture.request(nullptr, 0).gvr_count == 0);
std::puts("C04-C07/C11: PASS");
}
void run_scope_errors() {
Fixture fixture;
auto gvr = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t unsorted[] = {gvr + 1, gvr};
auto bad = fixture.request(unsorted, 2);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&bad, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_INVALID_ARGUMENT);
uint64_t duplicate[] = {gvr, gvr};
bad = fixture.request(duplicate, 2);
CHECK(lardon3d_track_builder_build_project(&bad, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_INVALID_ARGUMENT);
uint64_t missing[] = {gvr + 1000};
bad = fixture.request(missing, 1);
CHECK(lardon3d_track_builder_build_project(&bad, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK && track_set_count(fixture.db_path) == 0);
std::puts("C08-C10: PASS");
}
void run_revalidation_and_duplicate_scope() {
Fixture fixture;
auto gvr = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t ids[] = {gvr};
auto request = fixture.request(ids, 1);
g_delete_db = fixture.db_path;
g_delete_id = gvr;
g_delete_before_revalidation = true;
Lardon3DTrackBuilderProjectResult result{};
auto status = lardon3d_track_builder_build_project(&request, &result);
CHECK(status !=
LARDON3D_TRACK_BUILDER_PROJECT_OK &&
track_set_count(fixture.db_path) == 0);
Fixture duplicate_fixture;
auto first = duplicate_fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
auto second = duplicate_fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t duplicate_ids[] = {first, second};
auto duplicate_request = duplicate_fixture.request(duplicate_ids, 2);
CHECK(lardon3d_track_builder_build_project(&duplicate_request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && result.track_count == 1);
std::puts("C18/C25: PASS (duplicate collapse, selected-input disappearance detected)");
}
void run_remaining_matrix() {
{
Fixture fixture;
auto gvr = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t ids[] = {gvr};
auto request = fixture.request(ids, 1);
Lardon3DTrackBuilderProjectResult result{};
request.verifier_version = 2;
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK && track_set_count(fixture.db_path) == 0);
request.verifier_version = 1;
unsigned char wrong[32];
std::memset(wrong, 0x43, sizeof(wrong));
request.verifier_fingerprint = wrong;
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK && track_set_count(fixture.db_path) == 0);
request.gvr_ids = nullptr;
request.gvr_count = 0;
CHECK(lardon3d_track_builder_build_project(&request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_INVALID_ARGUMENT && track_set_count(fixture.db_path) == 0);
std::puts("C06/C07/C11: PASS");
}
{
Fixture fixture;
auto gvr = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t ids[] = {gvr};
auto request = fixture.request(ids, 1);
Lardon3DProjectDbGeometricVerificationResult loaded{};
CHECK(lardon3d_project_db_load_geometric_verification_result(fixture.db, gvr, &loaded) ==
LARDON3D_PROJECT_DB_OK);
Lardon3DProjectDbMatchResult match{};
CHECK(lardon3d_project_db_load_match_result(fixture.db, loaded.match_result_id, &match) ==
LARDON3D_PROJECT_DB_OK);
std::string path = fixture.directory + "/" + match.match_asset_path;
int fd = open(path.c_str(), O_WRONLY);
CHECK(fd >= 0);
unsigned char bad_magic = 'X';
CHECK(write(fd, &bad_magic, 1) == 1 && close(fd) == 0);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK && track_set_count(fixture.db_path) == 0);
std::puts("C12: PASS (Match File bad magic propagated)");
}
{
Fixture fixture;
std::vector<Lardon3DMatchFileEntry> entries;
for (uint32_t i = 0; i < 9; ++i) entries.push_back({i, i, 0.1F});
auto gvr = fixture.add_gvr(0, 1, entries, {0xff, 0x01});
uint64_t ids[] = {gvr};
execute_sql(fixture.db_path,
"UPDATE geometric_verification_results SET inlier_mask=X'FF' ");
auto request = fixture.request(ids, 1);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK && track_set_count(fixture.db_path) == 0);
std::puts("C13: PASS (mask length rejected by persisted loader)");
}
{
Fixture fixture;
auto gvr = fixture.add_gvr(0, 1, {{32, 0, 0.1F}}, {0x01});
uint64_t ids[] = {gvr};
auto request = fixture.request(ids, 1);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK && track_set_count(fixture.db_path) == 0);
std::puts("C14: PASS (Match File bounds validator rejected OOB index)");
}
{
Fixture fixture;
uint64_t extra = fixture.add_feature_set(0, 0x61);
auto first = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01},
LARDON3D_GEOMETRIC_VERIFIED, extra, fixture.feature[1]);
auto second = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t ids[] = {first, second};
auto request = fixture.request(ids, 2);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && result.track_count == 0);
std::puts("C15: PASS (same-image scientific conflict)");
}
{
Fixture fixture;
uint64_t extra = fixture.add_feature_set(1, 0x62);
auto first = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01},
LARDON3D_GEOMETRIC_VERIFIED, fixture.feature[0], extra);
auto second = fixture.add_gvr(1, 2, {{0, 0, 0.1F}}, {0x01},
LARDON3D_GEOMETRIC_VERIFIED, extra, fixture.feature[2]);
uint64_t ids[] = {first, second};
auto request = fixture.request(ids, 2);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && result.track_count == 0);
std::puts("C16: PASS (heterogeneous Feature Set conflict)");
}
{
Fixture fixture;
auto first = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01},
LARDON3D_GEOMETRIC_VERIFIED, 0, 0, "matcher-a", 1);
auto second = fixture.add_gvr(1, 2, {{0, 0, 0.1F}}, {0x01},
LARDON3D_GEOMETRIC_VERIFIED, 0, 0, "matcher-b", 2);
uint64_t ids[] = {first, second};
auto request = fixture.request(ids, 2);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && result.track_count == 1);
std::puts("C17: PASS (matcher configurations do not rank edges)");
}
{
Fixture fixture;
auto first = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
auto duplicate = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t one[] = {first};
uint64_t two[] = {first, duplicate};
auto request_one = fixture.request(one, 1);
auto request_two = fixture.request(two, 2);
Lardon3DTrackBuilderProjectResult a{}, b{};
CHECK(lardon3d_track_builder_build_project(&request_one, &a) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK);
CHECK(lardon3d_track_builder_build_project(&request_two, &b) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && a.track_set_id != b.track_set_id &&
a.track_count == b.track_count && track_set_count(fixture.db_path) == 2);
unsigned char expected_one[32]{};
unsigned char expected_two[32]{};
independent_scope_digest(one, 1, expected_one);
independent_scope_digest(two, 2, expected_two);
const unsigned char fixed_one[32] = {
0x5e, 0xf4, 0xf8, 0x44, 0x57, 0x8f, 0x92, 0x2c,
0x7d, 0x55, 0xb8, 0xb7, 0x9a, 0x9f, 0x71, 0x21,
0xac, 0x6b, 0x8a, 0x55, 0xe6, 0xb5, 0x3d, 0x6d,
0x87, 0x7e, 0x20, 0x4b, 0x52, 0x58, 0x59, 0xbe};
const unsigned char fixed_two[32] = {
0xff, 0xb4, 0x3e, 0x52, 0x87, 0x38, 0xac, 0x64,
0xc7, 0x39, 0xaa, 0xa8, 0xe2, 0x4a, 0xf1, 0xd4,
0xcd, 0x99, 0x4b, 0x59, 0xb4, 0x6a, 0x97, 0xc6,
0xf4, 0xb1, 0x66, 0x00, 0x52, 0x5b, 0x64, 0xa3};
Lardon3DProjectDbTrackSet loaded_one{}, loaded_two{};
CHECK(lardon3d_project_db_load_track_set(fixture.db, a.track_set_id, &loaded_one) ==
LARDON3D_PROJECT_DB_OK &&
lardon3d_project_db_load_track_set(fixture.db, b.track_set_id, &loaded_two) ==
LARDON3D_PROJECT_DB_OK &&
std::memcmp(expected_one, loaded_one.input_scope_hash, 32) == 0 &&
std::memcmp(expected_two, loaded_two.input_scope_hash, 32) == 0 &&
std::memcmp(expected_one, fixed_one, 32) == 0 &&
std::memcmp(expected_two, fixed_two, 32) == 0 &&
std::memcmp(expected_one, expected_two, 32) != 0);
std::puts("C19: PASS (same logical output, distinct scope identity)");
}
}
void run_durability_and_zero_track() {
Fixture fixture;
auto gvr = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t ids[] = {gvr};
auto request = fixture.request(ids, 1);
Lardon3DTrackBuilderProjectResult first{};
CHECK(lardon3d_track_builder_build_project(&request, &first) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && first.track_count == 1);
uint64_t tracks_before = table_count(fixture.db_path, "tracks");
uint64_t observations_before = table_count(fixture.db_path, "track_observations");
lardon3d_project_db_close(fixture.db);
fixture.db = nullptr;
char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY]{};
CHECK(lardon3d_project_db_open(fixture.db_path.c_str(), &fixture.db, error) ==
LARDON3D_PROJECT_DB_OK);
request.database = fixture.db;
Lardon3DProjectDbTrackSet loaded{};
CHECK(lardon3d_project_db_load_track_set(fixture.db, first.track_set_id, &loaded) ==
LARDON3D_PROJECT_DB_OK && loaded.track_count == 1 && loaded.gvr_count == 1);
assert_two_observation_track(fixture.db, first.track_set_id, fixture.feature[0],
fixture.feature[1]);
Lardon3DTrackBuilderProjectResult reused{};
CHECK(lardon3d_track_builder_build_project(&request, &reused) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && reused.reused &&
reused.track_set_id == first.track_set_id);
CHECK(track_set_count(fixture.db_path) == 1 && table_count(fixture.db_path, "tracks") ==
tracks_before &&
table_count(fixture.db_path, "track_observations") == observations_before);
std::puts("C21/C22: PASS (close/reopen and reuse durability)");
Fixture zero;
uint64_t extra = zero.add_feature_set(0, 0x63);
auto conflict_a = zero.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01},
LARDON3D_GEOMETRIC_VERIFIED, extra, zero.feature[1]);
auto conflict_b = zero.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
uint64_t conflict_ids[] = {conflict_a, conflict_b};
auto conflict_request = zero.request(conflict_ids, 2);
Lardon3DTrackBuilderProjectResult zero_result{};
CHECK(lardon3d_track_builder_build_project(&conflict_request, &zero_result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && zero_result.track_count == 0 &&
track_set_count(zero.db_path) == 1);
std::puts("C23: PASS (zero-track Track Set published)");
}
void run_scope_snapshot_case() {
Fixture fixture;
auto first = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
auto second = fixture.add_gvr(1, 2, {{0, 0, 0.1F}}, {0x01});
auto late = fixture.add_gvr(0, 1, {{7, 7, 0.1F}}, {0x01});
Lardon3DProjectDbGeometricVerificationResult late_gvr{};
CHECK(lardon3d_project_db_load_geometric_verification_result(fixture.db, late, &late_gvr) ==
LARDON3D_PROJECT_DB_OK);
execute_sql(fixture.db_path,
("DELETE FROM geometric_verification_results WHERE "
"geometric_verification_result_id=" + std::to_string(late))
.c_str());
g_insert_db = fixture.db_path;
g_insert_match_id = late_gvr.match_result_id;
g_insert_during_build = true;
uint64_t ids[] = {first, second};
auto request = fixture.request(ids, 2);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && result.track_count == 1 && result.gvr_count == 2);
CHECK(track_set_count(fixture.db_path) == 1);
std::puts("C24: PASS (late matching GVR excluded from explicit scope)");
}
void run_partial_input_failure() {
Fixture fixture;
auto valid = fixture.add_gvr(0, 1, {{0, 0, 0.1F}}, {0x01});
auto corrupt = fixture.add_gvr(1, 2, {{0, 0, 0.1F}}, {0x01});
Lardon3DProjectDbGeometricVerificationResult loaded{};
CHECK(lardon3d_project_db_load_geometric_verification_result(fixture.db, corrupt, &loaded) ==
LARDON3D_PROJECT_DB_OK);
Lardon3DProjectDbMatchResult match{};
CHECK(lardon3d_project_db_load_match_result(fixture.db, loaded.match_result_id, &match) ==
LARDON3D_PROJECT_DB_OK);
int fd = open((fixture.directory + "/" + match.match_asset_path).c_str(), O_WRONLY);
CHECK(fd >= 0);
unsigned char bad_magic = 'Q';
CHECK(write(fd, &bad_magic, 1) == 1 && close(fd) == 0);
uint64_t ids[] = {valid, corrupt};
auto request = fixture.request(ids, 2);
Lardon3DTrackBuilderProjectResult result{};
CHECK(lardon3d_track_builder_build_project(&request, &result) !=
LARDON3D_TRACK_BUILDER_PROJECT_OK && track_set_count(fixture.db_path) == 0);
std::puts("PARTIAL INPUT: PASS");
}
void run_resource_case() {
Fixture fixture(8192);
std::vector<Lardon3DMatchFileEntry> entries;
std::vector<unsigned char> mask(1024, 0xff);
entries.reserve(8192);
for (uint32_t i = 0; i < 8192; ++i) entries.push_back({i, i, 0.1F});
std::vector<uint64_t> ids;
for (size_t i = 0; i < 13; ++i) ids.push_back(fixture.add_gvr(0, 1, entries, mask));
auto request = fixture.request(ids.data(), ids.size());
Lardon3DTrackBuilderProjectResult result{};
auto started = std::chrono::steady_clock::now();
CHECK(lardon3d_track_builder_build_project(&request, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_OK && result.raw_inlier_edge_count == 106496 &&
result.core_observation_count == 16384 && result.track_count == 8192);
auto elapsed = std::chrono::duration<double>(std::chrono::steady_clock::now() - started);
struct rusage usage{};
CHECK(getrusage(RUSAGE_SELF, &usage) == 0);
std::printf("RESOURCE GVR=%zu RAW=%llu INLIERS=%llu FEATURES=3 OBS=%llu TRACKS=%llu\n",
ids.size(), static_cast<unsigned long long>(result.raw_inlier_edge_count),
static_cast<unsigned long long>(result.raw_inlier_edge_count),
static_cast<unsigned long long>(result.core_observation_count),
static_cast<unsigned long long>(result.track_count));
std::printf("RESOURCE DURATION_SECONDS=%.3f PEAK_RSS_KIB=%ld MAX_MATCH_FILES_LIVE=1\n",
elapsed.count(), usage.ru_maxrss);
}
} // namespace
#ifdef LARDON3D_TRACK_BUILDER_PROJECT_TESTING
extern "C" void lardon3d_track_builder_project_test_before_revalidation(
Lardon3DProjectDb *, const uint64_t *, size_t) {
if (g_insert_during_build) {
sqlite3 *connection = nullptr;
CHECK(sqlite3_open(g_insert_db.c_str(), &connection) == SQLITE_OK);
char sql[512];
std::snprintf(
sql, sizeof(sql),
"INSERT INTO geometric_verification_results "
"(match_result_id,verifier_kind,verifier_version,parameter_fingerprint,status,"
"inlier_count,inlier_mask,model_m00,model_m01,model_m02,model_m10,model_m11,model_m12,"
"model_m20,model_m21,model_m22,created_at) VALUES (%llu,1,1,"
"X'4242424242424242424242424242424242424242424242424242424242424242',2,1,X'01',"
"0,0,0,0,0,0,0,0,0,999)",
static_cast<unsigned long long>(g_insert_match_id));
int insert_result = sqlite3_exec(connection, sql, nullptr, nullptr, nullptr);
if (insert_result != SQLITE_OK) {
std::fprintf(stderr, "late GVR insert: %s\n", sqlite3_errmsg(connection));
}
CHECK(insert_result == SQLITE_OK);
CHECK(sqlite3_close(connection) == SQLITE_OK);
g_insert_during_build = false;
}
if (!g_delete_before_revalidation) return;
sqlite3 *connection = nullptr;
CHECK(sqlite3_open(g_delete_db.c_str(), &connection) == SQLITE_OK);
char sql[256];
std::snprintf(sql, sizeof(sql),
"DELETE FROM geometric_verification_results WHERE "
"geometric_verification_result_id=%llu",
static_cast<unsigned long long>(g_delete_id));
CHECK(sqlite3_exec(connection, sql, nullptr, nullptr, nullptr) == SQLITE_OK);
CHECK(sqlite3_close(connection) == SQLITE_OK);
g_delete_before_revalidation = false;
}
#endif
int main() {
Lardon3DTrackBuilderProjectResult result{};
Lardon3DTrackBuilderProjectRequest invalid{};
CHECK(lardon3d_track_builder_build_project(&invalid, &result) ==
LARDON3D_TRACK_BUILDER_PROJECT_INVALID_ARGUMENT);
run_basic_and_reuse();
run_mask_cases();
run_rejection_cases();
run_scope_errors();
run_revalidation_and_duplicate_scope();
run_remaining_matrix();
run_durability_and_zero_track();
run_scope_snapshot_case();
run_partial_input_failure();
run_resource_case();
std::puts("C01-C27 integration harness: PASS (C26 N/A; C27 deferred to Gate D)");
return 0;
}
Reference in a new issue View git blame Copy permalink