Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members  

gunu_basics.h

Go to the documentation of this file.
00001 /* LIBGUL - Geometry Utility Library
00002  * Copyright (C) 1998-1999 Norbert Irmer
00003  *
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Library General Public
00006  * License as published by the Free Software Foundation; either
00007  * version 2 of the License, or (at your option) any later version.
00008  *
00009  * This library is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  * Library General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU Library General Public
00015  * License along with this library; if not, write to the
00016  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017  * Boston, MA 02111-1307, USA.
00018  */
00019  
00020 #ifndef GUNU_BASICS_H
00021 #define GUNU_BASICS_H
00022 
00023 namespace gunu {
00024 
00025 using gul::Ptr;
00026 using gul::point;
00027 using gul::curve;
00028 
00029 /*************************************************************************
00030 
00031   BASICAL NURBS FUNCTIONS
00032 
00033 **************************************************************************/
00034 
00035 /*-------------------------------------------------------------------------
00036   Search for the knotspan containing 'u' in a knot vector 'U' (clamped,degree
00037   'p','n'+1 knots (see "The NURBS book"))
00038 -------------------------------------------------------------------------*/
00039 template< class T >
00040 int FindSpan( const T u, const int n, const int p, const Ptr< T >& U );
00041                         
00042 /*-------------------------------------------------------------------------
00043   Finds the knotspan containing 'u' in a knot vector 'U' (clamped,degree
00044   'p','n'+1 knots (see "The NURBS book")), and counts the multiplicity
00045   of 'u'
00046 -------------------------------------------------------------------------*/
00047 template< class T >
00048 int FindSpanMultip( const T u, const int n,  const int p, 
00049                     const Ptr< T >& U, int *s );
00050 
00051 /*-------------------------------------------------------------------------
00052   Counts the multiplicity of a knot 'u'
00053 -------------------------------------------------------------------------*/
00054 template< class T >
00055 inline int GetKnotMultiplicity( const T u, const Ptr< T >& U, const int span )
00056 {
00057   int l;
00058 
00059   l = span;
00060 
00061   while( l >= 0 )
00062   {
00063     if( U[l] != u )
00064       break; 
00065     l--;
00066   }
00067 
00068   return(span-l);
00069 }
00070 
00071 /*---------------------------------------------------------------------
00072   Normalizes a clamped knot vector 'U', so that it starts with 0.0 and
00073   ends with 1.0
00074 ---------------------------------------------------------------------*/
00075 template< class T >
00076 inline void NormalizeKnotVector( const int n, const int p, Ptr< T >& U )
00077 {
00078   T u0,su;
00079   int i;
00080   
00081   u0 = U[0];
00082   su = U[n+1] - u0;  
00083   if( (u0 == 0.) && (su == 1.) ) return;
00084 
00085   for( i = 0; i <= p; i++ )
00086     U[i] = 0.;
00087   for( i = p+1; i <= n; i++ )
00088     U[i] = (U[i] - u0) / su;
00089   for( i = n+1; i <= n+p+1; i++ )
00090     U[i] = 1.;
00091 }     
00092 
00093 /*---------------------------------------------------------------------
00094   Normalizes a clamped knot vector 'U', so that it starts with 0.0 and
00095   ends with 1.0
00096 ---------------------------------------------------------------------*/
00097 template< class T >
00098 inline void NormalizeKnotVector( const int n, const int p, const Ptr< T >& U,
00099                                  T& offsetU, T& scaleU, Ptr< T >& retU )
00100 {
00101   T u0,su;
00102   int i;
00103   
00104   offsetU = u0 = U[0];
00105   scaleU = su = U[n+1] - u0;  
00106   if( (u0 == 0.) && (su == 1.) ) return;
00107 
00108   for( i = 0; i <= p; i++ )
00109     retU[i] = 0.;
00110   for( i = p+1; i <= n; i++ )
00111     retU[i] = (U[i] - u0) / su;
00112   for( i = n+1; i <= n+p+1; i++ )
00113     retU[i] = 1.;
00114 }     
00115 
00116 /* --------------------------------------------------------------------
00117   Checks whether a knot vector is valid, clamped and normalized
00118 ---------------------------------------------------------------------*/
00119 template< class T >
00120 GULAPI bool ValidateKnotVec( 
00121                       const int n, const int p, const Ptr<T>& knt,
00122                       bool& is_clamped, bool& is_normalized );
00123 
00124 /*--------------------------------------------------------------------------
00125   Constructs a uniform clamped knot vector ( u_{i+1}-u_{i}) is equal
00126   for all inner nodes
00127 --------------------------------------------------------------------------*/ 
00128 template< class T >
00129 GULAPI void UniformKnotVector( const int n, const int p, Ptr< T >& U );
00130 
00131 /*--------------------------------------------------------------------------
00132   Constructs a clamped knot vector usabel for a Bezier function
00133 --------------------------------------------------------------------------*/ 
00134 
00135 template< class T >
00136 void BezierKnotVector( const int p, Ptr< T >& U )
00137 {
00138   int i;
00139   
00140   for( i = 0; i <= p; i++ )
00141   {
00142     U[i] = 0.;
00143     U[p+1+i] = 1.;
00144   }
00145 }
00146 
00147 /*--------------------------------------------------------------------------
00148   Mirrors a knot vector
00149 --------------------------------------------------------------------------*/ 
00150 template< class T >
00151 void MirrorKnotVector( int nU, Ptr<T>& U )
00152 {
00153   T uw,ui;
00154   int i, m = nU-1;
00155   
00156   uw = U[0] + U[m]; 
00157 
00158   for( i = 1; i <= m/2; i++ )
00159   {
00160     ui = U[i];
00161     U[i] = uw - U[m-i];
00162     U[m-i] = uw - ui;
00163   }
00164 }
00165                       
00166 /*--------------------------------------------------------------------------
00167   Mirrors a row vector
00168 --------------------------------------------------------------------------*/ 
00169 template< class EP >
00170 void MirrorVector( int nP, Ptr<EP>& P )
00171 {
00172   int i, m = nP-1;
00173   
00174   for( i = 0; i <= m/2; i++ )
00175     Swap( P[i], P[m-i] );
00176 }
00177 
00178 /*--------------------------------------------------------------------------
00179   Mirrors a column vector
00180 --------------------------------------------------------------------------*/ 
00181 template< class EP >
00182 void MirrorColumns( int nRows, int nCols, Ptr< Ptr<EP> >& P )
00183 {
00184   int i,j, m = nRows-1;
00185   
00186   for( i = 0; i <= m/2; i++ )
00187     for( j = 0; j < nCols; j++ )
00188       Swap( P[i][j], P[m-i][j] );
00189 }
00190 
00191 /*------------------------------------------------------------------
00192   Calculates a single basis function
00193 ------------------------------------------------------------------*/
00194 template< class T >
00195 GULAPI T CalcBasisFunction( int p, int i, T u, int n, const Ptr<T>& U );
00196 
00197 /*------------------------------------------------------------------
00198   Calculates the non vanishing NURBS basis functions (see "The NURBS book")
00199 -------------------------------------------------------------------*/
00200 template< class T >
00201 void CalcBasisFunctions( const T u, const int i, const int p, const Ptr< T >& U,
00202                          Ptr< T >& N );
00203 
00204 /*------------------------------------------------------------------------
00205   Calculates a point on a NURBS curve (see "The NURBS Book")
00206 ----------------------------------------------------------------------- */
00207 template< class T, class HP, class EP >
00208 GULAPI void CurvePoint( const T u, const int n, const int p, const Ptr< T >& U,
00209                         const Ptr< HP >& Pw, EP *C );
00210 
00211 /*------------------------------------------------------------------------
00212   Calculates a point on a NURBS surface (see "The NURBS Book")
00213 ----------------------------------------------------------------------- */
00214 template< class T, class HP, class EP > 
00215 GULAPI
00216 void SurfacePoint( 
00217                 const T u, const T v, 
00218                 const int nu, const int pu, const Ptr< T >& U,
00219                 const int nv, const int pv, const Ptr< T >& V,                    
00220                 const Ptr< Ptr< HP > >& Pw, EP *retS );
00221 
00222 /*------------------------------------------------------------------------
00223   Calculates a point on a Bezier surface (for Bezier surfaces there is
00224   no need to search the knot span)
00225 ----------------------------------------------------------------------- */
00226 template< class T, class HP, class EP > 
00227 GULAPI
00228 void BezierSurfacePoint( 
00229                 const T u, const T v, 
00230                 const int pu, const Ptr< T >& U,
00231                 const int pv, const Ptr< T >& V,                    
00232                 const Ptr< Ptr< HP > >& Pw, EP *retS );
00233                 
00234 /*------------------------------------------------------------------------
00235   Calculates a point on a NURBS curve (the curve is passed as a structure)
00236 ----------------------------------------------------------------------- */
00237 template< class T, class HP >
00238 void EvaluateCurve( const curve< T, HP > *Curv, 
00239                     const T u, point<T> *C )
00240 {
00241   CurvePoint( u, Curv->cpt.n, Curv->p, Curv->knt.U, Curv->cpt.Pw, C );
00242 }
00243 
00244 
00245 }
00246 
00247 #endif

Generated on Mon Jan 21 04:17:36 2002 for GUL 0.6 - Geometry Utility Library by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001