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::getNeighborFilter().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
 
}