gsParametrization.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsLinearAlgebra.h>
#include <gsIO/gsOptionList.h>
#include <gsUtils/gsMesh/gsHalfEdgeMesh.h>

namespace gismo
{
template<class T>
class gsParametrization
{
public:
    typedef gsPoint<2, T> Point2D;

    // if we use std::vector with static Eigen classes, the second template parameter is needed
    typedef std::vector<Point2D, typename Point2D::aalloc> VectorType;

    typedef memory::shared_ptr<gsParametrization<T> > uPtr;

protected:
    const gsHalfEdgeMesh<T> m_mesh; 
    VectorType m_parameterPoints;   
    gsOptionList m_options;

public:

    explicit gsParametrization(const gsMesh<T> &mesh, const gsOptionList & list = defaultOptions());

    virtual ~gsParametrization() {} // Prevent -Wdelete-non-virtual-dtor warning.

    static gsOptionList defaultOptions();

    virtual void compute();

    gsMatrix<T> createUVmatrix();

    gsMatrix<T> createXYZmatrix();

    virtual gsMesh<T> createFlatMesh() const;

    void writeTexturedMesh(std::string filename) const;

    virtual void restrictMatrices(gsMatrix<T>& , const gsMatrix<T>&,
                                  real_t = 0, real_t = 1) const
    {}

    gsOptionList& options() { return m_options; }

    gsParametrization<T>& setOptions(const gsOptionList& list);

protected:

    class LocalNeighbourhood
    {

    public:
        LocalNeighbourhood(const gsHalfEdgeMesh<T> &meshInfo,
                           const size_t vertexIndex,
                           const bool innerVertex = 1);

        size_t getVertexIndex() const;

        size_t getNumberOfNeighbours() const;

        const std::list<size_t> getVertexIndicesOfNeighbours() const;

        const std::list<T> &getAngles() const;

        T getInnerAngle() const;

        std::list<T> getNeighbourDistances() const;

    private:
        size_t m_vertexIndex; 
        typename gsHalfEdgeMesh<T>::Chain m_neighbours; 
        std::list<T> m_angles; 
        std::list<T> m_neighbourDistances; 
    };

    class LocalParametrization
    {

    public:
        LocalParametrization(const gsHalfEdgeMesh<T> &meshInfo,
                             const LocalNeighbourhood &localNeighbourhood,
                             const size_t parametrizationMethod = 2);

        const std::vector<T> &getLambdas() const;

    private:
        void calculateLambdas(const size_t N, VectorType& points);

        size_t m_vertexIndex; 
        std::vector<T> m_lambdas; 

    };

    class Neighbourhood
    {

    public:
        //Neighbourhood() { }

        explicit Neighbourhood(const gsHalfEdgeMesh<T> &meshInfo,
                               const size_t parametrizationMethod = 2);

        const std::vector<T> &getLambdas(const size_t i) const;

        const std::vector<index_t>
        getBoundaryCorners(const size_t method, const T range = 0.1, const size_t number = 4) const;

        static const Point2D findPointOnBoundary(T w, size_t index);

    private:
        std::vector<T> midpoints(const size_t numberOfCorners, const T length) const;
        void searchAreas(const T range,
                         std::vector<std::pair<T, size_t> > &sortedAngles,
                         std::vector<index_t> &corners) const;
        void takeCornersWithSmallestAngles(size_t number,
                                           std::vector<std::pair<T, size_t> > &sortedAngles,
                                           std::vector<index_t> &corners) const;

    protected:
        const gsHalfEdgeMesh<T> & m_basicInfos;
        std::vector<LocalParametrization> m_localParametrizations;
        std::vector<LocalNeighbourhood> m_localBoundaryNeighbourhoods;
    };


protected:
    const Point2D &getParameterPoint(size_t vertexIndex) const;

    void constructAndSolveEquationSystem(const Neighbourhood &neighbourhood, const size_t n, const size_t N);

    std::vector<size_t> indices(const gsMatrix<T>& vertices) const
    {
        std::vector<size_t> result;
        GISMO_ASSERT(vertices.rows() == 3, "three rows expected in vertices");
        for(index_t c=0; c<vertices.cols(); c++)
        {
            result.push_back(m_mesh.findVertex(vertices(0, c), vertices(1, c), vertices(2, c), true));
        }
        return result;
    }

    void calculate(const size_t boundaryMethod,
                   const size_t paraMethod,
                   const std::vector<index_t> &cornersInput,
                   const T rangeInput,
                   const size_t numberInput);

    T findLengthOfPositionPart(const size_t position,
                                    const size_t numberOfPositions,
                                    const std::vector<index_t> &bounds,
                                    const std::vector<T> &lengths);

    bool rangeCheck(const std::vector<index_t> &corners, const size_t minimum, const size_t maximum);

public:

    const gsHalfEdgeMesh<T> & mesh() const {return m_mesh;}

    const VectorType & pointParameters() const
    {
        return m_parameterPoints;
    }

}; // class gsParametrization

} // namespace gismo

#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsParametrization.hpp)
#endif