linePrimitive.h

 
/*
 Copyright (C) 2021 aniket agarwalla <aniketagarwalla37@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>
#include <Eigen/Core>
 
namespace Ponca
{
 
    template <class DataPoint, class _NFilter, typename T>
    class Line : public T, public Eigen::ParametrizedLine<typename DataPoint::Scalar, DataPoint::Dim>
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
 
    public:
        using EigenBase = Eigen::ParametrizedLine<typename DataPoint::Scalar, DataPoint::Dim>;
 
    protected:
        enum
        {
            check = Base::PROVIDES_PRIMITIVE_BASE, 
            PROVIDES_LINE                          
        };
 
    public:
        PONCA_EXPLICIT_CAST_OPERATORS(Line, line)
 
        
        PONCA_MULTIARCH inline void init()
        {
            Base::init();
            EigenBase::origin().setZero();
            EigenBase::direction().setZero();
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline bool isValid() const
        {
            static const typename EigenBase::VectorType zeros = EigenBase::VectorType::Zero();
            return !(EigenBase::origin().isApprox(zeros) && EigenBase::direction().isApprox(zeros));
        }
 
        PONCA_MULTIARCH inline bool operator==(const Line<DataPoint, NeighborFilter, T>& other) const
        {
            return EigenBase::isApprox(other);
        }
 
        PONCA_MULTIARCH inline bool operator!=(const Line<DataPoint, NeighborFilter, T>& other) const
        {
            return !((*this) == other);
        }
 
        PONCA_MULTIARCH inline void setLine(const VectorType& origin, const VectorType& direction)
        {
            EigenBase* cc = static_cast<EigenBase*>(this);
            *cc           = EigenBase(origin, direction);
        }
 
        PONCA_MULTIARCH inline void changeBasis(const VectorType& newbasis)
        {
            VectorType diff = Base::getNeighborFilter().evalPos() - newbasis;
            Base::m_nFilter.changeNeighborhoodFrame(newbasis);
            Base::init();
            EigenBase::origin() += diff;
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potential() const
        {
            // The potential is the distance from a point to the line
            return EigenBase::squaredDistance(VectorType::Zero());
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potential(const VectorType& _q) const
        {
            // Turn to centered basis
            const VectorType lq = Base::getNeighborFilter().convertToLocalBasis(_q);
            // The potential is the distance from a point to the line
            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)));
        }
 
    protected:
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potentialLocal(const VectorType& _lq) const
        {
            // The potential is the distance from a point to the line
            return EigenBase::squaredDistance(_lq);
        }
    }; // class Line
 
} // namespace Ponca