BoundedSurface.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 _GOBOUNDEDSURFACE_H
#define _GOBOUNDEDSURFACE_H

#include "ParamSurface.h"
#include "CurveOnSurface.h"
#include "CurveBoundedDomain.h"

using boost::shared_ptr;
using std::vector;

namespace Go
{


class BoundedSurface : public ParamSurface
{
public:

    BoundedSurface();

    BoundedSurface(shared_ptr<ParamSurface> surf,
                     vector<shared_ptr<CurveOnSurface> > loop,
                     double space_epsilon);


    BoundedSurface(shared_ptr<ParamSurface> surf,
                     vector<vector<shared_ptr<CurveOnSurface> > > loops,
                     double space_epsilon);

    virtual ~BoundedSurface();


    // From Streamable

    // @afr: These should not be called!
    virtual void read (std::istream& is);
    virtual void write (std::ostream& os) const;

    // From GeomObject

    virtual BoundingBox boundingBox() const;

    virtual int dimension() const;

    virtual ClassType instanceType() const;

    static ClassType classType()
    { return Class_BoundedSurface; }

    virtual BoundedSurface* clone() const
    { return new BoundedSurface(*this); }

    // From ParamSurface

    virtual DirectionCone normalCone() const;

    virtual DirectionCone tangentCone(bool pardir_is_u) const;

    virtual const CurveBoundedDomain& parameterDomain() const;

    virtual RectDomain containingDomain() const;


    virtual CurveLoop outerBoundaryLoop(double degenerate_epsilon
                                          = DEFAULT_SPACE_EPSILON) const;

    virtual std::vector<CurveLoop> allBoundaryLoops(double degenerate_epsilon
                                                      = DEFAULT_SPACE_EPSILON) const;

    std::vector<CurveLoop> absolutelyAllBoundaryLoops() const;


    virtual void point(Point& pt, double upar, double vpar) const;


    virtual void point(std::vector<Point>& pts, 
                       double upar, double vpar,
                       int derivs,
                       bool u_from_right = true,
                       bool v_from_right = true,
                       double resolution = 1.0e-12) const;

    virtual void point(std::vector<Point>& pts, 
                       double upar, double vpar,
                       int derivs) const;

    //    using ParamSurface::point;
    virtual void normal(Point& n, double upar, double vpar) const;

    virtual std::vector<boost::shared_ptr<ParamCurve> >
    constParamCurves(double parameter, bool pardir_is_u) const;

    virtual std::vector<boost::shared_ptr<ParamSurface> >
    subSurfaces(double from_upar, double from_vpar,
                double to_upar, double to_vpar,
                double fuzzy = DEFAULT_PARAMETER_EPSILON) const;

    virtual double nextSegmentVal(int dir, double par, bool forward, double tol) const;

    virtual void closestPoint(const Point& pt,
                              double&        clo_u,
                              double&        clo_v, 
                              Point&       clo_pt,
                              double&        clo_dist,
                              double         epsilon,
                              const RectDomain* domain_of_interest = NULL,
                              double   *seed = 0) const;


    virtual void closestBoundaryPoint(const Point& pt,
                                      double&        clo_u,
                                      double&        clo_v, 
                                      Point&       clo_pt,
                                      double&        clo_dist,
                                      double epsilon,
                                      const RectDomain* domain_of_interest = NULL,
                                      double *seed = 0) const;

    virtual void getBoundaryInfo(Point& pt1, Point& pt2, 
                                 double epsilon, SplineCurve*& cv,
                                 SplineCurve*& crosscv, double knot_tol = 1e-05) const;


    void getBoundaryInfo(Point& pt1, Point& pt2,
                         vector<shared_ptr<CurveOnSurface> >& bd_cvs) const;

    virtual void turnOrientation();

    virtual void reverseParameterDirection(bool direction_is_u);

    // If a segment in a loop in boundary_loops_ is not G1, curve is split.
    // Function to be called prior to a topology builder relying on smooth segments.

    void makeBoundaryCurvesG1(double kink);

    virtual void swapParameterDirection();

    void setParameterDomain(double u1, double u2, double v1, double v2);

    // If a boundary loop is represented as a single curve, it is split into 3 parts.
    // Handy tue to current limitations in topology analysator.

    void splitSingleLoops();

    // Access functions

    shared_ptr<ParamSurface> underlyingSurface()
    { return surface_; }

    shared_ptr<const ParamSurface> underlyingSurface() const
    { return surface_; }

    int numberOfLoops()
      { return boundary_loops_.size(); }

    shared_ptr<CurveLoop> loop(int idx)
      { return boundary_loops_[idx]; }

    SplineCurve* constParamCurve(double parameter, bool direction_is_u) const;

    virtual bool isDegenerate(bool& b, bool& r,
                              bool& t, bool& l, double tolerance) const;


private:
    shared_ptr<ParamSurface> surface_;

    vector<shared_ptr<CurveLoop> > boundary_loops_;

    mutable CurveBoundedDomain domain_;

    void orderBoundaryLoops(double degenerate_epsilon = DEFAULT_SPACE_EPSILON);

    // We want the boundary curve to be at least c1. To be called from public function.
    vector<shared_ptr<CurveOnSurface> >
    splitIntoC1Curves(shared_ptr<CurveOnSurface>& curve, double space_epsilon, double kink);

    // Run through the bounday loops, returning the smallest epsgeo.
    double getEpsGeo() const;

};


} // namespace Go


#endif // _GOBOUNDEDSURFACE_H

---