CurveLoop.h

//===========================================================================
// GoTools - SINTEF Geometry Tools version 1.1
//
// GoTools module: CORE
//
// Copyright (C) 2000-2007 SINTEF ICT, Applied Mathematics, Norway.
//
// This program is free software; you can redistribute it and/or          
// modify it under the terms of the GNU General Public License            
// as published by the Free Software Foundation version 2 of the License. 
//
// This program is distributed in the hope that it will be useful,        
// but WITHOUT ANY WARRANTY; without even the implied warranty of         
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          
// GNU General Public License for more details.                           
//
// You should have received a copy of the GNU General Public License      
// along with this program; if not, write to the Free Software            
// Foundation, Inc.,                                                      
// 59 Temple Place - Suite 330,                                           
// Boston, MA  02111-1307, USA.                                           
//
// Contact information: E-mail: tor.dokken@sintef.no                      
// SINTEF ICT, Department of Applied Mathematics,                         
// P.O. Box 124 Blindern,                                                 
// 0314 Oslo, Norway.                                                     
//
// Other licenses are also available for this software, notably licenses
// for:
// - Building commercial software.                                        
// - Building software whose source code you wish to keep private.        
//===========================================================================
#ifndef _GOCURVELOOP_H
#define _GOCURVELOOP_H

#include <boost/smart_ptr.hpp>
#include <vector>
#include "ParamCurve.h"


namespace Go
{

class CurveLoop
{
public:
    CurveLoop();

    CurveLoop(const std::vector< boost::shared_ptr<ParamCurve> >& curves,
              double space_epsilon);

    virtual ~CurveLoop();

    void swap(CurveLoop& other);
    
    void setCurves(const std::vector< boost::shared_ptr<ParamCurve> >& curves);

    void turnOrientation();

    void setSpaceEpsilon(const double space_epsilon);

    double getSpaceEpsilon() const;

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

    std::vector< boost::shared_ptr<ParamCurve> >::const_iterator begin() const
    { return curves_.begin(); }
    
    std::vector< boost::shared_ptr<ParamCurve> >::const_iterator end() const
    { return curves_.end(); }

    std::vector< boost::shared_ptr<ParamCurve> >::iterator begin()
    { return curves_.begin(); }

    std::vector< boost::shared_ptr<ParamCurve> >::iterator end()
    { return curves_.end(); }

    boost::shared_ptr<ParamCurve> operator[] (int index) const;

    void closestPoint(const Point& pt, int& clo_ind, double& clo_par, 
                      Point& clo_pt, double& clo_dist) const;

    void closestParPoint(const Point& pt, int& clo_ind, double& clo_par, 
                         Point& clo_pt, double& clo_dist) const;

private:
    std::vector< boost::shared_ptr<ParamCurve> > curves_;
    double space_epsilon_;
};




//===========================================================================
template <class PtrToCurveType>
inline double computeLoopGap(const std::vector< PtrToCurveType >& curves)
//===========================================================================
{

    // Here, we should check that the given curves indeed are forming a
    // loop, so every endpoint is within space_epsilon of the start of the
    // next curve.
    // Also, we make sure that all curves have the same dimension
    // and that the curves are of the same type

    int dim = curves[0]->dimension();
    ClassType type = curves[0]->instanceType();
    int n = curves.size();
    int i;
    for (i = 1; i < n; ++i) {
        if (curves[i]->dimension() != dim) {
            THROW("Curves do not have the same dimension.");
        }
        if (curves[i]->instanceType() != type) {
            THROW("Not all curves are of the same type.");
        }
    }
    Point startp(dim);
    Point endp(dim);
    double maxdist = 0.0;
    double dist;
    for (i = 1; i < n; ++i) {
        curves[i-1]->point(endp, curves[i-1]->endparam());
        curves[i]->point(startp, curves[i]->startparam());
        dist = endp.dist(startp);
        if (dist > maxdist) maxdist = dist;
    }
    curves[n-1]->point(endp, curves[n-1]->endparam());
    curves[0]->point(startp, curves[0]->startparam());
    dist = endp.dist(startp);
    if (dist > maxdist) maxdist = dist;
    return maxdist;
}

} // namespace Go

#endif // _GOCURVELOOP_H

---