SceneGraph.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 Povl Filip Sonne-Frederiksen
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
#include <ReUseX/geometry/Registry.hpp>
#include <ReUseX/types.hpp>
 
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/graphviz.hpp> // write_graphviz, read_graphviz
#include <boost/iterator/filter_iterator.hpp>
#include <boost/property_map/dynamic_property_map.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <fstream>
 
#include <spdlog/spdlog.h>
 
#include <fmt/format.h>
 
#include <set>
#include <string>
#include <vector>
 
#include <Eigen/StdVector>
 
#include <pcl/pcl_base.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
 
#include <range/v3/range/concepts.hpp>
#include <range/v3/view/zip.hpp>
 
enum class NodeType { PointCluster, Plane, Object };
 
struct PointCluster {
  std::vector<int> point_indices;
};
 
struct Plane {
  Eigen::Vector4d coefficients;
  Eigen::Vector3d origin;
};
 
struct Object {
  int label;
};
 
// Generic vertex bundle
struct VertexData {
  Eigen::Vector3d centroid;
  NodeType type;
  std::variant<PointCluster, Plane> data;
};
 
struct EdgeData {
  //
};
 
namespace ReUseX::geometry {
 
// TODO: Fully implement SceneGraph as central scene representation
// category=Geometry estimate=2w
// SceneGraph is partially defined but needs complete implementation to become
// the core data structure for ReUseX spatial reasoning. Required features:
// 1. Hierarchical object relationships (rooms contain walls, walls contain windows)
// 2. Spatial queries (find objects in bounding box, nearest neighbors)
// 3. Attribute management via Registry (materials, labels, metadata)
// 4. Serialization/deserialization to HDF5 format
// 5. Integration with CellComplex for 3D reconstruction pipeline
// 6. Visitor pattern for scene traversal and operations
// Major architectural work but enables modular scene manipulation
class SceneGraph
    : public boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
                                   VertexData, EdgeData>,
      public Registry {
    protected:
  using Graph = boost::adjacency_list<boost::vecS, boost::vecS,
                                      boost::undirectedS, VertexData, EdgeData>;
 
    public:
  using Vertex = boost::graph_traits<Graph>::vertex_descriptor;
 
    protected:
    private:
  CloudConstPtr cloud_ = nullptr;
  std::map<int, std::string> label_map_ = {};
  std::filesystem::path database_path_ = "";
 
    public:
  SceneGraph() = default;
  ~SceneGraph() = default;

  SceneGraph(CloudConstPtr cloud, CloudNConstPtr normals);

  std::vector<CloudConstPtr> extract(int label) const;

  std::vector<CloudConstPtr> ectract(std::string const label_name) const;

  std::set<int> get_labels() const;

  void set_database_path(std::filesystem::path db_path);

  int save(const std::filesystem::path &path) const;

  int export(const std::filesystem::path &path) const;

  static SceneGraph load(const std::filesystem::path &path);
 
    private:
  void patch_segmentation();

  void planar_region_growing();

  void project_labels_from_database();

  void segment_rooms();
};
} // namespace ReUseX::geometry
 
template <> struct fmt::formatter<ReUseX::geometry::SceneGraph> {
  // Parse function (optional)
  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) {
    return ctx.begin();
  }
 
  // Format function
  template <typename FormatContext>
  auto format(const ReUseX::geometry::SceneGraph &obj,
              FormatContext &ctx) const {
    return fmt::format_to(ctx.out(), "SceneGraph");
  }
};
 
// Implementation files