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