BoundedUtils.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 _GOBOUNDEDUTILS_H
#define _GOBOUNDEDUTILS_H


#include "BoundedSurface.h"
#include "SplineSurface.h"
#include "CurveOnSurface.h"
#include "LoopUtils.h"

#include <boost/smart_ptr.hpp>

using std::vector;
using boost::shared_ptr;
using Go::SplineSurface;
using Go::BoundedSurface;
using Go::CurveOnSurface;
using Go::Point;
using Go::ParamCurve;

namespace Go {


namespace BoundedUtils {


    std::vector<shared_ptr<CurveOnSurface> >
      intersectWithSurface(CurveOnSurface& curve,
                           BoundedSurface& bounded_surf, double epsge);

    void intersectWithSurfaces(vector<shared_ptr<CurveOnSurface> >& curves1,
                               shared_ptr<BoundedSurface>& bd_sf1,
                               vector<shared_ptr<CurveOnSurface> >& curves2,
                               shared_ptr<BoundedSurface>& bd_sf2,
                               double epsge);


    vector<vector<shared_ptr<CurveOnSurface> > >
      getBoundaryLoops(const BoundedSurface& sf, 
                       vector<shared_ptr<CurveOnSurface> >& part_bnd_cvs);

    vector<shared_ptr<BoundedSurface> >
      trimWithPlane(const shared_ptr<Go::ParamSurface>& surf,
                    Point point, Point normal, double epsge);

    
    vector<shared_ptr<BoundedSurface> >
    trimSurfWithSurf(const shared_ptr<Go::ParamSurface>& sf1,
                     const shared_ptr<Go::ParamSurface>& sf2, double epsge);
    


    BoundedSurface* convertToBoundedSurface(const SplineSurface& surf,
                                              double space_epsilon);




    vector<shared_ptr<BoundedSurface> >
     createTrimmedSurfs(vector<vector<boost::shared_ptr<CurveOnSurface> > >& loops,
                        shared_ptr<SplineSurface>& under_sf, 
                        double epsgeo);

    std::vector<shared_ptr<CurveOnSurface> >
      intersectWithPlane(shared_ptr<SplineSurface>& surf,
                         Point pnt, Point normal, double geom_tol);

    void getIntersectionCurve(shared_ptr<SplineSurface>& sf1,
                              shared_ptr<SplineSurface>& sf2,
                              vector<shared_ptr<CurveOnSurface> >& int_segments1,
                              vector<shared_ptr<CurveOnSurface> >& int_segments2,
                              double epsge);


    void translateBoundedSurf(Point trans_vec, BoundedSurface& bd_sf,
                              double deg_eps);

    // Rotate a given BoundedSurface
    void rotateBoundedSurf(Point rot_axis, double alpha,
                           BoundedSurface& bf_sf, double deg_eps);

} // namespace Go
} // namespace BoundedUtils

#endif // _GOBOUNDEDUTILS_H

---