CoonsPatchGen.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 _GOCOONSPATCHGEN_H
#define _GOCOONSPATCHGEN_H


#include "CurveLoop.h"


namespace Go {



class SplineSurface;
class SplineCurve;
class ParamCurve;



namespace CoonsPatchGen {


    // We introduce some exception classes.

    class UnKnownError{};

    SplineSurface* createCoonsPatch(const CurveLoop& boundary);


    // bd_curves must contain four curves cross_curves must contain
    // four curves (may be 0 curves) bd_curves and cross_curves must
    // be SplineCurves bd_curves and cross_curves must lie in the same
    // dimension and be nonrational bd curves will be reparameterized
    // to have reasonable tangent values at endpoints and
    // corresponding curves will share parameter interval.
    // neighbour_tol - hvor mye en kantkurve kan flyttes

    SplineSurface*
    createCoonsPatch(std::vector<boost::shared_ptr<ParamCurve> >& bd_curves,
                     std::vector<boost::shared_ptr<ParamCurve> >& cross_curves,
                     double epsge, double kink_tol);

    SplineSurface*
    createCoonsPatch(std::vector<boost::shared_ptr<SplineCurve> >& bd_curves,
                     std::vector<boost::shared_ptr<SplineCurve> >&
                     cross_curves);

    // None of the Gordon Surfaces perform manipulation of the cross
    // tangs.

    // @@sbr Include new version which sets up parameters.
    SplineSurface*
    createGordonSurface(std::vector<boost::shared_ptr<SplineCurve> >&
                        mesh_curves,
                        std::vector<double>& params, int& nmb_u_crvs,
                        bool use_param_values);

    SplineSurface*
    createGordonSurface(std::vector<boost::shared_ptr<SplineCurve> >&
                        mesh_curves,
                        std::vector<double>& params, int& nmb_u_crvs,
                        std::vector<boost::shared_ptr<SplineCurve> >&
                        cross_curves,
                        std::vector<int>& cross_index,
                        bool use_param_values = true);

    SplineSurface*
    doCreateSurface(std::vector<boost::shared_ptr<SplineCurve> >& mesh_curves,
                    std::vector<double>& params, int& nmb_u_crvs,
                    std::vector<boost::shared_ptr<SplineCurve> >& cross_curves,
                    std::vector<int>& cross_index);

    SplineSurface* loftSurface(std::vector<boost::shared_ptr<SplineCurve> >::iterator
                               first_curve, int nmb_crvs);

    SplineSurface* loftSurface(std::vector<boost::shared_ptr<SplineCurve> >::iterator
                               first_curve,
                               std::vector<double>::iterator first_param,
                               int nmb_crvs);

    SplineSurface*
      loftSurface(std::vector<boost::shared_ptr<SplineCurve> >::iterator first_curve,
                  std::vector<double>::iterator first_param,
                  int nmb_crvs,
                  std::vector<boost::shared_ptr<SplineCurve> >::iterator first_cross_curve,
                  std::vector<int>& cross_index);

    SplineSurface* tpSurface(const std::vector<boost::shared_ptr<SplineCurve> >& mesh_curves,
                              std::vector<double> params, int nmb_u_crvs,
                              const std::vector<boost::shared_ptr<SplineCurve> >& cross_curves,
                              std::vector<int>& cross_index);

    void splitMeshCurves(std::vector<boost::shared_ptr<SplineCurve> >& mesh_curves,
                         std::vector<double>& params, int& nmb_u_crvs,
                         std::vector<int>& cross_index, double epsgeo);

    void sortMeshCurves(std::vector<boost::shared_ptr<SplineCurve> >& mesh_curves,
                        std::vector<double>& params, int nmb_u_crvs,
                        std::vector<int>& cross_index);


    void getCrossTangs(const std::vector<boost::shared_ptr<SplineCurve> >& curves,
                       std::vector<boost::shared_ptr<SplineCurve> >& mod_cross_curves,
                       double tol1, double tol2);

    void addMissingCrossCurves(const std::vector<boost::shared_ptr<SplineCurve> >& bnd_curves,
                               std::vector<boost::shared_ptr<SplineCurve> >& cross_crvs);

    void getTangBlends(std::vector<boost::shared_ptr<SplineCurve> >& curves, int iedge,
                       std::vector<boost::shared_ptr<SplineCurve> >& blend_functions);

    void blendcoef(double evecu[],double evecv[],double etang[],
                   int idim,int isign,double *coef1, double *coef2);

    void hermit(double econd[], int icond, bool hasder1,
                double astart, double aend, int idim);

    void fixCrossEndPts(const std::vector<boost::shared_ptr<SplineCurve> >& bd_curves,
                        const std::vector<boost::shared_ptr<SplineCurve> >& cross_curves);


    void
    makeLoftParams(std::vector<boost::shared_ptr<SplineCurve> >::const_iterator first_curve,
                   int nmb_crvs, double param_length, std::vector<double>& params);

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

} // namespace CoonsPatchGen


} // namespace Go


#endif // _GOCOONSPATCHGEN_H

---