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;
}
