CurveOnSurface.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 _GOCURVEONSURFACE_H
#define _GOCURVEONSURFACE_H

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


namespace Go
{


class SplineCurve;

class CurveOnSurface : public ParamCurve
{
public:
    CurveOnSurface();

    CurveOnSurface(boost::shared_ptr<ParamSurface> surf,
                     boost::shared_ptr<ParamCurve> curve,
                     bool preferparameter);
    
    CurveOnSurface(boost::shared_ptr<ParamSurface> surf,
                     boost::shared_ptr<ParamCurve> pcurve,
                     boost::shared_ptr<ParamCurve> spacecurve,
                     bool preferparameter);

    CurveOnSurface(const CurveOnSurface& surface_curve);

    CurveOnSurface& operator= (const CurveOnSurface& other);
    
    virtual ~CurveOnSurface();


    // inherited from Streamable
    virtual void read (std::istream& is);
    virtual void write (std::ostream& os) const;

    // inherited from GeomObject
    // @afr: This one only returns the bounding box of the underlying surface
    virtual BoundingBox boundingBox() const;
    virtual DirectionCone directionCone() const;
    virtual int dimension() const;
    virtual ClassType instanceType() const;
    static ClassType classType()
    { return Class_CurveOnSurface; }
    
    // The function clone() calls the copy constructor,
    // so clone() also makes deep copies of the curves,
    // but not the underlying surface.
// #ifdef _MSC_VER
// #if _MSC_VER < 1300
//     virtual GeomObject* clone() const
//       { return new CurveOnSurface(*this); }
// #else
//     virtual CurveOnSurface* clone() const
//       { return new CurveOnSurface(*this); }
// #endif // _MSC_VER < 1300
// #else
    virtual CurveOnSurface* clone() const
    { return new CurveOnSurface(*this); }
// #endif

    // inherited from ParamCurve
    virtual void point(Point& pt, double tpar) const;

    virtual void point(std::vector<Point>& pts, 
                       double tpar,
                       int derivs, bool from_right = true) const;
    
    // inherited from ParamCurve
    virtual double startparam() const;

    // inherited from ParamCurve
    virtual double endparam() const;

    // inherited from ParamCurve
    virtual void reverseParameterDirection(bool switchparam = false);

    // inherited from ParamCurve
    virtual SplineCurve* geometryCurve();

    // inherited from ParamCurve
    virtual bool isDegenerate(double degenerate_epsilon);


// #if ((_MSC_VER > 0) && (_MSC_VER < 1300))
//     // inherited from ParamCurve
//     virtual ParamCurve* subCurve(double from_par, double to_par,
//                                 double fuzzy = DEFAULT_PARAMETER_EPSILON) const;
// #else
    // inherited from ParamCurve
    virtual CurveOnSurface* subCurve(double from_par, double to_par,
                                       double fuzzy =
                                       DEFAULT_PARAMETER_EPSILON) const;
// #endif

    // inherited from ParamCurve
    virtual void closestPoint(const Point& pt,
                              double         tmin,
                              double         tmax,
                              double&        clo_t,
                              Point&       clo_pt,
                              double&        clo_dist,
                              double const   *seed = 0) const;

    // inherited from ParamCurve.  NB: does not check whether the resulting ParamCurve
    // stays inside parameter domain (or that the space curve stays on surface).
    virtual void appendCurve(ParamCurve* cv, bool reparam=true);

    // inherited from ParamCurve.  NB: does not check whether the resulting ParamCurve
    // stays inside parameter domain (or that the space curve stays on surface).
    virtual void appendCurve(ParamCurve* cv,
                             int continuity, double& dist, bool reparam=true);

    void setUnderlyingSurface(boost::shared_ptr<ParamSurface> surface)
    {surface_ = surface;}

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


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

    boost::shared_ptr<ParamCurve> parameterCurve()
    { return pcurve_; }

    boost::shared_ptr<ParamCurve> spaceCurve()
    { return spacecurve_; }

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

    boost::shared_ptr<const ParamCurve> parameterCurve() const
    { return pcurve_; }

    boost::shared_ptr<const ParamCurve> spaceCurve() const
    { return spacecurve_; }
    
    bool parPref() const
    { return prefer_parameter_; }

    RectDomain containingDomain() const;

private:
    boost::shared_ptr<ParamSurface> surface_;
          // May point to null.
    boost::shared_ptr<ParamCurve> pcurve_;
    // An instance of the curve in the surface. May point to null.
    boost::shared_ptr<ParamCurve> spacecurve_;
    // Which representation to prefer if both exist
    bool prefer_parameter_;
};


} // namespace Go

#endif // _GOCURVEONSURFACE_H

---