GeometryTools.h

Go to the documentation of this file.

//===========================================================================
// 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 _GEOMETRYTOOLS_H
#define _GEOMETRYTOOLS_H

#include "SplineCurve.h"
#include "SplineSurface.h"
#include "LineCloud.h"
#include "Array.h"
#include <boost/smart_ptr.hpp>
#include <vector>



namespace Go
{


    //-----------------------------------------------------------------------
    //
    //  Tool functions in alphabetical order.
    //
    //-----------------------------------------------------------------------


    int analyzePeriodicity(const SplineCurve& cv, double knot_tol = 1e-12);

    int analyzePeriodicity(const SplineSurface& sf, int direction, double knot_tol = 1e-12);

    int analyzePeriodicity(const BsplineBasis& basis,
                           double knot_tol = 1e-12);

    int analyzePeriodicityDerivs(const ParamCurve& cv,
                                 int max_derivs,
                                 double tol = 1e-14);

    int analyzePeriodicityDerivs(const SplineSurface& sf,
                                 int direction,
                                 int max_derivs,
                                 double tol = 1e-14);

    boost::shared_ptr<SplineCurve>
    curveSum(const SplineCurve& crv1, double fac1,
             const SplineCurve& crv2, double fac2,
             double num_tol = 1e-05);

    // The same requirements as in curveSum().
    boost::shared_ptr<SplineSurface>
    surfaceSum(const SplineSurface& sf1, double fac1,
               const SplineSurface& sf2, double fac2,
               double num_tol = 1e-05);

    void estimateSurfaceSize(const SplineSurface& srf, double& length_u, 
                             double& length_v);

    void estimateIsoCurveLength(const SplineSurface& srf, bool dir_u, 
                                double par, double& length);

    bool degenerateToCurve(const SplineSurface& srf, bool dir_u, double tol);

    void makeBdDegenerate(SplineSurface& srf, int bd_idx);   // left, right, bottom, top

    bool checkConstantCoef(SplineCurve& cv, int idx, double val, double max_dist, double tol);

    void setSfBdCoefToConst(SplineSurface& srf, int bd_idx, int idx_d, double val,
                            double deg_tol);

    void findDominant(const SplineSurface& surface,
                      Vector3D& dominant_u, 
                      Vector3D& dominant_v);

    void getGnJoints(const ParamCurve& curve,
                     const std::vector<double>& cont,
                     std::vector<double>& gn_joints);

    void getGnJoints(const CurveLoop& loop,
                     const std::vector<double>& cont,
                     std::vector<std::vector<double> >& gn_joints);

    bool isCoincident(const ParamCurve& cv1, const ParamCurve& cv2, double epsge);

    bool negativeProj(const SplineSurface& surface,
                      const Array<Vector3D, 2>& refvector,
                      const double eps = 0.0);

    boost::shared_ptr<SplineCurve> projectCurve(const SplineCurve& incurve,
                                                const Point& normal,
                                                bool planar);

//     /// Project the input pt onto space defined by leg1 & leg2.
//     /// The projected pt is given as: proj_pt = coef1*leg1 + coef2*leg2.
//     void projectPoint(Point pt, Point leg1, Point leg2,
//                    double& coef1, double& coef2);

    boost::shared_ptr<SplineCurve>
    representSurfaceAsCurve(const SplineSurface& surface,
                            int cv_dir);


    boost::shared_ptr<SplineSurface>
    representCurveAsSurface(const SplineCurve& curve,
                            int cv_dir,
                            const BsplineBasis& other_bas,
                            bool rational);

    std::vector<double> getRotationMatrix(const Point& unit_axis_dir, double alpha);

    void rotateSplineSurf(Point rot_axis, double alpha, SplineSurface& sf);

    void rotateSplineCurve(Point rot_axis, double alpha, SplineCurve& cv);

    void rotateLineCloud(Point rot_axis, double alpha, LineCloud& lc);

    void rotatePoint(Point rot_axis, double alpha, double* space_pt);


    void splitCurveIntoSegments(const SplineCurve& cv,
                                   std::vector<SplineCurve>& seg);


    std::vector<boost::shared_ptr<SplineSurface> > 
    splitInKinks(const SplineSurface& sf,
                 const std::vector<double>& u_kinks,
                 const std::vector<double>& v_kinks);


    void splitSurfaceIntoPatches(const SplineSurface& sf,
                                 std::vector<SplineSurface>& pat);


    void surfaceKinks(const SplineSurface& sf, double max_normal_angle,
                      std::vector<double>& g1_disc_u, 
                      std::vector<double>& g1_disc_v);

    void translateSplineSurf(const Point& trans_vec, SplineSurface& sf);

    void translateSplineCurve(const Point& trans_vec, SplineCurve& cv);

    void translateLineCloud(const Point& trans_vec, LineCloud& lc);

    void
        averageBoundaryCoefs(boost::shared_ptr<SplineSurface>& srf1, int bd1, bool keep_first,
                             boost::shared_ptr<SplineSurface>& srf2, int bd2, bool keep_second,
                             bool found_corner1, Point corner1, bool found_corner2,
                             Point corner2, bool opposite);

    void
    unifyCurveSplineSpace(std::vector<boost::shared_ptr<SplineCurve> >& curves,
                          double tol);

    void
    unifySurfaceSplineSpace(std::vector<boost::
                            shared_ptr<SplineSurface> >& surfaces,
                            double tol, int dir = 0);

    boost::shared_ptr<SplineSurface>
    joinPatches(const std::vector<boost::shared_ptr<SplineSurface> >& patches,
                const SplineSurface& spline_space);

    void insertKnotsEvenly(BsplineBasis& basis, int num_knots);
    void insertKnotsEvenly(BsplineBasis& basis, double tmin, double tmax,
                           int num_knots, double knot_diff_tol = 1e-05);

    double getKnotAtLargestInterval(const BsplineBasis& basis);

    std::pair<double, double>
    getLargestParameterInterval(const BsplineBasis& basis);


} // namespace Go





#endif // _GEOMETRYTOOLS_H

---