plane.h

/*
 Copyright (C) 2014 Nicolas Mellado <nmellado0@gmail.com>
 
 This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
#pragma once
 
#include "./defines.h"
#include <Eigen/Geometry>
 
namespace Ponca
{
 
    template <class DataPoint, class _NFilter, typename T>
    class Plane : public T, public Eigen::Hyperplane<typename DataPoint::Scalar, DataPoint::Dim>
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
 
    public:
        using EigenBase = Eigen::Hyperplane<typename DataPoint::Scalar, DataPoint::Dim>;
 
    protected:
        enum
        {
            check = Base::PROVIDES_PRIMITIVE_BASE,
            PROVIDES_PLANE
        };
 
    public:
        PONCA_MULTIARCH inline Plane() : Base(), EigenBase() { init(); }
 
        PONCA_EXPLICIT_CAST_OPERATORS(Plane, compactPlane) //< \fixme To be removed, kept for compatibility only
        PONCA_EXPLICIT_CAST_OPERATORS(Plane, plane)
 
        PONCA_MULTIARCH inline void init()
        {
            Base::init();
            EigenBase::coeffs().setZero();
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline bool isValid() const
        {
            return !EigenBase::coeffs().isApprox(EigenBase::Coefficients::Zero());
        }
 
        PONCA_MULTIARCH inline bool operator==(const Plane<DataPoint, NeighborFilter, T>& other) const
        {
            return EigenBase::isApprox(other);
        }
 
        PONCA_MULTIARCH inline bool operator!=(const Plane<DataPoint, NeighborFilter, T>& other) const
        {
            return !((*this) == other);
        }
 
        /* \brief Init the plane from a direction and a position
           \param _dir Orientation of the plane, does not need to be normalized
           \param _pos Position of the plane
        */
        PONCA_MULTIARCH inline void setPlane(const VectorType& _dir, const VectorType& _pos)
        {
            auto cc = static_cast<EigenBase*>(this);
            *cc     = EigenBase(_dir.normalized(), _pos);
        }
 
        PONCA_MULTIARCH inline void changeBasis(const VectorType& newbasis)
        {
            VectorType diff = Base::getNeighborFilter().evalPos() - newbasis;
            Base::m_nFilter.changeNeighborhoodFrame(newbasis);
            Base::init();
            EigenBase::offset() -= EigenBase::normal().dot(diff);
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potential() const
        {
            return EigenBase::signedDistance(VectorType::Zero());
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potential(const VectorType& _q) const
        {
            // turn to centered basis
            const VectorType lq = Base::getNeighborFilter().convertToLocalBasis(_q);
            return potentialLocal(lq);
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline VectorType project(const VectorType& _q) const
        {
            // Project on the normal vector and add the offset value
            return Base::getNeighborFilter().convertToGlobalBasis(
                EigenBase::projection(Base::getNeighborFilter().convertToLocalBasis(_q)));
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline VectorType primitiveGradient() const
        {
            // Uniform gradient defined only by the orientation of the plane
            return EigenBase::normal();
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline VectorType primitiveGradient(const VectorType& /*_q*/) const
        {
            // Uniform gradient defined only by the orientation of the plane
            return EigenBase::normal();
        }
 
    protected:
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potentialLocal(const VectorType& _lq) const
        {
            // The potential is the distance from the point to the plane
            return EigenBase::signedDistance(_lq);
        }
        PONCA_MULTIARCH [[nodiscard]] inline VectorType primitiveGradientLocal(const VectorType& /*_lq*/) const
        {
            return EigenBase::normal();
        }
    }; // class Plane
 
} // namespace Ponca