ApproxSurface.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2008 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef REEN_APPROXSURFACE_H
#define REEN_APPROXSURFACE_H

#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <Handle_Geom_BSplineSurface.hxx>
#include <math_Matrix.hxx>

#include <Base/Vector3D.h>

namespace Base {
class SequencerLauncher;
}

// TODO: Replace OCC stuff with ublas & co

namespace Reen {

class ReenExport SplineBasisfunction
{
public:
  SplineBasisfunction(int iSize);

  SplineBasisfunction(TColStd_Array1OfReal& vKnots, int iOrder=1);

  SplineBasisfunction(TColStd_Array1OfReal& vKnots, TColStd_Array1OfInteger& vMults, int iSize, int iOrder=1);

  virtual ~SplineBasisfunction();

  virtual double BasisFunction(int iIndex, double fParam)=0;
  virtual void DerivativesOfBasisFunction(int iIndex, int iMaxDer, double fParam,
                                  TColStd_Array1OfReal& Derivat)=0;

  virtual double DerivativeOfBasisFunction(int iIndex, int k, double fParam)=0;

  virtual void SetKnots(TColStd_Array1OfReal& vKnots, int iOrder=1);

  virtual void SetKnots(TColStd_Array1OfReal& vKnots, TColStd_Array1OfInteger& vMults, int iOrder=1);

protected: //Member

  // Knotenvektor
  TColStd_Array1OfReal _vKnotVector;

  // Ordnung (=Grad+1)
  int _iOrder;

};

class ReenExport BSplineBasis : public SplineBasisfunction
{
public:

  BSplineBasis(int iSize);

  BSplineBasis(TColStd_Array1OfReal& vKnots, int iOrder=1);

  BSplineBasis(TColStd_Array1OfReal& vKnots, TColStd_Array1OfInteger& vMults, int iSize, int iOrder=1);

  virtual int FindSpan(double fParam);
  
  virtual void AllBasisFunctions(double fParam, TColStd_Array1OfReal& vFuncVals);

  virtual double BasisFunction(int iIndex, double fParam);

  virtual void DerivativesOfBasisFunction(int iIndex, int iMaxDer, double fParam,
                                  TColStd_Array1OfReal& Derivat);

  virtual double DerivativeOfBasisFunction(int iIndex, int k, double fParam);

  virtual double GetIntegralOfProductOfBSplines(int i, int j, int r, int s);

  virtual~ BSplineBasis();

protected:

  virtual void GenerateRootsAndWeights(TColStd_Array1OfReal& vAbscissas, TColStd_Array1OfReal& vWeights);

  virtual void FindIntegrationArea(int iIdx1, int iIdx2, int& iBegin, int& iEnd);

  int CalcSize(int r, int s);
};

class ReenExport ParameterCorrection
{

public:
  // Konstruktor
  ParameterCorrection(
                unsigned short usUOrder=4,               //Ordnung in u-Richtung (Ordnung=Grad+1)
                unsigned short usVOrder=4,               //Ordnung in v-Richtung
                unsigned short usUCtrlpoints=6,          //Anz. der Kontrollpunkte in u-Richtung
                unsigned short usVCtrlpoints=6);         //Anz. der Kontrollpunkte in v-Richtung

  virtual ~ParameterCorrection()
  {
    delete _pvcPoints;
    delete _pvcUVParam;
  };

protected:
  virtual void CalcEigenvectors();

  virtual bool DoInitialParameterCorrection(float fSizeFactor=0.0f);

  virtual bool GetUVParameters(float fSizeFactor);

  virtual void DoParameterCorrection(unsigned short usIter)=0;

  virtual bool SolveWithoutSmoothing()=0;

  virtual bool SolveWithSmoothing(float fWeight)=0;

public:
  virtual Handle_Geom_BSplineSurface CreateSurface(
                                           const TColgp_Array1OfPnt& points,
                                           unsigned short usIter,
                                           bool bParaCor,
                                           float fSizeFactor=0.0f);
  virtual void SetUVW(const Base::Vector3f& clU, const Base::Vector3f& clV, const Base::Vector3f& clW, bool bUseDir=true);

  virtual void GetUVW(Base::Vector3f& clU, Base::Vector3f& clV, Base::Vector3f& clW) const;

  virtual Base::Vector3f GetGravityPoint() const;

  virtual void EnableSmoothing(bool bSmooth=true, float fSmoothInfl=1.0f);

protected:
  bool                    _bGetUVDir;        
  bool                    _bSmoothing;       
  float                   _fSmoothInfluence; 
  unsigned short                 _usUOrder;         
  unsigned short                 _usVOrder;         
  unsigned short                 _usUCtrlpoints;    
  unsigned short                 _usVCtrlpoints;    
  Base::Vector3f               _clU;              
  Base::Vector3f               _clV;              
  Base::Vector3f               _clW;              
  TColgp_Array1OfPnt*     _pvcPoints;        
  TColgp_Array1OfPnt2d*   _pvcUVParam;       
  TColgp_Array2OfPnt      _vCtrlPntsOfSurf;  
  TColStd_Array1OfReal    _vUKnots;          
  TColStd_Array1OfReal    _vVKnots;          
  TColStd_Array1OfInteger _vUMults;          
  TColStd_Array1OfInteger _vVMults;          
};


class ReenExport BSplineParameterCorrection : public ParameterCorrection
{

public:
  // Konstruktor
  BSplineParameterCorrection(
                unsigned short usUOrder=4,               //Ordnung in u-Richtung (Ordnung=Grad+1)
                unsigned short usVOrder=4,               //Ordnung in v-Richtung
                unsigned short usUCtrlpoints=6,          //Anz. der Kontrollpunkte in u-Richtung
                unsigned short usVCtrlpoints=6);         //Anz. der Kontrollpunkte in v-Richtung

  virtual ~BSplineParameterCorrection(){};

protected:
  virtual void Init();

  virtual void DoParameterCorrection(unsigned short usIter);

  virtual bool SolveWithoutSmoothing();

  virtual bool SolveWithSmoothing(float fWeight);

public:
  void SetUKnots(const std::vector<float>& afKnots);

  void SetVKnots(const std::vector<float>& afKnots);

  virtual const math_Matrix& GetFirstSmoothMatrix() const;

  virtual const math_Matrix& GetSecondSmoothMatrix() const;

  virtual const math_Matrix& GetThirdSmoothMatrix() const;

  virtual void SetFirstSmoothMatrix(const math_Matrix& rclMat);

  virtual void SetSecondSmoothMatrix(const math_Matrix& rclMat);

  virtual void SetThirdSmoothMatrix(const math_Matrix& rclMat);

  virtual void EnableSmoothing(bool bSmooth=true, float fSmoothInfl=1.0f);

  virtual void EnableSmoothing(bool bSmooth, float fSmoothInfl, 
                               float fFirst, float fSec,  float fThird);

protected:
  virtual void CalcSmoothingTerms(bool bRecalc, float fFirst, float fSecond, float fThird);

  virtual void CalcFirstSmoothMatrix(Base::SequencerLauncher&);

  virtual void CalcSecondSmoothMatrix(Base::SequencerLauncher&);

  virtual void CalcThirdSmoothMatrix(Base::SequencerLauncher&);

protected:
  BSplineBasis           _clUSpline;        
  BSplineBasis           _clVSpline;        
  math_Matrix             _clSmoothMatrix;   
  math_Matrix             _clFirstMatrix;    
  math_Matrix             _clSecondMatrix;   
  math_Matrix             _clThirdMatrix;    
};

} // namespace Reen

#endif // REEN_APPROXSURFACE_H