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

1288 lines
52 KiB
C++
Raw Blame History

#include <lardon3d/dense_mvs.h>
#include <algorithm>
#include <cerrno>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fcntl.h>
#include <fstream>
#include <iomanip>
#include <limits>
#include <locale>
#include <map>
#include <new>
#include <opencv2/calib3d.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>
#include <openssl/evp.h>
#include <poll.h>
#include <sstream>
#include <signal.h>
#include <set>
#include <string>
#include <sys/stat.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <vector>
namespace lardon3d::dense_mvs_detail {
bool source_image_set_identity(const Lardon3DDenseMvsSourceImage *images,
size_t count, unsigned char digest[32]);
bool calibration_binding_identity(const Lardon3DDenseMvsSourceImage *images,
size_t count, unsigned char digest[32]);
} // namespace lardon3d::dense_mvs_detail
namespace {
constexpr size_t kMaxVersion = 16384;
constexpr int kVersionTimeoutMs = 5000;
constexpr uint64_t kMaxSourceFileBytes = UINT64_C(1024) * 1024 * 1024;
constexpr uint64_t kMaxBackendFileBytes = UINT64_C(1024) * 1024 * 1024;
constexpr size_t kMaxBackendLogBytes = 1024 * 1024;
constexpr size_t kMaxPlyHeader = 1024 * 1024;
constexpr size_t kMaxPlyLine = 64 * 1024;
constexpr size_t kMaxPlyProperties = 256;
bool sha(const unsigned char *p, size_t n, unsigned char d[32]) {
unsigned int length = 0;
return p && d &&
EVP_Digest(p, n, d, &length, EVP_sha256(), nullptr) == 1 &&
length == 32;
}
bool executable(const char *path) {
struct stat status {};
return path && stat(path, &status) == 0 && S_ISREG(status.st_mode) &&
access(path, X_OK) == 0;
}
bool same_file_snapshot(const struct stat &before, const struct stat &after) {
return before.st_dev == after.st_dev && before.st_ino == after.st_ino &&
before.st_size == after.st_size &&
before.st_mtim.tv_sec == after.st_mtim.tv_sec &&
before.st_mtim.tv_nsec == after.st_mtim.tv_nsec &&
before.st_ctim.tv_sec == after.st_ctim.tv_sec &&
before.st_ctim.tv_nsec == after.st_ctim.tv_nsec;
}
bool sha_regular_file(const char *path, unsigned char digest[32],
uint64_t max_bytes = UINT64_MAX,
uint64_t *remaining_bytes = nullptr) {
if (!path || !digest) return false;
const int descriptor = open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
if (descriptor < 0) return false;
struct stat status {};
const uint64_t effective_max = remaining_bytes
? std::min(max_bytes, *remaining_bytes)
: max_bytes;
bool ok = fstat(descriptor, &status) == 0 && S_ISREG(status.st_mode) &&
status.st_size >= 0 &&
static_cast<uint64_t>(status.st_size) <= effective_max;
if (!ok) {
(void)close(descriptor);
return false;
}
FILE *file = fdopen(descriptor, "rb");
if (!file) {
(void)close(descriptor);
return false;
}
const uint64_t expected_size = ok ? static_cast<uint64_t>(status.st_size) : 0;
EVP_MD_CTX *context = EVP_MD_CTX_new();
ok = ok && context && EVP_DigestInit_ex(context, EVP_sha256(), nullptr) == 1;
unsigned char buffer[8192];
uint64_t total = 0;
while (ok && total < expected_size) {
const uint64_t remaining = expected_size - total;
const size_t request = static_cast<size_t>(
std::min<uint64_t>(remaining, sizeof buffer));
const size_t size = std::fread(buffer, 1, request, file);
if (size != 0) {
total += size;
ok = EVP_DigestUpdate(context, buffer, size) == 1;
}
if (size < request) ok = false;
}
struct stat final_status {};
ok = ok && !std::ferror(file) && total == expected_size &&
fstat(fileno(file), &final_status) == 0 &&
same_file_snapshot(status, final_status);
unsigned int length = 0;
if (ok) ok = EVP_DigestFinal_ex(context, digest, &length) == 1 && length == 32;
EVP_MD_CTX_free(context);
const int close_result = std::fclose(file);
ok = ok && close_result == 0;
if (ok && remaining_bytes) *remaining_bytes -= expected_size;
return ok;
}
bool ms(uint64_t *value) {
timespec time {};
if (!value || clock_gettime(CLOCK_MONOTONIC, &time) || time.tv_sec < 0)
return false;
*value = static_cast<uint64_t>(time.tv_sec) * 1000 +
static_cast<uint64_t>(time.tv_nsec) / 1000000;
return true;
}
bool wait_nonblocking(pid_t child, int *status, bool *exited) {
for (;;) {
const pid_t result = waitpid(child, status, WNOHANG);
if (result == child) { *exited = true; return true; }
if (result == 0) return true;
if (errno == ECHILD) { *exited = true; return true; }
if (errno != EINTR) return false;
}
}
/* Probe children have a deadline; backend execution intentionally does not. */
bool signal_group(pid_t group, int signal) {
return kill(-group, signal) == 0 || errno == ESRCH;
}
bool owns_process_group(pid_t child) {
const pid_t group = getpgid(child);
return group == child || (group < 0 && errno == ESRCH);
}
bool terminate_and_reap(pid_t child, pid_t group) {
int status = 0;
bool exited = false;
if (!wait_nonblocking(child, &status, &exited)) return false;
if (!signal_group(group, SIGTERM)) return false;
uint64_t start = 0;
if (!ms(&start)) return false;
while (true) {
uint64_t now = 0;
if (!ms(&now) || now - start >= 250) break;
if (!wait_nonblocking(child, &status, &exited)) return false;
if (exited && kill(-group, 0) != 0 && errno == ESRCH) return true;
(void)poll(nullptr, 0, 10);
}
if (!signal_group(group, SIGKILL)) return false;
if (!ms(&start)) return false;
while (true) {
uint64_t now = 0;
if (!ms(&now) || now - start >= 250) return false;
if (!wait_nonblocking(child, &status, &exited)) return false;
if (exited) return true;
(void)poll(nullptr, 0, 10);
}
}
bool run(const std::vector<std::string>& a, const std::string &directory,
const char *log_name) {
if(a.empty())return false;
std::vector<char*> v;
for(const auto&x:a)v.push_back(const_cast<char*>(x.c_str()));
v.push_back(nullptr);
const std::string log_path = directory + "/" + log_name;
int log_fd = open(log_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (log_fd < 0) return false;
int output[2];
if (pipe(output) != 0) { close(log_fd); return false; }
int launch[2];
if (pipe(launch) != 0) {
close(output[0]); close(output[1]); close(log_fd); return false;
}
if (fcntl(launch[1], F_SETFD, FD_CLOEXEC) != 0) {
close(launch[0]); close(launch[1]); close(output[0]); close(output[1]);
close(log_fd); return false;
}
pid_t c=fork();
if(c<0){close(launch[0]);close(launch[1]);close(output[0]);close(output[1]);close(log_fd);return false;}
if(!c){
close(launch[0]);
close(output[0]);
const int input_fd = open("/dev/null", O_RDONLY);
if (setpgid(0, 0) != 0 || input_fd < 0 || dup2(input_fd, STDIN_FILENO) < 0 ||
dup2(output[1], STDOUT_FILENO) < 0 ||
dup2(output[1], STDERR_FILENO) < 0) {
const int error = errno;
(void)!write(launch[1], &error, sizeof error);
_exit(127);
}
close(input_fd);
close(output[1]);
close(log_fd);
execv(v[0],v.data());
const int error = errno;
(void)!write(launch[1], &error, sizeof error);
_exit(127);
}
close(launch[1]);
close(output[1]);
if (setpgid(c, c) != 0 && errno != EACCES && errno != ESRCH) {
close(launch[0]); close(output[0]); close(log_fd);
(void)terminate_and_reap(c, c);
return false;
}
if (!owns_process_group(c)) {
close(launch[0]); close(output[0]); close(log_fd);
(void)terminate_and_reap(c, c);
return false;
}
int launch_error = 0;
ssize_t launch_size;
do { launch_size = read(launch[0], &launch_error, sizeof launch_error); }
while (launch_size < 0 && errno == EINTR);
close(launch[0]);
if (launch_size != 0) {
close(output[0]); close(log_fd);
(void)terminate_and_reap(c, c);
return false;
}
int flags = fcntl(output[0], F_GETFL);
if (flags < 0 || fcntl(output[0], F_SETFL, flags | O_NONBLOCK) != 0) {
close(output[0]); close(log_fd);
(void)terminate_and_reap(c, c);
return false;
}
int s = 0;
bool exited = false, eof = false, io_ok = true;
size_t retained = 0;
while (!exited || !eof) {
if (!exited && !wait_nonblocking(c, &s, &exited)) { io_ok = false; break; }
for (;;) {
unsigned char buffer[8192];
const ssize_t size = read(output[0], buffer, sizeof buffer);
if (size > 0) {
const size_t keep = std::min<size_t>(static_cast<size_t>(size),
kMaxBackendLogBytes - retained);
if (keep && write(log_fd, buffer, keep) != static_cast<ssize_t>(keep))
io_ok = false;
retained += keep;
continue;
}
if (size == 0) eof = true;
else if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
io_ok = false;
break;
}
if (!io_ok || (exited && eof)) break;
pollfd descriptor{output[0], POLLIN | POLLHUP, 0};
if (poll(&descriptor, 1, 50) < 0 && errno != EINTR) { io_ok = false; break; }
if (exited && !eof && (kill(-c, 0) == 0 || errno != ESRCH)) {
if (!terminate_and_reap(c, c)) io_ok = false;
}
}
close(output[0]);
if (close(log_fd) != 0) io_ok = false;
if (!io_ok) {
(void)terminate_and_reap(c, c);
return false;
}
const bool ok = WIFEXITED(s)&&WEXITSTATUS(s)==0;
/* A successful direct child may still have left helpers in its owned group. */
if (kill(-c, 0) == 0 || errno != ESRCH) {
if (!terminate_and_reap(c, c)) return false;
}
return ok;
}
struct BackendCapabilities {
bool cuda_option;
unsigned char version_identity[32];
};
bool probe(const char *path, bool interface_colmap,
BackendCapabilities *capabilities) {
int fd[2];
if (!path || !capabilities || pipe(fd)) return false;
pid_t c=fork();
if(c<0){close(fd[0]);close(fd[1]);return false;}
if(!c){
if (setpgid(0, 0) != 0) _exit(127);
const char *arguments[] = {path, "--help", nullptr};
(void)dup2(fd[1],STDOUT_FILENO);
(void)dup2(fd[1],STDERR_FILENO);
close(fd[0]);
close(fd[1]);
execv(path, const_cast<char *const *>(arguments));
_exit(127);
}
if (setpgid(c, c) != 0 && errno != EACCES && errno != ESRCH) {
close(fd[0]);
close(fd[1]);
(void)terminate_and_reap(c, c);
return false;
}
if (!owns_process_group(c)) {
close(fd[0]);
close(fd[1]);
(void)terminate_and_reap(c, c);
return false;
}
close(fd[1]);
const int flags=fcntl(fd[0],F_GETFL);
if(flags<0||fcntl(fd[0],F_SETFL,flags|O_NONBLOCK)!=0){close(fd[0]);(void)terminate_and_reap(c,c);return false;}
std::vector<unsigned char> out;
uint64_t start=0;
bool ok=ms(&start), eof=false, exited=false;
const uint64_t deadline=start+kVersionTimeoutMs;
int s=0;
while (ok && (!exited || !eof)) {
if (!exited && !wait_nonblocking(c, &s, &exited)) {
ok = false;
break;
}
for (;;) {
unsigned char b[512];
const ssize_t n=read(fd[0],b,sizeof b);
if(n>0){if((size_t)n>kMaxVersion-out.size()){ok=false;break;}out.insert(out.end(),b,b+n);continue;}
if(n==0)eof=true;
else if(errno!=EAGAIN&&errno!=EWOULDBLOCK&&errno!=EINTR)ok=false;
break;
}
if (!ok || (exited && eof)) break;
uint64_t now=0;
if(!ms(&now)||now>=deadline){ok=false;break;}
pollfd x{fd[0],POLLIN|POLLHUP,0};
const int r=poll(&x,1,(int)std::min<uint64_t>(deadline-now,50));
if(r<0&&errno!=EINTR){ok=false;break;}
}
close(fd[0]);
if(!ok||!exited){(void)terminate_and_reap(c,c);return false;}
const bool process_ok = eof && WIFEXITED(s) && !out.empty();
if (kill(-c, 0) == 0 || errno != ESRCH) {
if (!terminate_and_reap(c, c)) return false;
}
if (!process_ok) return false;
const std::string output(out.begin(), out.end());
const bool pinned = output.find("OpenMVS") != std::string::npos &&
output.find("v2.4.0") != std::string::npos;
const bool common = output.find("--max-threads") != std::string::npos;
const bool specific = interface_colmap
? output.find("--image-folder") != std::string::npos
: output.find("--resolution-level") != std::string::npos &&
output.find("--min-resolution") != std::string::npos &&
output.find("--number-views") != std::string::npos &&
output.find("--fusion-mode") != std::string::npos;
static const unsigned char version_record[] = "OpenMVS v2.4.0";
capabilities->cuda_option = output.find("--cuda-device") != std::string::npos;
return pinned && common && specific &&
sha(version_record, sizeof version_record - 1,
capabilities->version_identity);
}
bool finite_cal(const Lardon3DSparseGeometryCalibration &calibration) {
return calibration.width && calibration.height &&
std::isfinite(calibration.fx) && std::isfinite(calibration.fy) &&
std::isfinite(calibration.cx) && std::isfinite(calibration.cy) &&
std::isfinite(calibration.k1) && std::isfinite(calibration.k2) &&
std::isfinite(calibration.p1) && std::isfinite(calibration.p2) &&
calibration.fx > 0 && calibration.fy > 0;
}
struct ObservationKey {
uint64_t feature_set_id;
uint32_t feature_index;
bool operator<(const ObservationKey &other) const {
return feature_set_id < other.feature_set_id ||
(feature_set_id == other.feature_set_id &&
feature_index < other.feature_index);
}
};
struct ExportObservation {
const Lardon3DSparseIncrementalLandmarkObservation *snapshot;
const Lardon3DSparseIncrementalObservation *source;
uint32_t point_id;
double x;
double y;
};
bool finalize(std::ofstream &file) {
file.flush();
const bool written = file.good();
file.close();
return written && !file.fail();
}
bool valid_rotation(const double *r) {
if (!r) return false;
for (int i = 0; i < 9; ++i) if (!std::isfinite(r[i])) return false;
double residual = 0;
for (int row = 0; row < 3; ++row) {
for (int col = 0; col < 3; ++col) {
double dot = 0;
for (int k = 0; k < 3; ++k) dot += r[row * 3 + k] * r[col * 3 + k];
residual = std::max(residual, std::fabs(dot - (row == col ? 1.0 : 0.0)));
}
}
const double det = r[0] * (r[4] * r[8] - r[5] * r[7]) -
r[1] * (r[3] * r[8] - r[5] * r[6]) +
r[2] * (r[3] * r[7] - r[4] * r[6]);
return residual <= 1e-6 && std::fabs(det - 1.0) <= 1e-6;
}
bool quaternion(const double *rotation, double q[4]) {
if (!rotation || !q || !valid_rotation(rotation)) return false;
const double trace = rotation[0] + rotation[4] + rotation[8];
double scale = 0;
if (trace > 0) {
scale = std::sqrt(trace + 1) * 2;
q[0] = 0.25 * scale;
q[1] = (rotation[7] - rotation[5]) / scale;
q[2] = (rotation[2] - rotation[6]) / scale;
q[3] = (rotation[3] - rotation[1]) / scale;
} else if (rotation[0] > rotation[4] && rotation[0] > rotation[8]) {
scale = std::sqrt(std::max(0.0, 1 + rotation[0] - rotation[4] - rotation[8])) * 2;
q[0] = (rotation[7] - rotation[5]) / scale;
q[1] = 0.25 * scale;
q[2] = (rotation[1] + rotation[3]) / scale;
q[3] = (rotation[2] + rotation[6]) / scale;
} else if (rotation[4] > rotation[8]) {
scale = std::sqrt(std::max(0.0, 1 + rotation[4] - rotation[0] - rotation[8])) * 2;
q[0] = (rotation[2] - rotation[6]) / scale;
q[1] = (rotation[1] + rotation[3]) / scale;
q[2] = 0.25 * scale;
q[3] = (rotation[5] + rotation[7]) / scale;
} else {
scale = std::sqrt(std::max(0.0, 1 + rotation[8] - rotation[0] - rotation[4])) * 2;
q[0] = (rotation[3] - rotation[1]) / scale;
q[1] = (rotation[2] + rotation[6]) / scale;
q[2] = (rotation[5] + rotation[7]) / scale;
q[3] = 0.25 * scale;
}
const double norm = std::sqrt(q[0] * q[0] + q[1] * q[1] +
q[2] * q[2] + q[3] * q[3]);
if (!(norm > 0) || !std::isfinite(norm)) return false;
for (size_t index = 0; index < 4; ++index) q[index] /= norm;
const bool negative = q[0] < 0 ||
(q[0] == 0 &&
(q[1] < 0 ||
(q[1] == 0 && (q[2] < 0 || (q[2] == 0 && q[3] < 0)))));
if (negative)
for (size_t index = 0; index < 4; ++index) q[index] = -q[index];
return std::all_of(q, q + 4, [](double value) { return std::isfinite(value); });
}
bool finite_point(const Lardon3DSparseGeometryPoint3 &point) {
return std::isfinite(point.x) && std::isfinite(point.y) &&
std::isfinite(point.z);
}
/* Two fixed-size CV_8UC3 image buffers cover decode plus undistortion. */
constexpr uint64_t kMaxImageDimension = 16384;
constexpr uint64_t kMaxImagePixels = 40000000;
constexpr uint64_t kMaxImageWorkingSetBytes = 240000000;
bool bounded_image_allocation(uint32_t width, uint32_t height) {
if (!width || !height || width > kMaxImageDimension ||
height > kMaxImageDimension || width > UINT64_MAX / height)
return false;
const uint64_t pixels = static_cast<uint64_t>(width) * height;
constexpr uint64_t bytes_per_pixel_for_two_images = 2U * 3U;
return pixels <= kMaxImagePixels &&
pixels <= kMaxImageWorkingSetBytes / bytes_per_pixel_for_two_images;
}
uint16_t be16(const unsigned char *p) {
return static_cast<uint16_t>((static_cast<uint16_t>(p[0]) << 8) |
static_cast<uint16_t>(p[1]));
}
uint32_t be32(const unsigned char *p) {
return uint32_t(p[0]) << 24 | uint32_t(p[1]) << 16 |
uint32_t(p[2]) << 8 | p[3];
}
uint32_t le32(const unsigned char *p) {
return uint32_t(p[0]) | uint32_t(p[1]) << 8 |
uint32_t(p[2]) << 16 | uint32_t(p[3]) << 24;
}
bool encoded_image_dimensions(const char *path, uint32_t *width,
uint32_t *height) {
if (!path || !width || !height) return false;
const int descriptor = open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
if (descriptor < 0) return false;
struct stat status {};
if (fstat(descriptor, &status) != 0 || !S_ISREG(status.st_mode)) {
(void)close(descriptor);
return false;
}
unsigned char data[64 * 1024];
size_t size = 0;
bool read_ok = true;
while (size < sizeof data) {
ssize_t amount;
do {
amount = read(descriptor, data + size, sizeof data - size);
} while (amount < 0 && errno == EINTR);
if (amount < 0) {
read_ok = false;
break;
}
if (amount == 0) break;
size += static_cast<size_t>(amount);
}
read_ok = close(descriptor) == 0 && read_ok;
if (!read_ok) return false;
if (size >= 24 && !std::memcmp(data, "\x89PNG\r\n\x1a\n", 8) &&
!std::memcmp(data + 12, "IHDR", 4)) {
*width = be32(data + 16); *height = be32(data + 20); return true;
}
if (size >= 26 && data[0] == 'B' && data[1] == 'M') {
*width = le32(data + 18);
const int32_t signed_height = static_cast<int32_t>(le32(data + 22));
if (signed_height == INT32_MIN) return false;
*height = static_cast<uint32_t>(std::abs(signed_height));
return true;
}
if (size >= 4 && data[0] == 0xff && data[1] == 0xd8) {
size_t offset = 2;
while (offset + 4 <= size) {
if (data[offset++] != 0xff) return false;
while (offset < size && data[offset] == 0xff) ++offset;
if (offset >= size) return false;
const unsigned char marker = data[offset++];
if (marker == 0xd8 || marker == 0xd9) continue;
if (offset + 2 > size) return false;
const uint16_t length = be16(data + offset);
if (length < 2 || offset + length > size) return false;
if ((marker >= 0xc0 && marker <= 0xc3) ||
(marker >= 0xc5 && marker <= 0xc7) ||
(marker >= 0xc9 && marker <= 0xcb) ||
(marker >= 0xcd && marker <= 0xcf)) {
if (length < 7) return false;
*height = be16(data + offset + 3); *width = be16(data + offset + 5);
return true;
}
offset += length;
}
}
return false;
}
Lardon3DDenseMvsStatus validate_snapshot(const Lardon3DDenseMvsInput &input) {
const auto &snapshot = *input.snapshot;
if (!input.source_observations ||
input.source_observation_count != snapshot.observation_count)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
if ((snapshot.camera_count && !snapshot.cameras) ||
(snapshot.landmark_count && !snapshot.landmarks) ||
(snapshot.observation_count && !snapshot.observations) ||
snapshot.camera_count == 0 || snapshot.landmark_count == 0 ||
snapshot.observation_count == 0 ||
snapshot.camera_count > UINT32_MAX ||
snapshot.landmark_count > UINT32_MAX)
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
std::map<uint64_t, uint64_t> camera_components;
std::map<uint64_t, const Lardon3DSparseIncrementalLandmark *> landmarks;
std::map<ObservationKey, const Lardon3DSparseIncrementalObservation *> sources;
std::map<uint64_t, uint64_t> observed;
std::set<std::pair<uint64_t, uint32_t>> positions;
for (size_t index = 0; index < snapshot.camera_count; ++index) {
const auto &camera = snapshot.cameras[index];
if (!camera.image_id || !camera.component_key ||
!camera_components.emplace(camera.image_id, camera.component_key).second)
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
for (double value : camera.pose_cw.translation_cw)
if (!std::isfinite(value)) return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
if (!valid_rotation(camera.pose_cw.rotation_cw))
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
}
for (size_t index = 0; index < snapshot.landmark_count; ++index) {
const auto &landmark = snapshot.landmarks[index];
if (!landmark.landmark_id || !landmark.track_id ||
landmark.observation_count == 0 || !finite_point(landmark.point) ||
!std::isfinite(landmark.reprojection_rmse_px) ||
!landmarks.emplace(landmark.landmark_id, &landmark).second)
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
}
for (size_t index = 0; index < input.source_observation_count; ++index) {
const auto &observation = input.source_observations[index];
if (!observation.image_id || !observation.track_id ||
!observation.feature_set_id || !std::isfinite(observation.x) ||
!std::isfinite(observation.y) ||
!sources.emplace(ObservationKey{observation.feature_set_id,
observation.feature_index},
&observation)
.second)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
}
for (size_t index = 0; index < snapshot.observation_count; ++index) {
const auto &observation = snapshot.observations[index];
const auto landmark = landmarks.find(observation.landmark_id);
const auto camera = camera_components.find(observation.image_id);
const auto source = sources.find(
{observation.feature_set_id, observation.feature_index});
if (landmark == landmarks.end() || camera == camera_components.end() ||
observation.track_id != landmark->second->track_id ||
camera->second != landmark->second->component_key ||
observation.position_in_track >= landmark->second->observation_count ||
!positions.emplace(observation.track_id,
observation.position_in_track)
.second)
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
if (source == sources.end() ||
source->second->image_id != observation.image_id ||
source->second->track_id != observation.track_id)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
++observed[observation.landmark_id];
}
for (const auto &entry : landmarks)
if (observed[entry.first] != entry.second->observation_count)
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
return LARDON3D_DENSE_MVS_OK;
}
Lardon3DDenseMvsStatus validate_sources(const Lardon3DDenseMvsInput &input) {
const auto &snapshot = *input.snapshot;
if (!input.source_observations ||
input.source_observation_count != snapshot.observation_count ||
input.source_image_count != snapshot.camera_count)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
std::set<uint64_t> camera_ids;
for (size_t index = 0; index < snapshot.camera_count; ++index)
camera_ids.insert(snapshot.cameras[index].image_id);
std::set<uint64_t> source_ids;
for (size_t index = 0; index < input.source_image_count; ++index) {
const auto &image = input.source_images[index];
if (!image.image_id || !image.source_path || !*image.source_path ||
!finite_cal(image.calibration) ||
!bounded_image_allocation(image.calibration.width,
image.calibration.height) ||
!source_ids.insert(image.image_id).second)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
uint32_t encoded_width = 0, encoded_height = 0;
if (!encoded_image_dimensions(image.source_path, &encoded_width,
&encoded_height) ||
!bounded_image_allocation(encoded_width, encoded_height) ||
encoded_width != image.calibration.width ||
encoded_height != image.calibration.height)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
}
if (source_ids != camera_ids) return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
return LARDON3D_DENSE_MVS_OK;
}
Lardon3DDenseMvsStatus export_colmap(const Lardon3DDenseMvsInput *in,
const std::string &directory) {
std::vector<const Lardon3DSparseIncrementalCamera *> cameras;
for (size_t i = 0; i < in->snapshot->camera_count; ++i)
cameras.push_back(in->snapshot->cameras + i);
std::sort(cameras.begin(), cameras.end(), [](const auto *a, const auto *b) {
return a->image_id < b->image_id;
});
if (cameras.size() != in->source_image_count)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
std::vector<const Lardon3DSparseIncrementalLandmark *> landmarks;
for (size_t index = 0; index < in->snapshot->landmark_count; ++index)
landmarks.push_back(in->snapshot->landmarks + index);
std::sort(landmarks.begin(), landmarks.end(), [](const auto *a, const auto *b) {
return a->landmark_id < b->landmark_id;
});
std::map<uint64_t, uint32_t> point_ids;
std::map<ObservationKey, const Lardon3DSparseIncrementalObservation *> source_coordinates;
for (size_t index = 0; index < in->source_observation_count; ++index) {
const auto &observation = in->source_observations[index];
source_coordinates.emplace(
ObservationKey{observation.feature_set_id, observation.feature_index},
&observation);
}
for (size_t index = 0; index < landmarks.size(); ++index)
point_ids.emplace(landmarks[index]->landmark_id, static_cast<uint32_t>(index + 1));
std::map<uint64_t, std::vector<ExportObservation>> image_observations;
for (size_t index = 0; index < in->snapshot->observation_count; ++index) {
const auto *observation = in->snapshot->observations + index;
const auto coordinate = source_coordinates.find(
{observation->feature_set_id, observation->feature_index});
image_observations[observation->image_id].push_back(
{observation, coordinate->second, point_ids.at(observation->landmark_id), 0, 0});
}
for (auto &entry : image_observations)
std::sort(entry.second.begin(), entry.second.end(), [](const auto &a, const auto &b) {
if (a.point_id != b.point_id) return a.point_id < b.point_id;
if (a.snapshot->feature_set_id != b.snapshot->feature_set_id)
return a.snapshot->feature_set_id < b.snapshot->feature_set_id;
return a.snapshot->feature_index < b.snapshot->feature_index;
});
const std::string sparse_directory = directory + "/sparse";
const std::string image_directory = directory + "/images";
if ((mkdir(sparse_directory.c_str(), 0700) != 0 && errno != EEXIST) ||
(mkdir(image_directory.c_str(), 0700) != 0 && errno != EEXIST))
return LARDON3D_DENSE_MVS_IO_ERROR;
std::ofstream camera_file(sparse_directory + "/cameras.txt",
std::ios::out | std::ios::trunc);
std::ofstream image_file(sparse_directory + "/images.txt",
std::ios::out | std::ios::trunc);
std::ofstream point_file(sparse_directory + "/points3D.txt",
std::ios::out | std::ios::trunc);
if (!camera_file || !image_file || !point_file)
return LARDON3D_DENSE_MVS_IO_ERROR;
for (std::ofstream *file : {&camera_file, &image_file, &point_file}) {
file->imbue(std::locale::classic());
*file << std::scientific
<< std::setprecision(std::numeric_limits<double>::max_digits10 - 1);
}
std::map<uint32_t, std::vector<std::pair<uint32_t, size_t>>> tracks;
uint64_t id = 1;
for (const auto *camera : cameras) {
if (id > 1 && cameras[id - 2]->image_id == camera->image_id)
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
const Lardon3DDenseMvsSourceImage *image = nullptr;
for (size_t index = 0; index < in->source_image_count; ++index)
if (in->source_images[index].image_id == camera->image_id)
image = in->source_images + index;
if (!image || !finite_cal(image->calibration))
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
double q[4];
if (!quaternion(camera->pose_cw.rotation_cw, q))
return LARDON3D_DENSE_MVS_INVALID_SNAPSHOT;
const auto &k = image->calibration;
if (!bounded_image_allocation(k.width, k.height))
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
uint32_t encoded_width = 0, encoded_height = 0;
if (!encoded_image_dimensions(image->source_path, &encoded_width,
&encoded_height) ||
!bounded_image_allocation(encoded_width, encoded_height) ||
encoded_width != k.width || encoded_height != k.height)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
cv::Mat source_image;
try {
source_image = cv::imread(image->source_path, cv::IMREAD_COLOR);
} catch (const cv::Exception &error) {
if (error.code == cv::Error::StsNoMem) throw std::bad_alloc();
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
}
if (source_image.empty() || source_image.cols != static_cast<int>(k.width) ||
source_image.rows != static_cast<int>(k.height))
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
const cv::Mat camera_matrix = cv::Mat(cv::Matx33d(
k.fx, 0, k.cx,
0, k.fy, k.cy,
0, 0, 1));
const cv::Mat distortion = cv::Mat(cv::Matx<double, 1, 4>(
k.k1, k.k2, k.p1, k.p2));
cv::Mat undistorted;
try {
cv::undistort(source_image, undistorted, camera_matrix, distortion,
camera_matrix);
} catch (const cv::Exception &error) {
if (error.code == cv::Error::StsNoMem) throw std::bad_alloc();
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
}
const std::string image_name = "image_" + std::to_string(id) + ".png";
try {
if (!cv::imwrite(image_directory + "/" + image_name, undistorted))
return LARDON3D_DENSE_MVS_IO_ERROR;
} catch (const cv::Exception &error) {
if (error.code == cv::Error::StsNoMem) throw std::bad_alloc();
return LARDON3D_DENSE_MVS_IO_ERROR;
}
auto &observations = image_observations[camera->image_id];
std::vector<cv::Point2d> distorted_points;
distorted_points.reserve(observations.size());
for (const auto &observation : observations)
distorted_points.emplace_back(observation.source->x, observation.source->y);
std::vector<cv::Point2d> undistorted_points;
if (!distorted_points.empty()) {
try {
cv::undistortPoints(distorted_points, undistorted_points, camera_matrix,
distortion, cv::noArray(), camera_matrix);
} catch (const cv::Exception &error) {
if (error.code == cv::Error::StsNoMem) throw std::bad_alloc();
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
}
}
for (size_t index = 0; index < observations.size(); ++index) {
observations[index].x = undistorted_points[index].x;
observations[index].y = undistorted_points[index].y;
if (!std::isfinite(observations[index].x) ||
!std::isfinite(observations[index].y))
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
}
/* InterfaceCOLMAP subtracts 0.5 from COLMAP's principal point. */
camera_file << id << " PINHOLE " << k.width << ' ' << k.height << ' '
<< k.fx << ' ' << k.fy << ' ' << k.cx + 0.5 << ' '
<< k.cy + 0.5 << '\n';
image_file << id << ' ' << q[0] << ' ' << q[1] << ' ' << q[2] << ' ' << q[3]
<< ' ' << camera->pose_cw.translation_cw[0] << ' '
<< camera->pose_cw.translation_cw[1] << ' '
<< camera->pose_cw.translation_cw[2] << ' ' << id << ' '
<< image_name << '\n';
for (size_t index = 0; index < observations.size(); ++index) {
const auto &observation = observations[index];
image_file << observation.x << ' ' << observation.y << ' '
<< observation.point_id << ' ';
tracks[observation.point_id].emplace_back(static_cast<uint32_t>(id), index);
}
image_file << '\n';
if (!camera_file || !image_file) return LARDON3D_DENSE_MVS_IO_ERROR;
++id;
}
for (const auto *landmark : landmarks) {
const uint32_t point_id = point_ids.at(landmark->landmark_id);
point_file << point_id << ' ' << landmark->point.x << ' ' << landmark->point.y
<< ' ' << landmark->point.z << " 0 0 0 "
<< landmark->reprojection_rmse_px;
const auto track = tracks.find(point_id);
if (track != tracks.end())
for (const auto &member : track->second)
point_file << ' ' << member.first << ' ' << member.second;
point_file << '\n';
if (!point_file) return LARDON3D_DENSE_MVS_IO_ERROR;
}
if (!finalize(camera_file) || !finalize(image_file) || !finalize(point_file))
return LARDON3D_DENSE_MVS_IO_ERROR;
return LARDON3D_DENSE_MVS_OK;
}
bool bounded_line(std::ifstream &file, std::string &line, bool *had_newline,
size_t *raw_size) {
line.clear();
*raw_size = 0;
char value = 0;
while (file.get(value)) {
if (*raw_size == SIZE_MAX) return false;
++*raw_size;
if (value == '\n') {
*had_newline = true;
if (!line.empty() && line.back() == '\r') line.pop_back();
return line.find('\r') == std::string::npos;
}
if (line.size() == kMaxPlyLine) return false;
line.push_back(value);
}
*had_newline = false;
return file.eof() && !line.empty() && line.find('\r') == std::string::npos;
}
bool bounded_header_line(std::ifstream &file, std::string &line, size_t &total) {
bool had_newline = false;
size_t raw_size = 0;
if (!bounded_line(file, line, &had_newline, &raw_size)) return false;
if (total > kMaxPlyHeader || raw_size > kMaxPlyHeader - total) return false;
total += raw_size;
return true;
}
bool ply_data_line(std::ifstream &file, std::string &line) {
bool had_newline = false;
size_t raw_size = 0;
return bounded_line(file, line, &had_newline, &raw_size);
}
enum class PlyScalar {
I8, U8, I16, U16, I32, U32, F32, F64
};
struct PlyProperty {
std::string name;
PlyScalar scalar{};
PlyScalar count_scalar{};
size_t scalar_size = 0;
size_t count_size = 0;
bool list = false;
};
bool ply_integer(PlyScalar scalar) {
return scalar != PlyScalar::F32 && scalar != PlyScalar::F64;
}
bool ply_scalar(const std::string &name, PlyScalar *scalar, size_t *size) {
if (name == "char" || name == "int8") {
*scalar = PlyScalar::I8;
*size = 1;
} else if (name == "uchar" || name == "uint8") {
*scalar = PlyScalar::U8;
*size = 1;
} else if (name == "short" || name == "int16") {
*scalar = PlyScalar::I16;
*size = 2;
} else if (name == "ushort" || name == "uint16") {
*scalar = PlyScalar::U16;
*size = 2;
} else if (name == "int" || name == "int32") {
*scalar = PlyScalar::I32;
*size = 4;
} else if (name == "uint" || name == "uint32") {
*scalar = PlyScalar::U32;
*size = 4;
} else if (name == "float" || name == "float32") {
*scalar = PlyScalar::F32;
*size = 4;
} else if (name == "double" || name == "float64") {
*scalar = PlyScalar::F64;
*size = 8;
} else {
return false;
}
return true;
}
bool read_little_endian(std::ifstream &file, PlyScalar scalar, double *value) {
size_t size = 0;
PlyScalar ignored{};
const char *name = scalar == PlyScalar::I8 ? "int8" :
scalar == PlyScalar::U8 ? "uint8" :
scalar == PlyScalar::I16 ? "int16" :
scalar == PlyScalar::U16 ? "uint16" :
scalar == PlyScalar::I32 ? "int32" :
scalar == PlyScalar::U32 ? "uint32" :
scalar == PlyScalar::F32 ? "float32" : "float64";
if (!ply_scalar(name, &ignored, &size)) return false;
unsigned char bytes[8]{};
if (!file.read(reinterpret_cast<char *>(bytes), static_cast<std::streamsize>(size)))
return false;
uint64_t bits = 0;
for (size_t index = 0; index < size; ++index)
bits |= static_cast<uint64_t>(bytes[index]) << (index * 8U);
switch (scalar) {
case PlyScalar::I8:
*value = static_cast<int8_t>(bytes[0]);
break;
case PlyScalar::U8:
*value = bytes[0];
break;
case PlyScalar::I16:
*value = static_cast<int16_t>(static_cast<uint16_t>(bits));
break;
case PlyScalar::U16:
*value = static_cast<uint16_t>(bits);
break;
case PlyScalar::I32:
*value = static_cast<int32_t>(static_cast<uint32_t>(bits));
break;
case PlyScalar::U32:
*value = static_cast<uint32_t>(bits);
break;
case PlyScalar::F32: {
const uint32_t raw = static_cast<uint32_t>(bits);
float decoded = 0;
std::memcpy(&decoded, &raw, sizeof decoded);
*value = decoded;
break;
}
case PlyScalar::F64: {
double decoded = 0;
std::memcpy(&decoded, &bits, sizeof decoded);
*value = decoded;
break;
}
}
return true;
}
bool ply(const std::string &path, uint64_t *point_count) {
struct stat status {};
if (!point_count || stat(path.c_str(), &status) || !S_ISREG(status.st_mode) ||
status.st_size <= 0) return false;
std::ifstream file(path, std::ios::in | std::ios::binary);
std::string line;
size_t header_size = 0;
if (!bounded_header_line(file, line, header_size) || line != "ply" ||
!bounded_header_line(file, line, header_size)) return false;
const bool ascii = line == "format ascii 1.0";
const bool binary_little_endian = line == "format binary_little_endian 1.0";
if (!ascii && !binary_little_endian) return false;
bool vertex_element = false;
bool header_complete = false;
uint64_t vertices = 0;
std::vector<std::vector<std::string>> properties;
while (bounded_header_line(file, line, header_size)) {
if (line == "end_header") { header_complete = true; break; }
std::istringstream fields(line);
fields.imbue(std::locale::classic());
std::string kind, type, name;
if (!(fields >> kind)) return false;
if (kind == "comment" || kind == "obj_info") continue;
if (kind == "element") {
if (vertex_element || !(fields >> type >> name) || type != "vertex") return false;
char *end = nullptr;
errno = 0;
const unsigned long long parsed = strtoull(name.c_str(), &end, 10);
if (errno || !end || *end || parsed == 0) return false;
vertices = parsed;
vertex_element = true;
continue;
}
if (kind == "property") {
if (!vertex_element || !(fields >> type) || properties.size() >= kMaxPlyProperties)
return false;
if (type == "list") {
std::string count_type, item_type;
if (ascii || !(fields >> count_type >> item_type >> name)) return false;
properties.push_back({type, count_type, item_type, name});
} else {
if (!(fields >> name)) return false;
properties.push_back({type, name});
}
continue;
}
return false;
}
int xi = -1, yi = -1, zi = -1;
std::vector<PlyProperty> decoded_properties;
for (size_t i = 0; i < properties.size(); ++i) {
PlyProperty property;
property.list = properties[i][0] == "list";
property.name = property.list ? properties[i][3] : properties[i][1];
const std::string &item_type = property.list ? properties[i][2] : properties[i][0];
if (!ply_scalar(item_type, &property.scalar, &property.scalar_size)) return false;
if (property.list &&
(!ply_scalar(properties[i][1], &property.count_scalar, &property.count_size) ||
!ply_integer(property.count_scalar)))
return false;
decoded_properties.push_back(property);
int *index = property.name == "x" ? &xi : property.name == "y" ? &yi :
property.name == "z" ? &zi : nullptr;
if (index) {
if (*index >= 0 || property.list ||
(item_type != "float" && item_type != "float32" && item_type != "double" &&
item_type != "float64"))
return false;
*index = static_cast<int>(i);
}
}
if (!header_complete || !vertex_element || xi < 0 || yi < 0 || zi < 0 ||
properties.empty()) return false;
uint64_t remaining = 0;
if (binary_little_endian) {
const std::streampos body_offset = file.tellg();
if (body_offset < 0 || static_cast<uint64_t>(body_offset) >
static_cast<uint64_t>(status.st_size))
return false;
remaining = static_cast<uint64_t>(status.st_size) - static_cast<uint64_t>(body_offset);
uint64_t minimum_vertex_size = 0;
for (const PlyProperty &property : decoded_properties) {
const size_t property_minimum = property.list ? property.count_size : property.scalar_size;
if (property_minimum > UINT64_MAX - minimum_vertex_size) return false;
minimum_vertex_size += property_minimum;
}
if (minimum_vertex_size == 0 || vertices > remaining / minimum_vertex_size) return false;
}
for (uint64_t vertex = 0; vertex < vertices; ++vertex) {
if (ascii) {
if (!ply_data_line(file, line)) return false;
std::istringstream fields(line);
fields.imbue(std::locale::classic());
for (size_t index = 0; index < decoded_properties.size(); ++index) {
double value = 0;
if (!(fields >> value) || !std::isfinite(value))
return false;
}
std::string extra;
if (fields >> extra) return false;
} else {
for (size_t index = 0; index < decoded_properties.size(); ++index) {
const PlyProperty &property = decoded_properties[index];
if (property.list) {
double count_value = 0;
if (property.count_size > remaining ||
!read_little_endian(file, property.count_scalar, &count_value) ||
count_value < 0)
return false;
remaining -= property.count_size;
const uint64_t count = static_cast<uint64_t>(count_value);
if (count > remaining / property.scalar_size) return false;
const uint64_t bytes = count * property.scalar_size;
if (bytes > static_cast<uint64_t>(std::numeric_limits<std::streamoff>::max()) ||
!file.seekg(static_cast<std::streamoff>(bytes), std::ios::cur))
return false;
remaining -= bytes;
continue;
}
double value = 0;
if (property.scalar_size > remaining ||
!read_little_endian(file, property.scalar, &value) ||
((static_cast<int>(index) == xi || static_cast<int>(index) == yi ||
static_cast<int>(index) == zi) && !std::isfinite(value)))
return false;
remaining -= property.scalar_size;
}
}
}
if (binary_little_endian)
return remaining == 0 && file.peek() == std::char_traits<char>::eof() &&
(*point_count = vertices, true);
char trailing;
bool pending_cr = false;
while (file.get(trailing)) {
if (pending_cr) {
if (trailing != '\n') return false;
pending_cr = false;
} else if (trailing == '\r') {
pending_cr = true;
} else if (!std::isspace(static_cast<unsigned char>(trailing))) {
return false;
}
}
if (pending_cr) return false;
*point_count = vertices;
return true;
}
Lardon3DDenseMvsStatus run_impl(const Lardon3DDenseMvsInput *input,
Lardon3DDenseMvsResult *result) {
if (!input || !result || !input->snapshot || !input->source_images ||
!input->source_image_count || !input->staging_directory ||
!input->execution_thread_count || !input->interface_colmap_executable ||
!input->densify_point_cloud_executable)
return LARDON3D_DENSE_MVS_INVALID_ARGUMENT;
if (input->parameters.fusion_mode != 0)
return LARDON3D_DENSE_MVS_INVALID_ARGUMENT;
unsigned char source_identity[32], calibration_binding_identity[32];
unsigned char parameter_fingerprint[32], backend_identity[32];
if (!lardon3d_dense_mvs_parameter_fingerprint(
&input->parameters, parameter_fingerprint))
return LARDON3D_DENSE_MVS_INVALID_ARGUMENT;
if (!lardon3d::dense_mvs_detail::source_image_set_identity(
input->source_images, input->source_image_count, source_identity))
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
if (!lardon3d::dense_mvs_detail::calibration_binding_identity(
input->source_images, input->source_image_count,
calibration_binding_identity))
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
const Lardon3DDenseMvsStatus snapshot_status = validate_snapshot(*input);
if (snapshot_status != LARDON3D_DENSE_MVS_OK) return snapshot_status;
const Lardon3DDenseMvsStatus source_status = validate_sources(*input);
if (source_status != LARDON3D_DENSE_MVS_OK) return source_status;
for (size_t index = 0; index < input->source_image_count; ++index) {
unsigned char actual[32];
const auto &image = input->source_images[index];
if (!sha_regular_file(image.source_path, actual, kMaxSourceFileBytes) ||
std::memcmp(actual, image.immutable_sha256, sizeof actual) != 0)
return LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
}
if (!executable(input->interface_colmap_executable) ||
!executable(input->densify_point_cloud_executable))
return LARDON3D_DENSE_MVS_BACKEND_ERROR;
BackendCapabilities interface_capabilities{};
BackendCapabilities densify_capabilities{};
if (!probe(input->interface_colmap_executable, true, &interface_capabilities) ||
!probe(input->densify_point_cloud_executable, false, &densify_capabilities))
return LARDON3D_DENSE_MVS_BACKEND_ERROR;
Lardon3DDenseMvsBackendManifest manifest{};
uint64_t remaining_backend_hash_bytes = kMaxBackendFileBytes;
if (!sha_regular_file(input->interface_colmap_executable,
manifest.interface_colmap_binary_sha256,
kMaxBackendFileBytes, &remaining_backend_hash_bytes) ||
!sha_regular_file(input->densify_point_cloud_executable,
manifest.densify_point_cloud_binary_sha256,
kMaxBackendFileBytes, &remaining_backend_hash_bytes))
return LARDON3D_DENSE_MVS_BACKEND_ERROR;
std::memcpy(manifest.interface_colmap_version_identity,
interface_capabilities.version_identity, 32);
std::memcpy(manifest.densify_point_cloud_version_identity,
densify_capabilities.version_identity, 32);
if (!lardon3d_dense_mvs_backend_manifest_digest(&manifest, backend_identity))
return LARDON3D_DENSE_MVS_BACKEND_ERROR;
Lardon3DDenseMvsIdentity identity{};
std::memcpy(identity.base_reconstruction_identity,
input->base_reconstruction_identity, 32);
std::memcpy(identity.source_image_set_identity, source_identity, 32);
std::memcpy(identity.calibration_scope_identity,
input->calibration_scope_identity, 32);
std::memcpy(identity.calibration_binding_identity,
calibration_binding_identity, 32);
identity.dense_kind = identity.backend_kind = LARDON3D_DENSE_MVS_KIND_OPENMVS;
identity.dense_version = identity.backend_version = LARDON3D_DENSE_MVS_VERSION;
std::memcpy(identity.backend_binary_sha256, backend_identity, 32);
std::memcpy(identity.parameter_fingerprint, parameter_fingerprint, 32);
unsigned char dense_identity[32];
if (!lardon3d_dense_mvs_identity_digest(&identity, dense_identity))
return LARDON3D_DENSE_MVS_INVALID_ARGUMENT;
const std::string staging(input->staging_directory);
constexpr char workspace_suffix[] = "/lardon3d-mvs-XXXXXX";
constexpr char cloud_suffix[] = "/dense.ply";
if (staging.size() > SIZE_MAX - sizeof workspace_suffix ||
staging.size() + sizeof workspace_suffix - 1 >
SIZE_MAX - sizeof cloud_suffix ||
staging.size() + sizeof workspace_suffix - 1 + sizeof cloud_suffix - 1 >=
sizeof result->point_cloud_path)
return LARDON3D_DENSE_MVS_INVALID_ARGUMENT;
if (mkdir(staging.c_str(), 0700) != 0 && errno != EEXIST)
return LARDON3D_DENSE_MVS_IO_ERROR;
std::vector<char> workspace_template(staging.begin(), staging.end());
workspace_template.insert(workspace_template.end(), workspace_suffix,
workspace_suffix + sizeof workspace_suffix);
char *created = mkdtemp(workspace_template.data());
if (!created) return LARDON3D_DENSE_MVS_IO_ERROR;
const std::string root(created);
const std::string workspace = root + "/colmap";
const std::string scene = root + "/scene.mvs";
const std::string cloud_stem = root + "/dense";
const std::string cloud = cloud_stem + ".ply";
if (mkdir(workspace.c_str(), 0700) != 0)
return LARDON3D_DENSE_MVS_IO_ERROR;
const Lardon3DDenseMvsStatus export_status = export_colmap(input, workspace);
if (export_status != LARDON3D_DENSE_MVS_OK) return export_status;
if (!run({input->interface_colmap_executable, "-i", workspace, "-o", scene,
"--max-threads", std::to_string(input->execution_thread_count)},
root, "interface-colmap.log"))
return LARDON3D_DENSE_MVS_BACKEND_ERROR;
std::vector<std::string> densify_arguments = {
input->densify_point_cloud_executable,
scene,
"-o",
cloud_stem,
"--resolution-level",
std::to_string(input->parameters.resolution_level),
"--min-resolution",
std::to_string(input->parameters.minimum_resolution),
"--number-views",
std::to_string(input->parameters.number_views),
"--fusion-mode",
std::to_string(input->parameters.fusion_mode),
"--max-threads",
std::to_string(input->execution_thread_count),
};
if (densify_capabilities.cuda_option) {
densify_arguments.emplace_back("--cuda-device");
densify_arguments.emplace_back("-2");
}
if (!run(densify_arguments, root, "densify-point-cloud.log"))
return LARDON3D_DENSE_MVS_BACKEND_ERROR;
if (!ply(cloud, &result->point_count)) return LARDON3D_DENSE_MVS_INVALID_OUTPUT;
std::memcpy(result->dense_identity, dense_identity, 32);
std::memcpy(result->parameter_fingerprint, parameter_fingerprint, 32);
std::memcpy(result->base_reconstruction_identity,
input->base_reconstruction_identity, 32);
std::memcpy(result->source_image_set_identity, source_identity, 32);
std::memcpy(result->backend_implementation_sha256, backend_identity, 32);
const int copied = std::snprintf(result->point_cloud_path,
sizeof result->point_cloud_path, "%s", cloud.c_str());
if (copied < 0 || static_cast<size_t>(copied) >= sizeof result->point_cloud_path)
return LARDON3D_DENSE_MVS_INVALID_ARGUMENT;
return LARDON3D_DENSE_MVS_OK;
}
}
extern "C" Lardon3DDenseMvsStatus lardon3d_dense_mvs_run(
const Lardon3DDenseMvsInput *input, Lardon3DDenseMvsResult *result) {
if (!result) return LARDON3D_DENSE_MVS_INVALID_ARGUMENT;
Lardon3DDenseMvsResult candidate{};
Lardon3DDenseMvsStatus status;
try {
status = run_impl(input, &candidate);
} catch (const std::bad_alloc &) {
status = LARDON3D_DENSE_MVS_OUT_OF_MEMORY;
} catch (const cv::Exception &error) {
status = error.code == cv::Error::StsNoMem
? LARDON3D_DENSE_MVS_OUT_OF_MEMORY
: LARDON3D_DENSE_MVS_INVALID_SOURCE_IMAGE;
} catch (...) {
status = LARDON3D_DENSE_MVS_IO_ERROR;
}
if (status == LARDON3D_DENSE_MVS_OK) {
candidate.status = status;
*result = candidate;
} else {
std::memset(result, 0, sizeof *result);
result->status = status;
}
return status;
}
extern "C" void lardon3d_dense_mvs_result_destroy(Lardon3DDenseMvsResult *result) {
if (result) std::memset(result, 0, sizeof *result);
}
Reference in a new issue View git blame Copy permalink