#include <marchingcubes.h>
Inheritance diagram for EMAN::MarchingCubes:
Public Member Functions | |
MarchingCubes () | |
Default constructor. | |
MarchingCubes (EMData *em) | |
Most commonly used constructor calls set_data(em). | |
virtual | ~MarchingCubes () |
void | set_data (EMData *data) |
Sets Voxel data for Isosurface implementation Calls calculate_min_max_vals which generates the tree of data. | |
void | set_surface_value (const float value) |
Set Isosurface value. | |
float | get_surface_value () const |
Get the current isosurface value being used. | |
void | set_sampling (const int rate) |
Set sampling rates A smaller value means a finer sampling. | |
int | get_sampling () const |
Current the current sampling rate Finest sampling is -1. | |
int | get_sampling_range () |
Get the range of feasible sampling rates. | |
Dict | get_isosurface () |
Get the isosurface as dictionary Traverses the tree and marches the cubes. | |
void | surface_face_z () |
Private Member Functions | |
bool | calculate_min_max_vals () |
Calculate the min and max value trees Stores minimum and maximum cube neighborhood values in a tree structure. | |
void | clear_min_max_vals () |
Clear the minimum and maximum value search trees Frees memory in the minvals and maxvals. | |
void | draw_cube (const int x, const int y, const int z, const int cur_level) |
The main cube drawing function To start the process of generate triangles call with draw_cube(0,0,0,minvals.size()-1) Once cur_level becomes drawing_level marching_cube is called. | |
void | marching_cube (int fX, int fY, int fZ, const int cur_level) |
Function for managing cases where a triangles can potentially be rendered Called by draw_cube. | |
void | calculate_surface () |
Calculate and generate the entire set of vertices and normals using current states Calls draw_cube(0,0,0,minvals.size()-1). | |
float | get_offset (float fValue1, float fValue2, float fValueDesired) |
Find the approximate point of intersection of the surface between two points with the values fValue1 and fValue2. | |
int | get_edge_num (int x, int y, int z, int edge) |
Get edge num needs better commenting. | |
void | get_normal (Vector3 &normal, int fX, int fY, int fZ) |
Find the gradient of the scalar field at a point. | |
Private Attributes | |
map< int, int > | point_map |
unsigned long | _isodl |
vector< EMData * > | minvals |
Vectors for storing the search trees. | |
vector< EMData * > | maxvals |
Vectors for storing the search trees. | |
int | drawing_level |
The "sampling rate". | |
CustomVector< float > | pp |
.Custom vectors for storing points, normals and faces | |
CustomVector< float > | nn |
CustomVector< unsigned int > | ff |
Friends | |
class | GLUtil |
|
Default constructor.
Definition at line 143 of file marchingcubes.cpp. 00144 : _isodl(0) 00145 { 00146 }
|
|
Most commonly used constructor calls set_data(em).
Definition at line 148 of file marchingcubes.cpp. References set_data().
|
|
Definition at line 210 of file marchingcubes.cpp. References clear_min_max_vals(). 00210 { 00211 clear_min_max_vals(); 00212 }
|
|
Calculate the min and max value trees Stores minimum and maximum cube neighborhood values in a tree structure.
Definition at line 169 of file marchingcubes.cpp. References clear_min_max_vals(), drawing_level, EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), maxvals, minvals, NullPointerException, nx, ny, process(), and EMAN::EMData::process(). Referenced by set_data(). 00170 { 00171 00172 if (_emdata == NULL ) throw NullPointerException("Error, cannot generate search tree if the overriding EMData object is NULL"); 00173 00174 clear_min_max_vals(); 00175 00176 int nx = _emdata->get_xsize(); 00177 int ny = _emdata->get_ysize(); 00178 int nz = _emdata->get_zsize(); 00179 00180 // Create the binary min max tree 00181 while ( nx > 1 || ny > 1 || nz > 1 ) 00182 { 00183 int size = minvals.size(); 00184 00185 if ( size == 0 ){ 00186 Dict a; 00187 // Setting search to 3 at the bottom level is most important. 00188 // FIXME - d.woolford add comments heere 00189 a["search"] = 3; 00190 minvals.push_back(_emdata->process("math.minshrink",a)); 00191 maxvals.push_back(_emdata->process("math.maxshrink",a)); 00192 }else { 00193 minvals.push_back(minvals[size-1]->process("math.minshrink")); 00194 maxvals.push_back(maxvals[size-1]->process("math.maxshrink")); 00195 } 00196 00197 nx = minvals[size]->get_xsize(); 00198 ny = minvals[size]->get_ysize(); 00199 nz = minvals[size]->get_zsize(); 00200 #if MARCHING_CUBES_DEBUG 00201 cout << "dims are " << nx << " " << ny << " " << nz << endl; 00202 #endif 00203 } 00204 00205 drawing_level = -1; 00206 00207 return true; 00208 }
|
|
Calculate and generate the entire set of vertices and normals using current states Calls draw_cube(0,0,0,minvals.size()-1).
Definition at line 272 of file marchingcubes.cpp. References EMAN::CustomVector< type >::clear(), draw_cube(), ff, max, maxvals, min, minvals, nn, NotExistingObjectException, NullPointerException, point_map, and pp. Referenced by get_isosurface(). 00272 { 00273 00274 if ( _emdata == 0 ) throw NullPointerException("Error, attempt to generate isosurface, but the emdata image object has not been set"); 00275 if ( minvals.size() == 0 || maxvals.size() == 0 ) throw NotExistingObjectException("Vector of EMData pointers", "Error, the min and max val search trees have not been created"); 00276 00277 point_map.clear(); 00278 pp.clear(); 00279 nn.clear(); 00280 ff.clear(); 00281 00282 #if MARCHING_CUBES_DEBUG 00283 int time0 = clock(); 00284 #endif 00285 00286 float min = minvals[minvals.size()-1]->get_value_at(0,0,0); 00287 float max = maxvals[minvals.size()-1]->get_value_at(0,0,0); 00288 if ( min < _surf_value && max > _surf_value) draw_cube(0,0,0,minvals.size()-1); 00289 00290 #if MARCHING_CUBES_DEBUG 00291 int time1 = clock(); 00292 cout << "It took " << (time1-time0) << " " << (float)(time1-time0)/CLOCKS_PER_SEC << " to traverse the search tree and generate polygons" << endl; 00293 cout << "... using surface value " << _surf_value << endl; 00294 #endif 00295 }
|
|
Clear the minimum and maximum value search trees Frees memory in the minvals and maxvals.
Definition at line 154 of file marchingcubes.cpp. References maxvals, and minvals. Referenced by calculate_min_max_vals(), and ~MarchingCubes(). 00155 { 00156 for (vector<EMData*>::iterator it = minvals.begin(); it != minvals.end(); ++it) 00157 { 00158 if ( (*it) != 0 ) delete *it; 00159 } 00160 minvals.clear(); 00161 00162 for (vector<EMData*>::iterator it = maxvals.begin(); it != maxvals.end(); ++it) 00163 { 00164 if ( (*it) != 0 ) delete *it; 00165 } 00166 maxvals.clear(); 00167 }
|
|
The main cube drawing function To start the process of generate triangles call with draw_cube(0,0,0,minvals.size()-1) Once cur_level becomes drawing_level marching_cube is called.
Definition at line 297 of file marchingcubes.cpp. References a2fPosXOffset, a2fPosXPosYOffset, a2fPosXPosZOffset, a2fPosYOffset, a2fPosYPosZOffset, a2fPosZOffset, a2fVertexOffset, drawing_level, EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), marching_cube(), max, maxvals, min, minvals, x, and y. Referenced by calculate_surface(). 00297 { 00298 00299 if ( cur_level == drawing_level ) 00300 { 00301 EMData* e; 00302 if ( drawing_level == - 1 ) e = _emdata; 00303 else e = minvals[drawing_level]; 00304 if ( x < (e->get_xsize()-1) && y < (e->get_ysize()-1) && z < (e->get_zsize()-1)) 00305 marching_cube(x,y,z, cur_level); 00306 } 00307 else 00308 { 00309 EMData* e; 00310 if ( cur_level > 0 ) { 00311 int xsize = minvals[cur_level-1]->get_xsize(); 00312 int ysize = minvals[cur_level-1]->get_ysize(); 00313 int zsize = minvals[cur_level-1]->get_zsize(); 00314 e = minvals[cur_level-1]; 00315 for(int i=0; i<8; ++i ) { 00316 int xx = 2*x+a2fVertexOffset[i][0]; 00317 if ( xx >= xsize ) continue; 00318 int yy = 2*y+a2fVertexOffset[i][1]; 00319 if ( yy >= ysize ) continue; 00320 int zz = 2*z+a2fVertexOffset[i][2]; 00321 if ( zz >= zsize ) continue; 00322 00323 float min = minvals[cur_level-1]->get_value_at(xx,yy,zz); 00324 float max = maxvals[cur_level-1]->get_value_at(xx,yy,zz); 00325 if ( min < _surf_value && max > _surf_value) 00326 draw_cube(xx,yy,zz,cur_level-1); 00327 } 00328 } 00329 else { 00330 e = _emdata; 00331 for(int i=0; i<8; ++i ) { 00332 draw_cube(2*x+a2fVertexOffset[i][0],2*y+a2fVertexOffset[i][1],2*z+a2fVertexOffset[i][2],cur_level-1); 00333 } 00334 } 00335 00336 if ( x == (minvals[cur_level]->get_xsize()-1) ) { 00337 if ( e->get_xsize() > 2*x ){ 00338 for(int i=0; i<4; ++i ) { 00339 draw_cube(2*x+a2fPosXOffset[i][0],2*y+a2fPosXOffset[i][1],2*z+a2fPosXOffset[i][2],cur_level-1); 00340 } 00341 } 00342 if ( y == (minvals[cur_level]->get_ysize()-1) ) { 00343 if ( e->get_ysize() > 2*y ) { 00344 for(int i=0; i<2; ++i ) { 00345 draw_cube(2*x+a2fPosXPosYOffset[i][0],2*y+a2fPosXPosYOffset[i][1],2*z+a2fPosXPosYOffset[i][2],cur_level-1); 00346 } 00347 } 00348 if ( z == (minvals[cur_level]->get_zsize()-1) ){ 00349 if ( e->get_zsize() > 2*z ) { 00350 draw_cube(2*x+2,2*y+2,2*z+2,cur_level-1); 00351 } 00352 } 00353 } 00354 if ( z == (minvals[cur_level]->get_zsize()-1) ) { 00355 if ( e->get_zsize() > 2*z ) { 00356 for(int i=0; i<2; ++i ) { 00357 draw_cube(2*x+a2fPosXPosZOffset[i][0],2*y+a2fPosXPosZOffset[i][1],2*z+a2fPosXPosZOffset[i][2],cur_level-1); 00358 } 00359 } 00360 } 00361 } 00362 if ( y == (minvals[cur_level]->get_ysize()-1) ) { 00363 if ( e->get_ysize() > 2*y ) { 00364 for(int i=0; i<4; ++i ) { 00365 draw_cube(2*x+a2fPosYOffset[i][0],2*y+a2fPosYOffset[i][1],2*z+a2fPosYOffset[i][2],cur_level-1); 00366 } 00367 } 00368 if ( z == (minvals[cur_level]->get_ysize()-1) ) { 00369 if ( e->get_zsize() > 2*z ) { 00370 for(int i=0; i<2; ++i ) { 00371 draw_cube(2*x+a2fPosYPosZOffset[i][0],2*y+a2fPosYPosZOffset[i][1],2*z+a2fPosYPosZOffset[i][2],cur_level-1); 00372 } 00373 } 00374 } 00375 } 00376 if ( z == (minvals[cur_level]->get_zsize()-1) ) { 00377 if ( e->get_zsize() > 2*z ) { 00378 for(int i=0; i<4; ++i ) { 00379 draw_cube(2*x+a2fPosZOffset[i][0],2*y+a2fPosZOffset[i][1],2*z+a2fPosZOffset[i][2],cur_level-1); 00380 } 00381 } 00382 } 00383 00384 } 00385 }
|
|
Get edge num needs better commenting.
Definition at line 406 of file marchingcubes.cpp. Referenced by marching_cube(). 00406 { 00407 // edge direction is right, down, back (x, y, z) 00408 unsigned int index = 0; 00409 index = (x << 22) | (y << 12) | (z << 2) | edge; 00410 return index; 00411 }
|
|
Get the isosurface as dictionary Traverses the tree and marches the cubes.
Implements EMAN::Isosurface. Definition at line 214 of file marchingcubes.cpp. References calculate_surface(), EMAN::CustomVector< type >::elem(), ff, EMAN::CustomVector< type >::get_data(), nn, pp, and EMAN::Dict::put(). 00215 { 00216 calculate_surface(); 00217 Dict d; 00218 d.put("points", (float*)pp.get_data()); 00219 for (unsigned int i = 0; i < ff.elem(); ++i ) ff[i] /= 3; 00220 d.put("faces", (unsigned int*)ff.get_data()); 00221 d.put("normals", (float*)nn.get_data()); 00222 d.put("size", ff.elem()); 00223 return d; 00224 }
|
|
Find the gradient of the scalar field at a point. This gradient can be used as a very accurate vertx normal for lighting calculations. THIS FUNCTION IS NO LONGER CALLED - d.woolford but is retained because it may be useful, perhaps even for saving time
Definition at line 387 of file marchingcubes.cpp. References EMAN::EMData::get_value_at(), and EMAN::Vector3::normalize(). 00388 { 00389 normal[0] = _emdata->get_value_at(fX-1, fY, fZ) - _emdata->get_value_at(fX+1, fY, fZ); 00390 normal[1] = _emdata->get_value_at(fX, fY-1, fZ) - _emdata->get_value_at(fX, fY+1, fZ); 00391 normal[2] = _emdata->get_value_at(fX, fY, fZ-1) - _emdata->get_value_at(fX, fY, fZ+1); 00392 normal.normalize(); 00393 }
|
|
Find the approximate point of intersection of the surface between two points with the values fValue1 and fValue2.
Definition at line 395 of file marchingcubes.cpp. Referenced by marching_cube(). 00396 { 00397 float fDelta = fValue2 - fValue1; 00398 00399 if(fDelta == 0.0f) 00400 { 00401 return 0.5f; 00402 } 00403 return (fValueDesired - fValue1)/fDelta; 00404 }
|
|
Current the current sampling rate Finest sampling is -1.
Implements EMAN::Isosurface. Definition at line 224 of file marchingcubes.h. 00224 { return drawing_level; }
|
|
Get the range of feasible sampling rates.
Implements EMAN::Isosurface. Definition at line 228 of file marchingcubes.h. 00228 { return minvals.size()-1; }
|
|
Get the current isosurface value being used.
Implements EMAN::Isosurface. Definition at line 209 of file marchingcubes.h. 00209 { return _surf_value; }
|
|
Function for managing cases where a triangles can potentially be rendered Called by draw_cube. Generates vertices, normals, and keeps track of common points
Definition at line 413 of file marchingcubes.cpp. References a2fEdgeDirection, a2fVertexOffset, a2iEdgeConnection, a2iTriangleConnectionTable, aiCubeEdgeFlags, edgeLookUp, EMAN::CustomVector< type >::elem(), ff, get_edge_num(), get_offset(), EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), minvals, nn, point_map, pp, EMAN::CustomVector< type >::push_back(), and EMAN::CustomVector< type >::push_back_3(). Referenced by draw_cube(). 00414 { 00415 extern int aiCubeEdgeFlags[256]; 00416 extern int a2iTriangleConnectionTable[256][16]; 00417 00418 int iCorner, iVertex, iVertexTest, iEdge, iTriangle, iFlagIndex, iEdgeFlags; 00419 float fOffset; 00420 Vector3 sColor; 00421 float afCubeValue[8]; 00422 float asEdgeVertex[12][3]; 00423 int pointIndex[12]; 00424 00425 int fxScale = 1, fyScale = 1, fzScale = 1; 00426 if ( cur_level != -1 ) 00427 { 00428 fxScale = _emdata->get_xsize()/minvals[cur_level]->get_xsize(); 00429 fyScale = _emdata->get_ysize()/minvals[cur_level]->get_ysize(); 00430 fzScale = _emdata->get_zsize()/minvals[cur_level]->get_zsize(); 00431 for(iVertex = 0; iVertex < 8; iVertex++) 00432 { 00433 afCubeValue[iVertex] = _emdata->get_value_at( fxScale*(fX + a2fVertexOffset[iVertex][0]), 00434 fyScale*(fY + a2fVertexOffset[iVertex][1]), fzScale*(fZ + a2fVertexOffset[iVertex][2])); 00435 } 00436 } 00437 else 00438 { 00439 //Make a local copy of the values at the cube's corners 00440 for(iVertex = 0; iVertex < 8; iVertex++) 00441 { 00442 afCubeValue[iVertex] = _emdata->get_value_at( fX + a2fVertexOffset[iVertex][0], 00443 fY + a2fVertexOffset[iVertex][1], fZ + a2fVertexOffset[iVertex][2]); 00444 } 00445 } 00446 00447 //Find which vertices are inside of the surface and which are outside 00448 iFlagIndex = 0; 00449 for(iVertexTest = 0; iVertexTest < 8; iVertexTest++) 00450 { 00451 if (_surf_value >= 0 ){ 00452 if(afCubeValue[iVertexTest] <= _surf_value) 00453 iFlagIndex |= 1<<iVertexTest; 00454 } 00455 else { 00456 if(afCubeValue[iVertexTest] >= _surf_value) 00457 iFlagIndex |= 1<<iVertexTest; 00458 } 00459 } 00460 00461 //Find which edges are intersected by the surface 00462 iEdgeFlags = aiCubeEdgeFlags[iFlagIndex]; 00463 00464 //If the cube is entirely inside or outside of the surface, then there will be no intersections 00465 if(iEdgeFlags == 0) return; 00466 00467 //Find the point of intersection of the surface with each edge 00468 //Then find the normal to the surface at those points 00469 for(iEdge = 0; iEdge < 12; iEdge++) 00470 { 00471 //if there is an intersection on this edge 00472 if(iEdgeFlags & (1<<iEdge)) 00473 { 00474 fOffset = get_offset(afCubeValue[ a2iEdgeConnection[iEdge][0] ], 00475 afCubeValue[ a2iEdgeConnection[iEdge][1] ], _surf_value); 00476 00477 if ( cur_level == -1 ){ 00478 asEdgeVertex[iEdge][0] = fX + (a2fVertexOffset[ a2iEdgeConnection[iEdge][0] ][0] + fOffset * a2fEdgeDirection[iEdge][0]) + 0.5f; 00479 asEdgeVertex[iEdge][1] = fY + (a2fVertexOffset[ a2iEdgeConnection[iEdge][0] ][1] + fOffset * a2fEdgeDirection[iEdge][1]) + 0.5f; 00480 asEdgeVertex[iEdge][2] = fZ + (a2fVertexOffset[ a2iEdgeConnection[iEdge][0] ][2] + fOffset * a2fEdgeDirection[iEdge][2]) + 0.5f; 00481 } else { 00482 asEdgeVertex[iEdge][0] = fxScale*(fX + (a2fVertexOffset[ a2iEdgeConnection[iEdge][0] ][0] + fOffset * a2fEdgeDirection[iEdge][0])) + 0.5f; 00483 asEdgeVertex[iEdge][1] = fyScale*(fY + (a2fVertexOffset[ a2iEdgeConnection[iEdge][0] ][1] + fOffset * a2fEdgeDirection[iEdge][1])) + 0.5f; 00484 asEdgeVertex[iEdge][2] = fzScale*(fZ + (a2fVertexOffset[ a2iEdgeConnection[iEdge][0] ][2] + fOffset * a2fEdgeDirection[iEdge][2])) + 0.5f; 00485 } 00486 00487 pointIndex[iEdge] = get_edge_num(fX+edgeLookUp[iEdge][0], fY+edgeLookUp[iEdge][1], fZ+edgeLookUp[iEdge][2], edgeLookUp[iEdge][3]); 00488 } 00489 } 00490 00491 //Draw the triangles that were found. There can be up to five per cube 00492 for(iTriangle = 0; iTriangle < 5; iTriangle++) 00493 { 00494 if(a2iTriangleConnectionTable[iFlagIndex][3*iTriangle] < 0) 00495 break; 00496 00497 float pts[3][3]; 00498 for(iCorner = 0; iCorner < 3; iCorner++) 00499 { 00500 iVertex = a2iTriangleConnectionTable[iFlagIndex][3*iTriangle+iCorner]; 00501 memcpy(&pts[iCorner][0], &asEdgeVertex[iVertex][0], 3*sizeof(float)); 00502 } 00503 00504 00505 00506 float v1[3] = {pts[1][0]-pts[0][0],pts[1][1]-pts[0][1],pts[1][2]-pts[0][2]}; 00507 float v2[3] = {pts[2][0]-pts[1][0],pts[2][1]-pts[1][1],pts[2][2]-pts[1][2]}; 00508 00509 float n[3] = { v1[1]*v2[2] - v1[2]*v2[1], v1[2]*v2[0] - v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0] }; 00510 00511 for(iCorner = 0; iCorner < 3; iCorner++) 00512 { 00513 // Without vertex normalization 00514 // iVertex = a2iTriangleConnectionTable[iFlagIndex][3*iTriangle+iCorner]; 00515 // int ss = pp.elem(); 00516 // pp.push_back_3(&pts[iCorner][0]); 00517 // nn.push_back_3(&n[0]); 00518 // ff.push_back(ss); 00519 00520 // With vertex normalization 00521 iVertex = a2iTriangleConnectionTable[iFlagIndex][3*iTriangle+iCorner]; 00522 map<int,int>::iterator it = point_map.find(pointIndex[iVertex]); 00523 if ( it == point_map.end() ){ 00524 int ss = pp.elem(); 00525 pp.push_back_3(&pts[iCorner][0]); 00526 nn.push_back_3(&n[0]); 00527 ff.push_back(ss); 00528 point_map[pointIndex[iVertex]] = ss; 00529 } else { 00530 int idx = it->second; 00531 ff.push_back(idx); 00532 nn[idx] += n[0]; 00533 nn[idx+1] += n[1]; 00534 nn[idx+2] += n[2]; 00535 } 00536 } 00537 } 00538 }
|
|
Sets Voxel data for Isosurface implementation Calls calculate_min_max_vals which generates the tree of data.
Reimplemented from EMAN::Isosurface. Definition at line 257 of file marchingcubes.cpp. References calculate_min_max_vals(), data, EMAN::EMData::get_zsize(), and ImageDimensionException. Referenced by MarchingCubes(). 00258 { 00259 if ( data->get_zsize() == 1 ) throw ImageDimensionException("The z dimension of the image must be greater than 1"); 00260 _emdata = data; 00261 calculate_min_max_vals(); 00262 }
|
|
Set sampling rates A smaller value means a finer sampling. The finest sampling level is -1 Sampling values increment in steps of 1, and a single increment is interpreted as one step up or down the tree stored in minvals and maxvals
Implements EMAN::Isosurface. Definition at line 219 of file marchingcubes.h. 00219 { drawing_level = rate; }
|
|
Set Isosurface value.
Implements EMAN::Isosurface. Definition at line 264 of file marchingcubes.cpp. 00264 { 00265 00266 if(_surf_value == value) return; 00267 00268 _surf_value = value; 00269 00270 }
|
|
Definition at line 226 of file marchingcubes.cpp. References EMAN::CustomVector< type >::elem(), EMAN::CustomVector< type >::get_data(), nn, EMAN::Vec3< Type >::normalize(), pp, t, and EMAN::Vec3f. 00227 { 00228 float* f = pp.get_data(); 00229 float* n = nn.get_data(); 00230 for (unsigned int i = 0; i < pp.elem(); i += 3 ) { 00231 if (f[i+2] == 0.5) continue; 00232 Vec3f z(0,0,1.0); 00233 Vec3f axis(-n[i+1],n[i],0); 00234 axis.normalize(); 00235 00236 Dict d; 00237 d["type"] = "spin"; 00238 d["Omega"] = 90.f; 00239 d["n1"] = axis[0]; 00240 d["n2"] = axis[1]; 00241 d["n3"] = 0; 00242 Transform t(d); 00243 Vec3f delta = t*z; 00244 00245 f[i] += delta[0]*.25f; 00246 f[i+1] += delta[1]*.25f; 00247 f[i+2] = 0.5; 00248 } 00249 00250 for (unsigned int i = 0; i < nn.elem(); i += 3 ) { 00251 n[i] = 0; 00252 n[i+1] = 0; 00253 n[i+2] = 1; 00254 } 00255 }
|
|
Definition at line 181 of file marchingcubes.h. |
|
Definition at line 239 of file marchingcubes.h. |
|
The "sampling rate".
Definition at line 258 of file marchingcubes.h. Referenced by calculate_min_max_vals(), and draw_cube(). |
|
Definition at line 316 of file marchingcubes.h. Referenced by calculate_surface(), get_isosurface(), and marching_cube(). |
|
Vectors for storing the search trees.
Definition at line 255 of file marchingcubes.h. Referenced by calculate_min_max_vals(), calculate_surface(), clear_min_max_vals(), and draw_cube(). |
|
Vectors for storing the search trees.
Definition at line 255 of file marchingcubes.h. Referenced by calculate_min_max_vals(), calculate_surface(), clear_min_max_vals(), draw_cube(), and marching_cube(). |
|
Definition at line 315 of file marchingcubes.h. Referenced by calculate_surface(), get_isosurface(), marching_cube(), and surface_face_z(). |
|
Definition at line 238 of file marchingcubes.h. Referenced by calculate_surface(), and marching_cube(). |
|
.Custom vectors for storing points, normals and faces
Definition at line 314 of file marchingcubes.h. Referenced by calculate_surface(), get_isosurface(), marching_cube(), and surface_face_z(). |