speckle.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/types.hpp"
 
#include <Eigen/Core>
#include <pcl/PolygonMesh.h>
 
#include <nlohmann/json.hpp>
 
#include <array>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace reusex::io {
struct ExportScene;
}
 
namespace reusex::io::speckle {
 
// --- Speckle Object Model ---

struct Base {
  std::string speckle_type = "Base";
  std::string applicationId;
  std::string name;
  std::map<std::string, nlohmann::json> properties;

  std::vector<std::shared_ptr<Base>> elements;
 
  virtual ~Base() = default;
};

struct Point : Base {
  double x = 0, y = 0, z = 0;
  std::string units = "m";
 
  Point() { speckle_type = "Objects.Geometry.Point"; }
  Point(double x, double y, double z) : x(x), y(y), z(z) {
    speckle_type = "Objects.Geometry.Point";
  }
};

struct Line : Base {
  Point start, end;
  std::string units = "m";
 
  Line() { speckle_type = "Objects.Geometry.Line"; }
};

struct Mesh : Base {
  std::vector<double> vertices; 
  std::vector<int> faces;       
  std::vector<int> colors;      
  std::string units = "m";
 
  Mesh() { speckle_type = "Objects.Geometry.Mesh"; }
};

struct Pointcloud : Base {
  std::vector<double> points; 
  std::vector<int> colors;    
  std::vector<double> sizes;  
  std::string units = "m";
 
  Pointcloud() { speckle_type = "Objects.Geometry.Pointcloud"; }
};

struct InstanceDefinitionProxy : Base {
  std::string definitionAppId;
  int maxDepth = 0;
  std::string units = "m";
  std::vector<std::string> objects;
 
  InstanceDefinitionProxy() {
    speckle_type = "Speckle.Core.Models.Instances.InstanceDefinitionProxy";
  }
};

struct InstanceProxy : Base {
  std::string definitionId;
  std::array<double, 16> transform{1, 0, 0, 0, 0, 1, 0, 0,
                                   0, 0, 1, 0, 0, 0, 0, 1};
  int maxDepth = 0;
  std::string units = "m";
 
  InstanceProxy() {
    speckle_type = "Speckle.Core.Models.Instances.InstanceProxy";
  }
};

struct Collection : Base {
  std::string collectionType;
  int version = 0;
  bool embed_elements = false;
  std::vector<std::shared_ptr<InstanceDefinitionProxy>>
      instanceDefinitionProxies;
 
  Collection() {
    speckle_type = "Speckle.Core.Models.Collections.Collection";
  }
};
 
// --- Client ---

class SpeckleClient {
    public:
  SpeckleClient(std::string server_url, std::string project_id,
                std::string token = "");

  std::string send(const Base &root);

  std::string commit(const std::string &object_id,
                     const std::string &branch = "main",
                     const std::string &message = "ReUseX upload");

  std::string upload(const Base &root, const std::string &branch = "main",
                     const std::string &message = "ReUseX upload");

  void set_max_batch_size(std::size_t bytes);
 
    private:
  void ensure_branch(const std::string &branch);
 
  std::string server_url_;
  std::string project_id_;
  std::string token_;
  std::size_t max_batch_bytes_ = 25 * 1024 * 1024; // 25 MB
};
 
// --- Conversion Helpers ---

Pointcloud to_speckle(CloudConstPtr cloud);

Mesh to_speckle(const pcl::PolygonMesh &mesh);

Mesh to_speckle(const Eigen::MatrixXd &vertices, const Eigen::MatrixXi &faces);
 
// --- Scene Export ---

struct SpeckleModel {
  std::string model_name;     
  std::shared_ptr<Base> root; 
};

struct ExportConfig {
  std::string project_id;
  std::string image_url_base = "https://minio.chrk.site/files/reusex";
};

auto export_to_speckle(const ExportScene &scene, const ExportConfig &cfg)
    -> std::vector<SpeckleModel>;
 
} // namespace reusex::io::speckle