---

gunu_parametrize.h

Go to the documentation of this file.

/* LIBGUL - Geometry Utility Library
 * Copyright (C) 1998-1999 Norbert Irmer
 *
 * 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; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifndef GUNU_PARAMETRIZE_H
#define GUNU_PARAMETRIZE_H

#include "gul_vector.h"

namespace gunu {

template< class T, class EP >
inline T ChordLength( int nQ, const gul::Ptr<EP>& Q, gul::Ptr<T>& d )
{
  T sum = (T)0;
  d[0] = (T)0;

  for( int i = 1; i < nQ; i++ )
  {
    d[i] = gul::distance( Q[i], Q[i-1] );
    sum += d[i];
  }
  return sum;
}

template< class T, class EP >
inline T ColumnChordLength( 
                   int nRows, int nCols, const gul::Ptr< gul::Ptr<EP> >& Q, 
                   int iCol, gul::Ptr<T>& d )
{
  T sum = (T)0;
  d[0] = (T)0;

  for( int i = 1; i < nRows; i++ )
  {
    d[i] = gul::distance( Q[i][iCol], Q[i-1][iCol] );
    sum += d[i];
  }
  return sum;
}

template< class T >
inline void ChordLengthParameters( int nQ, const T& dsum, const gul::Ptr<T>& d,
                                   gul::Ptr<T>& Uq )
{
  Uq[0] = (T)0;
  for( int i = 1; i < nQ-1; i++ ) 
    Uq[i] = Uq[i-1] + d[i]/dsum;
  Uq[nQ-1] = (T)1;
}

template< class T >
inline void KnotVectorByAveraging( int nQ, const gul::Ptr<T>& Uq, int p, 
                                   gul::Ptr<T>& U )
{
  int i,j;
  T p_inv,sum;
  int n = nQ-1, m = nQ+p; 

  for( i = 0; i <= p; i++ ) U[i] = (T)0;
  for( i = m-p; i <= m; i++ ) U[i] = (T)1;

  p_inv = (T)1/(T)p;
  for( j = 1; j <= n-p; j++ )
  {
    sum = (T)0;
    for( i = j; i < j+p; i++ )
      sum += Uq[i];
    U[j+p] = sum * p_inv;
  }
}

/*----------------------------------------------------------------------
  returns the maximum number of points which can lie in one knotspan
----------------------------------------------------------------------*/

template< class T >
inline int KnotVectorByAveraging( int nQ, const gul::Ptr<T>& Uq, 
                                   int n, int p, gul::Ptr<T>& U )
{
  T tid,tidf,d,alpha;
  int i,ii;

  for( i = 0; i <= p; i++ )
  {
    U[i] = 0.0;
    U[n+1+i] = 1.0;
  }

  d = (T)nQ / (T)(n - p + 1);
  if( d < (T)1 ) return 0;

  for( i = 1; i <= n - p; i++ )
  {
    tid = (T)i * d;
    tidf = gul::rtr<T>::floor(tid);

    ii = (int)tidf;
      
    alpha = tid - tidf;

    U[p+i] = ((T)1 - alpha) * Uq[ii-1] + alpha * Uq[ii]; 
  }
  return ((int)gul::rtr<T>::ceil(d))+1;
}

template< class T, class EP >
inline bool ChordLengthMeshParams( 
                   int nRows, int nCols, const gul::Ptr< gul::Ptr<EP> > &Q,
                   gul::Ptr<T>& Uq, gul::Ptr<T>& Vq )
{
  int nnzero,i,j,nu,nv;
  T f,dtotal,dsum;
  gul::Ptr<T> d;

  d.reserve_pool( gul::Max(nRows,nCols) );

  nu = nCols-1;
  nv = nRows-1;

/* -------- calc U-parameters ---------------------- */

  nnzero = nv+1;

  for( i = 0; i < nu; i++ ) Uq[i] = (T)0; 
  Uq[nu] = (T)1;

  for( i = 0; i <= nv; i++ )
  {
    dtotal = ChordLength( nu+1, Q[i], d );

    if( dtotal == (T)0 ) 
    {
      nnzero--;    
    }
    else
    {
      dsum = (T)0;
      for( j = 1; j < nu; j++ ) 
      {
        dsum += d[j];
        Uq[j] += dsum/dtotal;
      }
    }
  }
  if( nnzero == 0 ) return false;

  f = (T)1/(T)nnzero;

  for( i = 1; i < nu; i++ )
    Uq[i] *= f; 

/* -------- calc V-parameters ---------------------- */

  nnzero = nu+1;

  for( i = 0; i < nv; i++ ) Vq[i] = (T)0; 
  Vq[nv] = (T)1;

  for( i = 0; i <= nu; i++ )
  {
    dtotal = ColumnChordLength( nv+1, nu+1, Q, i, d ); // chord length of column

    if( dtotal == (T)0 ) 
    {
      nnzero--;    
    }
    else
    {
      dsum = (T)0;
      for( j = 1; j < nv; j++ ) 
      {
        dsum += d[j];
        Vq[j] += dsum/dtotal;
      }
    }
  }
  if( nnzero == 0 ) return false;

  f = (T)1/(T)nnzero;

  for( i = 1; i < nv; i++ )
    Vq[i] *= f; 

  return true;
}

}

#endif

---