gsCurveLoop.h

Go to the documentation of this file.

#pragma once

#include <iostream>

# include <gsCore/gsCurve.h>
# include <gsCore/gsForwardDeclarations.h>

namespace gismo
{

template<class T>
class gsCurveLoop
{

public:
    typedef typename std::vector< gsCurve<T> * >::iterator       iterator;
    typedef typename std::vector< gsCurve<T> * >::const_iterator const_iterator;

    typedef memory::shared_ptr< gsCurveLoop > Ptr;

    typedef memory::unique_ptr< gsCurveLoop > uPtr;

public:
    gsCurveLoop() { }

    explicit gsCurveLoop( gsCurve<T> * cc ) { this->insertCurve(cc); }

    explicit gsCurveLoop(std::vector< gsCurve<T> *> const & curves ) : m_curves(curves) { }

    gsCurveLoop(const std::vector<gsVector3d<T> *> points3D, const std::vector<bool> isConvex, T margin, gsVector3d<T> *outNormal);

    gsCurveLoop(const std::vector<T> angles3D, const std::vector<T> lengths3D, const std::vector<bool> isConvex, T margin, const bool unitSquare=false);

    gsCurveLoop(const gsCurveLoop & other)
    : m_curves( other.m_curves.size() )
    {
        cloneAll( other.m_curves.begin(), other.m_curves.end(),
                  this->m_curves.begin() );
    }

    gsCurveLoop& operator=(const gsCurveLoop & other)
    {
        freeAll( m_curves );
        m_curves.resize( other.m_curves.size() );
        cloneAll( other.m_curves.begin(), other.m_curves.end(),
                  this->m_curves.begin() );
        return *this;
    }

    ~gsCurveLoop()
    {
        freeAll( m_curves );
    }

    //GISMO_CLONE_FUNCTION(gsCurveLoop)
    uPtr clone() const
    {
        return uPtr(new gsCurveLoop(*this));
    }

public:

    bool isInterior ( gsVector<T> const & p, const T& tol);

    bool isOn(gsMatrix<T> const &u,T & paramResult, T tol = 1e-3);

    bool is_ccw();

    void reverse();

    void translate(gsVector<T> const & v);

    void insertCurve( gsCurve<T> * c )
    {
        m_curves.push_back( c ) ;
    }

    typename gsCurve<T>::uPtr singleCurve() const;

    int size() const { return m_curves.size(); }

    std::ostream &print(std::ostream &os) const
    { os << "gsCurveLoop with "<< size() <<" curves :\n";
        for (typename std::vector< gsCurve<T> *>::const_iterator it= m_curves.begin();
             it!= m_curves.end(); it++ )
        {
            os <<"("<<*it<<") "<< **it ;
        };
        return os;
    }

    gsMatrix<T> normal( int const & c, gsMatrix<T> const & u );

    uPtr split(int startIndex, int endIndex,
                           gsCurve<T> * newCurveThisFace, gsCurve<T> * newCurveNewFace);


    // to do: replace return type with std::multimap<int,T>
    std::vector<T> lineIntersections(int const & direction , T const & abscissa);

    std::vector< gsCurve<T> *> & curves() { return m_curves; }

    gsCurve<T> & curve(int i)
    {
        GISMO_ASSERT( i<int(m_curves.size()), "Curve does not exist" );
        return *m_curves[i];
    }

    const gsCurve<T> & curve(int i) const
    {
        GISMO_ASSERT( i<int(m_curves.size()), "Curve does not exist" );
        return *m_curves[i];
    }

    std::vector< gsCurve<T> *> const & curves() const
    { return m_curves; }

    int numCurves() const     { return m_curves.size(); }

    gsMatrix<T> sample(int npoints = 50, int numEndPoints=2) const;

    gsMatrix<T> getBoundingBox();

    static bool approximatingPolygon(const std::vector<T> &signedAngles, const std::vector<T> &lengths, T margin, gsMatrix<T> &result);

    std::vector<T> domainSizes() const;

    static void adjustPolygonToUnitSquare(gsMatrix<T> &corners, T const margin);

    gsMatrix<T> splitCurve(size_t curveId, T lengthRatio=.5);

    gsVector3d<T> initFrom3DPlaneFit(const std::vector<gsVector3d<T> *> points3D, T margin);

    bool initFrom3DByAngles(const std::vector<gsVector3d<T> *> points3D, const std::vector<bool> isConvex, T margin);

    void initFromIsConvex(const std::vector<bool> isConvex, T margin);

    void flip1(T minu = 0, T maxu = 1);

private:
    bool initFrom3DByAngles(const std::vector<T>& angles3D, const std::vector<T>& lengths3D, const std::vector<bool>& isConvex, T margin, bool unitsquare=false);

    bool parameterOf(gsMatrix<T> const &u, int i, T & result, T tol = 1e-5);

    void removeCurves(iterator begin, iterator end);

    void removeCurve(iterator it)
    { removeCurves(it, it+1); }

    // Data members

    std::vector< gsCurve<T> *> m_curves; // CCW

}; // class gsCurveLoop

template<class T>
bool gsCurveLoop<T>::isInterior ( gsVector<T> const &, const T&)
{
    GISMO_NO_IMPLEMENTATION
}

template<class T>
std::ostream &operator<<(std::ostream &os, const gsCurveLoop<T>& b)
{return b.print(os); }


} // namespace gismo

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