The Parametric Pseudo-Manifold (PPS) Library 1.0
ppsfrompnt::PNTriangle Class Reference

This class represents a PN triangle. More...

#include <pntriangle.h>

List of all members.

Public Member Functions

 PNTriangle (double p0[3], double p1[3], double p2[3], double n0[3], double n1[3], double n2[3])
 Creates an instance of this class.
 PNTriangle (const PNTriangle &pnt)
 Creates an instance of this class from another instance.
 ~PNTriangle ()
 Destroys an instance of this class.
void point (double u, double v, double &x, double &y, double &z) const
 Computes a point on this patch.
void normal (double u, double v, double &x, double &y, double &z) const
 Computes the unit normal of this PN triangle at a given point.

Private Attributes

double _b [10][3]
double _n [6][3]

Detailed Description

This class represents a PN triangle.

Definition at line 51 of file pntriangle.h.


Constructor & Destructor Documentation

ppsfrompnt::PNTriangle::PNTriangle ( double  p0[3],
double  p1[3],
double  p2[3],
double  n0[3],
double  n1[3],
double  n2[3] 
)

Creates an instance of this class.

Parameters:
p0Cartesian coordinates of the first vertex of the triangle defining the PN triangle.
p1Cartesian coordinates of the second vertex of the triangle defining the PN triangle.
p2Cartesian coordinates of the third vertex of the triangle defining the PN triangle.
n0A unit normal at the first vertex.
n1A unit normal at the second vertex.
n2A unit normal at the third vertex.

b300 = p0, b030 = p1, and b003 = p2

Compute the weight associated with the above control points.

w210 = ( p1 - p0 ).inner( n0 ) ;

w120 = ( p0 - p1 ).inner( n1 ) ;

w201 = ( p2 - p0 ).inner( n0 ) ;

w021 = ( p2 - p1 ).inner( n1 ) ;

w102 = ( p0 - p2 ).inner( n2 ) ;

w012 = ( p1 - p2 ).inner( n2 ) ;

b210 = ( 1. / 3. ) * ( ( 2 * p0 ) + p1 - ( w210 * n0 ) ) ;

b120 = ( 1. / 3. ) * ( ( 2 * p1 ) + p0 - ( w120 * n1 ) ) ;

b201 = ( 1. / 3. ) * ( ( 2 * p0 ) + p2 - ( w201 * n0 ) ) ;

b021 = ( 1. / 3. ) * ( ( 2 * p1 ) + p2 - ( w021 * n1 ) ) ;

b102 = ( 1. / 3. ) * ( ( 2 * p2 ) + p0 - ( w102 * n2 ) ) ;

b012 = ( 1. / 3. ) * ( ( 2 * p2 ) + p1 - ( w012 * n2 ) ) ;

b111 = e + ( ( 0.5 * ( e - v ) ) )

where

e = ( b210 + b120 + b021 + b012 + b102 + b201 ) / 6

and

v = ( p0 + p1 + p2 ) / 3

n200 = n0, n020 = n1, and n002 = n2.

Compute the weights associated with each unit normal.

n110 = mv1 - ( ( 2 * w110 ) / d110 ) * ( mv0 ) ;

mv0 = p1 - p0 mv1 = n0 + n1

d110 = mv0.inner( mv0 ) w110 = mv0.inner( mv1 )

n101 = mv1 - ( ( 2 * w101 ) / d101 ) * ( mv0 ) ;

mv0 = p2 - p0 mv1 = n0 + n2

d101 = mv0.inner( mv0 ) w101 = mv0.inner( mv1 )

n011 = mv1 - ( ( 2 * w011 ) / d011 ) * ( mv0 ) ;

mv0 = p2 - p1 mv1 = n1 + n2

d011 = mv0.inner( mv0 ) w011 = mv0.inner( mv1 )

Normalize the vectors n110, n101, and n011.

Definition at line 63 of file pntriangle.cpp.

References _b, and _n.

  {
    // ---------------------------------------------------------------
    //
    // Compute control points b300, b030, and b003.
    //
    // ---------------------------------------------------------------

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _b[ 0 ][ i ] = p0[ i ] ; 
      _b[ 1 ][ i ] = p1[ i ] ;
      _b[ 2 ][ i ] = p2[ i ] ;
    }

    // ---------------------------------------------------------------
    //
    // Compute control points b210, b120, b201, b021, b102, and b012.
    //
    // ---------------------------------------------------------------

    double w210 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      w210 += ( p1[ i ] - p0[ i ] ) * n0[ i ] ;
    }

    double w120 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      w120 += ( p0[ i ] - p1[ i ] ) * n1[ i ] ;
    }

    double w201 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      w201 += ( p2[ i ] - p0[ i ] ) * n0[ i ] ;
    }

    double w021 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      w021 += ( p2[ i ] - p1[ i ] ) * n1[ i ] ;
    }

    double w102 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      w102 += ( p0[ i ] - p2[ i ] ) * n2[ i ] ;
    }    

    double w012 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      w012 += ( p1[ i ] - p2[ i ] ) * n2[ i ] ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _b[ 3 ][ i ]  = ( 2 * p0[ i ] ) + p1[ i ] - ( w210 * n0[ i ] ) ;
      _b[ 3 ][ i ] /= 3. ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _b[ 4 ][ i ]  = ( 2 * p1[ i ] ) + p0[ i ] - ( w120 * n1[ i ] ) ;
      _b[ 4 ][ i ] /=  3. ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _b[ 5 ][ i ]  = ( 2 * p0[ i ] ) + p2[ i ] - ( w201 * n0[ i ] ) ;
      _b[ 5 ][ i ] /= 3. ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _b[ 6 ][ i ]  = ( 2 * p1[ i ] ) + p2[ i ] - ( w021 * n1[ i ] ) ;
      _b[ 6 ][ i ] /= 3. ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _b[ 7 ][ i ]  = ( 2 * p2[ i ] ) + p0[ i ] - ( w102 * n2[ i ] ) ;
      _b[ 7 ][ i ] /= 3. ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _b[ 8 ][ i ]  = ( 2 * p2[ i ] ) + p1[ i ] - ( w012 * n2[ i ] ) ;
      _b[ 8 ][ i ] /= 3. ;
    }

    // ---------------------------------------------------------------
    //
    // Compute control point b111.
    //
    // ---------------------------------------------------------------

    double e[ 3 ] ;
    double v[ 3 ] ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      e[ i ] = 0.0 ;
      for ( unsigned j = 3 ; j < 9 ; j++ ) {
        e[ i ] += _b[ j ][ i ] ;
      }

      e[ i ] /= 6. ;

      v[ i ] = ( p0[ i ] + p1[ i ] + p2[ i ] ) / 3. ;

      _b[ 9 ][ i ] = e[ i ] + ( 0.5 * ( e[ i ] - v[ i ] ) ) ;
    }

    // ---------------------------------------------------------------
    // 
    // Compute unit normals n200, n020, and n002.
    //
    // ---------------------------------------------------------------

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _n[ 0 ][ i ] = n0[ i ] ; 
      _n[ 1 ][ i ] = n1[ i ] ;
      _n[ 2 ][ i ] = n2[ i ] ;
    }

    // ---------------------------------------------------------------
    // 
    // Compute unit normals n110, n101, and n011.
    //
    // ---------------------------------------------------------------

    double mv0[ 3 ] ;
    double mv1[ 3 ] ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      mv0[ i ] = p1[ i ] - p0[ i ] ;
      mv1[ i ] = n0[ i ] + n1[ i ] ;
    }

    double d110 = 0 ;
    double w110 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      d110 += mv0[ i ] * mv0[ i ] ;
      w110 += mv0[ i ] * mv1[ i ] ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _n[ 3 ][ i ] = mv1[ i ] - ( ( 2 * w110 ) / d110 ) * ( mv0[ i ] ) ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      mv0[ i ] = p2[ i ] - p0[ i ] ;
      mv1[ i ] = n0[ i ] + n2[ i ] ;
    }

    double d101 = 0 ;
    double w101 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      d101 += mv0[ i ] * mv0[ i ] ;
      w101 += mv0[ i ] * mv1[ i ] ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _n[ 4 ][ i ] = mv1[ i ] - ( ( 2 * w101 ) / d101 ) * ( mv0[ i ] ) ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      mv0[ i ] = p2[ i ] - p1[ i ] ;
      mv1[ i ] = n1[ i ] + n2[ i ] ;
    }

    double d011 = 0 ;
    double w011 = 0 ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      d011 += mv0[ i ] * mv0[ i ] ;
      w011 += mv0[ i ] * mv1[ i ] ;
    }

    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      _n[ 5 ][ i ] = mv1[ i ] - ( ( 2 * w011 ) / d011 ) * ( mv0[ i ] ) ;
    }

    double l[ 3 ] ;
    for ( unsigned i = 3 ; i < 6 ; i++ ) {
      l[ i - 3 ] = 0.0 ;

      for ( unsigned j = 0 ; j < 3 ; j++ ) {
        l[ i - 3 ] += _n[ i ][ j ] * _n[ i ][ j ] ; 
      }

      double sqrtl = sqrt( l[ i - 3 ] ) ;

      for ( unsigned j = 0 ; j < 3 ; j++ ) {
        _n[ i ][ j ] /= sqrtl ;
      }      
    }

    return ;
  }
ppsfrompnt::PNTriangle::PNTriangle ( const PNTriangle pnt)

Creates an instance of this class from another instance.

Parameters:
pntAn instance of this class.

Definition at line 366 of file pntriangle.cpp.

References _b, and _n.

  {
    if ( &pnt != this ) {
      for ( unsigned i = 0 ; i < 10 ; i++ ) {
        _b[ i ][ 0 ] = pnt._b[ i ][ 0 ] ;
        _b[ i ][ 1 ] = pnt._b[ i ][ 1 ] ;
        _b[ i ][ 2 ] = pnt._b[ i ][ 2 ] ;
        
        if ( i < 6 ) {
          _n[ i ][ 0 ] = pnt._n[ i ][ 0 ] ;
          _n[ i ][ 1 ] = pnt._n[ i ][ 1 ] ;
          _n[ i ][ 2 ] = pnt._n[ i ][ 2 ] ;
        }         
      }
    }
    
    return ;
  }

Member Function Documentation

void ppsfrompnt::PNTriangle::normal ( double  u,
double  v,
double &  x,
double &  y,
double &  z 
) const

Computes the unit normal of this PN triangle at a given point.

Parameters:
uFirst barycentric coordinate of a given parameter point.
vSecond barycentric coordinate of a given parameter point.
xFirst component of the unit normal.
ySecond component of the unit normal.
zThird component of the unit normal.

Definition at line 474 of file pntriangle.cpp.

References _n.

  {

    if ( fabs( u ) <= 1e-15 ) {
      u = 0 ;
    }
    else if ( fabs( 1 - u ) <= 1e-15 ) {
      u = 1 ;
    }

    if ( fabs( v ) <= 1e-15 ) {
      v = 0 ;
    }
    else if ( fabs( 1 - v ) <= 1e-15 ) {
      v = 1 ;
    }

    double w = 1 - ( u + v ) ;

    if ( fabs( w ) <= 1e-15 ) {
      w = 0 ;
    }
    else if ( fabs( 1 - w ) <= 1e-15 ) {
      w = 1 ;
    }

    assert( 
           ( u >= 0 ) && ( u <= 1 ) && ( v >= 0 ) && 
           ( v <= 1 ) && ( w >= 0 ) && ( w <= 1 )
          ) ;

    double u2 = u * u ;
    double v2 = v * v ;
    double w2 = w * w ;

    double pt[ 3 ] ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      pt[ i ] =   u2       * _n[ 0 ][ i ]
              +   v2       * _n[ 1 ][ i ]
              +   w2       * _n[ 2 ][ i ]
              + ( u  * v ) * _n[ 3 ][ i ] 
              + ( u  * w ) * _n[ 4 ][ i ]
              + ( v  * w ) * _n[ 5 ][ i ] ;
     }

    x = pt[ 0 ] ;
    y = pt[ 1 ] ;
    z = pt[ 2 ] ;

    double l = sqrt( ( x * x ) + ( y * y ) + ( z * z ) ) ;

    assert( l > 0 ) ;

    x /= l ;
    y /= l ;
    z /= l ;

    return ; 
  }
void ppsfrompnt::PNTriangle::point ( double  u,
double  v,
double &  x,
double &  y,
double &  z 
) const

Computes a point on this patch.

Parameters:
uFirst barycentric coordinate of a given parameter point.
vSecond barycentric coordinate of a given parameter point.
xFirst Cartesian coordinate of the point on this PN triangle.
ySecond Cartesian coordinate of the point on this PN triangle.
zThird Cartesian coordinate of the point on this PN triangle.

Definition at line 399 of file pntriangle.cpp.

References _b.

Referenced by ppsfrompnt::PPSfromPNT::eval_surface().

  {
    if ( fabs( u ) <= 1e-15 ) {
      u = 0 ;
    }
    else if ( fabs( 1 - u ) <= 1e-15 ) {
      u = 1 ;
    }

    if ( fabs( v ) <= 1e-15 ) {
      v = 0 ;
    }
    else if ( fabs( 1 - v ) <= 1e-15 ) {
      v = 1 ;
    }

    double w = 1 - ( u + v ) ;

    if ( fabs( w ) <= 1e-15 ) {
      w = 0 ;
    }
    else if ( fabs( 1 - w ) <= 1e-15 ) {
      w = 1 ;
    }

    double u2 = u * u ;
    double v2 = v * v ;
    double w2 = w * w ;

    double u3 = u * u2 ;
    double v3 = v * v2 ;
    double w3 = w * w2 ;

    double pt[ 3 ] ;
    for ( unsigned i = 0 ; i < 3 ; i++ ) {
      pt[ i ] =            u3       * _b[ 0 ][ i ]
              +            v3       * _b[ 1 ][ i ]
              +            w3       * _b[ 2 ][ i ]
              + ( 3 * u2 * v  )     * _b[ 3 ][ i ] 
              + ( 3 * u  * v2 )     * _b[ 4 ][ i ]
              + ( 3 * u2 * w  )     * _b[ 5 ][ i ] 
              + ( 3 * v2 * w  )     * _b[ 6 ][ i ]
              + ( 3 * u  * w2 )     * _b[ 7 ][ i ]
              + ( 3 * v  * w2 )     * _b[ 8 ][ i ]
              + ( 6 * u  * v  * w ) * _b[ 9 ][ i ] ; 
    }

    x = pt[ 0 ] ;
    y = pt[ 1 ] ;
    z = pt[ 2 ] ;

    return ;
  }

Member Data Documentation

double ppsfrompnt::PNTriangle::_b[10][3] [private]

The "b( i , j , k )" coefficients of this PN triangle.

_b[ 0 ] --> b300 _b[ 1 ] --> b030 _b[ 2 ] --> b003 _b[ 3 ] --> b210 _b[ 4 ] --> b120 _b[ 5 ] --> b201 _b[ 6 ] --> b021 _b[ 7 ] --> b102 _b[ 8 ] --> b012 _b[ 9 ] --> b111

Definition at line 155 of file pntriangle.h.

Referenced by PNTriangle(), and point().

double ppsfrompnt::PNTriangle::_n[6][3] [private]

The "n( i , j , k )" coefficients for computing the unit normal of this PN triangle at a given point. These coefficients define a quadratic interpolant.

_n[ 0 ] --> n200 _n[ 1 ] --> n020 _n[ 2 ] --> n002 _n[ 3 ] --> n110 _n[ 4 ] --> n101 _n[ 5 ] --> n011

Definition at line 170 of file pntriangle.h.

Referenced by normal(), and PNTriangle().


The documentation for this class was generated from the following files: