ParamSurfaceInt.h

//===========================================================================
// GoTools - SINTEF Geometry Tools
//
// GoTools module: Intersections, version 1.0
//
// 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 _PARAMSURFACEINT_H
#define _PARAMSURFACEINT_H


#include "ParamGeomInt.h"
#include "ParamSurface.h"


namespace Go {



class AlgObj3DInt;
class ImplicitizeSurfaceAlgo;
class RotatedBox;



class ParamSurfaceInt : public ParamGeomInt {
public:
    explicit ParamSurfaceInt(boost::shared_ptr<ParamSurface> surf,
                             ParamGeomInt* parent = 0);
    
    virtual ~ParamSurfaceInt();
    
    virtual void point(Point& pt, const double* tpar) const 
    { surf_->point(pt, tpar[0], tpar[1]); }

    virtual void point(std::vector<Point>& pt, 
                       const double* tpar, 
                       int derivs,
                       const bool* from_right = 0,
                       double resolution = 1.0e-12) const 
    {
        if (from_right) {
            surf_->point(pt, tpar[0], tpar[1], derivs, from_right[0], 
                         from_right[1], resolution);
        } else {
            surf_->point(pt, tpar[0], tpar[1], derivs, true, true,
                         resolution);
        }
    }

    virtual ParamSurfaceInt* getParamSurfaceInt();

//     boost::shared_ptr<ParamSurface> getSurface()
//     { return surf_; }
//     boost::shared_ptr<const ParamSurface> getSurface() const
//     { return surf_;}

    boost::shared_ptr<ParamSurface> getParamSurface()
    { return surf_; }

    boost::shared_ptr<const ParamSurface> getParamSurface() const
    { return surf_;}

    boost::shared_ptr<ParamSurface> getParentParamSurface(RectDomain& domain);

    boost::shared_ptr<ParamSurface> getParentParamSurface();

    virtual boost::shared_ptr<ParamSurfaceInt>
    makeIntObject(boost::shared_ptr<ParamSurface> surf);

    virtual boost::shared_ptr<ParamCurveInt> 
    makeIntCurve(boost::shared_ptr<ParamCurve> crv, ParamGeomInt* parent);

    virtual int numParams() const
    { return 2;}

//     int checkCoincidence(double start, double end,
//                       ParamSurfaceInt *other,
//                       double other_start, double other_end);

    boost::shared_ptr<ParamCurve> 
    getIsoCurve(double param_start, double param_end,
                double isoval, bool pardir_is_u) const;

    boost::shared_ptr<ParamCurve>
    getConstantParameterCurve(int dir, double par);

    boost::shared_ptr<ParamCurve>
    getConstantParameterCurve(int dir, double par, double tmin, double tmax);

    void 
        minimumAlongCurve(int dir, double par, double tmin, double tmax,
                          Point& pnt, double& minpar, Point& minval, 
                          double& mindist);

    virtual void getLengthAndWiggle(double *length, double *wiggle);

    virtual bool hasInnerKnots(int pardir) const;

    virtual bool hasCriticalVals(int pardir) const;

    virtual bool hasCriticalValsOrKnots(int pardir) const;

    virtual bool canDivide(int pardir);

    virtual bool canDivideTinyTriang(int pardir);

    virtual std::vector<double> getCriticalVals(int pardir) const;

    virtual std::vector<double> getInnerKnotVals(int pardir,
                                                 bool sort = false) const; 

    virtual std::vector<double> getCriticalValsAndKnots(int pardir) const;

    virtual int getMeshSize(int dir);

    virtual double paramFromMesh(int dir, int idx);

    virtual std::vector<double>::iterator getMesh();

    virtual double startParam(int pardir) const;

    virtual double endParam(int pardir) const;

    virtual bool boundaryPoint(const double* par, double eps) const;

    std::vector<double> getMima() const;

    virtual bool inCorner(const double *par, double epspar) const;

    bool atDegenerateBd(const double *par, double epsge, double epspar);

    virtual void
    subdivide(int pardir, double par, 
              std::vector<boost::shared_ptr<ParamGeomInt> >& subdiv_objs,
              std::vector<boost::shared_ptr<ParamGeomInt> >& bd_objs);

    virtual std::vector<boost::shared_ptr<ParamSurfaceInt> >
    subSurfaces(double from_upar, double from_vpar,
                double to_upar, double to_vpar,
                double fuzzy);

    virtual CompositeBox compositeBox() const;

    virtual DirectionCone directionCone() const;

    virtual void 
    getBoundaryObjects(std::vector<boost::
                       shared_ptr<BoundaryGeomInt> >& bd_objs);

    virtual int checkPeriodicity(int pardir) const;

    virtual int dimension() const
    { return dim_; }

    virtual const RectDomain& getDomain() const
    { return domain_;}

    const RectDomain& getDegDomain(double epsge);

    virtual bool isSimple();

    virtual bool isSpline();

    virtual bool isIsoParametric(ParamCurveInt *curve, int dir, double par,
                                 double ptol, double tol)
        { return false; }  // Default behaviour

    virtual double getOptimizedConeAngle(Point& axis1, Point& axis2);

    virtual void knotIntervalFuzzy(double& u, double&v,
                                   double utol, double vtol) const; 

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

    // Degeneracy
    bool isDegenerate(double epsge);

    virtual int isDegenerate(double epsge, int dir);

    virtual bool isDegenerate(double epsge, int dir, double *par);

    double isolateDegPar(int dir, int deg_edge, double threshold, double *deg_factor=NULL);

    void setDegTriang()
    { deg_triang_ = true; }

    bool getDegTriang()
    { return deg_triang_; }
    
    double getParOffBd(int dir, bool atstart, double tol) const;

    void  first_fund_form(double u, 
                          double v, 
                          bool u_from_right, 
                          bool v_from_right, 
                          double& E, 
                          double& F, 
                          double& G) const
    {
        // Getting first derivatives
        surf_->point(temp_point_array_, u, v, 1,
                     u_from_right, v_from_right); 
        
        E = temp_point_array_[1] * temp_point_array_[1];
        F = temp_point_array_[1] * temp_point_array_[2];
        G = temp_point_array_[2] * temp_point_array_[2];
    }

    void second_fund_form(double u, 
                          double v, 
                          bool u_from_right,
                          bool v_from_right,
                          double& L, 
                          double& M, 
                          double& N) const
    {
        // Getting second derivatives
        surf_->point(temp_point_array_, u, v, 2,
                     u_from_right, v_from_right); 
        // Getting normal (we suppose that the surface contains a
        // continuous first derivative...)
        surf_->normal(temp_point_array_[0], u, v); // Setting first
                                                   // point to normal
                                                   // vec

        L = temp_point_array_[3] * temp_point_array_[0];  // d2r/du2 . N
        M = temp_point_array_[4] * temp_point_array_[0];  // d2r/dudv . N
        N = temp_point_array_[5] * temp_point_array_[0];  // d2r/dv2 . N
    }

    void derivs(double u, 
                double v, 
                Point& deriv_u, 
                Point& deriv_v,
                bool from_right_1 = true,
                bool from_right_2 = true) const
    {
        surf_->point(temp_point_array_, u, v, 1,
                     from_right_1, from_right_2);
        deriv_u = temp_point_array_[1];
        deriv_v = temp_point_array_[2];
    }

    void normal(double u, 
                double v, 
                Point& normal,
                bool from_right_1 = true,
                bool from_right_2 = true) const
    {
        surf_->point(temp_point_array_, u, v, 1,
                     from_right_1, from_right_2);
        normal = temp_point_array_[1] % temp_point_array_[2];
    }

    virtual RotatedBox getRotatedBox(std::vector<Point>& axis) const;

//     virtual void dumpToStream(std::ostream& os) const
//     {
//      surf_->writeStandardHeader(os);
//      surf_->write(os);
//     }

    void axisFromCorners(Point& axis1, Point& axis2) const;

    virtual void splitAtG0(double angtol,
                           std::vector<boost::
                           shared_ptr<ParamSurfaceInt> >& subG1);

    void getSingularity(double eps, double sing_par[], Point& sing_pt,
                        double& sing_val, double *seed);

    bool canSelfIntersect(double epsge) const;

    virtual boost::shared_ptr<ParamSurfaceInt> getNormalSurface() const
    {
        boost::shared_ptr<ParamSurfaceInt> dummy;
        return dummy;
    }

    virtual bool canImplicitize()
    { return false; }

    virtual bool implicitize(double tol)
    { return false; }

    // @@sbr Todo (tol2)!!!
    virtual bool getImplicit(double tol, double& tol2,
                             AlgObj3DInt& alg_obj_3d_int)
    { return false; }

//     /// Find the maximum curvature in a number of isocurves.
//     /// \param dir_is_u the direction of the isocurves.
//     /// \param nmb_params the number of isocurves to check.
//     /// \param iso_from start parameter of domain of interest in the
//     /// isocurves.
//     /// \param iso_to end parameter of domain of interest in the
//     /// isocurves.
//     /// \param guess_param initial guess for the parameter value with
//     /// the highest curvature.
//     /// \param max_curv_params the parameter values for the maximum
//     /// curvature in each isocurve.
//     /// \param max_curvatures the maximum curvature in each isocurve,
//     /// corresponding the parameters in max_curv_params.
     void maxCurvatures(bool dir_is_u, int nmb_params, double iso_from,
                       double iso_to, double guess_param,
                       std::vector<double>& max_curv_params,
                       std::vector<double>& max_curvatures);


protected:
    // Data members
    boost::shared_ptr<ParamSurface> surf_;
    int dim_; // Space dimension.
    double deg_tol_;
    bool deg_triang_;

    std::vector<std::pair<double, int> > segment_[2];

   // Generated data
    bool bd_deg_[4];  // Degeneracy, sequence left, right, bottom, top
    RectDomain domain_;
    RectDomain deg_domain_;   // Reduced domain for degenerate surfaces used in closest
                              // point computations
    // Approximating mesh
    mutable int nmesh_[2];
    mutable std::vector<double> mesh_;

    mutable DirectionCone cone_;

    mutable bool lw_set_;
    mutable double length_[2], wiggle_[2];

//     const static int nder_ = 2; // Order of derivatives to be
//                              // calulated.
//     double delta_;
//     std::vector<Point> ft_;     // Partial derivatives up to order
//                              // nder
//     std::vector<Point> gs_;     // Partial derivatives up to order
//                              // nder
    mutable std::vector<Point> temp_point_array_;

    // Implicit objects
    boost::shared_ptr<ImplicitizeSurfaceAlgo> impl_sf_algo_;
    double implicit_tol_; // Error tolerance used when creating
                          // impl_sf_algo_.
    int impl_deg_;
    boost::shared_ptr<AlgObj3DInt> implicit_obj_;
    double implicit_err_;
 
    
 private:
    void makeMesh(int size1, int size2) const;

    void computeDegDomain(double aepsge);

};


} // namespace Go


#endif // _PARAMSURFACEINT_H

---