SmoothSurf.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 _GOSMOOTHSURF_H_
#define _GOSMOOTHSURF_H_


//   -----------------------------------------------------------------------
//      Interface file for class SmoothSurf
//   -----------------------------------------------------------------------
//
//       Used to modify a tensor product B-spline surface with respect
//       to conditions on smoothness, editing constraints and boundary
//       conditions.
//
//       Implementation of the member functions are given in the
//       following files:
//
//          1. SmoothSurf.C
//
//   -----------------------------------------------------------------------
//    Written by: Vibeke Skytt                            08-11.1993.
//    Revised by: Vibeke Skytt                               09.1995
//    Revised by: Vibeke Skytt                               04.1998
//   -----------------------------------------------------------------------

#include "SplineSurface.h"
#include "ConstraintDefinitions.h"

#include <vector>


namespace Go
{


class SmoothSurf
{

public:
    SmoothSurf();

    SmoothSurf(bool copy_coefs);

    virtual
    ~SmoothSurf();

    void attach(boost::shared_ptr<SplineSurface>& insf, int seem[], int coef_known[],
                int num_side_constraints = 0, int has_normal_cond = 0);

    virtual
    void setOptimize(const double weight1, const double weight2,
                     const double weight3);

    void setLeastSquares(std::vector<double>& pnts,
                         std::vector<double>& param_pnts,
                         std::vector<double>& pnt_weights,
                         const double weight);

    int setNormalCond(std::vector<double>& pnts,
                      std::vector<double>& param_pnts,
                      std::vector<double>&  pnt_weights,
                      const double weight);

    void approxOrig(double weight);

    virtual
    void setPeriodicity(int pardir,
                       int cont,
                       double weight1,
                       double weight2);


    void setSideConstraints(std::vector<sideConstraint>& constraints);

    int equationSolve(boost::shared_ptr<SplineSurface>& surf);


protected:
    int kdim_;            // If the problem has normal-conditions: 3, otherwise: 1
    int idim_;             // Dimension of geomtry space. 
    int idim1_;            // Dimension of projective space (for rationals).
    int ider_;             // Maximum derivative involved in the computations. 
    bool integralset_; //

    int cont_seem_[2];     // Number of rows affected by continuity at a seem
    // for each parameter direction.
    int kncond_;           // Size of matrix system (# unknown coefficents + # side constraints)
    int knconstraint_;     // Number of side constraints.
    const int kpointer_; // If coefknown_[ki] >= kpointer_, the coefficients indexed by
                   // ki & coefknown_[ki] - kpointer_ should be equal.

    int *coefknown_; // Array indicating the status of coefficients, i.e.
                     // free, fixed, not involved, equal to a given coefficients.
                     // 0: not known, 1: known, 2: not of interest (i.e. assumed known).
                     // >= kpointer_: the coefficients indexed by
                     //               ki & coefknown_[ki] - kpointer_ should be equal.
    std::vector<int> pivot_;    // Array giving the position of the free coefficients
    // in the equation system.

    // Parameters defining the spline space.
    boost::shared_ptr<SplineSurface> srf_;        // Pointer to input surface.
    int kk1_, kk2_;         // Order of surface in both parameter directions.    
    int kn1_, kn2_;         // Number of coefficients of surface.                
    std::vector<double>::const_iterator st1_;    // Pointer to knot vector of 
    // surface in 1. par. dir. 
    std::vector<double>::const_iterator st2_;    // Pointer to knot vector of 
    // surface in 2. par. dir. 

    const bool copy_coefs_;

    std::vector<double> coef_array_; // Only used if copy_coefs_ == true
    std::vector<double>::iterator scoef_;   // Pointer to surface coefficients.      

    std::vector<double> gmat_;         // Matrix at left side of equation system.  
    std::vector<double> gright_;       // Right side of equation system.      

    virtual
    void releaseScratch(); 

    virtual
    void prepareIntegral();

    virtual
    void getBasis(const double *sb1, const double *sb2, int kleft1, int kleft2,
                  int ider, double *sbasis);

    void preparePeriodicity(int seem[]);

    void setC1AtSeem(int pardir, double weight);

    void setC2AtSeem(int pardir, double weight);

    virtual
    int adjustAtSeem();


private:

    // Parameters used in integration
    std::vector<double> vec1_, vec2_;
    double ***integral1_;  // Array used to store integrals of inner product
    // of derivatives of B-splines in 1. par. dir.  
    double ***integral2_;  // Array used to store integrals of inner product
    // of derivatives of B-splines in 2. par. dir.  


}; // end of class SmoothSurf


} // end of namespace Go

#endif

---