ParamSurface.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 _GOPARAMSURFACE_H
#define _GOPARAMSURFACE_H

#include "Domain.h"
#include "GeomObject.h"
#include "RectDomain.h"
#include "CurveLoop.h"
#include <vector>


namespace Go
{


class CurveLoop; // forward declaration

class ParamSurface : public GeomObject
{
public:
    virtual ~ParamSurface();

    virtual ParamSurface* clone() const = 0;
    virtual const Domain& parameterDomain() const = 0;

    virtual RectDomain containingDomain() const = 0;


    virtual CurveLoop outerBoundaryLoop(double degenerate_epsilon
                                          = DEFAULT_SPACE_EPSILON) const = 0;

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

    virtual DirectionCone normalCone() const = 0;
    
    virtual DirectionCone tangentCone(bool pardir_is_u) const = 0;

    virtual CompositeBox compositeBox() const;
   
    virtual void point(Point& pt, double upar, double vpar) const = 0;

    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 = 0;

    Point point(double upar, double vpar) const;

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

    virtual void normal(Point& n, double upar, double vpar) const = 0;

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

    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 = 0;

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

    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 = 0;

    void singularity(double& sing_u,
                     double& sing_v, 
                     Point& sing_pt,
                     double& sing_dist,
                     double epsilon,
                     const RectDomain* rd = 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* rd = NULL,
                                      double *seed = 0) const = 0;

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

    virtual void turnOrientation() = 0;

    virtual void reverseParameterDirection(bool direction_is_u) = 0;

    virtual void swapParameterDirection() = 0;


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


} // namespace Go


#endif // _GOPARAMSURFACE_H

---