 |
TAPs 0.7.7.3
|
|
TAPs 0.7.7.3
|
00001 /****************************************************************************** 00002 TAPsGridGenerator.cpp 00003 ******************************************************************************/ 00007 /****************************************************************************** 00008 SUKITTI PUNAK (07/22/2007) 00009 UPDATE (04/16/2010) 00010 ******************************************************************************/ 00011 #include "TAPsGridGenerator.hpp" 00012 // Using Inclusion Model (i.e. definitions are included in declarations) 00013 // (this name.cpp is included in name.hpp) 00014 // Each friend is defined directly inside its declaration. 00015 00016 BEGIN_NAMESPACE_TAPs 00017 //============================================================================= 00018 //----------------------------------------------------------------------------- 00019 // Constructor 00020 template <typename T, typename DATA> 00021 GridGenerator<T,DATA>::GridGenerator ( OpenGL::Model<T> * pModel, 00022 bool useSoftware, bool genInversely, 00023 bool useDefaultIntpValue = false, 00024 T defaultIntpValue = 0.5 ) 00025 : m_pModel( pModel ), 00026 m_atVertexPosition( NULL ), 00027 m_atVertexNormal( NULL ), 00028 m_abVertexFlag1( NULL ), 00029 m_atVertexInterpolation( NULL ), 00030 m_bUseSoftwareToGenGrid( useSoftware ), 00031 m_bGenGridInversely( genInversely ), 00032 m_bUseDefaultIntpVal( useDefaultIntpValue ), 00033 m_tDefaultIntpVal( defaultIntpValue ) 00034 { 00035 m_atGridDimension[0] = m_atGridDimension[1] = m_atGridDimension[2] = 0; 00036 m_auiGridSize[0] = m_auiGridSize[1] = m_auiGridSize[2] = 0; 00037 //--------------------------------------------------------------- 00038 } 00039 //----------------------------------------------------------------------------- 00040 // Destructor 00041 template <typename T, typename DATA> 00042 GridGenerator<T,DATA>::~GridGenerator () 00043 { 00044 DeleteGrids(); 00045 } 00046 //----------------------------------------------------------------------------- 00047 // Regenerate Grids with set Dimension 00048 template <typename T, typename DATA> 00049 bool GridGenerator<T,DATA>::RegenerateGrids () 00050 { 00051 if ( !m_pModel ) return false; 00052 if ( m_atGridDimension[0] == 0 ) return false; 00053 if ( !IsGridGenerated() ) return false; 00054 //--------------------------------------------------------------- 00055 // Generate Grids 00056 #ifdef TAPs_GRID_GENERATOR_BY_SOFTWARE 00057 if ( m_bUseSoftwareToGenGrid ) { 00058 std::cout << "Use SW to generate grids\n"; 00059 SetGridPointsToInsideOutsideModelBoundary_SW(); 00060 SetAllGridPointsToInsideOutsideModel_SW(); 00061 } 00062 #endif 00063 #ifdef TAPs_GRID_GENERATOR_BY_HARDWARE 00064 if ( !m_bUseSoftwareToGenGrid ) { 00065 std::cout << "Use HW to generate grids\n"; 00066 SetAllGridPointsToInsideOutsideModel_HW(); 00067 } 00068 #endif 00069 //--------------------------------------------------------------- 00070 ClearExtraRightOutsidePoints(); 00071 if ( m_bGenGridInversely ) { 00072 InverseInsideOutside(); 00073 ClearExtraRightOutsidePoints(); 00074 } 00075 SetVertexInterpolationData( 0.5 ); 00076 //--------------------------------------------------------------- 00077 #ifdef TAPs_DEBUG_MODE 00078 #ifdef TAPs_USE_WXWIDGETS 00079 wxLogWarning( wxT( "Regenerated Grids:" ) ); 00080 wxLogWarning( wxT( " w/ size: %i, %i, %i" ), m_auiGridSize[0], m_auiGridSize[1], m_auiGridSize[2] ); 00081 wxLogWarning( wxT( " w/ dim: %g, %g, %g" ), m_atGridDimension[0], m_atGridDimension[1], m_atGridDimension[2] ); 00082 #else 00083 //std::cerr << "Error: " << glewGetErrorString( err ) << std::endl; 00084 #endif 00085 #endif 00086 //--------------------------------------------------------------- 00087 return true; 00088 } 00089 //----------------------------------------------------------------------------- 00090 // Generate Grids with Input Dimension 00091 template <typename T, typename DATA> 00092 bool GridGenerator<T,DATA>::GenerateGridsWithDimension ( 00093 T iGridWidth, T iGridHeight, T iGridDepth, 00094 Vector3<T> * lowPoint, Vector3<T> * highPoint 00095 ) 00096 { 00097 if ( !m_pModel ) return false; 00098 //--------------------------------------------------------------- 00099 //if ( iGridWidth == m_atGridDimension[0] 00100 // && iGridHeight == m_atGridDimension[1] 00101 // && iGridDepth == m_atGridDimension[2] ) 00102 //{ 00103 // return false; 00104 //} 00105 //--------------------------------------------------------------- 00106 DeleteGrids(); 00107 //--------------------------------------------------------------- 00108 // Set Dimension 00109 m_atGridDimension[0] = iGridWidth; 00110 m_atGridDimension[1] = iGridHeight; 00111 m_atGridDimension[2] = iGridDepth; 00112 //--------------------------------------------------------------- 00113 // Set Size 00114 FindBoundingBoxDimension( lowPoint, highPoint ); 00115 T xSize = ( m_tAABBMax[0] - m_tAABBMin[0] ) / m_atGridDimension[0]; 00116 T ySize = ( m_tAABBMax[1] - m_tAABBMin[1] ) / m_atGridDimension[1]; 00117 T zSize = ( m_tAABBMax[2] - m_tAABBMin[2] ) / m_atGridDimension[2]; 00118 m_auiGridSize[0] = ceil( xSize ); 00119 m_auiGridSize[1] = ceil( ySize ); 00120 m_auiGridSize[2] = ceil( zSize ); 00121 ++m_auiGridSize[0]; 00122 ++m_auiGridSize[1]; 00123 ++m_auiGridSize[2]; 00124 00125 // DEBUG 00126 //wxLogWarning( wxT( " w/ left over: %g, %g, %g" ), 00127 // xSize - m_atGridDimension[0], 00128 // ySize - m_atGridDimension[1], 00129 // zSize - m_atGridDimension[2] ); 00130 //--------------------------------------------------------------- 00131 GenerateGrids(); 00132 //--------------------------------------------------------------- 00133 #ifdef TAPs_DEBUG_MODE 00134 #ifdef TAPs_USE_WXWIDGETS 00135 wxLogWarning( wxT( "Grid Generator:" ) ); 00136 wxLogWarning( wxT( " w/ size: %i, %i, %i" ), m_auiGridSize[0], m_auiGridSize[1], m_auiGridSize[2] ); 00137 wxLogWarning( wxT( " w/ dim: %g, %g, %g" ), m_atGridDimension[0], m_atGridDimension[1], m_atGridDimension[2] ); 00138 #else 00139 //std::cerr << "Error: " << glewGetErrorString( err ) << std::endl; 00140 #endif 00141 #endif 00142 //--------------------------------------------------------------- 00143 return true; 00144 } 00145 //----------------------------------------------------------------------------- 00146 // Generate Grids with Input Size 00147 template <typename T, typename DATA> 00148 bool GridGenerator<T,DATA>::GenerateGridsWithSize ( 00149 int iNumOfXSlices, int iNumOfYSlices, int iNumOfZSlices, 00150 Vector3<T> * lowPoint, Vector3<T> * highPoint 00151 ) 00152 { 00153 if ( !m_pModel ) return false; 00154 //--------------------------------------------------------------- 00155 //if ( iNumOfXSlices == m_auiGridSize[0] 00156 // && iNumOfYSlices == m_auiGridSize[1] 00157 // && iNumOfZSlices == m_auiGridSize[2] ) 00158 //{ 00159 // return false; 00160 //} 00161 //--------------------------------------------------------------- 00162 DeleteGrids(); 00163 //--------------------------------------------------------------- 00164 // Set Size 00165 m_auiGridSize[0] = iNumOfXSlices; 00166 m_auiGridSize[1] = iNumOfYSlices; 00167 m_auiGridSize[2] = iNumOfZSlices; 00168 //--------------------------------------------------------------- 00169 //* 00170 // Set Dimension 00171 // without adjustment 00172 FindBoundingBoxDimension( lowPoint, highPoint ); 00173 m_atGridDimension[0] = ( m_tAABBMax[0] - m_tAABBMin[0] ) / ( m_auiGridSize[0] - 1 ); 00174 m_atGridDimension[1] = ( m_tAABBMax[1] - m_tAABBMin[1] ) / ( m_auiGridSize[1] - 1 ); 00175 m_atGridDimension[2] = ( m_tAABBMax[2] - m_tAABBMin[2] ) / ( m_auiGridSize[2] - 1 ); 00176 //*/ 00177 //--------------------------------------------------------------- 00178 /* 00179 //=============================================================== 00180 // Set Dimension 00181 // with adjustment for expaning the AABB box 00182 // so that all of the boundary elements are outside of the mesh 00183 //--------------------------------------------------------------- 00184 FindBoundingBoxDimension( lowPoint, highPoint ); 00185 m_atGridDimension[0] = ( m_tAABBMax[0] - m_tAABBMin[0] ) / ( m_auiGridSize[0] - 3 ); 00186 m_atGridDimension[1] = ( m_tAABBMax[1] - m_tAABBMin[1] ) / ( m_auiGridSize[1] - 3 ); 00187 m_atGridDimension[2] = ( m_tAABBMax[2] - m_tAABBMin[2] ) / ( m_auiGridSize[2] - 3 ); 00188 //------------------------------------------- 00189 // Adjust Mins and Maxs of AABB 00190 m_tAABBMin[0] -= m_atGridDimension[0]; 00191 m_tAABBMin[1] -= m_atGridDimension[1]; 00192 m_tAABBMin[2] -= m_atGridDimension[2]; 00193 m_tAABBMax[0] += m_atGridDimension[0]; 00194 m_tAABBMax[1] += m_atGridDimension[1]; 00195 m_tAABBMax[2] += m_atGridDimension[2]; 00196 //--------------------------------------------------------------- 00197 //=============================================================== 00198 //*/ 00199 //--------------------------------------------------------------- 00200 GenerateGrids(); 00201 //--------------------------------------------------------------- 00202 #ifdef TAPs_DEBUG_MODE 00203 #ifdef TAPs_USE_WXWIDGETS 00204 wxLogWarning( wxT( "Grid Generator:" ) ); 00205 wxLogWarning( wxT( " w/ size: %i, %i, %i" ), m_auiGridSize[0], m_auiGridSize[1], m_auiGridSize[2] ); 00206 wxLogWarning( wxT( " w/ dim: %g, %g, %g" ), m_atGridDimension[0], m_atGridDimension[1], m_atGridDimension[2] ); 00207 #else 00208 //std::cerr << "Error: " << glewGetErrorString( err ) << std::endl; 00209 #endif 00210 #endif 00211 //--------------------------------------------------------------- 00212 return true; 00213 } 00214 //----------------------------------------------------------------------------- 00215 00216 //* 00217 //***************************************************************************** 00218 // START: DEBUG for Checking Marching Cubes Tables 00219 //----------------------------------------------------------------------------- 00220 // Generate Grids 00221 template <typename T, typename DATA> 00222 bool GridGenerator<T,DATA>::GenerateDefinedGrids2x2x2 ( 00223 unsigned char config, 00224 int iNumOfXSlices, int iNumOfYSlices, int iNumOfZSlices, 00225 Vector3<T> * lowPoint, Vector3<T> * highPoint 00226 ) 00227 { 00228 // Flag arrangement (right-handed xyz-coordinates) 00229 // 3---2 00230 // /| /| 00231 // / 0-/-1 00232 // 7---6 / 00233 // |/ |/ 00234 // 4---5 00235 int idx[8][3] = { 00236 { 0,0,0 }, 00237 { 1,0,0 }, 00238 { 1,1,0 }, 00239 { 0,1,0 }, 00240 { 0,0,1 }, 00241 { 1,0,1 }, 00242 { 1,1,1 }, 00243 { 0,1,1 } 00244 }; 00245 00246 if ( !m_pModel ) return false; 00247 //--------------------------------------------------------------- 00248 DeleteGrids(); 00249 //--------------------------------------------------------------- 00250 // Set Size 00251 m_auiGridSize[0] = iNumOfXSlices = 2; 00252 m_auiGridSize[1] = iNumOfYSlices = 2; 00253 m_auiGridSize[2] = iNumOfZSlices = 2; 00254 //--------------------------------------------------------------- 00255 //* 00256 // Set Dimension 00257 // without adjustment 00258 FindBoundingBoxDimension( lowPoint, highPoint ); 00259 m_atGridDimension[0] = ( m_tAABBMax[0] - m_tAABBMin[0] ) / ( m_auiGridSize[0] - 1 ); 00260 m_atGridDimension[1] = ( m_tAABBMax[1] - m_tAABBMin[1] ) / ( m_auiGridSize[1] - 1 ); 00261 m_atGridDimension[2] = ( m_tAABBMax[2] - m_tAABBMin[2] ) / ( m_auiGridSize[2] - 1 ); 00262 00263 T tMinMaxIdx[8][3] = { 00264 { m_tAABBMin[0], m_tAABBMin[1], m_tAABBMin[2] }, 00265 { m_tAABBMax[0], m_tAABBMin[1], m_tAABBMin[2] }, 00266 { m_tAABBMax[0], m_tAABBMax[1], m_tAABBMin[2] }, 00267 { m_tAABBMin[0], m_tAABBMax[1], m_tAABBMin[2] }, 00268 { m_tAABBMin[0], m_tAABBMin[1], m_tAABBMax[2] }, 00269 { m_tAABBMax[0], m_tAABBMin[1], m_tAABBMax[2] }, 00270 { m_tAABBMax[0], m_tAABBMax[1], m_tAABBMax[2] }, 00271 { m_tAABBMin[0], m_tAABBMax[1], m_tAABBMax[2] }, 00272 }; 00273 //*/ 00274 //--------------------------------------------------------------- 00275 //GenerateGrids(); 00276 GenerateGridsForPosition(); 00277 GenerateGridsForNormal(); 00278 GenerateGridsForFlag1(); 00279 GenerateGridsForVertexInterpolation(); 00280 //--------------------------------------------------------------- 00281 char mask = 1; 00282 for ( int i = 0; i < 8; ++i ) { 00283 m_atVertexPosition[idx[i][0]][idx[i][1]][idx[i][2]][0] = tMinMaxIdx[i][0]; 00284 m_atVertexPosition[idx[i][0]][idx[i][1]][idx[i][2]][1] = tMinMaxIdx[i][1]; 00285 m_atVertexPosition[idx[i][0]][idx[i][1]][idx[i][2]][2] = tMinMaxIdx[i][2]; 00286 if ( config & mask ) { 00287 m_abVertexFlag1[idx[i][0]][idx[i][1]][idx[i][2]] = RIGHT_INSIDE_BOUNDARY; 00288 } 00289 else { 00290 m_abVertexFlag1[idx[i][0]][idx[i][1]][idx[i][2]] = RIGHT_OUTSIDE_BOUNDARY; 00291 } 00292 mask = mask<<1; 00293 } 00294 //--------------------------------------------------------------- 00295 SetVertexInterpolationData( 0.5 ); 00296 //--------------------------------------------------------------- 00297 #ifdef TAPs_DEBUG_MODE 00298 #ifdef TAPs_USE_WXWIDGETS 00299 wxLogWarning( wxT( "Grid Generator (GenerateDefinedGrids2x2x2):" ) ); 00300 wxLogWarning( wxT( " w/ size: %i, %i, %i" ), m_auiGridSize[0], m_auiGridSize[1], m_auiGridSize[2] ); 00301 wxLogWarning( wxT( " w/ dim: %g, %g, %g" ), m_atGridDimension[0], m_atGridDimension[1], m_atGridDimension[2] ); 00302 #else 00303 //std::cerr << "Error: " << glewGetErrorString( err ) << std::endl; 00304 #endif 00305 #endif 00306 //--------------------------------------------------------------- 00307 return true; 00308 } 00309 //----------------------------------------------------------------------------- 00310 // END: DEBUG for Checking Marching Cubes Tables 00311 //***************************************************************************** 00312 //*/ 00313 00314 //----------------------------------------------------------------------------- 00315 // Find Bounding Box Dimension 00316 template <typename T, typename DATA> 00317 void GridGenerator<T,DATA>::FindBoundingBoxDimension ( 00318 Vector3<T> * lowPoint, Vector3<T> * highPoint 00319 ) 00320 { 00321 if ( lowPoint == NULL || highPoint == NULL ) { 00322 m_pModel->CalBoundingAABB(); // Could be commented out 00323 Vector3<T> lowPoint = m_pModel->GetBoundingAABBLowPoint(); 00324 Vector3<T> highPoint = m_pModel->GetBoundingAABBHighPoint(); 00325 00326 // AABB SCALING ADJUSTER 00327 //----------------------------------------------------- 00328 // This scaling makes the grid box bigger than the AABB of the mesh. 00329 // So that all of the border grid points are outside the mesh. 00330 //* 00331 Vector3<T> scale = (highPoint - lowPoint) * 0.00001; 00332 //Vector3<T> scale = (highPoint - lowPoint) * 0.25; 00333 //Vector3<T> scale = (highPoint - lowPoint) * 1; 00334 lowPoint -= scale; 00335 highPoint += scale; 00336 //*/ 00337 //----------------------------------------------------- 00338 // Set the size of the grid box 00339 m_tAABBMin[0] = lowPoint[0]; 00340 m_tAABBMin[1] = lowPoint[1]; 00341 m_tAABBMin[2] = lowPoint[2]; 00342 m_tAABBMax[0] = highPoint[0]; 00343 m_tAABBMax[1] = highPoint[1]; 00344 m_tAABBMax[2] = highPoint[2]; 00345 } 00346 else { 00347 //----------------------------------------------------- 00348 // Set the size of the grid box 00349 m_tAABBMin[0] = lowPoint->GetX(); 00350 m_tAABBMin[1] = lowPoint->GetY(); 00351 m_tAABBMin[2] = lowPoint->GetZ(); 00352 m_tAABBMax[0] = highPoint->GetX(); 00353 m_tAABBMax[1] = highPoint->GetY(); 00354 m_tAABBMax[2] = highPoint->GetZ(); 00355 } 00356 } 00357 //----------------------------------------------------------------------------- 00358 00359 00360 00361 00362 //----------------------------------------------------------------------------- 00363 // Generate Grids 00364 template <typename T, typename DATA> 00365 void GridGenerator<T,DATA>::GenerateGrids () 00366 { 00367 GenerateGridsForPosition(); 00368 GenerateGridsForNormal(); 00369 GenerateGridsForFlag1(); 00370 GenerateGridsForVertexInterpolation(); 00371 //--------------------------------------------------------------- 00372 #ifdef TAPs_GRID_GENERATOR_BY_SOFTWARE 00373 if ( m_bUseSoftwareToGenGrid ) { 00374 std::cout << "Use SW to generate grids\n"; 00375 SetGridPointsToInsideOutsideModelBoundary_SW(); 00376 SetAllGridPointsToInsideOutsideModel_SW(); 00377 } 00378 #endif 00379 #ifdef TAPs_GRID_GENERATOR_BY_HARDWARE 00380 if ( !m_bUseSoftwareToGenGrid ) { 00381 std::cout << "Use HW to generate grids\n"; 00382 SetAllGridPointsToInsideOutsideModel_HW(); 00383 } 00384 #endif 00385 //--------------------------------------------------------------- 00386 ClearExtraRightOutsidePoints(); 00387 if ( m_bGenGridInversely ) { 00388 InverseInsideOutside(); 00389 ClearExtraRightOutsidePoints(); 00390 } 00391 SetVertexInterpolationData(); 00392 } 00393 //----------------------------------------------------------------------------- 00394 // Generate Position Grids 00395 template <typename T, typename DATA> 00396 void GridGenerator<T,DATA>::GenerateGridsForPosition () 00397 { 00398 AllocateGridsForPosition(); 00399 //--------------------------------------------------------------- 00400 T x = m_tAABBMin[0];// - m_atGridDimension[0]; 00401 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 00402 T y = m_tAABBMin[1];// - m_atGridDimension[1]; 00403 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 00404 T z = m_tAABBMin[2];// - m_atGridDimension[2]; 00405 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 00406 m_atVertexPosition[i][j][k][0] = x; 00407 m_atVertexPosition[i][j][k][1] = y; 00408 m_atVertexPosition[i][j][k][2] = z; 00409 z += m_atGridDimension[2]; 00410 } 00411 y += m_atGridDimension[1]; 00412 } 00413 x += m_atGridDimension[0]; 00414 } 00415 //--------------------------------------------------------------- 00416 } 00417 //----------------------------------------------------------------------------- 00418 // Generate Normal Grids 00419 template <typename T, typename DATA> 00420 void GridGenerator<T,DATA>::GenerateGridsForNormal () 00421 { 00422 //--------------------------------------------------------------- 00423 AllocateGridsForNormal(); 00424 //--------------------------------------------------------------- 00425 } 00426 //----------------------------------------------------------------------------- 00427 // Generate Flag1 Grids 00428 template <typename T, typename DATA> 00429 void GridGenerator<T,DATA>::GenerateGridsForFlag1 () 00430 { 00431 //--------------------------------------------------------------- 00432 AllocateGridsForFlag1(); 00433 //--------------------------------------------------------------- 00434 } 00435 //----------------------------------------------------------------------------- 00436 // Generate Vertex Interpolation Grids 00437 template <typename T, typename DATA> 00438 void GridGenerator<T,DATA>::GenerateGridsForVertexInterpolation () 00439 { 00440 //--------------------------------------------------------------- 00441 AllocateGridsForVertexInterpolation(); 00442 //--------------------------------------------------------------- 00443 } 00444 //----------------------------------------------------------------------------- 00445 // Allocate Position Grids 00446 template <typename T, typename DATA> 00447 void GridGenerator<T,DATA>::AllocateGridsForPosition () 00448 { 00449 //DeleteGridsForPosition(); 00450 //--------------------------------------------------------------- 00451 m_atVertexPosition = new T***[ m_auiGridSize[0] ]; 00452 assert( m_atVertexPosition ); 00453 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 00454 m_atVertexPosition[i] = new T**[ m_auiGridSize[1] ]; 00455 assert( m_atVertexPosition[i] ); 00456 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 00457 m_atVertexPosition[i][j] = new T*[ m_auiGridSize[2] ]; 00458 assert( m_atVertexPosition[i][j] ); 00459 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 00460 m_atVertexPosition[i][j][k] = new T[ 3 ]; 00461 assert( m_atVertexPosition[i][j][k] ); 00462 } 00463 } 00464 } 00465 //--------------------------------------------------------------- 00466 } 00467 //----------------------------------------------------------------------------- 00468 // Allocate Normal Grids 00469 template <typename T, typename DATA> 00470 void GridGenerator<T,DATA>::AllocateGridsForNormal () 00471 { 00472 //DeleteGridsForNormal(); 00473 //--------------------------------------------------------------- 00474 m_atVertexNormal = new T***[ m_auiGridSize[0] ]; 00475 assert( m_atVertexNormal ); 00476 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 00477 m_atVertexNormal[i] = new T**[ m_auiGridSize[1] ]; 00478 assert( m_atVertexNormal[i] ); 00479 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 00480 m_atVertexNormal[i][j] = new T*[ m_auiGridSize[2] ]; 00481 assert( m_atVertexNormal[i][j] ); 00482 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 00483 m_atVertexNormal[i][j][k] = new T[ 3 ]; 00484 assert( m_atVertexNormal[i][j][k] ); 00485 } 00486 } 00487 } 00488 //--------------------------------------------------------------- 00489 } 00490 //----------------------------------------------------------------------------- 00491 // Allocate Flag1 Grids 00492 template <typename T, typename DATA> 00493 void GridGenerator<T,DATA>::AllocateGridsForFlag1 () 00494 { 00495 //DeleteGridsForFlag1(); 00496 //--------------------------------------------------------------- 00497 m_abVertexFlag1 = new VertexFlag **[ m_auiGridSize[0] ]; 00498 assert( m_abVertexFlag1 ); 00499 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 00500 m_abVertexFlag1[i] = new VertexFlag *[ m_auiGridSize[1] ]; 00501 assert( m_abVertexFlag1[i] ); 00502 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 00503 m_abVertexFlag1[i][j] = new VertexFlag [ m_auiGridSize[2] ]; 00504 assert( m_abVertexFlag1[i][j] ); 00505 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 00506 m_abVertexFlag1[i][j][k] = UNSET; 00507 } 00508 } 00509 } 00510 //--------------------------------------------------------------- 00511 } 00512 //----------------------------------------------------------------------------- 00513 // Allocate Vertex Interpolation Grids 00514 template <typename T, typename DATA> 00515 void GridGenerator<T,DATA>::AllocateGridsForVertexInterpolation () 00516 { 00517 //DeleteGridsForVertexInterpolation(); 00518 //--------------------------------------------------------------- 00519 m_atVertexInterpolation = new T***[ m_auiGridSize[0] ]; 00520 assert( m_atVertexInterpolation ); 00521 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 00522 m_atVertexInterpolation[i] = new T**[ m_auiGridSize[1] ]; 00523 assert( m_atVertexInterpolation[i] ); 00524 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 00525 m_atVertexInterpolation[i][j] = new T*[ m_auiGridSize[2] ]; 00526 assert( m_atVertexInterpolation[i][j] ); 00527 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 00528 m_atVertexInterpolation[i][j][k] = new T[ 3 ]; 00529 assert( m_atVertexInterpolation[i][j][k] ); 00530 } 00531 } 00532 } 00533 //--------------------------------------------------------------- 00534 } 00535 //----------------------------------------------------------------------------- 00536 00537 00538 //============================================================================= 00539 #ifdef TAPs_GRID_GENERATOR_BY_SOFTWARE 00540 //----------------------------------------------------------------------------- 00541 // Set Grid Points To Inside and Outside the Model 00542 template <typename T, typename DATA> 00543 void GridGenerator<T,DATA>::SetGridPointsToInsideOutsideModelBoundary_SW () 00544 { 00545 if ( !m_pModel ) return; 00546 //--------------------------------------------------------------- 00547 OpenGL::PolygonalModel<T> * pPologonalModel 00548 = dynamic_cast< OpenGL::PolygonalModel<T> * >( m_pModel ); 00549 OpenGL::XPolygonalModel<T> * pXPologonalModel 00550 = dynamic_cast< OpenGL::XPolygonalModel<T> * >( m_pModel ); 00551 OpenGL::HalfEdgeModel<T> * pHalfEdgeModel 00552 = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( m_pModel ); 00553 //--------------------------------------------------------------- 00554 // For PolygonalModel 00555 if ( pPologonalModel ) { 00556 SetGridPointsToInsideOutsideModelBoundary_SW( pPologonalModel ); 00557 return; 00558 } 00559 //--------------------------------------------------------------- 00560 // For XPolygonalModel 00561 if ( pXPologonalModel ) { 00562 SetGridPointsToInsideOutsideModelBoundary_SW( pXPologonalModel ); 00563 return; 00564 } 00565 //--------------------------------------------------------------- 00566 // For HalfEdgeModel 00567 if ( pHalfEdgeModel ) { 00568 SetGridPointsToInsideOutsideModelBoundary_SW( pHalfEdgeModel ); 00569 return; 00570 } 00571 //--------------------------------------------------------------- 00572 } 00573 //----------------------------------------------------------------------------- 00574 // Set Grid Points To Inside and Outside the Model 00575 template <typename T, typename DATA> 00576 void GridGenerator<T,DATA>::SetGridPointsToInsideOutsideModelBoundary_SW ( 00577 OpenGL::PolygonalModel<T> * pPModel ) 00578 { 00579 Vertex<T> * vertexList = pPModel->GetVertexList(); 00580 assert( false ); 00581 // Find two vertices; (-x,0,0) and (x,0,0) 00582 // and faces that contain them 00583 } 00584 //----------------------------------------------------------------------------- 00585 // Set Grid Points To Inside and Outside the Model 00586 template <typename T, typename DATA> 00587 void GridGenerator<T,DATA>::SetGridPointsToInsideOutsideModelBoundary_SW ( 00588 OpenGL::XPolygonalModel<T> * pXPModel ) 00589 { 00590 //--------------------------------------------------------------- 00591 XVertex<T> * vertex = pXPModel->GetVertexList(); 00592 Face<T> * face = pXPModel->GetFaceList(); 00593 int NumFaces = pXPModel->GetNoFaces(); 00594 //--------------------------------------------------------------- 00595 // Generate Grid by a Software Algorithm 00596 //----------------------------------------------------- 00597 Vector3<T> vMin, vMax, vPos, vAverage; 00598 //----------------------------------------------------- 00599 // For Each Face 00600 for ( int i = 0; i < NumFaces; ++i ) { 00601 //--------------------------------------- 00602 // Find a box that contain this face 00603 vAverage = vMin = vMax = vertex[ face[i].GetVertexNo(0) ].GetPosition(); 00604 for ( int n = 1; n < face[i].GetNoVertices(); ++n ) { 00605 vPos = vertex[ face[i].GetVertexNo(n) ].GetPosition(); 00606 vAverage += vPos; 00607 for ( int d = 0; d < 3; ++d ) { 00608 if ( vMin[d] > vPos[d] ) vMin[d] = vPos[d]; 00609 else if ( vMax[d] < vPos[d] ) vMax[d] = vPos[d]; 00610 } 00611 } 00612 //assert( vMin[0] <= vMax[0] ); 00613 //assert( vMin[1] <= vMax[1] ); 00614 //assert( vMin[2] <= vMax[2] ); 00615 //--------------------------------------- 00616 // Find a box of grids that contain this face 00617 // i.e. a bigger box that contain the face box 00618 int gMinNum[3], gMaxNum[3]; 00619 T gMin, gMax; 00620 for ( int d = 0; d < 3; ++d ) { 00621 int step = m_auiGridSize[d] / 2; 00622 gMinNum[d] = gMaxNum[d] = step; 00623 gMin = m_tAABBMin[d] + gMinNum[d] * m_atGridDimension[d]; 00624 T minOffset = vMin[d] - m_atGridDimension[d] / 2; 00625 T maxOffset = vMax[d] + m_atGridDimension[d] / 2; 00626 //T minOffset = vMin[d]; 00627 //T maxOffset = vMax[d]; 00628 //------------------------- 00629 // Find a box of this current face 00630 while ( ( gMin < minOffset || maxOffset < gMin ) && step > 1 ) { 00631 step /= 2; 00632 if ( gMin < minOffset ) { 00633 gMinNum[d] += step; 00634 } 00635 else { 00636 gMinNum[d] -= step; 00637 } 00638 gMin = m_tAABBMin[d] + gMinNum[d] * m_atGridDimension[d]; 00639 } 00640 gMax = gMin; 00641 gMaxNum[d] = gMinNum[d]; 00642 00643 // DEBUG 00644 //gridBoxCenterPt[d] = gMinNum[d]; 00645 00646 //------------------------- 00647 // Find a grid box that covers the box of this current face 00648 //minMoveStep[d] = maxMoveStep[d] = 0; // DEBUG 00649 //------------------------- 00650 // Find the low 00651 while ( vMin[d] < gMin ) { 00652 //while ( minOffset < gMin ) { 00653 //--minMoveStep[d]; // DEBUG 00654 --gMinNum[d]; 00655 gMin -= m_atGridDimension[d]; 00656 } 00657 if ( gMinNum[d] < 0 ) { 00658 gMinNum[d] = 0; 00659 } 00660 //------------------------- 00661 // Find the high 00662 while ( gMax < vMax[d] ) { 00663 //while ( gMax < maxOffset ) { 00664 //++maxMoveStep[d]; // DEBUG 00665 ++gMaxNum[d]; 00666 gMax += m_atGridDimension[d]; 00667 } 00668 if ( gMaxNum[d] >= m_auiGridSize[d] ) { 00669 gMaxNum[d] = m_auiGridSize[d] - 1; 00670 } 00671 //----------------------------------- 00672 //assert( gMinNum[d] <= gMaxNum[d] ); 00673 //assert( 0 <= gMinNum[d] && gMinNum[d] < m_auiGridSize[d] ); 00674 //assert( 0 <= gMaxNum[d] && gMaxNum[d] < m_auiGridSize[d] ); 00675 } 00676 //------------------------------------------------- 00677 // Set Inside / Outside 00678 //vPos = vertex[ face[i].GetVertexNo(0) ].GetPosition(); 00679 vAverage /= face[i].GetNoVertices(); 00680 Vector3<T> normal = face[i].GetNormal(); 00681 Vector3<T> direction; 00682 for ( int x = gMinNum[0]; x <= gMaxNum[0]; ++x ) { 00683 for ( int y = gMinNum[1]; y <= gMaxNum[1]; ++y ) { 00684 for ( int z = gMinNum[2]; z <= gMaxNum[2]; ++z ) { 00685 direction.SetXYZ( 00686 m_atVertexPosition[x][y][z][0] - vAverage[0], 00687 m_atVertexPosition[x][y][z][1] - vAverage[1], 00688 m_atVertexPosition[x][y][z][2] - vAverage[2] 00689 ); 00690 //--------------------------- 00691 // If just outside boundary 00692 if ( m_abVertexFlag1[x][y][z] == RIGHT_OUTSIDE_BOUNDARY ) continue; 00693 //--------------------------- 00694 // The point is inside, on, or outside the boundary. 00695 if ( normal * direction < 0.0 ) { 00696 m_abVertexFlag1[x][y][z] = RIGHT_INSIDE_BOUNDARY; 00697 } 00698 else if ( normal * direction == 0.0 ) { 00699 m_abVertexFlag1[x][y][z] = ON_BOUNDARY; 00700 } 00701 else { 00702 m_abVertexFlag1[x][y][z] = RIGHT_OUTSIDE_BOUNDARY; 00703 } 00704 } 00705 } 00706 } 00707 //------------------------------------------------- 00708 } 00709 //--------------------------------------------------------------- 00710 // End of Generating Grid by a Software Algorithm 00711 } 00712 //----------------------------------------------------------------------------- 00713 // Set Grid Points To Inside and Outside the Model 00714 // NOT IMPLEMENTED YET! 00715 template <typename T, typename DATA> 00716 void GridGenerator<T,DATA>::SetGridPointsToInsideOutsideModelBoundary_SW ( 00717 OpenGL::HalfEdgeModel<T> * pHEModel ) 00718 { 00719 assert( false ); 00720 // Find two vertices; (-x,0,0) and (x,0,0) 00721 // and faces that contain them 00722 } 00723 //----------------------------------------------------------------------------- 00724 // Set (Flood-Fill) All Grid Points To Inside and Outside the Model 00725 template <typename T, typename DATA> 00726 void GridGenerator<T,DATA>::SetAllGridPointsToInsideOutsideModel_SW () 00727 { 00728 //* 00729 int val = 0; 00730 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 00731 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 00732 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 00733 val = 0; 00734 if ( m_abVertexFlag1[i][j][k] == UNSET ) { 00735 if ( m_abVertexFlag1[i+1][j][k] == RIGHT_OUTSIDE_BOUNDARY ) --val; 00736 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) ++val; 00737 if ( m_abVertexFlag1[i-1][j][k] == RIGHT_OUTSIDE_BOUNDARY ) --val; 00738 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) ++val; 00739 if ( m_abVertexFlag1[i][j+1][k] == RIGHT_OUTSIDE_BOUNDARY ) --val; 00740 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) ++val; 00741 if ( m_abVertexFlag1[i][j-1][k] == RIGHT_OUTSIDE_BOUNDARY ) --val; 00742 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) ++val; 00743 if ( m_abVertexFlag1[i][j][k+1] == RIGHT_OUTSIDE_BOUNDARY ) --val; 00744 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) ++val; 00745 if ( m_abVertexFlag1[i][j][k-1] == RIGHT_OUTSIDE_BOUNDARY ) --val; 00746 else if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) ++val; 00747 if ( val > 0 ) { 00748 m_abVertexFlag1[i][j][k] = INSIDE_MODEL; 00749 } 00750 else { 00751 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 00752 } 00753 } 00754 } 00755 } 00756 } 00757 //*/ 00758 } 00759 //----------------------------------------------------------------------------- 00760 #endif // of #ifdef TAPs_GRID_GENERATOR_BY_SOFTWARE 00761 //============================================================================= 00762 00763 00764 //============================================================================= 00765 #ifdef TAPs_GRID_GENERATOR_BY_HARDWARE 00766 //----------------------------------------------------------------------------- 00767 // Set Grid Points To Inside and Outside the Model 00768 template <typename T, typename DATA> 00769 void GridGenerator<T,DATA>::SetAllGridPointsToInsideOutsideModel_HW () 00770 { 00771 if ( !m_pModel ) return; 00772 //--------------------------------------------------------------- 00773 OpenGL::PolygonalModel<T> * pPologonalModel 00774 = dynamic_cast< OpenGL::PolygonalModel<T> * >( m_pModel ); 00775 OpenGL::XPolygonalModel<T> * pXPologonalModel 00776 = dynamic_cast< OpenGL::XPolygonalModel<T> * >( m_pModel ); 00777 OpenGL::HalfEdgeModel<T> * pHalfEdgeModel 00778 = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( m_pModel ); 00779 //--------------------------------------------------------------- 00780 // For PolygonalModel 00781 if ( pPologonalModel ) { 00782 SetAllGridPointsToInsideOutsideModel_HW( pPologonalModel ); 00783 return; 00784 } 00785 //--------------------------------------------------------------- 00786 // For XPolygonalModel 00787 if ( pXPologonalModel ) { 00788 SetAllGridPointsToInsideOutsideModel_HW( pXPologonalModel ); 00789 return; 00790 } 00791 //--------------------------------------------------------------- 00792 // For HalfEdgeModel 00793 if ( pHalfEdgeModel ) { 00794 SetAllGridPointsToInsideOutsideModel_HW( pHalfEdgeModel ); 00795 return; 00796 } 00797 //--------------------------------------------------------------- 00798 } 00799 //----------------------------------------------------------------------------- 00800 // Set Grid Points To Inside and Outside the Model 00801 // NOT IMPLEMENTED YET! 00802 template <typename T, typename DATA> 00803 void GridGenerator<T,DATA>::SetAllGridPointsToInsideOutsideModel_HW ( 00804 OpenGL::PolygonalModel<T> * pPModel ) 00805 { 00806 Vertex<T> * vertexList = pPModel->GetVertexList(); 00807 assert( false ); 00808 // Find two vertices; (-x,0,0) and (x,0,0) 00809 // and faces that contain them 00810 } 00811 //----------------------------------------------------------------------------- 00812 // Set Grid Points To Inside and Outside the Model 00813 template <typename T, typename DATA> 00814 void GridGenerator<T,DATA>::SetAllGridPointsToInsideOutsideModel_HW ( 00815 OpenGL::XPolygonalModel<T> * pXPModel ) 00816 { 00817 //--------------------------------------------------------------- 00818 XVertex<T> * vertex = pXPModel->GetVertexList(); 00819 Face<T> * face = pXPModel->GetFaceList(); 00820 int NumFaces = pXPModel->GetNoFaces(); 00821 //--------------------------------------------------------------- 00822 // Check draw framebuffer size 00823 GLint bitSize[4]; 00824 glGetIntegerv( GL_RED_BITS, &bitSize[0] ); 00825 glGetIntegerv( GL_GREEN_BITS, &bitSize[1] ); 00826 glGetIntegerv( GL_BLUE_BITS, &bitSize[2] ); 00827 glGetIntegerv( GL_ALPHA_BITS, &bitSize[3] ); 00828 //std::cout << "GL_RED_BITS: " << bitSize[0] << "\n"; 00829 //std::cout << "GL_GREEN_BITS: " << bitSize[1] << "\n"; 00830 //std::cout << "GL_BLUE_BITS: " << bitSize[2] << "\n"; 00831 //std::cout << "GL_ALPHA_BITS: " << bitSize[3] << "\n"; 00832 GLenum pixelFormat; 00833 GLfloat * drawData; 00834 GLint pixelSize; 00835 if ( bitSize[3] == 0 ) { // No alpha channel 00836 pixelFormat = GL_RGB; 00837 pixelSize = 3; 00838 } 00839 else { 00840 pixelFormat = GL_RGBA; 00841 pixelSize = 4; 00842 } 00843 GLint startX = 0; 00844 GLint startY = 0; 00845 GLint width = m_auiGridSize[0]; 00846 GLint height = m_auiGridSize[1]; 00847 GLenum dataType = GL_FLOAT; 00848 drawData = new GLfloat[ width * height * pixelSize ]; 00849 assert( drawData ); 00850 00851 // DEBUG 00852 //for ( unsigned int i = 0; i < width * height * pixelSize; ++i ) { 00853 // drawData[i] = 1; 00854 //} 00855 00856 // For each (Z) slice, create a clipping plane with the same 00857 // position and orientation as the slice. 00858 glPushAttrib( GL_ALL_ATTRIB_BITS ); 00859 glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); 00860 GLdouble zPlane[4] = { 0.0, 0.0, -1.0, m_tAABBMin[2] }; 00861 //------------------------------------------- 00862 // Set drawing area 00863 glMatrixMode( GL_PROJECTION ); 00864 glPushMatrix(); 00865 glLoadIdentity(); 00866 //------------------------------------------- 00868 // Since the sampling position is at the center of the pixel 00869 // 00870 // +--------------------------+ 00871 // | 0 | 1 | 2 | 3 | .... |n-1| 00872 // | 0 | 1 | 2 | 3 | .... |n-1| 00873 // | ........................ | 00874 // | ........................ | 00875 // | ........................ | 00876 // | 0 | 1 | 2 | 3 | .... |n-1| 00877 // +--------------------------+ 00878 // ^ ^ ^ ^ ^ ^ 00879 // | | | | | | 00880 // | | --h-- | | 00881 // | ---min & Max of model--- | 00882 // ---min & Max of ortho view-- 00883 // h = ((Max - min) of model) / (n-1) 00884 // min of ortho view = min of model - h/2 00885 // Max of ortho view = Max of model + h/2 00887 T h_half[3]; 00888 T orthoMin[3], orthoMax[3]; 00889 for ( int i = 0; i < 3; ++i ) { 00890 int steps = m_auiGridSize[i] - 1; 00891 if ( steps >= 0 ) { 00892 h_half[i] = ( m_tAABBMax[i] - m_tAABBMin[i] ) / static_cast<T>(steps) / 2.0; 00893 } 00894 else { 00895 h_half[i] = 0; 00896 } 00897 orthoMin[i] = m_tAABBMin[i] - h_half[i]; 00898 orthoMax[i] = m_tAABBMax[i] + h_half[i]; 00899 } 00901 //glOrtho( m_tAABBMin[0], m_tAABBMax[0], 00902 // m_tAABBMin[1], m_tAABBMax[1], 00903 // m_tAABBMin[2]-100, m_tAABBMax[2]+100 ); 00905 //glOrtho( 00906 // orthoMin[0], orthoMax[0], 00907 // orthoMin[1], orthoMax[1], 00908 // orthoMin[2]-100, orthoMax[2]+100 00909 //); 00911 T orthoAdjustZ = ( orthoMax[2] - orthoMin[2] ); 00912 glOrtho( 00913 orthoMin[0], orthoMax[0], 00914 orthoMin[1], orthoMax[1], 00915 orthoMin[2] - orthoAdjustZ, orthoMax[2] + orthoAdjustZ 00916 ); 00917 TAPs::OpenGL::Fn::CHECK_GL_ERROR(); 00919 glMatrixMode( GL_MODELVIEW ); 00920 glPushMatrix(); 00921 glLoadIdentity(); 00922 TAPs::OpenGL::Fn::CHECK_GL_ERROR(); 00923 //------------------------------------------- 00924 glViewport( 0, 0, width, height ); 00925 TAPs::OpenGL::Fn::CHECK_GL_ERROR(); 00926 //glDisable( GL_TEXTURE_1D ); 00927 //glDisable( GL_TEXTURE_2D ); 00928 //glDisable( GL_TEXTURE_3D ); 00929 //glDisable( GL_BLEND ); 00930 glDisable( GL_LIGHTING ); 00931 glDisable( GL_DEPTH_TEST ); 00932 glDrawBuffer( GL_BACK ); 00933 glReadBuffer( GL_BACK ); 00934 //------------------------------------------- 00935 for ( int z = 0; z < m_auiGridSize[2]; ++z ) 00936 { 00937 //--------------------------------------- 00938 // Setup clipping plane for the slice 00939 glClipPlane( GL_CLIP_PLANE0, zPlane ); 00940 glEnable( GL_CLIP_PLANE0 ); 00941 //--------------------------------------- 00942 // Clear the slice with a background color 00943 glClearColor( 0.0, 0.0, 0.0, 0.0 ); 00944 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); 00945 //--------------------------------------- 00946 // Render the back faces of the model in the foreground color 00947 glColor3f( 1.0, 0.0, 0.0 ); 00948 glCullFace( GL_FRONT ); 00949 glEnable( GL_CULL_FACE ); 00950 for ( int i = 0; i < NumFaces; ++i ) { 00951 glBegin( GL_POLYGON ); 00952 for ( int n = 0; n < face[i].GetNoVertices(); ++n ) { 00953 Vector3<T> vPos = vertex[ face[i].GetVertexNo(n) ].GetPosition(); 00954 glVertex3d( vPos[0], vPos[1], vPos[2] ); 00955 } 00956 glEnd(); 00957 } 00958 //--------------------------------------- 00959 // Render the back faces of the model in the background color 00960 glColor3f( 0.0, 0.0, 0.0 ); 00961 glCullFace( GL_BACK ); 00962 glEnable( GL_CULL_FACE ); 00963 for ( int i = 0; i < NumFaces; ++i ) { 00964 glBegin( GL_POLYGON ); 00965 for ( int n = 0; n < face[i].GetNoVertices(); ++n ) { 00966 Vector3<T> vPos = vertex[ face[i].GetVertexNo(n) ].GetPosition(); 00967 glVertex3d( vPos[0], vPos[1], vPos[2] ); 00968 } 00969 glEnd(); 00970 } 00971 //--------------------------------------- 00972 glDisable( GL_CLIP_PLANE0 ); 00973 //--------------------------------------- 00974 // Copy the data to m_abVertexFlag1 00975 glReadPixels( startX, startY, width, height, pixelFormat, dataType, drawData ); 00976 int idx = 0; 00977 for ( int h = 0; h < height; ++h ) { 00978 for ( int w = 0; w < width; ++w ) { 00979 if ( drawData[idx] > 0.01 ) { 00980 m_abVertexFlag1[w][h][z] = RIGHT_INSIDE_BOUNDARY; 00981 } 00982 else { 00983 m_abVertexFlag1[w][h][z] = RIGHT_OUTSIDE_BOUNDARY; 00984 } 00985 idx += pixelSize; 00986 } 00987 } 00988 //----------------------------- 00989 // Update the clip plane equation 00990 zPlane[3] += m_atGridDimension[2]; 00991 } // end of for loop 00992 glPopMatrix(); 00993 glMatrixMode( GL_PROJECTION ); 00994 glPopMatrix(); 00995 glMatrixMode( GL_MODELVIEW ); 00996 glPopAttrib(); 00997 delete [] drawData; 00998 //--------------------------------------------------------------- 00999 } 01000 //----------------------------------------------------------------------------- 01001 // Set Grid Points To Inside and Outside the Model 01002 // NOT IMPLEMENTED YET! 01003 template <typename T, typename DATA> 01004 void GridGenerator<T,DATA>::SetAllGridPointsToInsideOutsideModel_HW ( 01005 OpenGL::HalfEdgeModel<T> * pHEModel ) 01006 { 01007 //--------------------------------------------------------------- 01008 //HEVertexList<T> * vertexList = pHEModel->GetVertexList(); 01009 HEFaceList<T> * faceList = pHEModel->GetFaceList(); 01010 //int NumFaces = pHEModel->GetNoFaces(); 01011 //--------------------------------------------------------------- 01012 // Check draw framebuffer size 01013 GLint bitSize[4]; 01014 glGetIntegerv( GL_RED_BITS, &bitSize[0] ); 01015 glGetIntegerv( GL_GREEN_BITS, &bitSize[1] ); 01016 glGetIntegerv( GL_BLUE_BITS, &bitSize[2] ); 01017 glGetIntegerv( GL_ALPHA_BITS, &bitSize[3] ); 01018 //std::cout << "GL_RED_BITS: " << bitSize[0] << "\n"; 01019 //std::cout << "GL_GREEN_BITS: " << bitSize[1] << "\n"; 01020 //std::cout << "GL_BLUE_BITS: " << bitSize[2] << "\n"; 01021 //std::cout << "GL_ALPHA_BITS: " << bitSize[3] << "\n"; 01022 GLenum pixelFormat; 01023 GLfloat * drawData; 01024 GLint pixelSize; 01025 if ( bitSize[3] == 0 ) { // No alpha channel 01026 pixelFormat = GL_RGB; 01027 pixelSize = 3; 01028 } 01029 else { 01030 pixelFormat = GL_RGBA; 01031 pixelSize = 4; 01032 } 01033 GLint startX = 0; 01034 GLint startY = 0; 01035 GLint width = m_auiGridSize[0]; 01036 GLint height = m_auiGridSize[1]; 01037 GLenum dataType = GL_FLOAT; 01038 drawData = new GLfloat[ width * height * pixelSize ]; 01039 assert( drawData ); 01040 01041 // DEBUG 01042 //for ( unsigned int i = 0; i < width * height * pixelSize; ++i ) { 01043 // drawData[i] = 1; 01044 //} 01045 01046 // For each (Z) slice, create a clipping plane with the same 01047 // position and orientation as the slice. 01048 glPushAttrib( GL_ALL_ATTRIB_BITS ); 01049 glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); 01050 GLdouble zPlane[4] = { 0.0, 0.0, -1.0, m_tAABBMin[2] }; 01051 //------------------------------------------- 01052 // Set drawing area 01053 glMatrixMode( GL_PROJECTION ); 01054 glPushMatrix(); 01055 glLoadIdentity(); 01056 //------------------------------------------- 01058 // Since the sampling position is at the center of the pixel 01059 // 01060 // +--------------------------+ 01061 // | 0 | 1 | 2 | 3 | .... |n-1| 01062 // | 0 | 1 | 2 | 3 | .... |n-1| 01063 // | ........................ | 01064 // | ........................ | 01065 // | ........................ | 01066 // | 0 | 1 | 2 | 3 | .... |n-1| 01067 // +--------------------------+ 01068 // ^ ^ ^ ^ ^ ^ 01069 // | | | | | | 01070 // | | --h-- | | 01071 // | ---min & Max of model--- | 01072 // ---min & Max of ortho view-- 01073 // h = ((Max - min) of model) / (n-1) 01074 // min of ortho view = min of model - h/2 01075 // Max of ortho view = Max of model + h/2 01077 T h_half[3]; 01078 T orthoMin[3], orthoMax[3]; 01079 for ( int i = 0; i < 3; ++i ) { 01080 int steps = m_auiGridSize[i] - 1; 01081 if ( steps >= 0 ) { 01082 h_half[i] = ( m_tAABBMax[i] - m_tAABBMin[i] ) / static_cast<T>(steps) / 2.0; 01083 } 01084 else { 01085 h_half[i] = 0; 01086 } 01087 orthoMin[i] = m_tAABBMin[i] - h_half[i]; 01088 orthoMax[i] = m_tAABBMax[i] + h_half[i]; 01089 } 01091 //glOrtho( m_tAABBMin[0], m_tAABBMax[0], 01092 // m_tAABBMin[1], m_tAABBMax[1], 01093 // m_tAABBMin[2]-100, m_tAABBMax[2]+100 ); 01095 //glOrtho( 01096 // orthoMin[0], orthoMax[0], 01097 // orthoMin[1], orthoMax[1], 01098 // orthoMin[2]-100, orthoMax[2]+100 01099 //); 01101 T orthoAdjustZ = ( orthoMax[2] - orthoMin[2] ); 01102 glOrtho( 01103 orthoMin[0], orthoMax[0], 01104 orthoMin[1], orthoMax[1], 01105 orthoMin[2] - orthoAdjustZ, orthoMax[2] + orthoAdjustZ 01106 ); 01107 TAPs::OpenGL::Fn::CHECK_GL_ERROR(); 01109 glMatrixMode( GL_MODELVIEW ); 01110 glPushMatrix(); 01111 glLoadIdentity(); 01112 TAPs::OpenGL::Fn::CHECK_GL_ERROR(); 01113 //------------------------------------------- 01114 glViewport( 0, 0, width, height ); 01115 TAPs::OpenGL::Fn::CHECK_GL_ERROR(); 01116 //glDisable( GL_TEXTURE_1D ); 01117 //glDisable( GL_TEXTURE_2D ); 01118 //glDisable( GL_TEXTURE_3D ); 01119 //glDisable( GL_BLEND ); 01120 glDisable( GL_LIGHTING ); 01121 glDisable( GL_DEPTH_TEST ); 01122 glDrawBuffer( GL_BACK ); 01123 glReadBuffer( GL_BACK ); 01124 HEHalfEdge<T> *halfEdge; 01125 HEFace<T> * face; 01126 //------------------------------------------- 01127 for ( int z = 0; z < m_auiGridSize[2]; ++z ) 01128 { 01129 //--------------------------------------- 01130 // Setup clipping plane for the slice 01131 glClipPlane( GL_CLIP_PLANE0, zPlane ); 01132 glEnable( GL_CLIP_PLANE0 ); 01133 //--------------------------------------- 01134 // Clear the slice with a background color 01135 glClearColor( 0.0, 0.0, 0.0, 0.0 ); 01136 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); 01137 //--------------------------------------- 01138 // Render the back faces of the model in the foreground color 01139 glColor3f( 1.0, 0.0, 0.0 ); 01140 glCullFace( GL_FRONT ); 01141 glEnable( GL_CULL_FACE ); 01142 face = faceList->Head(); 01143 while( face != NULL ) { 01144 glBegin( GL_POLYGON ); 01145 01146 halfEdge = face->IncidentHalfEdge(); 01147 do { 01148 glVertex3dv( halfEdge->Vertex()->GetPosition().GetDataDouble() ); 01149 halfEdge = halfEdge->Next(); 01150 } while ( halfEdge != face->IncidentHalfEdge() ); 01151 glEnd(); 01152 face = face->Next(); 01153 } 01154 //--------------------------------------- 01155 // Render the back faces of the model in the background color 01156 glColor3f( 0.0, 0.0, 0.0 ); 01157 glCullFace( GL_BACK ); 01158 glEnable( GL_CULL_FACE ); 01159 face = faceList->Head(); 01160 while( face != NULL ) { 01161 glBegin( GL_POLYGON ); 01162 01163 halfEdge = face->IncidentHalfEdge(); 01164 do { 01165 glVertex3dv( halfEdge->Vertex()->GetPosition().GetDataDouble() ); 01166 halfEdge = halfEdge->Next(); 01167 } while ( halfEdge != face->IncidentHalfEdge() ); 01168 glEnd(); 01169 face = face->Next(); 01170 } 01171 //--------------------------------------- 01172 glDisable( GL_CLIP_PLANE0 ); 01173 //--------------------------------------- 01174 // Copy the data to m_abVertexFlag1 01175 glReadPixels( startX, startY, width, height, pixelFormat, dataType, drawData ); 01176 int idx = 0; 01177 for ( int h = 0; h < height; ++h ) { 01178 for ( int w = 0; w < width; ++w ) { 01179 if ( drawData[idx] > 0.01 ) { 01180 m_abVertexFlag1[w][h][z] = RIGHT_INSIDE_BOUNDARY; 01181 } 01182 else { 01183 m_abVertexFlag1[w][h][z] = RIGHT_OUTSIDE_BOUNDARY; 01184 } 01185 idx += pixelSize; 01186 } 01187 } 01188 //----------------------------- 01189 // Update the clip plane equation 01190 zPlane[3] += m_atGridDimension[2]; 01191 } // end of for loop 01192 glPopMatrix(); 01193 glMatrixMode( GL_PROJECTION ); 01194 glPopMatrix(); 01195 glMatrixMode( GL_MODELVIEW ); 01196 glPopAttrib(); 01197 delete [] drawData; 01198 //--------------------------------------------------------------- 01199 }//----------------------------------------------------------------------------- 01200 #endif // of #ifdef TAPs_GRID_GENERATOR_BY_HARDWARE 01201 //============================================================================= 01202 01203 //============================================================================= 01204 // Clear extra right outside points from the generated grid data 01205 //----------------------------------------------------------------------------- 01206 template <typename T, typename DATA> 01207 void GridGenerator<T,DATA>::ClearExtraRightOutsidePoints () 01208 { 01209 bool bNeedChange; 01210 //=============================================================== 01211 // All elements not on bounding box's boundary 01212 //--------------------------------------------------------------- 01213 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01214 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01215 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01216 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01217 bNeedChange = true; 01218 //----------------- 01219 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01220 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01221 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01222 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01223 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01224 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01225 //----------------- 01226 if ( bNeedChange ) { 01227 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01228 } 01229 } 01230 } 01231 } 01232 } 01233 //--------------------------------------------------------------- 01234 // END INSIDE BOUNDARY 01235 //=============================================================== 01236 01237 //=============================================================== 01238 // All elements on the RIGHT boundary of bounding box 01239 //--------------------------------------------------------------- 01240 for ( int i = m_auiGridSize[0]-1; i <= m_auiGridSize[0]-1; ++i ) { 01241 //------------------------------------------------- 01242 // Inside the RIGHT boundary 01243 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01244 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01245 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01246 bNeedChange = true; 01247 //----------------- 01248 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01249 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01250 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01251 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01252 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01253 //else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01254 //----------------- 01255 if ( bNeedChange ) { 01256 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01257 } 01258 } 01259 } 01260 } 01261 //------------------------------------------------- 01262 // Top row of the RIGHT boundary, except cornors 01263 for ( int j = m_auiGridSize[1]-1; j <= m_auiGridSize[1]-1; ++j ) { 01264 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01265 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01266 bNeedChange = true; 01267 //----------------- 01268 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01269 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01270 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01271 //else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01272 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01273 //else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01274 //----------------- 01275 if ( bNeedChange ) { 01276 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01277 } 01278 } 01279 } 01280 } 01281 //------------------------------------------------- 01282 // Bottom row of the RIGHT boundary, except cornors 01283 for ( int j = 0; j <= 0; ++j ) { 01284 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01285 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01286 bNeedChange = true; 01287 //----------------- 01288 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01289 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01290 //else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01291 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01292 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01293 //else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01294 //----------------- 01295 if ( bNeedChange ) { 01296 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01297 } 01298 } 01299 } 01300 } 01301 //------------------------------------------------- 01302 // Right-most column of the RIGHT boundary, except cornors 01303 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01304 for ( int k = m_auiGridSize[2]-1; k <= m_auiGridSize[2]-1; ++k ) { 01305 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01306 bNeedChange = true; 01307 //----------------- 01308 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01309 //else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01310 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01311 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01312 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01313 //else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01314 //----------------- 01315 if ( bNeedChange ) { 01316 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01317 } 01318 } 01319 } 01320 } 01321 //------------------------------------------------- 01322 // Left-most column of the RIGHT boundary, except cornors 01323 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01324 for ( int k = 0; k <= 0; ++k ) { 01325 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01326 bNeedChange = true; 01327 //----------------- 01328 //if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01329 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01330 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01331 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01332 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01333 //else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01334 //----------------- 01335 if ( bNeedChange ) { 01336 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01337 } 01338 } 01339 } 01340 } 01341 } 01342 //--------------------------------------------------------------- 01343 // END RIGHT BOUNDARY 01344 //=============================================================== 01345 01346 //=============================================================== 01347 // All elements on the LEFT boundary of bounding box 01348 //--------------------------------------------------------------- 01349 for ( int i = 0; i <= 0; ++i ) { 01350 //------------------------------------------------- 01351 // Inside the LEFT boundary 01352 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01353 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01354 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01355 bNeedChange = true; 01356 //----------------- 01357 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01358 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01359 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01360 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01361 //else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01362 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01363 //----------------- 01364 if ( bNeedChange ) { 01365 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01366 } 01367 } 01368 } 01369 } 01370 //------------------------------------------------- 01371 // Top row of the LEFT boundary, except cornors 01372 for ( int j = m_auiGridSize[1]-1; j <= m_auiGridSize[1]-1; ++j ) { 01373 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01374 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01375 bNeedChange = true; 01376 //----------------- 01377 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01378 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01379 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01380 //else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01381 //else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01382 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01383 //----------------- 01384 if ( bNeedChange ) { 01385 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01386 } 01387 } 01388 } 01389 } 01390 //------------------------------------------------- 01391 // Bottom row of the LEFT boundary, except cornors 01392 for ( int j = 0; j <= 0; ++j ) { 01393 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01394 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01395 bNeedChange = true; 01396 //----------------- 01397 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01398 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01399 //else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01400 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01401 //else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01402 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01403 //----------------- 01404 if ( bNeedChange ) { 01405 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01406 } 01407 } 01408 } 01409 } 01410 //------------------------------------------------- 01411 // Right-most column of the LEFT boundary, except cornors 01412 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01413 for ( int k = m_auiGridSize[2]-1; k <= m_auiGridSize[2]-1; ++k ) { 01414 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01415 bNeedChange = true; 01416 //----------------- 01417 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01418 //else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01419 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01420 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01421 //else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01422 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01423 //----------------- 01424 if ( bNeedChange ) { 01425 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01426 } 01427 } 01428 } 01429 } 01430 //------------------------------------------------- 01431 // Left-most column of the LEFT boundary, except cornors 01432 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01433 for ( int k = 0; k <= 0; ++k ) { 01434 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01435 bNeedChange = true; 01436 //----------------- 01437 //if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01438 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01439 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01440 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01441 //else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01442 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01443 //----------------- 01444 if ( bNeedChange ) { 01445 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01446 } 01447 } 01448 } 01449 } 01450 } 01451 //--------------------------------------------------------------- 01452 // END LEFT BOUNDARY 01453 //=============================================================== 01454 01455 //=============================================================== 01456 // All elements on the TOP boundary of bounding box 01457 //--------------------------------------------------------------- 01458 for ( int j = m_auiGridSize[1]-1; j <= m_auiGridSize[1]-1; ++j ) { 01459 //------------------------------------------------- 01460 // Inside the TOP boundary 01461 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01462 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01463 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01464 bNeedChange = true; 01465 //----------------- 01466 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01467 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01468 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01469 //else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01470 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01471 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01472 //----------------- 01473 if ( bNeedChange ) { 01474 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01475 } 01476 } 01477 } 01478 } 01479 //------------------------------------------------- 01480 // Top row of the TOP boundary, except cornors 01481 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01482 for ( int k = 0; k <= 0; ++k ) { 01483 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01484 bNeedChange = true; 01485 //----------------- 01486 //if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01487 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01488 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01489 //else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01490 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01491 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01492 //----------------- 01493 if ( bNeedChange ) { 01494 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01495 } 01496 } 01497 } 01498 } 01499 //------------------------------------------------- 01500 // Bottom row of the TOP boundary, except cornors 01501 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01502 for ( int k = m_auiGridSize[2]-1; k <= m_auiGridSize[2]-1; ++k ) { 01503 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01504 bNeedChange = true; 01505 //----------------- 01506 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01507 //else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01508 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01509 //else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01510 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01511 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01512 //----------------- 01513 if ( bNeedChange ) { 01514 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01515 } 01516 } 01517 } 01518 } 01519 } 01520 //--------------------------------------------------------------- 01521 // END TOP BOUNDARY 01522 //=============================================================== 01523 01524 //=============================================================== 01525 // All elements on the BOTTOM boundary of bounding box 01526 //--------------------------------------------------------------- 01527 for ( int j = 0; j <= 0; ++j ) { 01528 //------------------------------------------------- 01529 // Inside the BOTTOM boundary 01530 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01531 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01532 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01533 bNeedChange = true; 01534 //----------------- 01535 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01536 else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01537 //else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01538 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01539 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01540 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01541 //----------------- 01542 if ( bNeedChange ) { 01543 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01544 } 01545 } 01546 } 01547 } 01548 //------------------------------------------------- 01549 // Top row of the BOTTOM boundary, except cornors 01550 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01551 for ( int k = 0; k <= 0; ++k ) { 01552 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01553 bNeedChange = true; 01554 //----------------- 01555 //if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01556 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01557 //else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01558 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01559 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01560 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01561 //----------------- 01562 if ( bNeedChange ) { 01563 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01564 } 01565 } 01566 } 01567 } 01568 //------------------------------------------------- 01569 // Bottom row of the BOTTOM boundary, except cornors 01570 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01571 for ( int k = m_auiGridSize[2]-1; k <= m_auiGridSize[2]-1; ++k ) { 01572 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01573 bNeedChange = true; 01574 //----------------- 01575 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01576 //else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01577 //else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01578 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01579 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01580 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01581 //----------------- 01582 if ( bNeedChange ) { 01583 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01584 } 01585 } 01586 } 01587 } 01588 } 01589 //--------------------------------------------------------------- 01590 // END BOTTOM BOUNDARY 01591 //=============================================================== 01592 01593 //=============================================================== 01594 // All elements on the FRONT boundary of bounding box 01595 //--------------------------------------------------------------- 01596 for ( int k = m_auiGridSize[2]-1; k <= m_auiGridSize[2]-1; ++k ) { 01597 //------------------------------------------------- 01598 // Inside the FRONT boundary 01599 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01600 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01601 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01602 bNeedChange = true; 01603 //----------------- 01604 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01605 //else if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01606 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01607 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01608 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01609 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01610 //----------------- 01611 if ( bNeedChange ) { 01612 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01613 } 01614 } 01615 } 01616 } 01617 } 01618 //--------------------------------------------------------------- 01619 // END FRONT BOUNDARY 01620 //=============================================================== 01621 01622 //=============================================================== 01623 // All elements on the BACK boundary of bounding box 01624 //--------------------------------------------------------------- 01625 for ( int k = 0; k <= 0; ++k ) { 01626 //------------------------------------------------- 01627 // Inside the BACK boundary 01628 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01629 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01630 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 01631 bNeedChange = true; 01632 //----------------- 01633 //if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01634 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01635 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01636 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01637 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01638 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01639 //----------------- 01640 if ( bNeedChange ) { 01641 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01642 } 01643 } 01644 } 01645 } 01646 } 01647 //--------------------------------------------------------------- 01648 // END BACK BOUNDARY 01649 //=============================================================== 01650 01651 //=============================================================== 01652 // All of the eight corner points of the boundary of bounding box 01653 //--------------------------------------------------------------- 01654 // ^ j 01655 // | 01656 // | 01657 // O----->i 01658 // / 01659 // / 01660 // k 01661 { 01662 //--------------------------------------- 01663 int i = 0, j = 0, k = 0; 01664 bNeedChange = true; 01665 //----------------- 01666 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01667 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01668 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01669 //----------------- 01670 if ( bNeedChange ) { 01671 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01672 } 01673 //--------------------------------------- 01674 k = m_auiGridSize[2]-1; 01675 bNeedChange = true; 01676 //----------------- 01677 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01678 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01679 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01680 //----------------- 01681 if ( bNeedChange ) { 01682 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01683 } 01684 //--------------------------------------- 01685 j = m_auiGridSize[1]-1; 01686 bNeedChange = true; 01687 //----------------- 01688 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01689 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01690 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01691 //----------------- 01692 if ( bNeedChange ) { 01693 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01694 } 01695 //--------------------------------------- 01696 k = 0; 01697 bNeedChange = true; 01698 //----------------- 01699 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01700 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01701 else if ( m_abVertexFlag1[i+1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01702 //----------------- 01703 if ( bNeedChange ) { 01704 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01705 } 01706 //--------------------------------------- 01707 i = m_auiGridSize[0]-1; 01708 j = 0; 01709 bNeedChange = true; 01710 //----------------- 01711 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01712 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01713 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01714 //----------------- 01715 if ( bNeedChange ) { 01716 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01717 } 01718 //--------------------------------------- 01719 k = m_auiGridSize[2]-1; 01720 bNeedChange = true; 01721 //----------------- 01722 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01723 else if ( m_abVertexFlag1[i][j+1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01724 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01725 //----------------- 01726 if ( bNeedChange ) { 01727 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01728 } 01729 //--------------------------------------- 01730 j = m_auiGridSize[1]-1; 01731 bNeedChange = true; 01732 //----------------- 01733 if ( m_abVertexFlag1[i][j][k-1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01734 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01735 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01736 //----------------- 01737 if ( bNeedChange ) { 01738 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01739 } 01740 //--------------------------------------- 01741 k = 0; 01742 bNeedChange = true; 01743 //----------------- 01744 if ( m_abVertexFlag1[i][j][k+1] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01745 else if ( m_abVertexFlag1[i][j-1][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01746 else if ( m_abVertexFlag1[i-1][j][k] > RIGHT_OUTSIDE_BOUNDARY ) bNeedChange = false; 01747 //----------------- 01748 if ( bNeedChange ) { 01749 m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01750 } 01751 //--------------------------------------- 01752 } 01753 //--------------------------------------------------------------- 01754 // END THE EIGHT CORNERS BOUNDARY 01755 //=============================================================== 01756 } 01757 //----------------------------------------------------------------------------- 01758 // END: ClearExtraRightOutsidePoints () 01759 //============================================================================= 01760 01761 //============================================================================= 01762 // Inverse Points -- Outside <--> Inside & Empty becomes Inside 01763 //----------------------------------------------------------------------------- 01764 template <typename T, typename DATA> 01765 void GridGenerator<T,DATA>::InverseInsideOutside () 01766 { 01767 //=============================================================== 01768 // All elements not on bounding box's boundary 01769 //--------------------------------------------------------------- 01770 for ( int i = 1; i < m_auiGridSize[0]-1; ++i ) { 01771 for ( int j = 1; j < m_auiGridSize[1]-1; ++j ) { 01772 for ( int k = 1; k < m_auiGridSize[2]-1; ++k ) { 01773 if ( m_abVertexFlag1[i][j][k] == UNSET ) m_abVertexFlag1[i][j][k] = INSIDE_MODEL; 01774 else if ( m_abVertexFlag1[i][j][k] == OUTSIDE_MODEL ) m_abVertexFlag1[i][j][k] = INSIDE_MODEL; 01775 //else if ( m_abVertexFlag1[i][j][k] == ON_BOUNDARY ) m_abVertexFlag1[i][j][k] = ON_BOUNDARY; 01776 else if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) m_abVertexFlag1[i][j][k] = RIGHT_INSIDE_BOUNDARY; 01777 else if ( m_abVertexFlag1[i][j][k] == RIGHT_INSIDE_BOUNDARY ) m_abVertexFlag1[i][j][k] = RIGHT_OUTSIDE_BOUNDARY; 01778 else if ( m_abVertexFlag1[i][j][k] == INSIDE_MODEL ) m_abVertexFlag1[i][j][k] = OUTSIDE_MODEL; 01779 } 01780 } 01781 } 01782 } 01783 //----------------------------------------------------------------------------- 01784 // END: InverseInsideOutside () 01785 //============================================================================= 01786 01787 //============================================================================= 01788 // START the group functions of SetVertexInterpolationData 01789 //----------------------------------------------------------------------------- 01790 template <typename T, typename DATA> 01791 void GridGenerator<T,DATA>::SetVertexInterpolationData ( T tDefaultVal ) 01792 { 01793 if ( !m_pModel ) return; 01794 //--------------------------------------------------------------- 01795 // Set global default interpolation value 01796 m_bUseDefaultIntpVal = true; 01797 m_tDefaultIntpVal = tDefaultVal; 01798 //--------------------------------------------------------------- 01799 OpenGL::PolygonalModel<T> * pPologonalModel 01800 = dynamic_cast< OpenGL::PolygonalModel<T> * >( m_pModel ); 01801 OpenGL::XPolygonalModel<T> * pXPologonalModel 01802 = dynamic_cast< OpenGL::XPolygonalModel<T> * >( m_pModel ); 01803 OpenGL::HalfEdgeModel<T> * pHalfEdgeModel 01804 = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( m_pModel ); 01805 //--------------------------------------------------------------- 01806 // For PolygonalModel 01807 if ( pPologonalModel ) { 01808 SetVertexInterpolationData( pPologonalModel ); 01809 return; 01810 } 01811 //--------------------------------------------------------------- 01812 // For XPolygonalModel 01813 if ( pXPologonalModel ) { 01814 SetVertexInterpolationData( pXPologonalModel ); 01815 return; 01816 } 01817 //--------------------------------------------------------------- 01818 // For HalfEdgeModel 01819 if ( pHalfEdgeModel ) { 01820 SetVertexInterpolationData( pHalfEdgeModel ); 01821 return; 01822 } 01823 //--------------------------------------------------------------- 01824 } 01825 01826 01827 //============================================================================= 01828 // START the group functions of SetVertexInterpolationData 01829 //----------------------------------------------------------------------------- 01830 template <typename T, typename DATA> 01831 void GridGenerator<T,DATA>::SetVertexInterpolationData () 01832 { 01833 if ( !m_pModel ) return; 01834 //--------------------------------------------------------------- 01835 OpenGL::PolygonalModel<T> * pPologonalModel 01836 = dynamic_cast< OpenGL::PolygonalModel<T> * >( m_pModel ); 01837 OpenGL::XPolygonalModel<T> * pXPologonalModel 01838 = dynamic_cast< OpenGL::XPolygonalModel<T> * >( m_pModel ); 01839 OpenGL::HalfEdgeModel<T> * pHalfEdgeModel 01840 = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( m_pModel ); 01841 //--------------------------------------------------------------- 01842 // For PolygonalModel 01843 if ( pPologonalModel ) { 01844 SetVertexInterpolationData( pPologonalModel ); 01845 return; 01846 } 01847 //--------------------------------------------------------------- 01848 // For XPolygonalModel 01849 if ( pXPologonalModel ) { 01850 SetVertexInterpolationData( pXPologonalModel ); 01851 return; 01852 } 01853 //--------------------------------------------------------------- 01854 // For HalfEdgeModel 01855 if ( pHalfEdgeModel ) { 01856 SetVertexInterpolationData( pHalfEdgeModel ); 01857 return; 01858 } 01859 //--------------------------------------------------------------- 01860 } 01861 //----------------------------------------------------------------------------- 01862 // Set Grid Points To Inside and Outside the Model 01863 template <typename T, typename DATA> 01864 void GridGenerator<T,DATA>::SetVertexInterpolationData ( 01865 OpenGL::PolygonalModel<T> * pPModel ) 01866 { 01867 Vertex<T> * vertexList = pPModel->GetVertexList(); 01868 assert( false ); 01869 // Find two vertices; (-x,0,0) and (x,0,0) 01870 // and faces that contain them 01871 } 01872 //----------------------------------------------------------------------------- 01873 // Set Grid Points To Inside and Outside the Model 01874 template <typename T, typename DATA> 01875 void GridGenerator<T,DATA>::SetVertexInterpolationData ( 01876 OpenGL::XPolygonalModel<T> * pXPModel ) 01877 { 01888 //--------------------------------------------------------------- 01889 // Check if "use default interpolation value" is set 01890 if ( m_bUseDefaultIntpVal ) { 01891 // Set all interpolation data to m_tDefaultIntpVal 01892 for ( int x = 0; x < m_auiGridSize[0]; ++x ) { 01893 for ( int y = 0; y < m_auiGridSize[1]; ++y ) { 01894 for ( int z = 0; z < m_auiGridSize[2]; ++z ) { 01895 m_atVertexInterpolation[x][y][z][0] = 01896 m_atVertexInterpolation[x][y][z][1] = 01897 m_atVertexInterpolation[x][y][z][2] = m_tDefaultIntpVal; 01898 } 01899 } 01900 } 01901 return; 01902 } 01903 else { 01904 // Set all interpolation data to random values 01905 srand( time(NULL) ); 01906 for ( int x = 0; x < m_auiGridSize[0]; ++x ) { 01907 for ( int y = 0; y < m_auiGridSize[1]; ++y ) { 01908 for ( int z = 0; z < m_auiGridSize[2]; ++z ) { 01909 m_atVertexInterpolation[x][y][z][0] = 01910 m_atVertexInterpolation[x][y][z][1] = 01911 m_atVertexInterpolation[x][y][z][2] = 0.49; 01912 01913 //0.25 + static_cast<T>( rand() / static_cast<T>( RAND_MAX * 2 ) ); // range of [0.25-0.75] 01914 01915 //static_cast<T>( rand() / static_cast<T>( RAND_MAX ) ); // range of [0.00-0.99] 01916 } 01917 } 01918 } 01919 } 01920 01921 // DEBUG 01922 //return; // No finding interpolation values for the surface 01923 01924 //--------------------------------------------------------------- 01925 XVertex<T> * vertex = pXPModel->GetVertexList(); 01926 Face<T> * face = pXPModel->GetFaceList(); 01927 int NumFaces = pXPModel->GetNoFaces(); 01928 //--------------------------------------------------------------- 01929 // Find interpolation values for the surface by a Software Algorithm 01930 //----------------------------------------------------- 01931 Vector3<T> vMin, vMax, vPos, vAverage; 01932 //----------------------------------------------------- 01933 // For Each Face 01934 for ( int i = 0; i < NumFaces; ++i ) { 01935 //--------------------------------------- 01936 // Find a box that contain this face 01937 vAverage = vMin = vMax = vertex[ face[i].GetVertexNo(0) ].GetPosition(); 01938 for ( int n = 1; n < face[i].GetNoVertices(); ++n ) { 01939 vPos = vertex[ face[i].GetVertexNo(n) ].GetPosition(); 01940 vAverage += vPos; 01941 for ( int d = 0; d < 3; ++d ) { 01942 if ( vMin[d] > vPos[d] ) vMin[d] = vPos[d]; 01943 else if ( vMax[d] < vPos[d] ) vMax[d] = vPos[d]; 01944 } 01945 } 01946 //assert( vMin[0] <= vMax[0] ); 01947 //assert( vMin[1] <= vMax[1] ); 01948 //assert( vMin[2] <= vMax[2] ); 01949 //--------------------------------------- 01950 // Find a box of grids that contain this face 01951 // i.e. a bigger box that contain the face box 01952 int gMinNum[3], gMaxNum[3]; 01953 T gMin, gMax; 01954 for ( int d = 0; d < 3; ++d ) { 01955 int step = m_auiGridSize[d] / 2; 01956 gMinNum[d] = gMaxNum[d] = step; 01957 gMin = m_tAABBMin[d] + gMinNum[d] * m_atGridDimension[d]; 01958 T minOffset = vMin[d] - m_atGridDimension[d] / 2; 01959 T maxOffset = vMax[d] + m_atGridDimension[d] / 2; 01960 //T minOffset = vMin[d]; 01961 //T maxOffset = vMax[d]; 01962 //------------------------- 01963 // Find a box of this current face 01964 while ( ( gMin < minOffset || maxOffset < gMin ) && step > 1 ) { 01965 step /= 2; 01966 if ( gMin < minOffset ) { 01967 gMinNum[d] += step; 01968 } 01969 else { 01970 gMinNum[d] -= step; 01971 } 01972 gMin = m_tAABBMin[d] + gMinNum[d] * m_atGridDimension[d]; 01973 } 01974 gMax = gMin; 01975 gMaxNum[d] = gMinNum[d]; 01976 01977 // DEBUG 01978 //gridBoxCenterPt[d] = gMinNum[d]; 01979 01980 //------------------------- 01981 // Find a grid box that covers the box of this current face 01982 //minMoveStep[d] = maxMoveStep[d] = 0; // DEBUG 01983 //------------------------- 01984 // Find the low 01985 while ( vMin[d] < gMin ) { 01986 //while ( minOffset < gMin ) { 01987 //--minMoveStep[d]; // DEBUG 01988 --gMinNum[d]; 01989 gMin -= m_atGridDimension[d]; 01990 } 01991 if ( gMinNum[d] < 0 ) { 01992 gMinNum[d] = 0; 01993 } 01994 //------------------------- 01995 // Find the high 01996 while ( gMax < vMax[d] ) { 01997 //while ( gMax < maxOffset ) { 01998 //++maxMoveStep[d]; // DEBUG 01999 ++gMaxNum[d]; 02000 gMax += m_atGridDimension[d]; 02001 } 02002 if ( gMaxNum[d] >= m_auiGridSize[d] ) { 02003 gMaxNum[d] = m_auiGridSize[d] - 1; 02004 } 02005 //----------------------------------- 02006 //assert( gMinNum[d] <= gMaxNum[d] ); 02007 //assert( 0 <= gMinNum[d] && gMinNum[d] < m_auiGridSize[d] ); 02008 //assert( 0 <= gMaxNum[d] && gMaxNum[d] < m_auiGridSize[d] ); 02009 } 02010 //------------------------------------------------- 02011 // Set Inside / Outside 02012 //vPos = vertex[ face[i].GetVertexNo(0) ].GetPosition(); 02013 vAverage /= face[i].GetNoVertices(); 02014 Vector3<T> normal = face[i].GetNormal(); 02015 Vector3<T> direction; 02016 for ( int x = gMinNum[0]; x <= gMaxNum[0]; ++x ) { 02017 for ( int y = gMinNum[1]; y <= gMaxNum[1]; ++y ) { 02018 for ( int z = gMinNum[2]; z <= gMaxNum[2]; ++z ) { 02019 02020 /* 02021 // RANDOM VALUES 02022 T interpolationVal = static_cast<T>( rand() / static_cast<T>( RAND_MAX ) ); 02023 m_atVertexInterpolation[x][y][z][0] = ( interpolationVal - 0.5 ) / 2.0 + 0.5; 02024 interpolationVal = static_cast<T>( rand() / static_cast<T>( RAND_MAX ) ); 02025 m_atVertexInterpolation[x][y][z][1] = ( interpolationVal - 0.5 ) / 2.0 + 0.5; 02026 interpolationVal = static_cast<T>( rand() / static_cast<T>( RAND_MAX ) ); 02027 m_atVertexInterpolation[x][y][z][2] = ( interpolationVal - 0.5 ) / 2.0 + 0.5; 02028 //*/ 02029 02030 02031 //* 02032 // OFFSET FROM TRIANGLE SURFACE 02033 if ( m_abVertexFlag1[x][y][z] > RIGHT_OUTSIDE_BOUNDARY ) { 02034 T ratio; 02035 Vector3<T> projPt; 02036 //--------------------------------- 02037 // x-direction 02038 bool result = false; 02039 if ( x >= 0 ) { 02040 if ( m_abVertexFlag1[x+1][y][z] == RIGHT_OUTSIDE_BOUNDARY ) { 02041 result = CGMath<T>::FindIntersectionLineSegmentTriangle( 02042 m_atVertexPosition[x][y][z], 02043 m_atVertexPosition[x+1][y][z], 02044 vertex[ face[i].GetVertexNo(0) ].GetPosition(), 02045 vertex[ face[i].GetVertexNo(1) ].GetPosition(), 02046 vertex[ face[i].GetVertexNo(2) ].GetPosition(), 02047 ratio, projPt // O/P: 02048 ); 02049 } 02050 if ( result ) { 02051 m_atVertexInterpolation[x][y][z][0] = ratio; 02052 //m_atVertexInterpolation[x+1][y][z][0] = 1.0 - ratio; 02053 } 02054 } 02055 if ( x < m_auiGridSize[0] ) { 02056 if ( m_abVertexFlag1[x-1][y][z] == RIGHT_OUTSIDE_BOUNDARY ) { 02057 result = CGMath<T>::FindIntersectionLineSegmentTriangle( 02058 m_atVertexPosition[x][y][z], 02059 m_atVertexPosition[x-1][y][z], 02060 vertex[ face[i].GetVertexNo(0) ].GetPosition(), 02061 vertex[ face[i].GetVertexNo(1) ].GetPosition(), 02062 vertex[ face[i].GetVertexNo(2) ].GetPosition(), 02063 ratio, projPt // O/P: 02064 ); 02065 } 02066 if ( result ) { 02067 m_atVertexInterpolation[x][y][z][0] = ratio; 02068 //m_atVertexInterpolation[x-1][y][z][0] = 1.0 - ratio; 02069 } 02070 } 02071 //--------------------------------- 02072 // y-direction 02073 result = false; 02074 if ( y >= 0 ) { 02075 if ( m_abVertexFlag1[x][y+1][z] == RIGHT_OUTSIDE_BOUNDARY ) { 02076 result = CGMath<T>::FindIntersectionLineSegmentTriangle( 02077 m_atVertexPosition[x][y][z], 02078 m_atVertexPosition[x][y+1][z], 02079 vertex[ face[i].GetVertexNo(0) ].GetPosition(), 02080 vertex[ face[i].GetVertexNo(1) ].GetPosition(), 02081 vertex[ face[i].GetVertexNo(2) ].GetPosition(), 02082 ratio, projPt // O/P: 02083 ); 02084 } 02085 if ( result ) { 02086 m_atVertexInterpolation[x][y][z][1] = ratio; 02087 //m_atVertexInterpolation[x][y+1][z][1] = 1.0 - ratio; 02088 } 02089 } 02090 if ( y < m_auiGridSize[1] ) { 02091 if ( m_abVertexFlag1[x][y-1][z] == RIGHT_OUTSIDE_BOUNDARY ) { 02092 result = CGMath<T>::FindIntersectionLineSegmentTriangle( 02093 m_atVertexPosition[x][y][z], 02094 m_atVertexPosition[x][y-1][z], 02095 vertex[ face[i].GetVertexNo(0) ].GetPosition(), 02096 vertex[ face[i].GetVertexNo(1) ].GetPosition(), 02097 vertex[ face[i].GetVertexNo(2) ].GetPosition(), 02098 ratio, projPt // O/P: 02099 ); 02100 } 02101 if ( result ) { 02102 m_atVertexInterpolation[x][y][z][1] = ratio; 02103 //m_atVertexInterpolation[x][y-1][z][1] = 1.0 - ratio; 02104 } 02105 } 02106 //--------------------------------- 02107 // z-direction 02108 result = false; 02109 if ( z >= 0 ) { 02110 if ( m_abVertexFlag1[x][y][z+1] == RIGHT_OUTSIDE_BOUNDARY ) { 02111 result = CGMath<T>::FindIntersectionLineSegmentTriangle( 02112 m_atVertexPosition[x][y][z], 02113 m_atVertexPosition[x][y][z+1], 02114 vertex[ face[i].GetVertexNo(0) ].GetPosition(), 02115 vertex[ face[i].GetVertexNo(1) ].GetPosition(), 02116 vertex[ face[i].GetVertexNo(2) ].GetPosition(), 02117 ratio, projPt // O/P: 02118 ); 02119 } 02120 if ( result ) { 02121 m_atVertexInterpolation[x][y][z][2] = ratio; 02122 //m_atVertexInterpolation[x][y][z+1][2] = 1.0 - ratio; 02123 } 02124 } 02125 if ( z < m_auiGridSize[2] ) { 02126 if ( m_abVertexFlag1[x][y][z-1] == RIGHT_OUTSIDE_BOUNDARY ) { 02127 result = CGMath<T>::FindIntersectionLineSegmentTriangle( 02128 m_atVertexPosition[x][y][z], 02129 m_atVertexPosition[x][y][z-1], 02130 vertex[ face[i].GetVertexNo(0) ].GetPosition(), 02131 vertex[ face[i].GetVertexNo(1) ].GetPosition(), 02132 vertex[ face[i].GetVertexNo(2) ].GetPosition(), 02133 ratio, projPt // O/P: 02134 ); 02135 } 02136 if ( result ) { 02137 m_atVertexInterpolation[x][y][z][2] = ratio; 02138 //m_atVertexInterpolation[x][y][z-1][2] = 1.0 - ratio; 02139 } 02140 } 02141 //--------------------------------- 02142 } 02143 //*/ 02144 02145 /* 02146 direction.SetXYZ( 02147 m_atVertexPosition[x][y][z][0] - vAverage[0], 02148 m_atVertexPosition[x][y][z][1] - vAverage[1], 02149 m_atVertexPosition[x][y][z][2] - vAverage[2] 02150 ); 02151 //--------------------------- 02152 // If just outside boundary 02153 if ( m_abVertexFlag1[x][y][z] == RIGHT_OUTSIDE_BOUNDARY ) continue; 02154 //--------------------------- 02155 // The point is inside, on, or outside the boundary. 02156 if ( normal * direction < 0.0 ) { 02157 m_abVertexFlag1[x][y][z] = RIGHT_INSIDE_BOUNDARY; 02158 } 02159 else if ( normal * direction == 0.0 ) { 02160 m_abVertexFlag1[x][y][z] = ON_BOUNDARY; 02161 } 02162 else { 02163 m_abVertexFlag1[x][y][z] = RIGHT_OUTSIDE_BOUNDARY; 02164 } 02165 //*/ 02166 } 02167 } 02168 } 02169 //------------------------------------------------- 02170 } 02171 //--------------------------------------------------------------- 02172 } 02173 //----------------------------------------------------------------------------- 02174 // Set Grid Points To Inside and Outside the Model 02175 // NOT IMPLEMENTED YET! 02176 template <typename T, typename DATA> 02177 void GridGenerator<T,DATA>::SetVertexInterpolationData ( 02178 OpenGL::HalfEdgeModel<T> * pHEModel ) 02179 { 02180 //assert( false ); 02181 // Find two vertices; (-x,0,0) and (x,0,0) 02182 // and faces that contain them 02183 } 02184 //----------------------------------------------------------------------------- 02185 // END the group functions of SetVertexInterpolationData 02186 //============================================================================= 02187 02188 //----------------------------------------------------------------------------- 02189 // Delete Grids 02190 template <typename T, typename DATA> 02191 void GridGenerator<T,DATA>::DeleteGrids () 02192 { 02193 DeleteGridsForPosition(); 02194 DeleteGridsForNormal(); 02195 DeleteGridsForFlag1(); 02196 DeleteGridsForVertexInterpolation(); 02197 } 02198 //----------------------------------------------------------------------------- 02199 // Delete Position Grids 02200 template <typename T, typename DATA> 02201 void GridGenerator<T,DATA>::DeleteGridsForPosition () 02202 { 02203 //--------------------------------------------------------------- 02204 if ( m_atVertexPosition ) { 02205 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02206 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02207 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 02208 delete [] m_atVertexPosition[i][j][k]; 02209 } 02210 delete [] m_atVertexPosition[i][j]; 02211 } 02212 delete [] m_atVertexPosition[i]; 02213 } 02214 delete m_atVertexPosition; 02215 m_atVertexPosition = NULL; 02216 } 02217 } 02218 //----------------------------------------------------------------------------- 02219 // Delete Normal Grids 02220 template <typename T, typename DATA> 02221 void GridGenerator<T,DATA>::DeleteGridsForNormal () 02222 { 02223 //--------------------------------------------------------------- 02224 if ( m_atVertexNormal ) { 02225 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02226 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02227 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 02228 delete [] m_atVertexNormal[i][j][k]; 02229 } 02230 delete [] m_atVertexNormal[i][j]; 02231 } 02232 delete [] m_atVertexNormal[i]; 02233 } 02234 delete m_atVertexNormal; 02235 m_atVertexNormal = NULL; 02236 } 02237 } 02238 //----------------------------------------------------------------------------- 02239 // Delete Flag1 Grids 02240 template <typename T, typename DATA> 02241 void GridGenerator<T,DATA>::DeleteGridsForFlag1 () 02242 { 02243 //--------------------------------------------------------------- 02244 if ( m_abVertexFlag1 ) { 02245 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02246 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02247 delete [] m_abVertexFlag1[i][j]; 02248 } 02249 delete [] m_abVertexFlag1[i]; 02250 } 02251 delete m_abVertexFlag1; 02252 m_abVertexFlag1 = NULL; 02253 } 02254 } 02255 //----------------------------------------------------------------------------- 02256 // Delete Vertex Interpolation Grids 02257 template <typename T, typename DATA> 02258 void GridGenerator<T,DATA>::DeleteGridsForVertexInterpolation () 02259 { 02260 //--------------------------------------------------------------- 02261 if ( m_atVertexInterpolation ) { 02262 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02263 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02264 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 02265 delete [] m_atVertexInterpolation[i][j][k]; 02266 } 02267 delete [] m_atVertexInterpolation[i][j]; 02268 } 02269 delete [] m_atVertexInterpolation[i]; 02270 } 02271 delete m_atVertexInterpolation; 02272 m_atVertexInterpolation = NULL; 02273 } 02274 } 02275 //----------------------------------------------------------------------------- 02276 #if defined(__gl_h_) || defined(__GL_H__) 02277 //============================================================================= 02278 // DrawByOpenGL 02279 //----------------------------------------------------------------------------- 02280 template <typename T, typename DATA> GLuint GridGenerator<T,DATA>::g_uiDisplayList = 0; 02281 template <typename T, typename DATA> GLenum GridGenerator<T,DATA>::g_eDrawStyle = GLU_LINE; 02282 //----------------------------------------------------------------------------- 02283 template <typename T, typename DATA> 02284 void GridGenerator<T,DATA>::DrawByOpenGL ( T diameter, GLenum drawStyle ) 02285 { 02286 if ( !IsGridGenerated() ) return; 02287 //----------------------------------------------------- 02288 //std::cout << "Draw Grids\n"; 02289 if ( drawStyle != g_eDrawStyle ) { 02290 g_eDrawStyle = drawStyle; 02291 if ( g_uiDisplayList ) { 02292 glDeleteLists( g_uiDisplayList, 1 ); 02293 g_uiDisplayList = 0; 02294 } 02295 } 02296 if ( !g_uiDisplayList ) { 02297 g_uiDisplayList = glGenLists( 1 ); 02298 GLUquadricObj *qObj = gluNewQuadric(); 02299 glNewList( g_uiDisplayList, GL_COMPILE ); 02300 // GLenum drawStyle 02301 // GLU_FILL 02302 // GLU_LINE 02303 // GLU_SILHOUETTE 02304 // GLU_POINT 02305 gluQuadricDrawStyle( qObj, drawStyle ); // wireframe 02306 gluSphere( qObj, 1, 8, 8 ); 02307 glEndList(); 02308 gluDeleteQuadric( qObj ); 02309 } 02310 //----------------------------------------------------- 02311 glPushMatrix(); 02312 glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POINT_BIT ); 02313 glEnable( GL_COLOR_MATERIAL ); 02314 //--------------------------------------- 02315 if ( m_pModel ) m_pModel->GetTransform().TransformByOpenGLForDrawing(); 02316 //--------------------------------------- 02317 float factor = 1.0f / diameter; 02318 float xScale = m_atGridDimension[0] / factor; 02319 float yScale = m_atGridDimension[1] / factor; 02320 float zScale = m_atGridDimension[2] / factor; 02321 float xScale2 = xScale * 0.5; 02322 float yScale2 = yScale * 0.5; 02323 float zScale2 = zScale * 0.5; 02324 float xScale3 = xScale2 * 0.5; 02325 float yScale3 = yScale2 * 0.5; 02326 float zScale3 = zScale2 * 0.5; 02327 float xScale4 = xScale3 * 0.5; 02328 float yScale4 = yScale3 * 0.5; 02329 float zScale4 = zScale3 * 0.5; 02330 float xScale5 = xScale4 * 0.5; 02331 float yScale5 = yScale4 * 0.5; 02332 float zScale5 = zScale4 * 0.5; 02333 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02334 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02335 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 02336 glPushMatrix(); 02337 glTranslatef( 02338 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02339 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02340 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02341 ); 02342 if ( m_abVertexFlag1[i][j][k] >= INSIDE_MODEL ) { 02343 glScalef( xScale, yScale, zScale ); 02344 glColor4f( 0.2f, 0.2f, 0.5f, 1.0f ); 02345 } 02346 else if ( m_abVertexFlag1[i][j][k] >= RIGHT_INSIDE_BOUNDARY ) { 02347 glScalef( xScale2, yScale2, zScale2 ); 02348 glColor4f( 0.2f, 0.2f, 0.25f, 1.0f ); 02349 } 02350 else if ( m_abVertexFlag1[i][j][k] >= ON_BOUNDARY ) { 02351 glScalef( xScale3, yScale3, zScale3 ); 02352 glColor4f( 0.2f, 0.2f, 0.2f, 1.0f ); 02353 } 02354 else if ( m_abVertexFlag1[i][j][k] >= RIGHT_OUTSIDE_BOUNDARY ) { 02355 glScalef( xScale4, yScale4, zScale4 ); 02356 glColor4f( 0.25f, 0.2f, 0.2f, 1.0f ); 02357 } 02358 else if ( m_abVertexFlag1[i][j][k] >= OUTSIDE_MODEL ) { 02359 glScalef( xScale5, yScale5, zScale5 ); 02360 glColor4f( 0.5f, 0.2f, 0.2f, 1.0f ); 02361 } 02362 else { 02363 continue; 02364 } 02365 glCallList( g_uiDisplayList ); 02366 glPopMatrix(); 02367 } 02368 } 02369 } 02370 glPopAttrib(); 02371 glPopMatrix(); 02372 } 02373 //----------------------------------------------------------------------------- 02374 template <typename T, typename DATA> 02375 void GridGenerator<T,DATA>::DrawAsPointsByOpenGL ( Vector4<T> color ) 02376 { 02377 if ( !IsGridGenerated() ) return; 02378 //----------------------------------------------------- 02379 glPushMatrix(); 02380 glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POINT_BIT ); 02381 //glDisable( GL_LIGHTING ); 02382 glEnable( GL_LIGHTING ); 02383 glEnable( GL_COLOR_MATERIAL ); 02384 glColor4f( color[0], color[1], color[2], color[3] ); 02385 //----------------------------------------------------- 02386 if ( m_pModel ) m_pModel->GetTransform().TransformByOpenGLForDrawing(); 02387 //----------------------------------------------------- 02388 int pointSizeInside = 3; 02389 int pointsizeOutside = 1; 02390 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02391 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02392 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 02393 if ( m_abVertexFlag1[i][j][k] >= INSIDE_MODEL ) { 02394 glPointSize( pointSizeInside ); 02395 glColor4f( color[0], color[1], color[2]/2, color[3] ); 02396 } 02397 else if ( m_abVertexFlag1[i][j][k] >= RIGHT_INSIDE_BOUNDARY ) { 02398 glPointSize( pointSizeInside ); 02399 glColor4f( color[0], color[1], color[2], color[3] ); 02400 } 02401 else if ( m_abVertexFlag1[i][j][k] >= ON_BOUNDARY ) { 02402 glPointSize( pointSizeInside ); 02403 glColor4f( color[0], color[1], color[2]*2, color[3] ); 02404 } 02405 else if ( m_abVertexFlag1[i][j][k] >= RIGHT_OUTSIDE_BOUNDARY ) { 02406 glPointSize( pointsizeOutside ); 02407 glColor4f( 0.75, 0, 0, 0.5 ); 02408 } 02409 else if ( m_abVertexFlag1[i][j][k] >= OUTSIDE_MODEL ) { 02410 glPointSize( pointsizeOutside ); 02411 glColor4f( 0.25, 0, 0, 0.5 ); 02412 } 02413 else { 02414 continue; 02415 } 02416 //------------------------------- 02417 glBegin( GL_POINTS ); 02418 glVertex3f ( 02419 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02420 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02421 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02422 ); 02423 glEnd(); 02424 //------------------------------- 02425 } 02426 } 02427 } 02428 //----------------------------------------------------- 02429 glPopAttrib(); 02430 glPopMatrix(); 02431 } 02432 //----------------------------------------------------------------------------- 02433 template <typename T, typename DATA> 02434 void GridGenerator<T,DATA>::DrawAllOuterPointsByOpenGL ( Vector4<T> color ) 02435 { 02436 if ( !IsGridGenerated() ) return; 02437 //----------------------------------------------------- 02438 glPushMatrix(); 02439 glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POINT_BIT ); 02440 //glDisable( GL_LIGHTING ); 02441 glEnable( GL_LIGHTING ); 02442 glEnable( GL_COLOR_MATERIAL ); 02443 glColor4f( color[0], color[1], color[2], color[3] ); 02444 glPointSize( 3 ); 02445 //----------------------------------------------------- 02446 if ( m_pModel ) m_pModel->GetTransform().TransformByOpenGLForDrawing(); 02447 //----------------------------------------------------- 02448 glBegin( GL_POINTS ); 02449 //--------------------------------------- 02450 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02451 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02452 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 02453 if ( m_abVertexFlag1[i][j][k] == RIGHT_OUTSIDE_BOUNDARY ) { 02454 glVertex3f ( 02455 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02456 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02457 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02458 ); 02459 } 02460 } 02461 } 02462 } 02463 //--------------------------------------- 02464 glEnd(); 02465 //----------------------------------------------------- 02466 glPopAttrib(); 02467 glPopMatrix(); 02468 } 02469 //----------------------------------------------------------------------------- 02470 template <typename T, typename DATA> 02471 void GridGenerator<T,DATA>::DrawAllInnerPointsByOpenGL ( Vector4<T> color ) 02472 { 02473 if ( !IsGridGenerated() ) return; 02474 //----------------------------------------------------- 02475 glPushMatrix(); 02476 glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POINT_BIT ); 02477 //glDisable( GL_LIGHTING ); 02478 glEnable( GL_LIGHTING ); 02479 glEnable( GL_COLOR_MATERIAL ); 02480 glColor4f( color[0], color[1], color[2], color[3] ); 02481 glPointSize( 3 ); 02482 //----------------------------------------------------- 02483 if ( m_pModel ) m_pModel->GetTransform().TransformByOpenGLForDrawing(); 02484 //----------------------------------------------------- 02485 glBegin( GL_POINTS ); 02486 //--------------------------------------- 02487 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 02488 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 02489 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 02490 if ( m_abVertexFlag1[i][j][k] > RIGHT_OUTSIDE_BOUNDARY ) { 02491 glVertex3f ( 02492 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02493 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02494 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02495 ); 02496 } 02497 } 02498 } 02499 } 02500 //--------------------------------------- 02501 glEnd(); 02502 //----------------------------------------------------- 02503 glPopAttrib(); 02504 glPopMatrix(); 02505 } 02506 //----------------------------------------------------------------------------- 02507 template <typename T, typename DATA> 02508 void GridGenerator<T,DATA>::DrawAsBoxesByOpenGL ( Vector4<T> color ) 02509 { 02510 if ( !IsGridGenerated() ) return; 02511 //----------------------------------------------------- 02512 glPushMatrix(); 02513 glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT ); 02514 //glDisable( GL_LIGHTING ); 02515 glEnable( GL_LIGHTING ); 02516 glEnable( GL_COLOR_MATERIAL ); 02517 glColor4f( color[0], color[1], color[2], color[3] ); 02518 //----------------------------------------------------- 02519 if ( m_pModel ) m_pModel->GetTransform().TransformByOpenGLForDrawing(); 02520 //----------------------------------------------------- 02521 int i, j, k; 02522 //--------------------------------- 02523 // Z Lines 02524 for ( i = 0; i < m_auiGridSize[0]; ++i ) { 02525 for ( j = 0; j < m_auiGridSize[1]; ++j ) { 02526 glBegin( GL_LINE_STRIP ); 02527 for ( k = 0; k < m_auiGridSize[2]; ++k ) { 02528 glVertex3f ( 02529 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02530 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02531 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02532 ); 02533 } 02534 glEnd(); 02535 } 02536 } 02537 //--------------------------------- 02538 // Y Lines 02539 for ( k = 0; k < m_auiGridSize[2]; ++k ) { 02540 for ( i = 0; i < m_auiGridSize[0]; ++i ) { 02541 glBegin( GL_LINE_STRIP ); 02542 for ( j = 0; j < m_auiGridSize[1]; ++j ) { 02543 glVertex3f ( 02544 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02545 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02546 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02547 ); 02548 } 02549 glEnd(); 02550 } 02551 } 02552 //--------------------------------- 02553 // X Lines 02554 for ( j = 0; j < m_auiGridSize[1]; ++j ) { 02555 for ( k = 0; k < m_auiGridSize[2]; ++k ) { 02556 glBegin( GL_LINE_STRIP ); 02557 for ( i = 0; i < m_auiGridSize[0]; ++i ) { 02558 glVertex3f ( 02559 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02560 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02561 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02562 ); 02563 } 02564 glEnd(); 02565 } 02566 } 02567 //--------------------------------------------------------------- 02568 glPopAttrib(); 02569 glPopMatrix(); 02570 } 02571 /* 02572 //----------------------------------------------------------------------------- 02573 template <typename T, typename DATA>> 02574 void GridGenerator<T,DATA>::DrawAPlaneByOpenGL ( int planeNo, int plane ) 02575 { 02576 // plane: 2: xy-, 0: yz-, 1: xz-plane 02577 //----------------------------------------------------- 02578 if ( planeNo < 0 ) 02579 planeNo = 0; 02580 else if ( planeNo >= m_auiGridSize[ plane ] ) 02581 planeNo = m_auiGridSize[ plane ] - 1; 02582 //----------------------------------------------------- 02583 //glPushAttrib( GL_CURRENT_BIT | GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT ); 02584 glPushAttrib( GL_CURRENT_BIT | GL_LIGHTING_BIT ); 02585 glDisable( GL_LIGHTING ); 02586 glMatrixMode( GL_PROJECTION ); 02587 glPushMatrix(); 02588 glLoadIdentity(); 02589 glOrtho( -1, 1, -1, 1, -0.2, 0.2 ); 02590 glMatrixMode( GL_MODELVIEW ); 02591 glPushMatrix(); 02592 glLoadIdentity(); 02593 //gluLookAt( 0, 0, 2, 0, 0, 0, 0, 1, 0 ); 02594 //----------------------------------------------------- 02595 DrawAsBoxesByOpenGL( Vector4<T>( 1, 0, 1, 1 ) ); 02596 glColor3f( 0, 0, 1 ); 02597 if ( m_pModel ) { 02598 OpenGL::OpenGLModel<T> * pGLModel = 02599 dynamic_cast< OpenGL::OpenGLModel<T> * >( m_pModel ); 02600 if ( pGLModel ) { 02601 pGLModel->DisplayGL( OpenGL::Enum::POLYGON ); 02602 } 02603 } 02604 //----------------------------------------------------- 02605 glPopMatrix(); 02606 glMatrixMode( GL_PROJECTION ); 02607 glPopMatrix(); 02608 glPopAttrib(); 02609 //----------------------------------------------------- 02610 //----------------------------------------------------- 02611 } 02612 //*/ 02613 //----------------------------------------------------------------------------- 02614 template <typename T, typename DATA> 02615 void GridGenerator<T,DATA>::DrawBoundingBoxByOpenGL ( Vector4<T> color ) 02616 { 02617 if ( !IsGridGenerated() ) return; 02618 //----------------------------------------------------- 02619 glPushMatrix(); 02620 glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT | GL_LINE_BIT | GL_POINT_BIT ); 02621 //glDisable( GL_LIGHTING ); 02622 glEnable( GL_LIGHTING ); 02623 glEnable( GL_COLOR_MATERIAL ); 02624 glColor4f( color[0], color[1], color[2], color[3] ); 02625 glLineWidth( 1 ); 02626 //----------------------------------------------------- 02627 if ( m_pModel ) m_pModel->GetTransform().TransformByOpenGLForDrawing(); 02628 //----------------------------------------------------- 02629 int i, j, k; 02630 //--------------------------------- 02631 // Z Lines 02632 for ( i = 0; i < m_auiGridSize[0]; i += m_auiGridSize[0]-1 ) { 02633 for ( j = 0; j < m_auiGridSize[1]; j += m_auiGridSize[1]-1 ) { 02634 glBegin( GL_LINE_STRIP ); 02635 for ( k = 0; k < m_auiGridSize[2]; k += m_auiGridSize[2]-1 ) { 02636 glVertex3f ( 02637 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02638 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02639 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02640 ); 02641 } 02642 glEnd(); 02643 } 02644 } 02645 //--------------------------------- 02646 // Y Lines 02647 for ( k = 0; k < m_auiGridSize[2]; k += m_auiGridSize[2]-1 ) { 02648 for ( i = 0; i < m_auiGridSize[0]; i += m_auiGridSize[0]-1 ) { 02649 glBegin( GL_LINE_STRIP ); 02650 for ( j = 0; j < m_auiGridSize[1]; j += m_auiGridSize[1]-1 ) { 02651 glVertex3f ( 02652 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02653 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02654 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02655 ); 02656 } 02657 glEnd(); 02658 } 02659 } 02660 //--------------------------------- 02661 // X Lines 02662 for ( j = 0; j < m_auiGridSize[1]; j += m_auiGridSize[1]-1 ) { 02663 for ( k = 0; k < m_auiGridSize[2]; k += m_auiGridSize[2]-1 ) { 02664 glBegin( GL_LINE_STRIP ); 02665 for ( i = 0; i < m_auiGridSize[0]; i += m_auiGridSize[0]-1 ) { 02666 glVertex3f ( 02667 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02668 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02669 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02670 ); 02671 } 02672 glEnd(); 02673 } 02674 } 02675 //--------------------------------------------------------------- 02676 02677 /* 02678 //=============================================================== 02679 // Start DEBUG 02680 //--------------------------------------------------------------- 02681 float pt[8][3]; 02682 glLineWidth( 2 ); 02683 // Draw Face Bounding Box 02684 pt[0][0] = vMin[0]; pt[0][1] = vMin[1]; pt[0][2] = vMin[2]; 02685 pt[1][0] = vMax[0]; pt[1][1] = vMin[1]; pt[1][2] = vMin[2]; 02686 pt[2][0] = vMax[0]; pt[2][1] = vMax[1]; pt[2][2] = vMin[2]; 02687 pt[3][0] = vMin[0]; pt[3][1] = vMax[1]; pt[3][2] = vMin[2]; 02688 pt[4][0] = vMin[0]; pt[4][1] = vMin[1]; pt[4][2] = vMax[2]; 02689 pt[5][0] = vMax[0]; pt[5][1] = vMin[1]; pt[5][2] = vMax[2]; 02690 pt[6][0] = vMax[0]; pt[6][1] = vMax[1]; pt[6][2] = vMax[2]; 02691 pt[7][0] = vMin[0]; pt[7][1] = vMax[1]; pt[7][2] = vMax[2]; 02692 glColor3f( 1, 0, 0 ); 02693 glBegin( GL_LINES ); 02694 //------------------- 02695 glVertex3fv ( pt[0] ); 02696 glVertex3fv ( pt[1] ); 02697 glVertex3fv ( pt[1] ); 02698 glVertex3fv ( pt[2] ); 02699 glVertex3fv ( pt[2] ); 02700 glVertex3fv ( pt[3] ); 02701 glVertex3fv ( pt[3] ); 02702 glVertex3fv ( pt[0] ); 02703 //------------------- 02704 glVertex3fv ( pt[4] ); 02705 glVertex3fv ( pt[5] ); 02706 glVertex3fv ( pt[5] ); 02707 glVertex3fv ( pt[6] ); 02708 glVertex3fv ( pt[6] ); 02709 glVertex3fv ( pt[7] ); 02710 glVertex3fv ( pt[7] ); 02711 glVertex3fv ( pt[4] ); 02712 //------------------- 02713 glVertex3fv ( pt[0] ); 02714 glVertex3fv ( pt[4] ); 02715 glVertex3fv ( pt[1] ); 02716 glVertex3fv ( pt[5] ); 02717 glVertex3fv ( pt[2] ); 02718 glVertex3fv ( pt[6] ); 02719 glVertex3fv ( pt[3] ); 02720 glVertex3fv ( pt[7] ); 02721 //------------------- 02722 glEnd(); 02723 //----------------------------------------------------- 02724 //glPointSize( 7 ); 02725 //glColor3f( 1, 0, 1 ); 02726 //glBegin( GL_POINTS ); 02727 // glColor3f( 1, 0, 0 ); 02728 // glVertex3f ( vMin[0], vMin[1], vMin[2] ); 02729 // glColor3f( 0, 1, 0 ); 02730 // glVertex3f ( vMax[0], vMax[1], vMax[2] ); 02731 //glEnd(); 02732 //----------------------------------------------------- 02733 // Draw Grid Bounding Box 02734 glLineWidth( 3 ); 02735 Vector3<T> vvMin, vvMax; 02736 for ( int d = 0; d < 3; ++d ) { 02737 vvMin[d] = m_tAABBMin[d] + gMinNum[d] * m_atGridDimension[d]; 02738 vvMax[d] = m_tAABBMin[d] + gMaxNum[d] * m_atGridDimension[d]; 02739 } 02740 pt[0][0] = vvMin[0]; pt[0][1] = vvMin[1]; pt[0][2] = vvMin[2]; 02741 pt[1][0] = vvMax[0]; pt[1][1] = vvMin[1]; pt[1][2] = vvMin[2]; 02742 pt[2][0] = vvMax[0]; pt[2][1] = vvMax[1]; pt[2][2] = vvMin[2]; 02743 pt[3][0] = vvMin[0]; pt[3][1] = vvMax[1]; pt[3][2] = vvMin[2]; 02744 pt[4][0] = vvMin[0]; pt[4][1] = vvMin[1]; pt[4][2] = vvMax[2]; 02745 pt[5][0] = vvMax[0]; pt[5][1] = vvMin[1]; pt[5][2] = vvMax[2]; 02746 pt[6][0] = vvMax[0]; pt[6][1] = vvMax[1]; pt[6][2] = vvMax[2]; 02747 pt[7][0] = vvMin[0]; pt[7][1] = vvMax[1]; pt[7][2] = vvMax[2]; 02748 glColor3f( 0, 1, 0 ); 02749 glBegin( GL_LINES ); 02750 //------------------- 02751 glVertex3fv ( pt[0] ); 02752 glVertex3fv ( pt[1] ); 02753 glVertex3fv ( pt[1] ); 02754 glVertex3fv ( pt[2] ); 02755 glVertex3fv ( pt[2] ); 02756 glVertex3fv ( pt[3] ); 02757 glVertex3fv ( pt[3] ); 02758 glVertex3fv ( pt[0] ); 02759 //------------------- 02760 glVertex3fv ( pt[4] ); 02761 glVertex3fv ( pt[5] ); 02762 glVertex3fv ( pt[5] ); 02763 glVertex3fv ( pt[6] ); 02764 glVertex3fv ( pt[6] ); 02765 glVertex3fv ( pt[7] ); 02766 glVertex3fv ( pt[7] ); 02767 glVertex3fv ( pt[4] ); 02768 //------------------- 02769 glVertex3fv ( pt[0] ); 02770 glVertex3fv ( pt[4] ); 02771 glVertex3fv ( pt[1] ); 02772 glVertex3fv ( pt[5] ); 02773 glVertex3fv ( pt[2] ); 02774 glVertex3fv ( pt[6] ); 02775 glVertex3fv ( pt[3] ); 02776 glVertex3fv ( pt[7] ); 02777 //------------------- 02778 glEnd(); 02779 //----------------------------------------------------- 02780 //glPointSize( 7 ); 02781 //glColor3f( 1, 0, 1 ); 02782 //glBegin( GL_POINTS ); 02783 // glColor3f( 1, 0, 0 ); 02784 // glVertex3f ( vvMin[0], vvMin[1], vvMin[2] ); 02785 // glColor3f( 0, 1, 0 ); 02786 // glVertex3f ( vvMax[0], vvMax[1], vvMax[2] ); 02787 //glEnd(); 02788 //----------------------------------------------------- 02789 // Draw Grid Start Point 02790 glPointSize( 7 ); 02791 glColor3f( 1, 0, 1 ); 02792 pt[0][0] = m_tAABBMin[0] + gridBoxCenterPt[0] * m_atGridDimension[0]; 02793 pt[0][1] = m_tAABBMin[1] + gridBoxCenterPt[1] * m_atGridDimension[1]; 02794 pt[0][2] = m_tAABBMin[2] + gridBoxCenterPt[2] * m_atGridDimension[2]; 02795 //glBegin( GL_POINTS ); 02796 // glVertex3fv ( pt[0] ); 02797 // glColor3f( 1, 0, 0 ); 02798 // glVertex3f ( m_tAABBMin[0], m_tAABBMin[1], m_tAABBMin[2] ); 02799 // glColor3f( 0, 1, 0 ); 02800 // glVertex3f ( m_tAABBMax[0], m_tAABBMax[1], m_tAABBMax[2] ); 02801 //glEnd(); 02802 //----------------------------------------------------- 02803 //glLineWidth( 5 ); 02804 //glBegin( GL_LINES ); 02805 // glColor3f( 1, 0, 1 ); 02806 // glVertex3fv ( pt[0] ); 02807 // glVertex3f ( pt[0][0] + m_atGridDimension[0] * minMoveStep[0], pt[0][1], pt[0][2] ); 02808 // glVertex3fv ( pt[0] ); 02809 // glVertex3f ( pt[0][0], pt[0][1] + m_atGridDimension[1] * minMoveStep[1], pt[0][2] ); 02810 // glVertex3fv ( pt[0] ); 02811 // glVertex3f ( pt[0][0], pt[0][1], pt[0][2] + m_atGridDimension[2] * minMoveStep[2] ); 02812 02813 // glColor3f( 0, 1, 1 ); 02814 // glVertex3fv ( pt[0] ); 02815 // glVertex3f ( pt[0][0] + m_atGridDimension[0] * maxMoveStep[0], pt[0][1], pt[0][2] ); 02816 // glVertex3fv ( pt[0] ); 02817 // glVertex3f ( pt[0][0], pt[0][1] + m_atGridDimension[1] * maxMoveStep[1], pt[0][2] ); 02818 // glVertex3fv ( pt[0] ); 02819 // glVertex3f ( pt[0][0], pt[0][1], pt[0][2] + m_atGridDimension[2] * maxMoveStep[2] ); 02820 //glEnd(); 02821 //--------------------------------------------------------------- 02822 // End DEBUG 02823 //=============================================================== 02824 //*/ 02825 02826 //--------------------------------------------------------------- 02827 glPopAttrib(); 02828 glPopMatrix(); 02829 } 02830 //----------------------------------------------------------------------------- 02831 template <typename T, typename DATA> 02832 void GridGenerator<T,DATA>::DrawAPlaneByOpenGL ( 02833 int drawDirection, Vector4<T> color ) 02834 // int planeNo, int drawDirection, Vector4<T> color ) 02835 { 02836 if ( !IsGridGenerated() ) return; 02837 //----------------------------------------------------- 02838 glPushMatrix(); 02839 glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POINT_BIT | GL_DEPTH_BUFFER_BIT ); 02840 glDisable( GL_DEPTH_TEST ); 02841 //glDisable( GL_LIGHTING ); 02842 glEnable( GL_LIGHTING ); 02843 glEnable( GL_COLOR_MATERIAL ); 02844 glColor4f( color[0], color[1], color[2], color[3] ); 02845 //----------------------------------------------------- 02846 if ( m_pModel ) m_pModel->GetTransform().TransformByOpenGLForDrawing(); 02847 //----------------------------------------------------- 02848 int dim1 = 0, dim2 = 1; // xy-plane 02849 switch ( drawDirection ) { 02850 case 0: // yz-plane 02851 dim1 = 1, dim2 = 2; 02852 break; 02853 case 1: // zx-plane 02854 dim1 = 2, dim2 = 0; 02855 break; 02856 } 02857 //----------------------------------------------------- 02858 // -- DEBUG -- 02859 // int k = planeNo; 02860 // if ( k < 0 ) k = 0; 02861 // else if ( k > 02862 static int k = 0; 02863 //----------------------------------------------------- 02864 for ( int i = 0; i < m_auiGridSize[dim1]; ++i ) { 02865 for ( int j = 0; j < m_auiGridSize[dim2]; ++j ) { 02866 if ( m_abVertexFlag1[i][j][k] >= INSIDE_MODEL ) { 02867 glPointSize( 3 ); 02868 //glColor4f( color[0], color[1], color[2]/2, color[3] ); 02869 glColor4f( 1, 1, 0, color[3] ); 02870 } 02871 else if ( m_abVertexFlag1[i][j][k] >= RIGHT_INSIDE_BOUNDARY ) { 02872 glPointSize( 3 ); 02873 glColor4f( color[0], color[1], color[2], color[3] ); 02874 } 02875 else if ( m_abVertexFlag1[i][j][k] >= ON_BOUNDARY ) { 02876 glPointSize( 3 ); 02877 //glColor4f( color[0], color[1], color[2]*2, color[3] ); 02878 glColor4f( 1, 1, 1, color[3] ); 02879 } 02880 else if ( m_abVertexFlag1[i][j][k] >= RIGHT_OUTSIDE_BOUNDARY ) { 02881 glPointSize( 1 ); 02882 glColor4f( 0.75, 0, 0, 0.5 ); 02883 } 02884 else if ( m_abVertexFlag1[i][j][k] >= OUTSIDE_MODEL ) { 02885 continue; 02886 glPointSize( 1 ); 02887 glColor4f( 0.25, 0, 0, 0.5 ); 02888 } 02889 else { 02890 continue; 02891 } 02892 02893 /* 02894 if ( m_abVertexFlag1[i][j][k] > RIGHT_OUTSIDE_BOUNDARY ) { 02895 glPointSize( 3 ); 02896 glColor4f( color[0], color[1], color[2], color[3] ); 02897 } 02898 else if ( m_abVertexFlag1[i][j][k] > UNSET ) { 02899 glPointSize( 1 ); 02900 glColor4f( 0.75, 0, 0, 0.5 ); 02901 } 02902 else { 02903 continue; 02904 } 02905 //*/ 02906 02907 //------------------------------- 02908 glBegin( GL_POINTS ); 02909 glVertex3f ( 02910 static_cast<float>( m_atVertexPosition[i][j][k][0] ), 02911 static_cast<float>( m_atVertexPosition[i][j][k][1] ), 02912 static_cast<float>( m_atVertexPosition[i][j][k][2] ) 02913 ); 02914 glEnd(); 02915 //------------------------------- 02916 } 02917 } 02918 ++k; 02919 //----------------------------------------------------- 02920 // -- DEBUG -- 02921 if ( k >= m_auiGridSize[2] - 1 ) k = 0; 02922 //----------------------------------------------------- 02923 glPopAttrib(); 02924 glPopMatrix(); 02925 } 02926 //----------------------------------------------------------------------------- 02927 02928 02929 02930 // DEBUG BY DRAWING 02931 //----------------------------------------------------------------------------- 02932 // Set Grid Points To Inside and Outside the Model 02933 template <typename T, typename DATA> 02934 void GridGenerator<T,DATA>::DRAW_SetGridPointsToInsideOutsideModelBoundary_SW ( 02935 OpenGL::XPolygonalModel<T> * pXPModel ) 02936 { 02937 if ( !IsGridGenerated() ) return; 02938 //--------------------------------------------------------------- 02939 glPushAttrib( GL_ALL_ATTRIB_BITS ); 02940 glDisable( GL_LIGHTING ); 02941 glLineWidth( 3 ); 02942 glPointSize( 7 ); 02943 //--------------------------------------------------------------- 02944 XVertex<T> * vertex = pXPModel->GetVertexList(); 02945 Face<T> * face = pXPModel->GetFaceList(); 02946 int NumFaces = pXPModel->GetNoFaces(); 02947 //--------------------------------------------------------------- 02948 // Generate Grid by a Software Algorithm 02949 //----------------------------------------------------- 02950 Vector3<T> vMin, vMax, vPos, vAverage; 02951 //----------------------------------------------------- 02952 // For Each Face 02953 static unsigned int faceNo = 0; 02954 static unsigned int count = 0; 02955 if ( ++count >= 1000 ) { 02956 count = 0; 02957 if ( ++faceNo >= NumFaces ) { 02958 faceNo = 0; 02959 } 02960 } 02961 { 02962 unsigned int i = faceNo; 02963 //--------------------------------------- 02964 // Find a box that contain this face 02965 vAverage = vMin = vMax = vertex[ face[i].GetVertexNo(0) ].GetPosition(); 02966 for ( unsigned int n = 1; n < face[i].GetNoVertices(); ++n ) { 02967 vPos = vertex[ face[i].GetVertexNo(n) ].GetPosition(); 02968 vAverage += vPos; 02969 for ( int d = 0; d < 3; ++d ) { 02970 if ( vMin[d] > vPos[d] ) vMin[d] = vPos[d]; 02971 else if ( vMax[d] < vPos[d] ) vMax[d] = vPos[d]; 02972 } 02973 } 02974 //assert( vMin[0] <= vMax[0] ); 02975 //assert( vMin[1] <= vMax[1] ); 02976 //assert( vMin[2] <= vMax[2] ); 02977 //--------------------------------------- 02978 // Find a box of grids that contain this face 02979 // i.e. a bigger box that contain the face box 02980 int gMinNum[3], gMaxNum[3]; 02981 T gMin, gMax; 02982 for ( int d = 0; d < 3; ++d ) { 02983 int step = m_auiGridSize[d] / 2; 02984 gMinNum[d] = gMaxNum[d] = step; 02985 gMin = m_tAABBMin[d] + gMinNum[d] * m_atGridDimension[d]; 02986 T minOffset = vMin[d] - m_atGridDimension[d] / 2; 02987 T maxOffset = vMax[d] + m_atGridDimension[d] / 2; 02988 //T minOffset = vMin[d]; 02989 //T maxOffset = vMax[d]; 02990 //------------------------- 02991 // Find a box of this current face 02992 while ( ( gMin < minOffset || maxOffset < gMin ) && step > 1 ) { 02993 step /= 2; 02994 if ( gMin < minOffset ) { 02995 gMinNum[d] += step; 02996 } 02997 else { 02998 gMinNum[d] -= step; 02999 } 03000 gMin = m_tAABBMin[d] + gMinNum[d] * m_atGridDimension[d]; 03001 } 03002 gMax = gMin; 03003 gMaxNum[d] = gMinNum[d]; 03004 03005 // DEBUG 03006 //gridBoxCenterPt[d] = gMinNum[d]; 03007 03008 //------------------------- 03009 // Find a grid box that covers the box of this current face 03010 //minMoveStep[d] = maxMoveStep[d] = 0; // DEBUG 03011 //------------------------- 03012 // Find the low 03013 while ( vMin[d] < gMin ) { 03014 //while ( minOffset < gMin ) { 03015 //--minMoveStep[d]; // DEBUG 03016 --gMinNum[d]; 03017 gMin -= m_atGridDimension[d]; 03018 } 03019 if ( gMinNum[d] < 0 ) { 03020 gMinNum[d] = 0; 03021 } 03022 //------------------------- 03023 // Find the high 03024 while ( gMax < vMax[d] ) { 03025 //while ( gMax < maxOffset ) { 03026 //++maxMoveStep[d]; // DEBUG 03027 ++gMaxNum[d]; 03028 gMax += m_atGridDimension[d]; 03029 } 03030 if ( gMaxNum[d] >= m_auiGridSize[d] ) { 03031 gMaxNum[d] = m_auiGridSize[d] - 1; 03032 } 03033 //----------------------------------- 03034 //assert( gMinNum[d] <= gMaxNum[d] ); 03035 //assert( 0 <= gMinNum[d] && gMinNum[d] < m_auiGridSize[d] ); 03036 //assert( 0 <= gMaxNum[d] && gMaxNum[d] < m_auiGridSize[d] ); 03037 } 03038 03039 //------------------------------------------------- 03040 // Set Inside / Outside 03041 //vPos = vertex[ face[i].GetVertexNo(0) ].GetPosition(); 03042 vAverage /= face[i].GetNoVertices(); 03043 Vector3<T> normal = face[i].GetNormal(); 03044 Vector3<T> direction; 03045 for ( int x = gMinNum[0]; x <= gMaxNum[0]; ++x ) { 03046 for ( int y = gMinNum[1]; y <= gMaxNum[1]; ++y ) { 03047 for ( int z = gMinNum[2]; z <= gMaxNum[2]; ++z ) { 03048 direction.SetXYZ( 03049 m_atVertexPosition[x][y][z][0] - vAverage[0], 03050 m_atVertexPosition[x][y][z][1] - vAverage[1], 03051 m_atVertexPosition[x][y][z][2] - vAverage[2] 03052 ); 03053 //--------------------------- 03054 // If just outside boundary 03055 if ( m_abVertexFlag1[x][y][z] == RIGHT_OUTSIDE_BOUNDARY ) continue; 03056 //--------------------------- 03057 // The point is inside, on, or outside the boundary. 03058 if ( normal * direction < 0.0 ) { 03059 m_abVertexFlag1[x][y][z] = RIGHT_INSIDE_BOUNDARY; 03060 } 03061 else if ( normal * direction == 0.0 ) { 03062 m_abVertexFlag1[x][y][z] = ON_BOUNDARY; 03063 } 03064 else { 03065 m_abVertexFlag1[x][y][z] = RIGHT_OUTSIDE_BOUNDARY; 03066 } 03067 } 03068 } 03069 } 03070 //------------------------------------------------- 03071 03072 //================================================= 03073 // START: DRAWING 03074 //------------------------------------------------- 03075 { // Draw Triangle 03076 glColor3ub( 75, 255, 75 ); 03077 glBegin( GL_TRIANGLES ); 03078 //glBegin( GL_POINTS ); 03079 for ( unsigned int n = 0; n < face[i].GetNoVertices(); ++n ) { 03080 vPos = vertex[ face[i].GetVertexNo(n) ].GetPosition(); 03081 glVertex3f( vPos[0], vPos[1], vPos[2] ); 03082 } 03083 glEnd(); 03084 } 03085 { // Draw the box 03086 Vector3<T> boxMin( m_atVertexPosition[ gMinNum[0] ][ gMinNum[1] ][ gMinNum[2] ] ); 03087 Vector3<T> boxMax( m_atVertexPosition[ gMaxNum[0] ][ gMaxNum[1] ][ gMaxNum[2] ] ); 03088 //glColor3f( 03089 // rand() / static_cast<T>( RAND_MAX ), 03090 // rand() / static_cast<T>( RAND_MAX ), 03091 // rand() / static_cast<T>( RAND_MAX ) 03092 //); 03093 glColor3ub( 15, 75, 15 ); 03094 glBegin( GL_LINE_LOOP ); 03095 glVertex3f( boxMin[0], boxMin[1], boxMin[2] ); 03096 glVertex3f( boxMax[0], boxMin[1], boxMin[2] ); 03097 glVertex3f( boxMax[0], boxMax[1], boxMin[2] ); 03098 glVertex3f( boxMin[0], boxMax[1], boxMin[2] ); 03099 glEnd(); 03100 glBegin( GL_LINE_LOOP ); 03101 glVertex3f( boxMin[0], boxMin[1], boxMax[2] ); 03102 glVertex3f( boxMax[0], boxMin[1], boxMax[2] ); 03103 glVertex3f( boxMax[0], boxMax[1], boxMax[2] ); 03104 glVertex3f( boxMin[0], boxMax[1], boxMax[2] ); 03105 glEnd(); 03106 glBegin( GL_LINES ); 03107 glVertex3f( boxMin[0], boxMin[1], boxMin[2] ); 03108 glVertex3f( boxMin[0], boxMin[1], boxMax[2] ); 03109 glVertex3f( boxMax[0], boxMin[1], boxMin[2] ); 03110 glVertex3f( boxMax[0], boxMin[1], boxMax[2] ); 03111 glVertex3f( boxMax[0], boxMax[1], boxMin[2] ); 03112 glVertex3f( boxMax[0], boxMax[1], boxMax[2] ); 03113 glVertex3f( boxMin[0], boxMax[1], boxMin[2] ); 03114 glVertex3f( boxMin[0], boxMax[1], boxMax[2] ); 03115 glEnd(); 03116 } 03117 { // Draw Points 03118 glBegin( GL_POINTS ); 03119 for ( int x = gMinNum[0]; x <= gMaxNum[0]; ++x ) { 03120 for ( int y = gMinNum[1]; y <= gMaxNum[1]; ++y ) { 03121 for ( int z = gMinNum[2]; z <= gMaxNum[2]; ++z ) { 03122 if ( m_abVertexFlag1[x][y][z] == UNSET ) glColor3ub( 0, 0, 0 ); 03123 if ( m_abVertexFlag1[x][y][z] == OUTSIDE_MODEL ) glColor3ub( 127, 0, 0 ); 03124 if ( m_abVertexFlag1[x][y][z] == RIGHT_OUTSIDE_BOUNDARY ) glColor3ub( 255, 0, 0 ); 03125 if ( m_abVertexFlag1[x][y][z] == ON_BOUNDARY ) glColor3ub( 0, 255, 0 ); 03126 if ( m_abVertexFlag1[x][y][z] == RIGHT_INSIDE_BOUNDARY ) glColor3ub( 0, 0, 127 ); 03127 if ( m_abVertexFlag1[x][y][z] == INSIDE_MODEL ) glColor3ub( 0, 0, 255 ); 03128 glVertex3f( m_atVertexPosition[x][y][z][0], 03129 m_atVertexPosition[x][y][z][1], 03130 m_atVertexPosition[x][y][z][2] ); 03131 } 03132 } 03133 } 03134 glEnd(); 03135 } 03136 //------------------------------------------------- 03137 // END: DRAWING 03138 //================================================= 03139 } 03140 //--------------------------------------------------------------- 03141 glPopAttrib(); 03142 // End of Generating Grid by a Software Algorithm 03143 } 03144 03145 03146 //----------------------------------------------------------------------------- 03147 #endif 03148 03149 03150 03151 03152 //============================================================================= 03153 #ifdef TAPs_GRID_GENERATOR_ADD_BARYCENTRIC 03154 //----------------------------------------------------------------------------- 03155 //--------------------------- 03156 // FOR HEXAHEDRAL FEM 03157 //--------------------------- 03158 03159 template <typename T, typename DATA> 03160 void GridGenerator<T,DATA>::RecordHexBarycentricCoordinates () 03161 { 03162 if ( !m_pModel ) return; 03163 //--------------------------------------------------------------- 03164 OpenGL::PolygonalModel<T> * pPologonalModel 03165 = dynamic_cast< OpenGL::PolygonalModel<T> * >( m_pModel ); 03166 OpenGL::XPolygonalModel<T> * pXPologonalModel 03167 = dynamic_cast< OpenGL::XPolygonalModel<T> * >( m_pModel ); 03168 OpenGL::HalfEdgeModel<T> * pHalfEdgeModel 03169 = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( m_pModel ); 03170 //--------------------------------------------------------------- 03171 // For PolygonalModel 03172 if ( pPologonalModel ) { 03173 m_cHexBaryCoords.clear(); 03174 return; 03175 } 03176 //--------------------------------------------------------------- 03177 // For XPolygonalModel 03178 else if ( pXPologonalModel ) { 03179 RecordHexBarycentricCoordinates( pXPologonalModel ); 03180 return; 03181 } 03182 //--------------------------------------------------------------- 03183 // For HalfEdgeModel 03184 else if ( pHalfEdgeModel ) { 03185 RecordHexBarycentricCoordinates( pHalfEdgeModel ); 03186 return; 03187 } 03188 //--------------------------------------------------------------- 03189 } 03190 03191 03192 template <typename T, typename DATA> 03193 void GridGenerator<T,DATA>::RecordHexBarycentricCoordinates ( OpenGL::XPolygonalModel<T> * pXPModel ) 03194 { 03195 std::cout << __FILE__ << " (LINE#" << __LINE__ << ") NOT IMPLEMENTED YET!\n"; 03196 } 03197 03198 03199 template <typename T, typename DATA> 03200 void GridGenerator<T,DATA>::RecordHexBarycentricCoordinates ( OpenGL::HalfEdgeModel<T> * pHEModel ) 03201 { 03202 m_cHexBaryCoords.clear(); 03203 //std::cout << "#vertices: " << pHEModel->GetNoVertices() << "\n"; 03204 //std::cout << "#vertices: " << pHEModel->GetNumVertices() << "\n"; 03205 //std::cout << "#vertices: " << pHEModel->GetVertexList()->Size() << "\n"; 03206 HEVertex<T> * pVertex = pHEModel->GetVertexList()->Head(); 03207 unsigned int i,j,k; 03208 T u,v,w; 03209 T sx = 1.0 / (m_atGridDimension[0]*m_atGridDimension[0]); 03210 T sy = 1.0 / (m_atGridDimension[1]*m_atGridDimension[1]); 03211 T sz = 1.0 / (m_atGridDimension[2]*m_atGridDimension[2]); 03212 while ( pVertex != NULL ) { 03213 03214 Vector3<T> P = pVertex->GetPosition(); 03215 LocateHexGrid( P[0], P[1], P[2], i, j, k ); 03216 Vector3<T> O( m_atVertexPosition[i][j][k][0], m_atVertexPosition[i][j][k][1], m_atVertexPosition[i][j][k][2] ); 03217 Vector3<T> p = P - O; 03218 Vector3<T> X = Vector3<T>( m_atVertexPosition[i+1][j][k][0], m_atVertexPosition[i+1][j][k][1], m_atVertexPosition[i+1][j][k][2] ) - O; 03219 Vector3<T> Y = Vector3<T>( m_atVertexPosition[i][j+1][k][0], m_atVertexPosition[i][j+1][k][1], m_atVertexPosition[i][j+1][k][2] ) - O; 03220 Vector3<T> Z = Vector3<T>( m_atVertexPosition[i][j][k+1][0], m_atVertexPosition[i][j][k+1][1], m_atVertexPosition[i][j][k+1][2] ) - O; 03221 u = (X*p * sx - 0.5) * 2.0; 03222 v = (Y*p * sy - 0.5) * 2.0; 03223 w = (Z*p * sz - 0.5) * 2.0; 03224 03225 // i,j,k are the grid location (i.e. element) relative to the FEM Mesh. 03226 // u,v,w are the parametric coordinates of the point in the element. 03227 m_cHexBaryCoords.push_back( HexBarycentricCoordsForVertexRef<T,DATA>( pVertex->RefToPosition(), i,j,k, u,v,w ) ); 03228 03229 // WON'T WORK because of m_cHexBaryCoords is relocated after expansion due to it is an std::vector!!! 03230 // So set it somewhere else. 03231 //pVertex->SetBarycentricPtr( &m_cHexBaryCoords.back() ); 03232 03233 // DEBUG 03234 static int cc = 0; 03235 ++cc; 03236 //std::cout << cc << "\tHEX: " << pVertex->GetBarycentricPtr() << "\t" << *( pVertex->GetBarycentricPtr() ) << "\n"; 03237 03238 pVertex = pVertex->Next(); 03239 } 03240 } 03241 03242 03243 template <typename T, typename DATA> 03244 void GridGenerator<T,DATA>::LocateHexGrid ( T x, T y, T z, unsigned int &i, unsigned int &j, unsigned int &k ) 03245 { 03246 i = static_cast<unsigned int>( (x-m_atVertexPosition[0][0][0][0]) / m_atGridDimension[0] ); 03247 j = static_cast<unsigned int>( (y-m_atVertexPosition[0][0][0][1]) / m_atGridDimension[1] ); 03248 k = static_cast<unsigned int>( (z-m_atVertexPosition[0][0][0][2]) / m_atGridDimension[2] ); 03249 03250 //std::cout << i << "\t" << j << "\t" << k << "\n"; 03251 } 03252 03253 03254 template <typename T, typename DATA> 03255 void GridGenerator<T,DATA>::AnimateHex () 03256 { 03257 srand(time(0)); 03258 for ( int i = 0; i < m_auiGridSize[0]; ++i ) { 03259 for ( int j = 0; j < m_auiGridSize[1]; ++j ) { 03260 for ( int k = 0; k < m_auiGridSize[2]; ++k ) { 03261 m_atVertexPosition[i][j][k][0] += (((float)rand()/RAND_MAX) - 0.5f)*2E-3f*m_atGridDimension[0]; 03262 m_atVertexPosition[i][j][k][1] += (((float)rand()/RAND_MAX) - 0.5f)*2E-3f*m_atGridDimension[1]; 03263 m_atVertexPosition[i][j][k][2] += (((float)rand()/RAND_MAX) - 0.5f)*2E-3f*m_atGridDimension[2]; 03264 } 03265 } 03266 } 03267 03268 // Itarate all vertices 03269 std::vector< HexBarycentricCoordsForVertexRef<T,DATA> >::iterator it = m_cHexBaryCoords.begin(); 03270 unsigned int i=0,j=0,k=0; 03271 03272 //std::cout << "TEST AnimateHex\n"; 03273 03274 while ( it != m_cHexBaryCoords.end() ) { 03275 03276 it->GetGridLocations( i, j, k ); 03277 //std::cout << i << "\t" << j << "\t" << k << "\n"; 03278 03279 it->ComputeNewVertexLocation(); 03280 // m_atVertexPosition[i ][j ][k ][0], m_atVertexPosition[i ][j ][k ][1], m_atVertexPosition[i ][j ][k ][2], 03281 // m_atVertexPosition[i+1][j ][k ][0], m_atVertexPosition[i+1][j ][k ][1], m_atVertexPosition[i+1][j ][k ][2], 03282 // m_atVertexPosition[i+1][j+1][k ][0], m_atVertexPosition[i+1][j+1][k ][1], m_atVertexPosition[i+1][j+1][k ][2], 03283 // m_atVertexPosition[i ][j+1][k ][0], m_atVertexPosition[i ][j+1][k ][1], m_atVertexPosition[i ][j+1][k ][2], 03284 // m_atVertexPosition[i ][j ][k+1][0], m_atVertexPosition[i ][j ][k+1][1], m_atVertexPosition[i ][j ][k+1][2], 03285 // m_atVertexPosition[i+1][j ][k+1][0], m_atVertexPosition[i+1][j ][k+1][1], m_atVertexPosition[i+1][j ][k+1][2], 03286 // m_atVertexPosition[i+1][j+1][k+1][0], m_atVertexPosition[i+1][j+1][k+1][1], m_atVertexPosition[i+1][j+1][k+1][2], 03287 // m_atVertexPosition[i ][j+1][k+1][0], m_atVertexPosition[i ][j+1][k+1][1], m_atVertexPosition[i ][j+1][k+1][2] 03288 //); 03289 03290 ++it; 03291 } 03292 } 03293 //--------------------------- 03294 // FOR HEXAHEDRAL FEM 03295 //--------------------------- 03296 //----------------------------------------------------------------------------- 03297 #endif//TAPs_GRID_GENERATOR_ADD_BARYCENTRIC 03298 //============================================================================= 03299 03300 03301 03302 03303 //============================================================================= 03304 END_NAMESPACE_TAPs 03305 //----------------------------------------------------------------------------- 03306 //34567890123456789012345678901234567890123456789012345678901234567890123456789 03307 //--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
1.7.4 
