LineSet.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <Logging.h>
 
#include <string>
 
#include "cloudViewer/core/Tensor.h"
#include "cloudViewer/core/TensorCheck.h"
#include "cloudViewer/geometry/LineSet.h"
#include "cloudViewer/t/geometry/BoundingVolume.h"
#include "cloudViewer/t/geometry/DrawableGeometry.h"
#include "cloudViewer/t/geometry/Geometry.h"
#include "cloudViewer/t/geometry/TensorMap.h"
 
namespace cloudViewer {
namespace t {
namespace geometry {
 
class TriangleMesh;
 
 
class LineSet : public Geometry, public DrawableGeometry {
public:
    LineSet(const core::Device &device = core::Device("CPU:0"));
 
    LineSet(const core::Tensor &point_positions,
            const core::Tensor &line_indices);
 
    virtual ~LineSet() override {}
 
    LineSet To(const core::Device &device, bool copy = false) const;
 
    LineSet Clone() const { return To(GetDevice(), /*copy=*/true); }
 
    std::string ToString() const;
 
    const TensorMap &GetPointAttr() const { return point_attr_; }
 
    TensorMap &GetPointAttr() { return point_attr_; }
 
    core::Tensor &GetPointAttr(const std::string &key) {
        return point_attr_.at(key);
    }
 
    core::Tensor &GetPointPositions() { return GetPointAttr("positions"); }
 
    const TensorMap &GetLineAttr() const { return line_attr_; }
 
    TensorMap &GetLineAttr() { return line_attr_; }
 
    core::Tensor &GetLineAttr(const std::string &key) {
        return line_attr_.at(key);
    }
 
    core::Tensor &GetLineIndices() { return GetLineAttr("indices"); }
 
    core::Tensor &GetLineColors() { return GetLineAttr("colors"); }
 
    const core::Tensor &GetPointAttr(const std::string &key) const {
        return point_attr_.at(key);
    }
 
    void RemovePointAttr(const std::string &key) { point_attr_.Erase(key); }
 
    const core::Tensor &GetPointPositions() const {
        return GetPointAttr("positions");
    }
 
    const core::Tensor &GetLineAttr(const std::string &key) const {
        return line_attr_.at(key);
    }
 
    void RemoveLineAttr(const std::string &key) { line_attr_.Erase(key); }
 
    const core::Tensor &GetLineIndices() const {
        return GetLineAttr("indices");
    }
 
    const core::Tensor &GetLineColors() const { return GetLineAttr("colors"); }
 
    void SetPointAttr(const std::string &key, const core::Tensor &value) {
        core::AssertTensorDevice(value, device_);
        point_attr_[key] = value;
    }
 
    void SetPointPositions(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetPointAttr("positions", value);
    }
 
    void SetLineAttr(const std::string &key, const core::Tensor &value) {
        core::AssertTensorDevice(value, device_);
        line_attr_[key] = value;
    }
 
    void SetLineIndices(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 2});
        SetLineAttr("indices", value);
    }
 
    void SetLineColors(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetLineAttr("colors", value);
    }
 
    bool HasPointAttr(const std::string &key) const {
        return point_attr_.Contains(key) && GetPointAttr(key).GetLength() > 0 &&
               GetPointAttr(key).GetLength() == GetPointPositions().GetLength();
    }
 
    bool HasPointPositions() const { return HasPointAttr("positions"); }
 
    bool HasLineAttr(const std::string &key) const {
        return line_attr_.Contains(key) && GetLineAttr(key).GetLength() > 0 &&
               GetLineAttr(key).GetLength() == GetLineIndices().GetLength();
    }
 
    bool HasLineIndices() const { return HasLineAttr("indices"); }
 
    bool HasLineColors() const { return HasLineAttr("colors"); }
 
    LineSet &Clear() override {
        point_attr_.clear();
        line_attr_.clear();
        return *this;
    }
 
    bool IsEmpty() const override { return !HasPointPositions(); }
 
    core::Tensor GetMinBound() const { return GetPointPositions().Min({0}); }
 
    core::Tensor GetMaxBound() const { return GetPointPositions().Max({0}); }
 
    core::Tensor GetCenter() const { return GetPointPositions().Mean({0}); }
 
    LineSet &Transform(const core::Tensor &transformation);
 
    LineSet &Translate(const core::Tensor &translation, bool relative = true);
 
    LineSet &Scale(double scale, const core::Tensor &center);
 
    LineSet &Rotate(const core::Tensor &R, const core::Tensor &center);
 
    LineSet &PaintUniformColor(const core::Tensor &color);
 
    core::Device GetDevice() const override { return device_; }
 
    static geometry::LineSet FromLegacy(
            const cloudViewer::geometry::LineSet &lineset_legacy,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    cloudViewer::geometry::LineSet ToLegacy() const;
 
    AxisAlignedBoundingBox GetAxisAlignedBoundingBox() const;
 
    OrientedBoundingBox GetOrientedBoundingBox() const;
 
    TriangleMesh ExtrudeRotation(double angle,
                                 const core::Tensor &axis,
                                 int resolution = 16,
                                 double translation = 0.0,
                                 bool capping = true) const;
 
    TriangleMesh ExtrudeLinear(const core::Tensor &vector,
                               double scale = 1.0,
                               bool capping = true) const;
 
    static LineSet CreateCameraVisualization(int view_width_px,
                                             int view_height_px,
                                             const core::Tensor &intrinsic,
                                             const core::Tensor &extrinsic,
                                             double scale,
                                             const core::Tensor &color = {});
 
protected:
    core::Device device_ = core::Device("CPU:0");
    TensorMap point_attr_;
    TensorMap line_attr_;
};
 
}  // namespace geometry
}  // namespace t
}  // namespace cloudViewer