Line3D.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <Eigen/Core>
#include <Eigen/Geometry>
#include <limits>
 
#include "open3d/geometry/BoundingVolume.h"
#include "open3d/geometry/Geometry.h"
#include "open3d/utility/Optional.h"
 
#pragma once
 
namespace open3d {
namespace geometry {

class Line3D : protected Eigen::ParametrizedLine<double, 3> {
public:
    static Line3D Through(const Eigen::Vector3d& p0,
                          const Eigen::Vector3d& p1) {
        return {p0, (p1 - p0).normalized()};
    }

    enum class LineType {
        Line = 0,

        Ray = 1,

        Segment = 2,
    };

    Line3D(const Eigen::Vector3d& origin, const Eigen::Vector3d& direction);
 
    virtual ~Line3D() = default;

    LineType GetLineType() const { return line_type_; }

    const Eigen::Vector3d& Origin() const { return m_origin; }

    const Eigen::Vector3d& Direction() const { return m_direction; }

    virtual double Length() const {
        return std::numeric_limits<double>::infinity();
    }

    virtual void Transform(const Eigen::Transform<double, 3, Eigen::Affine>& t);

    const Eigen::ParametrizedLine<double, 3>& Line() const { return *this; }

    virtual utility::optional<double> IntersectionParameter(
            const Eigen::Hyperplane<double, 3>& plane) const;

    double ProjectionParameter(const Eigen::Vector3d& point) const;

    virtual Eigen::Vector3d Projection(const Eigen::Vector3d& point) const;

    virtual utility::optional<double> SlabAABB(
            const AxisAlignedBoundingBox& box) const;

    virtual utility::optional<double> ExactAABB(
            const AxisAlignedBoundingBox& box) const;

    std::pair<double, double> ClosestParameters(const Line3D& other) const;

    std::pair<Eigen::Vector3d, Eigen::Vector3d> ClosestPoints(
            const Line3D& other) const;

    double DistanceTo(const Line3D& other) const;

    virtual double ClampParameter(double parameter) const { return parameter; }

    virtual bool IsParameterValid(double parameter) const { return true; }
 
protected:
    Line3D(const Eigen::Vector3d& origin,
           const Eigen::Vector3d& direction,
           LineType type);

    std::pair<double, double> SlabAABBBase(
            const AxisAlignedBoundingBox& box) const;
 
private:
    const LineType line_type_ = LineType::Line;
 
    // Pre-calculated inverse values for the line's direction used to
    // accelerate the slab method
    double x_inv_;
    double y_inv_;
    double z_inv_;
};

class Ray3D : public Line3D {
public:
    static Ray3D Through(const Eigen::Vector3d& p0, const Eigen::Vector3d& p1) {
        return {p0, (p1 - p0).normalized()};
    }

    Ray3D(const Eigen::Vector3d& origin, const Eigen::Vector3d& direction);

    double Length() const override {
        return std::numeric_limits<double>::infinity();
    }

    utility::optional<double> IntersectionParameter(
            const Eigen::Hyperplane<double, 3>& plane) const override;

    utility::optional<double> SlabAABB(
            const AxisAlignedBoundingBox& box) const override;

    double ClampParameter(double parameter) const override {
        return std::max(parameter, 0.);
    }

    bool IsParameterValid(double parameter) const override {
        return parameter >= 0;
    }
};

class Segment3D : public Line3D {
public:
    static Segment3D Through(const Eigen::Vector3d& p0,
                             const Eigen::Vector3d& p1) {
        return {p0, p1};
    }

    Segment3D(const Eigen::Vector3d& start_point,
              const Eigen::Vector3d& end_point);

    explicit Segment3D(const std::pair<Eigen::Vector3d, Eigen::Vector3d>& pair);

    double Length() const override { return length_; }

    Eigen::Vector3d MidPoint() const { return 0.5 * (origin() + end_point_); }

    const Eigen::Vector3d& EndPoint() const { return end_point_; }

    void Transform(
            const Eigen::Transform<double, 3, Eigen::Affine>& t) override;

    AxisAlignedBoundingBox GetBoundingBox() const;

    utility::optional<double> IntersectionParameter(
            const Eigen::Hyperplane<double, 3>& plane) const override;

    utility::optional<double> SlabAABB(
            const AxisAlignedBoundingBox& box) const override;

    utility::optional<double> ExactAABB(
            const AxisAlignedBoundingBox& box) const override;

    double ClampParameter(double parameter) const override {
        return std::max(std::min(parameter, length_), 0.);
    }

    bool IsParameterValid(double parameter) const override {
        return parameter >= 0 && parameter <= length_;
    }
 
private:
    Eigen::Vector3d end_point_;
    double length_;
};
 
}  // namespace geometry
}  // namespace open3d