The Parametric Pseudo-Manifold (PPS) Library 1.0
|
This class represents a PN triangle. More...
#include <pntriangle.h>
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] |
This class represents a PN triangle.
Definition at line 51 of file pntriangle.h.
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.
p0 | Cartesian coordinates of the first vertex of the triangle defining the PN triangle. |
p1 | Cartesian coordinates of the second vertex of the triangle defining the PN triangle. |
p2 | Cartesian coordinates of the third vertex of the triangle defining the PN triangle. |
n0 | A unit normal at the first vertex. |
n1 | A unit normal at the second vertex. |
n2 | A 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.
{ // --------------------------------------------------------------- // // 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.
pnt | An instance of this class. |
Definition at line 366 of file pntriangle.cpp.
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.
u | First barycentric coordinate of a given parameter point. |
v | Second barycentric coordinate of a given parameter point. |
x | First component of the unit normal. |
y | Second component of the unit normal. |
z | Third 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.
u | First barycentric coordinate of a given parameter point. |
v | Second barycentric coordinate of a given parameter point. |
x | First Cartesian coordinate of the point on this PN triangle. |
y | Second Cartesian coordinate of the point on this PN triangle. |
z | Third 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 ; }
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().