Geometry3D.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2023 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <Eigen/Core>
#include <Eigen/Geometry>
#include <vector>
 
#include "open3d/geometry/Geometry.h"
#include "open3d/utility/Eigen.h"
 
namespace open3d {
namespace geometry {
 
class AxisAlignedBoundingBox;
class OrientedBoundingBox;
 
class Geometry3D : public Geometry {
public:
    ~Geometry3D() override {}
 
protected:
    Geometry3D(GeometryType type) : Geometry(type, 3) {}
 
public:
    Geometry3D& Clear() override = 0;
    bool IsEmpty() const override = 0;
    virtual Eigen::Vector3d GetMinBound() const = 0;
    virtual Eigen::Vector3d GetMaxBound() const = 0;
    virtual Eigen::Vector3d GetCenter() const = 0;
 
    virtual AxisAlignedBoundingBox GetAxisAlignedBoundingBox() const = 0;
 
    virtual OrientedBoundingBox GetOrientedBoundingBox(
            bool robust = false) const = 0;
 
    virtual OrientedBoundingBox GetMinimalOrientedBoundingBox(
            bool robust = false) const = 0;
 
    virtual Geometry3D& Transform(const Eigen::Matrix4d& transformation) = 0;
 
    virtual Geometry3D& Translate(const Eigen::Vector3d& translation,
                                  bool relative = true) = 0;
    virtual Geometry3D& Scale(const double scale,
                              const Eigen::Vector3d& center) = 0;
 
    virtual Geometry3D& Rotate(const Eigen::Matrix3d& R,
                               const Eigen::Vector3d& center) = 0;
 
    virtual Geometry3D& Rotate(const Eigen::Matrix3d& R);
 
    static Eigen::Matrix3d GetRotationMatrixFromXYZ(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromYZX(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromZXY(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromXZY(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromZYX(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromYXZ(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromAxisAngle(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromQuaternion(
            const Eigen::Vector4d& rotation);
 
protected:
    Eigen::Vector3d ComputeMinBound(
            const std::vector<Eigen::Vector3d>& points) const;
    Eigen::Vector3d ComputeMaxBound(
            const std::vector<Eigen::Vector3d>& points) const;
    Eigen::Vector3d ComputeCenter(
            const std::vector<Eigen::Vector3d>& points) const;
 
    void ResizeAndPaintUniformColor(std::vector<Eigen::Vector3d>& colors,
                                    const size_t size,
                                    const Eigen::Vector3d& color) const;
 
    void TransformPoints(const Eigen::Matrix4d& transformation,
                         std::vector<Eigen::Vector3d>& points) const;
 
    void TransformNormals(const Eigen::Matrix4d& transformation,
                          std::vector<Eigen::Vector3d>& normals) const;
 
    void TransformCovariances(const Eigen::Matrix4d& transformation,
                              std::vector<Eigen::Matrix3d>& covariances) const;
 
    void TranslatePoints(const Eigen::Vector3d& translation,
                         std::vector<Eigen::Vector3d>& points,
                         bool relative) const;
 
    void ScalePoints(const double scale,
                     std::vector<Eigen::Vector3d>& points,
                     const Eigen::Vector3d& center) const;
 
    void RotatePoints(const Eigen::Matrix3d& R,
                      std::vector<Eigen::Vector3d>& points,
                      const Eigen::Vector3d& center) const;
 
    void RotateNormals(const Eigen::Matrix3d& R,
                       std::vector<Eigen::Vector3d>& normals) const;
 
    void RotateCovariances(const Eigen::Matrix3d& R,
                           std::vector<Eigen::Matrix3d>& covariances) const;
};
 
}  // namespace geometry
}  // namespace open3d