gsPeriodicStitch.h

Go to the documentation of this file.

#pragma once

#include <gsIO/gsOptionList.h>
#include <gsModeling/gsPeriodicParametrization.h>

namespace gismo
{

template <class T>
class GISMO_EXPORT gsPeriodicStitch : public gsPeriodicParametrization<T>
{

public:

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

protected:

    class Neighbourhood : public gsParametrization<T>::Neighbourhood
    {
    public:
        typedef typename gsParametrization<T>::LocalNeighbourhood LocalNeighbourhood;

        explicit Neighbourhood(const gsHalfEdgeMesh<T> &meshInfo,
                               const std::vector<size_t>& stitchIndices,
                               gsSparseMatrix<int>& corrections,
                               const size_t parametrizationMethod = 2);

    protected:
        std::vector<size_t> computeCorrections(const std::vector<size_t>& stitchIndices,
                                               const LocalNeighbourhood& localNeighbourhood) const;
    };

public:

    explicit gsPeriodicStitch(const gsMesh<T> &mesh,
                              const gsMatrix<T>& verticesV0,
                              const gsMatrix<T>& paramsV0,
                              const gsMatrix<T>& verticesV1,
                              const gsMatrix<T>& paramsV1,
                              const gsMatrix<T>& stitchVertices,
                              const gsOptionList &list = gsParametrization<T>::defaultOptions())
        : gsPeriodicParametrization<T>(mesh, verticesV0, paramsV0, verticesV1, paramsV1, list),
        m_stitchIndices(this->indices(stitchVertices))
    {
        // Note: m_corrections gets filled later.
    }

    void compute();

protected:
    void calculate(const size_t paraMethod);

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

public:

    gsMesh<T> createFlatMesh() const
    {
        gsMesh<T> unfolded = createUnfoldedFlatMesh();
        typename gsPeriodicParametrization<T>::FlatMesh display(unfolded);
        return display.createRestrictedFlatMesh();
    }

protected:
    gsMesh<T> createUnfoldedFlatMesh() const;

    bool isOnStitch(size_t vertexIndex) const
    {
        return (std::find(m_stitchIndices.begin(), m_stitchIndices.end(), vertexIndex)
                != m_stitchIndices.end());
    }

    bool edgeIsInCorrections(index_t beg, index_t end) const
    {
        return ((m_corrections(beg, end) ==  1) ||
                (m_corrections(beg, end) == -1) ||
                (m_corrections(end, beg) ==  1) ||
                (m_corrections(end, beg) == -1));
        // Actually, the first two conditions should be enough.         
    }

protected:

    gsSparseMatrix<int> m_corrections;

    const std::vector<size_t> m_stitchIndices; 
};

} // namespace gismo

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