int main(int argc,char* argv[]){ RayScene scene; int cplx=DEFAULT_COMPLEXITY; int width=DEFAULT_RESOLUTION; int height=DEFAULT_RESOLUTION; cmdLineString In; cmdLineInt Width,Height,Complexity; char* paramNames[]= {"in", "width", "height", "cplx"}; cmdLineReadable* params[]= {&In, &Width, &Height, &Complexity}; cmdLineParse(argc-1,&argv[1],paramNames,4,params); if(!In.set){ ShowUsage(argv[0]); return EXIT_FAILURE; } if(Complexity.set){cplx=Complexity.value;} if(Width.set){width=Width.value;} if(Height.set){height=Height.value;} scene.read(In.value); RayWindow::RayView(&scene,width,height,cplx); return EXIT_SUCCESS; }
int main(int argc,char* argv[]){ // Read the parameters in from the command line cmdLineString In; char* paramNames[]={"in"}; cmdLineReadable* params[]={&In}; cmdLineParse(argc-1,&argv[1],paramNames,sizeof(paramNames)/sizeof(char*),params); if(!In.set){ fprintf(stderr,"You must specify an input file\n"); return EXIT_FAILURE; } int res; float l2; CircularArray<> cIn,cOut; Complex<>* coeffs; // Read in the array cIn.read(In.value); res=cIn.resolution(); // Allocate space for the Fourier coefficients coeffs=new Complex<>[res]; // Run the forward and inverse Fourier transforms cOut.resize(res); ForwardFFT(cIn,coeffs); InverseFFT(coeffs,cOut); // Correct for the scaling term for(int i=0;i<res;i++){cOut(i)/=res;} // Test that the Fourier coefficients satisfy the conjugacy relations (difference should be zero) l2=0; for(int i=0;i<res;i++){l2+=(coeffs[i]-coeffs[(res-i)%res].conjugate()).squareNorm();} printf("Conjugate Test: %f\n",l2); // Compare the input and output (the difference should be zero) printf("Forward-Inverse Test: %f\n",CircularArray<>::SquareDifference(cIn,cOut)); // Now compare the values of the Fourier coefficients (difference should be zero) FourierKey1D<> key; FourierTransform<> xForm; xForm.ForwardFourier(cIn,key); l2=0; float n=float(1.0/(2.0*PI))*key.resolution(); // for(int i=0;i<32;i++){ // for(int i=0;i<key.size();i++){ // printf("%d kr: %-15f ki: %-15f cr: %-15f ci: %-15f diff: %f\n", i, key(i).r*n, key(i).i*n, coeffs[i].r, coeffs[i].i, key(i)*n - coeffs[i]); // } for(int i=0;i<key.size();i++){l2+=(key(i)*n-coeffs[i]).squareNorm();} printf("Coefficient test: %f\n",l2); return EXIT_SUCCESS; }
int main( int argc , char* argv[] ) { bool resample = true; #if 0 unsigned int control_word_x87 , control_word_sse2; __control87_2( _DN_FLUSH , _MCW_DN , &control_word_x87 , &control_word_sse2 ); #endif cmdLineParse( argc-1 , &argv[1] , sizeof(params) / sizeof(cmdLineReadable*) , params , 0 ); char valueString[1024]; for( int i=0 ; i<sizeof(params) / sizeof(cmdLineReadable*) ; i++ ) if( params[i]->set ) { params[i]->writeValue( valueString ); printf( "\t--%s %s\n" , params[i]->name , valueString ); } if( !In.set || !Out.set ) { ShowUsage(argv[0]); return EXIT_FAILURE; } char tmpDir[1024]; if( TempDir.set) sprintf( tmpDir , "TMP=%s" , TempDir.value ); else sprintf( tmpDir , "TMP=" ); _putenv( tmpDir ); int w , h; GetReadSize< float >( In.value , w , h ); int height = 1; while( 2*height<w || height<h ) height <<= 1; if( 2*height==w && height==h ) resample = false; if( resample ) printf( "%d x %d -> %d x %d\n" , w , h , 2*height , height ); IWeight.value = -IWeight.value; IWeight.value *= height / 2; IWeight.value *= (height*2) / 2; IWeight.value /= 4. * M_PI; double t = Time( ); if( HighPrecision.set ) if( HDRLabels.set ) Execute< double , double , __int16 >( height , resample ); else Execute< double , double , unsigned char >( height , resample ); else if( HDRLabels.set ) Execute< float , half , __int16 >( height , resample ); else Execute< float , half , unsigned char >( height , resample ); size_t current,peak; WorkingSetInfo( current , peak ); printf( "Running Time: %f\n" , Time()-t ); printf( "Peak working set: %d MB\n" , peak>>20 ); return EXIT_SUCCESS; }
int main( int argc , char* argv[] ) { cmdLineParse( argc-1 , argv+1 , params ); if( !Resolution.set && !In.set ){ ShowUsage( argv[0] ) ; return EXIT_FAILURE; } FILE* fp = fopen( In.value , "rb" ); if( !fp ) { fprintf( stderr , "[ERROR] Failed to open file for reading: %s\n" , In.value ); return EXIT_FAILURE; } char *filename = Out.set ? Out.value : NULL; return IsoSurfaceExtractionFile( fp, SmoothIterations.value, Float.set, Dimensions.values, Resolution.values, IsoValue.value, Out.set, filename, Polygons.set, FullCaseTable.set, QuadraticFit.set, FlipOrientation.set, NonManifold.set ); return EXIT_SUCCESS; }
int main( int argc , char* argv[] ) { double t = Time(); cmdLineParse( argc-1 , &argv[1] , sizeof(params)/sizeof(cmdLineReadable*) , params , 1 ); if( Density.set ) Execute< 2 , PlyValueVertex< Real > , true >( argc , argv ); else Execute< 2 , PlyVertex< Real > , false >( argc , argv ); #ifdef _WIN32 if( Performance.set ) { HANDLE cur_thread=GetCurrentThread(); FILETIME tcreat, texit, tkernel, tuser; if( GetThreadTimes( cur_thread , &tcreat , &texit , &tkernel , &tuser ) ) printf( "Time (Wall/User/Kernel): %.2f / %.2f / %.2f\n" , Time()-t , to_seconds( tuser ) , to_seconds( tkernel ) ); else printf( "Time: %.2f\n" , Time()-t ); HANDLE h = GetCurrentProcess(); PROCESS_MEMORY_COUNTERS pmc; if( GetProcessMemoryInfo( h , &pmc , sizeof(pmc) ) ) printf( "Peak Memory (MB): %d\n" , pmc.PeakWorkingSetSize>>20 ); }
void PoissonReconstruction::PoissonRecon(int argc , char* argv[], const MagicDGP::Point3DSet* pPC, std::vector< PlyValueVertex< float > >& vertices, std::vector< std::vector< int > >& polygons) { cmdLineString In( "in" ) , Out( "out" ) , VoxelGrid( "voxel" ) , XForm( "xForm" ); cmdLineReadable Performance( "performance" ) , ShowResidual( "showResidual" ) , NoComments( "noComments" ) , PolygonMesh( "polygonMesh" ) , Confidence( "confidence" ) , NonManifold( "nonManifold" ) , ASCII( "ascii" ) , Density( "density" ) , Verbose( "verbose" ); cmdLineInt Depth( "depth" , 8 ) , SolverDivide( "solverDivide" , 8 ) , IsoDivide( "isoDivide" , 8 ) , KernelDepth( "kernelDepth" ) , AdaptiveExponent( "adaptiveExp" , 1 ) , MinIters( "minIters" , 24 ) , FixedIters( "iters" , -1 ) , VoxelDepth( "voxelDepth" , -1 ) , MinDepth( "minDepth" , 5 ) , MaxSolveDepth( "maxSolveDepth" ) , BoundaryType( "boundary" , 1 ) , Threads( "threads" , omp_get_num_procs() ); cmdLineFloat SamplesPerNode( "samplesPerNode" , 1.f ) , Scale( "scale" , 1.1f ) , SolverAccuracy( "accuracy" , float(1e-3) ) , PointWeight( "pointWeight" , 4.f ); cmdLineReadable* params[] = { &In , &Depth , &Out , &XForm , &SolverDivide , &IsoDivide , &Scale , &Verbose , &SolverAccuracy , &NoComments , &KernelDepth , &SamplesPerNode , &Confidence , &NonManifold , &PolygonMesh , &ASCII , &ShowResidual , &MinIters , &FixedIters , &VoxelDepth , &PointWeight , &VoxelGrid , &Threads , &MinDepth , &MaxSolveDepth , &AdaptiveExponent , &BoundaryType , &Density }; cmdLineParse( argc , argv , sizeof(params)/sizeof(cmdLineReadable*) , params , 1 ); /*if( Density.set ) return Execute< 2 , PlyValueVertex< Real > , true >(argc , argv, pPC); else return Execute< 2 , PlyVertex< Real > , false >(argc , argv, pPC);*/ //Execute int i; int paramNum = sizeof(params)/sizeof(cmdLineReadable*); int commentNum=0; char **comments; comments = new char*[paramNum + 7]; for( i=0 ; i<paramNum+7 ; i++ ) comments[i] = new char[1024]; //if( Verbose.set ) echoStdout=1; XForm4x4< Real > xForm , iXForm; if( XForm.set ) { FILE* fp = fopen( XForm.value , "r" ); if( !fp ) { fprintf( stderr , "[WARNING] Could not read x-form from: %s\n" , XForm.value ); xForm = XForm4x4< Real >::Identity(); } else { for( int i=0 ; i<4 ; i++ ) for( int j=0 ; j<4 ; j++ ) fscanf( fp , " %f " , &xForm( i , j ) ); fclose( fp ); } } else xForm = XForm4x4< Real >::Identity(); iXForm = xForm.inverse(); //DumpOutput2( comments[commentNum++] , "Running Screened Poisson Reconstruction (Version 5.0)\n" , Degree ); //char str[1024]; //for( int i=0 ; i<paramNum ; i++ ) // if( params[i]->set ) // { // params[i]->writeValue( str ); // if( strlen( str ) ) DumpOutput2( comments[commentNum++] , "\t--%s %s\n" , params[i]->name , str ); // else DumpOutput2( comments[commentNum++] , "\t--%s\n" , params[i]->name ); // } double t; double tt=Time(); Real isoValue = 0; //Octree< Degree , OutputDensity > tree; Octree< 2 , true > tree; tree.threads = Threads.value; //if( !In.set ) //{ // ShowUsage(argv[0]); // return 0; //} if( !MaxSolveDepth.set ) MaxSolveDepth.value = Depth.value; if( SolverDivide.value<MinDepth.value ) { fprintf( stderr , "[WARNING] %s must be at least as large as %s: %d>=%d\n" , SolverDivide.name , MinDepth.name , SolverDivide.value , MinDepth.value ); SolverDivide.value = MinDepth.value; } if( IsoDivide.value<MinDepth.value ) { fprintf( stderr , "[WARNING] %s must be at least as large as %s: %d>=%d\n" , IsoDivide.name , MinDepth.name , IsoDivide.value , IsoDivide.value ); IsoDivide.value = MinDepth.value; } OctNode< TreeNodeData< true > , Real >::SetAllocator( MEMORY_ALLOCATOR_BLOCK_SIZE ); t=Time(); int kernelDepth = KernelDepth.set ? KernelDepth.value : Depth.value-2; tree.setBSplineData( Depth.value , BoundaryType.value ); //if( kernelDepth>Depth.value ) //{ // fprintf( stderr,"[ERROR] %s can't be greater than %s: %d <= %d\n" , KernelDepth.name , Depth.name , KernelDepth.value , Depth.value ); // return EXIT_FAILURE; //} // int pointNumber = pPC->GetPointNumber(); std::vector<float> posList(pointNumber * 3); std::vector<float> norList(pointNumber * 3); for (int pIndex = 0; pIndex < pointNumber; pIndex++) { posList.at(3 * pIndex + 0) = pPC->GetPoint(pIndex)->GetPosition()[0]; posList.at(3 * pIndex + 1) = pPC->GetPoint(pIndex)->GetPosition()[1]; posList.at(3 * pIndex + 2) = pPC->GetPoint(pIndex)->GetPosition()[2]; norList.at(3 * pIndex + 0) = pPC->GetPoint(pIndex)->GetNormal()[0]; norList.at(3 * pIndex + 1) = pPC->GetPoint(pIndex)->GetNormal()[1]; norList.at(3 * pIndex + 2) = pPC->GetPoint(pIndex)->GetNormal()[2]; } // double maxMemoryUsage; t=Time() , tree.maxMemoryUsage=0; //int pointCount = tree.setTree( In.value , Depth.value , MinDepth.value , kernelDepth , Real(SamplesPerNode.value) , Scale.value , Confidence.set , PointWeight.value , AdaptiveExponent.value , xForm ); int pointCount = tree.setTree( posList, norList, Depth.value , MinDepth.value , kernelDepth , Real(SamplesPerNode.value) , Scale.value , Confidence.set , PointWeight.value , AdaptiveExponent.value , xForm ); tree.ClipTree(); tree.finalize( IsoDivide.value ); /*DumpOutput2( comments[commentNum++] , "# Tree set in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); DumpOutput( "Input Points: %d\n" , pointCount ); DumpOutput( "Leaves/Nodes: %d/%d\n" , tree.tree.leaves() , tree.tree.nodes() ); DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage() )/(1<<20) );*/ maxMemoryUsage = tree.maxMemoryUsage; t=Time() , tree.maxMemoryUsage=0; tree.SetLaplacianConstraints(); /*DumpOutput2( comments[commentNum++] , "# Constraints set in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage())/(1<<20) );*/ maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage ); t=Time() , tree.maxMemoryUsage=0; tree.LaplacianMatrixIteration( SolverDivide.value, ShowResidual.set , MinIters.value , SolverAccuracy.value , MaxSolveDepth.value , FixedIters.value ); /*DumpOutput2( comments[commentNum++] , "# Linear system solved in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage() )/(1<<20) );*/ maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage ); CoredFileMeshData< PlyValueVertex< Real > > mesh; if( Verbose.set ) tree.maxMemoryUsage=0; t=Time(); isoValue = tree.GetIsoValue(); //DumpOutput( "Got average in: %f\n" , Time()-t ); //DumpOutput( "Iso-Value: %e\n" , isoValue ); if( VoxelGrid.set ) { double t = Time(); FILE* fp = fopen( VoxelGrid.value , "wb" ); if( !fp ) fprintf( stderr , "Failed to open voxel file for writing: %s\n" , VoxelGrid.value ); else { int res; Pointer( Real ) values = tree.GetSolutionGrid( res , isoValue , VoxelDepth.value ); fwrite( &res , sizeof(int) , 1 , fp ); if( sizeof(Real)==sizeof(float) ) fwrite( values , sizeof(float) , res*res*res , fp ); else { float *fValues = new float[res*res*res]; for( int i=0 ; i<res*res*res ; i++ ) fValues[i] = float( values[i] ); fwrite( fValues , sizeof(float) , res*res*res , fp ); delete[] fValues; } fclose( fp ); DeletePointer( values ); } //DumpOutput( "Got voxel grid in: %f\n" , Time()-t ); } if( Out.set ) { t = Time() , tree.maxMemoryUsage = 0; tree.GetMCIsoTriangles( isoValue , IsoDivide.value , &mesh , 0 , 1 , !NonManifold.set , PolygonMesh.set ); //if( PolygonMesh.set ) DumpOutput2( comments[commentNum++] , "# Got polygons in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); //else DumpOutput2( comments[commentNum++] , "# Got triangles in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage ); //DumpOutput2( comments[commentNum++],"# Total Solve: %9.1f (s), %9.1f (MB)\n" , Time()-tt , maxMemoryUsage ); //if( NoComments.set ) //{ // if( ASCII.set ) PlyWritePolygons( Out.value , &mesh , PLY_ASCII , NULL , 0 , iXForm ); // else PlyWritePolygons( Out.value , &mesh , PLY_BINARY_NATIVE , NULL , 0 , iXForm ); //} //else //{ // if( ASCII.set ) PlyWritePolygons( Out.value , &mesh , PLY_ASCII , comments , commentNum , iXForm ); // else PlyWritePolygons( Out.value , &mesh , PLY_BINARY_NATIVE , comments , commentNum , iXForm ); //} vertices.clear(); polygons.clear(); int incorePointNum = int( mesh.inCorePoints.size() ); int outofcorePointNum = mesh.outOfCorePointCount(); DebugLog << "incorePointNum: " << incorePointNum << std::endl; DebugLog << "outofcorePointNum: " << outofcorePointNum << std::endl; mesh.resetIterator(); for(int pIndex = 0 ; pIndex < incorePointNum ; pIndex++ ) { PlyValueVertex< Real > vertex = iXForm * mesh.inCorePoints[pIndex]; vertices.push_back(vertex); //ply_put_element(ply, (void *) &vertex); } for(int pIndex = 0; pIndex < outofcorePointNum; pIndex++ ) { PlyValueVertex< Real > vertex; mesh.nextOutOfCorePoint( vertex ); vertex = iXForm * ( vertex ); vertices.push_back(vertex); //ply_put_element(ply, (void *) &vertex); } int polyNum = mesh.polygonCount(); DebugLog << "polyNum: " << polyNum << std::endl; for (int pIndex = 0; pIndex < polyNum; pIndex++) { std::vector< CoredVertexIndex > coreIndex; mesh.nextPolygon(coreIndex); std::vector< int > pureIndex; for (int ii = 0; ii < coreIndex.size(); ii++) { if (coreIndex.at(ii).inCore) { pureIndex.push_back(coreIndex.at(ii).idx); } else { pureIndex.push_back(coreIndex.at(ii).idx + incorePointNum); } } if (coreIndex.size() != 3) { DebugLog << "Error: coreIndex.size: " << coreIndex.size() << std::endl; } polygons.push_back(pureIndex); } //just for test /*DebugLog << "Export inter object" << std::endl; std::ofstream fout("pc_inter.obj"); for (int pIndex = 0; pIndex < vertices.size(); pIndex++) { PlyValueVertex< float > vert = vertices.at(pIndex); fout << "v " << vert.point[0] << " " << vert.point[1] << " " << vert.point[2] << std::endl; } for (int pIndex = 0; pIndex < polygons.size(); pIndex++) { fout << "f " << polygons.at(pIndex).at(0) + 1 << " " << polygons.at(pIndex).at(1) + 1 << " " << polygons.at(pIndex).at(2) + 1 << std::endl; } fout.close();*/ } }
MagicDGP::LightMesh3D* PoissonReconstruction::SurfaceTrimmer(int argc , char* argv[], std::vector< PlyValueVertex< float > >& vertices, std::vector< std::vector< int > >& polygons) { cmdLineString In( "in" ) , Out( "out" ); cmdLineInt Smooth( "smooth" , 5 ); cmdLineFloat Trim( "trim" ) , IslandAreaRatio( "aRatio" , 0.001f ); cmdLineFloatArray< 2 > ColorRange( "color" ); cmdLineReadable PolygonMesh( "polygonMesh" ); cmdLineReadable* params[] = { &In , &Out , &Trim , &PolygonMesh , &ColorRange , &Smooth , &IslandAreaRatio }; int paramNum = sizeof(params)/sizeof(cmdLineReadable*); cmdLineParse( argc , argv, paramNum , params , 0 ); float min , max; //std::vector< PlyValueVertex< float > > vertices; //std::vector< std::vector< int > > polygons; //int ft , commentNum = paramNum+2; //char** comments; //bool readFlags[ PlyValueVertex< float >::Components ]; //PlyReadPolygons( In.value , vertices , polygons , PlyValueVertex< float >::Properties , PlyValueVertex< float >::Components , ft , &comments , &commentNum , readFlags ); //if( !readFlags[3] ){ fprintf( stderr , "[ERROR] vertices do not have value flag\n" ) ; return EXIT_FAILURE; } for( int i=0 ; i<Smooth.value ; i++ ) SmoothValues( vertices , polygons ); min = max = vertices[0].value; for( size_t i=0 ; i<vertices.size() ; i++ ) min = std::min< float >( min , vertices[i].value ) , max = std::max< float >( max , vertices[i].value ); printf( "Value Range: [%f,%f]\n" , min , max ); if( Trim.set ) { hash_map< long long , int > vertexTable; std::vector< std::vector< int > > ltPolygons , gtPolygons; std::vector< bool > ltFlags , gtFlags; /*for( int i=0 ; i<paramNum+2 ; i++ ) comments[i+commentNum]=new char[1024]; sprintf( comments[commentNum++] , "Running Surface Trimmer (V5)" ); if( In.set ) sprintf(comments[commentNum++],"\t--%s %s" , In.name , In.value ); if( Out.set ) sprintf(comments[commentNum++],"\t--%s %s" , Out.name , Out.value ); if( Trim.set ) sprintf(comments[commentNum++],"\t--%s %f" , Trim.name , Trim.value ); if( Smooth.set ) sprintf(comments[commentNum++],"\t--%s %d" , Smooth.name , Smooth.value ); if( IslandAreaRatio.set ) sprintf(comments[commentNum++],"\t--%s %f" , IslandAreaRatio.name , IslandAreaRatio.value ); if( PolygonMesh.set ) sprintf(comments[commentNum++],"\t--%s" , PolygonMesh.name );*/ double t=Time(); for( size_t i=0 ; i<polygons.size() ; i++ ) SplitPolygon( polygons[i] , vertices , <Polygons , >Polygons , <Flags , >Flags , vertexTable , Trim.value ); if( IslandAreaRatio.value>0 ) { std::vector< std::vector< int > > _ltPolygons , _gtPolygons; std::vector< std::vector< int > > ltComponents , gtComponents; SetConnectedComponents( ltPolygons , ltComponents ); SetConnectedComponents( gtPolygons , gtComponents ); std::vector< double > ltAreas( ltComponents.size() , 0. ) , gtAreas( gtComponents.size() , 0. ); std::vector< bool > ltComponentFlags( ltComponents.size() , false ) , gtComponentFlags( gtComponents.size() , false ); double area = 0.; for( size_t i=0 ; i<ltComponents.size() ; i++ ) { for( size_t j=0 ; j<ltComponents[i].size() ; j++ ) { ltAreas[i] += PolygonArea( vertices , ltPolygons[ ltComponents[i][j] ] ); ltComponentFlags[i] = ( ltComponentFlags[i] || ltFlags[ ltComponents[i][j] ] ); } area += ltAreas[i]; } for( size_t i=0 ; i<gtComponents.size() ; i++ ) { for( size_t j=0 ; j<gtComponents[i].size() ; j++ ) { gtAreas[i] += PolygonArea( vertices , gtPolygons[ gtComponents[i][j] ] ); gtComponentFlags[i] = ( gtComponentFlags[i] || gtFlags[ gtComponents[i][j] ] ); } area += gtAreas[i]; } for( size_t i=0 ; i<ltComponents.size() ; i++ ) { if( ltAreas[i]<area*IslandAreaRatio.value && ltComponentFlags[i] ) for( size_t j=0 ; j<ltComponents[i].size() ; j++ ) _gtPolygons.push_back( ltPolygons[ ltComponents[i][j] ] ); else for( size_t j=0 ; j<ltComponents[i].size() ; j++ ) _ltPolygons.push_back( ltPolygons[ ltComponents[i][j] ] ); } for( size_t i=0 ; i<gtComponents.size() ; i++ ) { if( gtAreas[i]<area*IslandAreaRatio.value && gtComponentFlags[i] ) for( size_t j=0 ; j<gtComponents[i].size() ; j++ ) _ltPolygons.push_back( gtPolygons[ gtComponents[i][j] ] ); else for( size_t j=0 ; j<gtComponents[i].size() ; j++ ) _gtPolygons.push_back( gtPolygons[ gtComponents[i][j] ] ); } ltPolygons = _ltPolygons , gtPolygons = _gtPolygons; } if( !PolygonMesh.set ) { { std::vector< std::vector< int > > polys = ltPolygons; Triangulate( vertices , ltPolygons , polys ) , ltPolygons = polys; } { std::vector< std::vector< int > > polys = gtPolygons; Triangulate( vertices , gtPolygons , polys ) , gtPolygons = polys; } } RemoveHangingVertices( vertices , gtPolygons ); MagicDGP::LightMesh3D* pExportMesh = new MagicDGP::LightMesh3D; for (int pIndex = 0; pIndex < vertices.size(); pIndex++) { PlyValueVertex< float > vert = vertices.at(pIndex); MagicMath::Vector3 vertPos(vert.point[0], vert.point[1], vert.point[2]); pExportMesh->InsertVertex(vertPos); } for (int pIndex = 0; pIndex < gtPolygons.size(); pIndex++) { MagicDGP::FaceIndex faceIdx; for (int k = 0; k < 3; k++) { faceIdx.mIndex[k] = gtPolygons.at(pIndex).at(k); } pExportMesh->InsertFace(faceIdx); } pExportMesh->UpdateNormal(); return pExportMesh; } else { //if( ColorRange.set ) min = ColorRange.values[0] , max = ColorRange.values[1]; //std::vector< PlyColorVertex< float > > outVertices; //ColorVertices( vertices , outVertices , min , max ); ////if( Out.set ) PlyWritePolygons( Out.value , outVertices , polygons , PlyColorVertex< float >::Properties , PlyColorVertex< float >::Components , ft , comments , commentNum ); //if( Out.set ) PlyWritePolygons( Out.value , outVertices , polygons , PlyColorVertex< float >::Properties , PlyColorVertex< float >::Components , 1 , NULL , 0 ); } return NULL; }
int ExecuteMemory( int argc , char* argv[], std::vector< std::vector< float > > & positions, std::vector< std::vector< float > > & normals, std::vector< std::vector< float > > & vertices, std::vector< std::vector< int > > & faces ) { argc = (int)argc; argv = argv; cmdLineParse( argc-1 , &argv[1] , sizeof(params)/sizeof(cmdLineReadable*) , params , 1 ); typedef PlyVertex< Real > Vertex; bool OutputDensity = false; OutputDensity = OutputDensity; int i; int paramNum = sizeof(params)/sizeof(cmdLineReadable*); int commentNum=0; char **comments; comments = new char*[paramNum+7]; for( i=0 ; i<paramNum+7 ; i++ ) comments[i] = new char[1024]; if( Verbose.set ) echoStdout=1; XForm4x4< Real > xForm , iXForm; if( XForm.set ) { FILE* fp = fopen( XForm.value , "r" ); if( !fp ) { fprintf( stderr , "[WARNING] Could not read x-form from: %s\n" , XForm.value ); xForm = XForm4x4< Real >::Identity(); } else { for( int i=0 ; i<4 ; i++ ) for( int j=0 ; j<4 ; j++ ) fscanf( fp , " %f " , &xForm( i , j ) ); fclose( fp ); } } else xForm = XForm4x4< Real >::Identity(); iXForm = xForm.inverse(); DumpOutput2( comments[commentNum++] , "Running Screened Poisson Reconstruction (Version 5.5)\n" , Degree ); char str[1024]; for( int i=0 ; i<paramNum ; i++ ) if( params[i]->set ) { params[i]->writeValue( str ); if( strlen( str ) ) DumpOutput2( comments[commentNum++] , "\t--%s %s\n" , params[i]->name , str ); else DumpOutput2( comments[commentNum++] , "\t--%s\n" , params[i]->name ); } double t; double tt=Time(); Real isoValue = 0; Octree< Degree , false > tree; tree.threads = Threads.value; //if( !In.set ) //{ // ShowUsage(argv[0]); // return 0; //} if( !MaxSolveDepth.set ) MaxSolveDepth.value = Depth.value; if( SolverDivide.value<MinDepth.value ) { fprintf( stderr , "[WARNING] %s must be at least as large as %s: %d>=%d\n" , SolverDivide.name , MinDepth.name , SolverDivide.value , MinDepth.value ); SolverDivide.value = MinDepth.value; } if( IsoDivide.value<MinDepth.value ) { fprintf( stderr , "[WARNING] %s must be at least as large as %s: %d>=%d\n" , IsoDivide.name , MinDepth.name , IsoDivide.value , IsoDivide.value ); IsoDivide.value = MinDepth.value; } OctNode< TreeNodeData< false > , Real >::SetAllocator( MEMORY_ALLOCATOR_BLOCK_SIZE ); t=Time(); int kernelDepth = KernelDepth.set ? KernelDepth.value : Depth.value-2; tree.setBSplineData( Depth.value , BoundaryType.value ); if( kernelDepth>Depth.value ) { fprintf( stderr,"[ERROR] %s can't be greater than %s: %d <= %d\n" , KernelDepth.name , Depth.name , KernelDepth.value , Depth.value ); return EXIT_FAILURE; } double maxMemoryUsage; t=Time() , tree.maxMemoryUsage=0; //int pointCount = tree.setTree( In.value , Depth.value , MinDepth.value , kernelDepth , Real(SamplesPerNode.value) , Scale.value , Confidence.set , PointWeight.value , AdaptiveExponent.value , xForm ); // Load data MemoryPointStream< Real >* ps = new MemoryPointStream< Real >( &positions, &normals ); int pointCount = tree.setTreeMemory( ps , Depth.value , MinDepth.value , kernelDepth , Real(SamplesPerNode.value) , Scale.value , Confidence.set , PointWeight.value , AdaptiveExponent.value , xForm ); tree.ClipTree(); tree.finalize( IsoDivide.value ); DumpOutput2( comments[commentNum++] , "# Tree set in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); DumpOutput( "Input Points: %d\n" , pointCount ); DumpOutput( "Leaves/Nodes: %d/%d\n" , tree.tree.leaves() , tree.tree.nodes() ); DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage() )/(1<<20) ); maxMemoryUsage = tree.maxMemoryUsage; t=Time() , tree.maxMemoryUsage=0; tree.SetLaplacianConstraints(); DumpOutput2( comments[commentNum++] , "# Constraints set in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage())/(1<<20) ); maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage ); t=Time() , tree.maxMemoryUsage=0; tree.LaplacianMatrixIteration( SolverDivide.value, ShowResidual.set , MinIters.value , SolverAccuracy.value , MaxSolveDepth.value , FixedIters.value ); DumpOutput2( comments[commentNum++] , "# Linear system solved in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage() )/(1<<20) ); maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage ); CoredFileMeshData< Vertex > mesh; if( Verbose.set ) tree.maxMemoryUsage=0; t=Time(); isoValue = tree.GetIsoValue(); DumpOutput( "Got average in: %f\n" , Time()-t ); DumpOutput( "Iso-Value: %e\n" , isoValue ); if( VoxelGrid.set ) { double t = Time(); FILE* fp = fopen( VoxelGrid.value , "wb" ); if( !fp ) fprintf( stderr , "Failed to open voxel file for writing: %s\n" , VoxelGrid.value ); else { int res; Pointer( Real ) values = tree.GetSolutionGrid( res , isoValue , VoxelDepth.value ); fwrite( &res , sizeof(int) , 1 , fp ); if( sizeof(Real)==sizeof(float) ) fwrite( values , sizeof(float) , res*res*res , fp ); else { float *fValues = new float[res*res*res]; for( int i=0 ; i<res*res*res ; i++ ) fValues[i] = float( values[i] ); fwrite( fValues , sizeof(float) , res*res*res , fp ); delete[] fValues; } fclose( fp ); DeletePointer( values ); } DumpOutput( "Got voxel grid in: %f\n" , Time()-t ); } if( Out.set ) { t = Time() , tree.maxMemoryUsage = 0; tree.GetMCIsoTriangles( isoValue , IsoDivide.value , &mesh , 0 , 1 , !NonManifold.set , PolygonMesh.set ); if( PolygonMesh.set ) DumpOutput2( comments[commentNum++] , "# Got polygons in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); else DumpOutput2( comments[commentNum++] , "# Got triangles in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage ); maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage ); DumpOutput2( comments[commentNum++],"# Total Solve: %9.1f (s), %9.1f (MB)\n" , Time()-tt , maxMemoryUsage ); /* if( NoComments.set ) { if( ASCII.set ) PlyWritePolygons( Out.value , &mesh , PLY_ASCII , NULL , 0 , iXForm ); else PlyWritePolygons( Out.value , &mesh , PLY_BINARY_NATIVE , NULL , 0 , iXForm ); } else { if( ASCII.set ) PlyWritePolygons( Out.value , &mesh , PLY_ASCII , comments , commentNum , iXForm ); else PlyWritePolygons( Out.value , &mesh , PLY_BINARY_NATIVE , comments , commentNum , iXForm ); }*/ // Write to memory writeTriMesh(&mesh, vertices, faces); } return 1; }
int Execute(int argc,char* argv[]) { int i; cmdLineString In,Out; cmdLineReadable Binary,Verbose,NoResetSamples,NoClipTree,Confidence,Manifold,PolygonMesh; cmdLineInt Depth(8),SolverDivide(8),IsoDivide(8),Refine(3); cmdLineInt KernelDepth; cmdLineFloat SamplesPerNode(1.0f),Scale(1.1f); char* paramNames[]= { "in","depth","out","refine","noResetSamples","noClipTree", "binary","solverDivide","isoDivide","scale","verbose", "kernelDepth","samplesPerNode","confidence","manifold","polygonMesh" }; cmdLineReadable* params[]= { &In,&Depth,&Out,&Refine,&NoResetSamples,&NoClipTree, &Binary,&SolverDivide,&IsoDivide,&Scale,&Verbose, &KernelDepth,&SamplesPerNode,&Confidence,&Manifold,&PolygonMesh }; int paramNum=sizeof(paramNames)/sizeof(char*); int commentNum=0; char **comments; comments=new char*[paramNum+7]; for(i=0;i<paramNum+7;i++){comments[i]=new char[1024];} const char* Rev = "Rev: V2 "; const char* Date = "Date: 2006-11-09 (Thur, 09 Nov 2006) "; cmdLineParse(argc-1,&argv[1],paramNames,paramNum,params,0); if(Verbose.set){echoStdout=1;} DumpOutput2(comments[commentNum++],"Running Multi-Grid Octree Surface Reconstructor (degree %d). Version 3\n", Degree); if(In.set) {DumpOutput2(comments[commentNum++],"\t--in %s\n",In.value);} if(Out.set) {DumpOutput2(comments[commentNum++],"\t--out %s\n",Out.value);} if(Binary.set) {DumpOutput2(comments[commentNum++],"\t--binary\n");} if(Depth.set) {DumpOutput2(comments[commentNum++],"\t--depth %d\n",Depth.value);} if(SolverDivide.set) {DumpOutput2(comments[commentNum++],"\t--solverDivide %d\n",SolverDivide.value);} if(IsoDivide.set) {DumpOutput2(comments[commentNum++],"\t--isoDivide %d\n",IsoDivide.value);} if(Refine.set) {DumpOutput2(comments[commentNum++],"\t--refine %d\n",Refine.value);} if(Scale.set) {DumpOutput2(comments[commentNum++],"\t--scale %f\n",Scale.value);} if(KernelDepth.set) {DumpOutput2(comments[commentNum++],"\t--kernelDepth %d\n",KernelDepth.value);} if(SamplesPerNode.set) {DumpOutput2(comments[commentNum++],"\t--samplesPerNode %f\n",SamplesPerNode.value);} if(NoResetSamples.set) {DumpOutput2(comments[commentNum++],"\t--noResetSamples\n");} if(NoClipTree.set) {DumpOutput2(comments[commentNum++],"\t--noClipTree\n");} if(Confidence.set) {DumpOutput2(comments[commentNum++],"\t--confidence\n");} if(Manifold.set) {DumpOutput2(comments[commentNum++],"\t--manifold\n");} if(PolygonMesh.set) {DumpOutput2(comments[commentNum++],"\t--polygonMesh\n");} double t; double tt=Time(); Point3D<float> center; Real scale=1.0; Real isoValue=0; ////////////////////////////////// // Fix courtesy of David Gallup // TreeNodeData::UseIndex = 1; // ////////////////////////////////// Octree<Degree> tree; PPolynomial<Degree> ReconstructionFunction=PPolynomial<Degree>::GaussianApproximation(); center.coords[0]=center.coords[1]=center.coords[2]=0; if(!In.set || !Out.set) { ShowUsage(argv[0]); return 0; } TreeOctNode::SetAllocator(MEMORY_ALLOCATOR_BLOCK_SIZE); t=Time(); int kernelDepth=Depth.value-2; if(KernelDepth.set){kernelDepth=KernelDepth.value;} tree.setFunctionData(ReconstructionFunction,Depth.value,0,Real(1.0)/(1<<Depth.value)); DumpOutput("Function Data Set In: %lg\n",Time()-t); DumpOutput("Memory Usage: %.3f MB\n",float(MemoryInfo::Usage())/(1<<20)); if(kernelDepth>Depth.value){ fprintf(stderr,"KernelDepth can't be greater than Depth: %d <= %d\n",kernelDepth,Depth.value); return EXIT_FAILURE; } t=Time(); #if 1 tree.setTree(In.value,Depth.value,Binary.set,kernelDepth,Real(SamplesPerNode.value),Scale.value,center,scale,!NoResetSamples.set,Confidence.set); #else if(Confidence.set){ tree.setTree(In.value,Depth.value,Binary.set,kernelDepth,Real(SamplesPerNode.value),Scale.value,center,scale,!NoResetSamples.set,0,1); } else{ tree.setTree(In.value,Depth.value,Binary.set,kernelDepth,Real(SamplesPerNode.value),Scale.value,center,scale,!NoResetSamples.set,0,0); } #endif DumpOutput2(comments[commentNum++],"# Tree set in: %9.1f (s), %9.1f (MB)\n",Time()-t,tree.maxMemoryUsage); DumpOutput("Leaves/Nodes: %d/%d\n",tree.tree.leaves(),tree.tree.nodes()); DumpOutput(" Tree Size: %.3f MB\n",float(sizeof(TreeOctNode)*tree.tree.nodes())/(1<<20)); DumpOutput("Memory Usage: %.3f MB\n",float(MemoryInfo::Usage())/(1<<20)); if(!NoClipTree.set){ t=Time(); tree.ClipTree(); DumpOutput("Tree Clipped In: %lg\n",Time()-t); DumpOutput("Leaves/Nodes: %d/%d\n",tree.tree.leaves(),tree.tree.nodes()); DumpOutput(" Tree Size: %.3f MB\n",float(sizeof(TreeOctNode)*tree.tree.nodes())/(1<<20)); } t=Time(); tree.finalize1(Refine.value); DumpOutput("Finalized 1 In: %lg\n",Time()-t); DumpOutput("Leaves/Nodes: %d/%d\n",tree.tree.leaves(),tree.tree.nodes()); DumpOutput("Memory Usage: %.3f MB\n",float(MemoryInfo::Usage())/(1<<20)); t=Time(); tree.maxMemoryUsage=0; tree.SetLaplacianWeights(); DumpOutput2(comments[commentNum++],"#Laplacian Weights Set In: %9.1f (s), %9.1f (MB)\n",Time()-t,tree.maxMemoryUsage); DumpOutput("Memory Usage: %.3f MB\n",float(MemoryInfo::Usage())/(1<<20)); t=Time(); tree.finalize2(Refine.value); DumpOutput("Finalized 2 In: %lg\n",Time()-t); DumpOutput("Leaves/Nodes: %d/%d\n",tree.tree.leaves(),tree.tree.nodes()); DumpOutput("Memory Usage: %.3f MB\n",float(MemoryInfo::Usage())/(1<<20)); tree.maxMemoryUsage=0; t=Time(); tree.LaplacianMatrixIteration(SolverDivide.value); DumpOutput2(comments[commentNum++],"# Linear System Solved In: %9.1f (s), %9.1f (MB)\n",Time()-t,tree.maxMemoryUsage); DumpOutput("Memory Usage: %.3f MB\n",float(MemoryInfo::Usage())/(1<<20)); CoredVectorMeshData mesh; tree.maxMemoryUsage=0; t=Time(); isoValue=tree.GetIsoValue(); DumpOutput("Got average in: %f\n",Time()-t); DumpOutput("Iso-Value: %e\n",isoValue); DumpOutput("Memory Usage: %.3f MB\n",float(tree.MemoryUsage())); t=Time(); if(IsoDivide.value) tree.GetMCIsoTriangles( isoValue , IsoDivide.value , &mesh , 0 , 1 , Manifold.set , PolygonMesh.set ); else tree.GetMCIsoTriangles( isoValue , &mesh , 0 , 1 , Manifold.set , PolygonMesh.set ); if( PolygonMesh.set ) DumpOutput2(comments[commentNum++],"# Got Polygons in: %9.1f (s), %9.1f (MB)\n",Time()-t,tree.maxMemoryUsage); else DumpOutput2(comments[commentNum++],"# Got Triangles in: %9.1f (s), %9.1f (MB)\n",Time()-t,tree.maxMemoryUsage); DumpOutput2(comments[commentNum++],"# Total Time: %9.1f (s)\n",Time()-tt); PlyWritePolygons(Out.value,&mesh,PLY_BINARY_NATIVE,center,scale,comments,commentNum); return 1; }
int main( int argc , char* argv[] ) { int paramNum = sizeof(params)/sizeof(cmdLineReadable*); cmdLineParse( argc-1 , &argv[1] , paramNum , params , 0 ); #if FOR_RELEASE if( !In.set || !Trim.set ) { ShowUsage( argv[0] ); return EXIT_FAILURE; } #else // !FOR_RELEASE if( !In.set ) { ShowUsage( argv[0] ); return EXIT_FAILURE; } #endif // FOR_RELEASE float min , max; std::vector< PlyValueVertex< float > > vertices; std::vector< std::vector< int > > polygons; int ft , commentNum = paramNum+2; char** comments; bool readFlags[ PlyValueVertex< float >::Components ]; PlyReadPolygons( In.value , vertices , polygons , PlyValueVertex< float >::Properties , PlyValueVertex< float >::Components , ft , &comments , &commentNum , readFlags ); if( !readFlags[3] ){ fprintf( stderr , "[ERROR] vertices do not have value flag\n" ) ; return EXIT_FAILURE; } #if 0 if( Trim.set ) for( int i=0 ; i<Smooth.value ; i++ ) SmoothValues( vertices , polygons , Trim.value-0.5f , Trim.value+0.5f ); else for( int i=0 ; i<Smooth.value ; i++ ) SmoothValues( vertices , polygons ); #else for( int i=0 ; i<Smooth.value ; i++ ) SmoothValues( vertices , polygons ); #endif min = max = vertices[0].value; for( size_t i=0 ; i<vertices.size() ; i++ ) min = std::min< float >( min , vertices[i].value ) , max = std::max< float >( max , vertices[i].value ); printf( "Value Range: [%f,%f]\n" , min , max ); if( Trim.set ) { hash_map< long long , int > vertexTable; std::vector< std::vector< int > > ltPolygons , gtPolygons; std::vector< bool > ltFlags , gtFlags; for( int i=0 ; i<paramNum+2 ; i++ ) comments[i+commentNum]=new char[1024]; sprintf( comments[commentNum++] , "Running Surface Trimmer (V5)" ); if( In.set ) sprintf(comments[commentNum++],"\t--%s %s" , In.name , In.value ); if( Out.set ) sprintf(comments[commentNum++],"\t--%s %s" , Out.name , Out.value ); if( Trim.set ) sprintf(comments[commentNum++],"\t--%s %f" , Trim.name , Trim.value ); if( Smooth.set ) sprintf(comments[commentNum++],"\t--%s %d" , Smooth.name , Smooth.value ); if( IslandAreaRatio.set ) sprintf(comments[commentNum++],"\t--%s %f" , IslandAreaRatio.name , IslandAreaRatio.value ); if( PolygonMesh.set ) sprintf(comments[commentNum++],"\t--%s" , PolygonMesh.name ); double t=Time(); for( size_t i=0 ; i<polygons.size() ; i++ ) SplitPolygon( polygons[i] , vertices , <Polygons , >Polygons , <Flags , >Flags , vertexTable , Trim.value ); if( IslandAreaRatio.value>0 ) { std::vector< std::vector< int > > _ltPolygons , _gtPolygons; std::vector< std::vector< int > > ltComponents , gtComponents; SetConnectedComponents( ltPolygons , ltComponents ); SetConnectedComponents( gtPolygons , gtComponents ); std::vector< double > ltAreas( ltComponents.size() , 0. ) , gtAreas( gtComponents.size() , 0. ); std::vector< bool > ltComponentFlags( ltComponents.size() , false ) , gtComponentFlags( gtComponents.size() , false ); double area = 0.; for( size_t i=0 ; i<ltComponents.size() ; i++ ) { for( size_t j=0 ; j<ltComponents[i].size() ; j++ ) { ltAreas[i] += PolygonArea( vertices , ltPolygons[ ltComponents[i][j] ] ); ltComponentFlags[i] = ( ltComponentFlags[i] || ltFlags[ ltComponents[i][j] ] ); } area += ltAreas[i]; } for( size_t i=0 ; i<gtComponents.size() ; i++ ) { for( size_t j=0 ; j<gtComponents[i].size() ; j++ ) { gtAreas[i] += PolygonArea( vertices , gtPolygons[ gtComponents[i][j] ] ); gtComponentFlags[i] = ( gtComponentFlags[i] || gtFlags[ gtComponents[i][j] ] ); } area += gtAreas[i]; } for( size_t i=0 ; i<ltComponents.size() ; i++ ) { if( ltAreas[i]<area*IslandAreaRatio.value && ltComponentFlags[i] ) for( size_t j=0 ; j<ltComponents[i].size() ; j++ ) _gtPolygons.push_back( ltPolygons[ ltComponents[i][j] ] ); else for( size_t j=0 ; j<ltComponents[i].size() ; j++ ) _ltPolygons.push_back( ltPolygons[ ltComponents[i][j] ] ); } for( size_t i=0 ; i<gtComponents.size() ; i++ ) { if( gtAreas[i]<area*IslandAreaRatio.value && gtComponentFlags[i] ) for( size_t j=0 ; j<gtComponents[i].size() ; j++ ) _ltPolygons.push_back( gtPolygons[ gtComponents[i][j] ] ); else for( size_t j=0 ; j<gtComponents[i].size() ; j++ ) _gtPolygons.push_back( gtPolygons[ gtComponents[i][j] ] ); } ltPolygons = _ltPolygons , gtPolygons = _gtPolygons; } if( !PolygonMesh.set ) { { std::vector< std::vector< int > > polys = ltPolygons; Triangulate( vertices , ltPolygons , polys ) , ltPolygons = polys; } { std::vector< std::vector< int > > polys = gtPolygons; Triangulate( vertices , gtPolygons , polys ) , gtPolygons = polys; } } RemoveHangingVertices( vertices , gtPolygons ); sprintf( comments[commentNum++] , "#Trimmed In: %9.1f (s)" , Time()-t ); if( Out.set ) PlyWritePolygons( Out.value , vertices , gtPolygons , PlyValueVertex< float >::Properties , PlyValueVertex< float >::Components , ft , comments , commentNum ); } else { if( ColorRange.set ) min = ColorRange.values[0] , max = ColorRange.values[1]; std::vector< PlyColorVertex< float > > outVertices; ColorVertices( vertices , outVertices , min , max ); if( Out.set ) PlyWritePolygons( Out.value , outVertices , polygons , PlyColorVertex< float >::Properties , PlyColorVertex< float >::Components , ft , comments , commentNum ); } return EXIT_SUCCESS; }