instance_evidence.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Povl Filip Sonne-Frederiksen
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
// Evidence for a scanned instance: where it is (centroid), which sensor
// frames see it (photo counts for every survey part in one pass), and which
// 360° panoramas were taken near it (with the equirect pixel it lands on).
//
// Lives in `core` next to `frame_visibility` for the same reason that does:
// the GUI read endpoints (`ruxd_api_lib`) link `reusex_core` only. Core does
// not link `reusex_geometry_common`, so the equirect bearing convention of
// `geometry/EquirectProjection.hpp` is restated here (`equirect_uv`) and
// pinned by a test against the frontend's `bearingToUv`.
 
#include "reusex/core/frame_visibility.hpp"
 
#include <Eigen/Core>
 
#include <cstddef>
#include <cstdint>
#include <map>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace reusex {
class ProjectDB;
}
 
namespace reusex::core {

class CloudMisalignedError : public std::runtime_error {
    public:
  using std::runtime_error::runtime_error;
};
 
struct InstanceCentroid {
  Eigen::Vector3d centroid = Eigen::Vector3d::Zero();
  std::size_t point_count = 0; 
};

std::map<std::uint32_t, InstanceCentroid>
instance_centroids(const ProjectDB &db, std::string_view label_cloud,
                   std::string_view positions_cloud = "cloud");

struct PhotoQuery {
  OcclusionQuery occlusion{};
  std::size_t samples_per_instance = 8;
};

struct InstanceProbe {
  InstanceCentroid centroid;
  std::vector<Eigen::Vector3d> samples;
  [[nodiscard]] VisibilityProbe probe() const {
    return {centroid.centroid, samples};
  }
};

std::map<std::uint32_t, InstanceProbe>
instance_probes(const ProjectDB &db, std::string_view label_cloud,
                std::string_view positions_cloud = "cloud",
                std::size_t samples = PhotoQuery{}.samples_per_instance);

struct PartPhotos {
  std::size_t count = 0;            
  std::optional<int> best_frame_id; 
};

struct InstanceEvidence {
  InstanceCentroid centroid;
  std::vector<FrameVisibility> frames;
  [[nodiscard]] PartPhotos photos() const {
    PartPhotos p;
    p.count = frames.size();
    if (!frames.empty())
      p.best_frame_id = frames.front().frame_id;
    return p;
  }
};

std::map<std::uint32_t, InstanceEvidence>
instance_evidence(const ProjectDB &db, std::string_view label_cloud,
                  const PhotoQuery &query = {},
                  std::string_view positions_cloud = "cloud",
                  const std::atomic<bool> *cancel = nullptr);

std::map<std::uint32_t, PartPhotos>
instance_photos(const ProjectDB &db, std::string_view label_cloud,
                const PhotoQuery &query = {},
                std::string_view positions_cloud = "cloud");

struct PanoramaQuery {
  double max_distance = 15.0;
};

enum class PanoramaHeading {
  resected, 
  levelled, 
};

struct PanoramaSighting {
  int panorama_id = 0;
  int node_id = -1;    
  double distance = 0; 
  double u = 0;        
  double v = 0;        
  PanoramaHeading heading = PanoramaHeading::resected;
};

Eigen::Vector2d equirect_uv(const Eigen::Vector3d &bearing);

std::vector<PanoramaSighting>
panoramas_for_point(const ProjectDB &db, const Eigen::Vector3d &world_point,
                    const PanoramaQuery &query = {});
 
} // namespace reusex::core