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 <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::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 Collection : Base {
    std::string name;
    std::string collectionType = "Container";
 
    Collection() { speckle_type = "Speckle.Core.Models.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;       
};

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