void BigInt::ToComplement() { Refine(); for(long long i = 0; i < MAXBIT - 1; i++) m_element[i] = JINZHI - 1 - m_element[i]; m_element[0] += 1; Refine(); }
/* Refine a curve until it can be approximated with straight lines to within ** the given tolerance. Always does at least one refinement, even if the ** original curve is inside tolerance. */ void CubicBspline::Refine_Tolerance(CubicBspline &result, const float tolerance) { Refine(result); while ( ! result.Within_Tolerance(tolerance) ) result.Refine(result); }
void Tile::Init(float roughness) { // Zufallsgenerator initialisieren srand(static_cast<unsigned int>(time(0))); // x- und z-Koordinaten berechnen. // Das Wurzel-Tile ersteckt sich entlang der x- und z-Achse immer im Bereich // [-2.5, 2.5] int i = 0; for (int y = 0; y < size_; ++y) { for (int x = 0; x < size_; ++x, ++i) { vertices_[i].x = x * 5.0f / (size_ - 1) - 2.5f; vertices_[i].z = y * 5.0f / (size_ - 1) - 2.5f; } } // Ecken mit Zufallshöhenwerten initialisieren int block_size = size_ - 1; vertices_[I(0, 0)].y = randf(); vertices_[I(0, block_size)].y = randf(); vertices_[I(block_size, 0)].y = randf(); vertices_[I(block_size, block_size)].y = randf(); // Verfeinerungsschritte durchführen bis sämtliche Werte berechnet sind while (block_size > 1) { Refine(block_size, roughness); block_size = block_size / 2; } }
BigInt::BigInt(const BigInt& x) { m_element = new unsigned long long[MAXBIT]; m_isRefined = false; for(long long i = 0; i < MAXBIT; i++) m_element[i] = x.GetElement(i); Refine(); }
void Run() { SetStartTime(); Log("Started %s\n", GetTimeAsStr()); for (int i = 0; i < g_argc; ++i) Log("%s ", g_argv[i]); Log("\n"); #if TIMING TICKS t1 = GetClockTicks(); #endif if (g_bRefine) Refine(); else if (g_bRefineW) { extern void DoRefineW(); DoRefineW(); } else if (g_bProfDB) ProfDB(); else if (g_bSW) Local(); else if (0 != g_pstrSPFileName) DoSP(); else if (g_bProfile) Profile(); else if (g_bPPScore) PPScore(); else if (g_bPAS) ProgAlignSubFams(); else DoMuscle(); #if TIMING extern TICKS g_ticksDP; extern TICKS g_ticksObjScore; TICKS t2 = GetClockTicks(); TICKS TotalTicks = t2 - t1; TICKS ticksOther = TotalTicks - g_ticksDP - g_ticksObjScore; double dSecs = TicksToSecs(TotalTicks); double PctDP = (double) g_ticksDP*100.0/(double) TotalTicks; double PctOS = (double) g_ticksObjScore*100.0/(double) TotalTicks; double PctOther = (double) ticksOther*100.0/(double) TotalTicks; Log(" Ticks Secs Pct\n"); Log(" ============ ======= =====\n"); Log("DP %12ld %7.2f %5.1f%%\n", (long) g_ticksDP, TicksToSecs(g_ticksDP), PctDP); Log("OS %12ld %7.2f %5.1f%%\n", (long) g_ticksObjScore, TicksToSecs(g_ticksObjScore), PctOS); Log("Other %12ld %7.2f %5.1f%%\n", (long) ticksOther, TicksToSecs(ticksOther), PctOther); Log("Total %12ld %7.2f 100.0%%\n", (long) TotalTicks, dSecs); #endif ListDiagSavings(); Log("Finished %s\n", GetTimeAsStr()); }
bool RiemannianGeodesic<Real>::Subdivide (const GVector<Real>& end0, GVector<Real>& mid, const GVector<Real>& end1) { mid = ((Real)0.5)*(end0 + end1); RefineCallbackFunction save = RefineCallback; RefineCallback = 0; bool changed = Refine(end0, mid, end1); RefineCallback = save; return changed; }
void RiemannianGeodesic<Real>::ComputeGeodesic (const GVector<Real>& point0, const GVector<Real>& point1, int& quantity, GVector<Real>*& path) { assertion(Subdivisions < 32, "Exceeds maximum iterations\n"); quantity = (1 << Subdivisions) + 1; path = new1<GVector<Real> >(quantity); int i; for (i = 0; i < quantity; ++i) { path[i].SetSize(mDimension); } mCurrentQuantity = 2; path[0] = point0; path[1] = point1; for (mSubdivide = 1; mSubdivide <= Subdivisions; ++mSubdivide) { // A subdivision essentially doubles the number of points. int newQuantity = 2*mCurrentQuantity - 1; assertion(newQuantity <= quantity, "Unexpected condition.\n"); // Copy the old points so that there are slots for the midpoints // during the subdivision, the slots interleaved between the old // points. for (i = mCurrentQuantity-1; i > 0; --i) { path[2*i] = path[i]; } // Subdivide the polyline. for (i = 0; i <= mCurrentQuantity-2; ++i) { Subdivide(path[2*i], path[2*i+1], path[2*i+2]); } mCurrentQuantity = newQuantity; // Refine the current polyline vertices. for (mRefine = 1; mRefine <= Refinements; ++mRefine) { for (i = 1; i <= mCurrentQuantity-2; ++i) { Refine(path[i-1], path[i], path[i+1]); } } } assertion(mCurrentQuantity == quantity, "Unexpected condition\n"); mSubdivide = 0; mRefine = 0; mCurrentQuantity = 0; }
Tile::Tile(Tile *parent, Tile::Direction direction, float roughness, Tile *north, Tile *west) : lod_(parent->lod_ + 1), size_(parent->size_), num_lod_(parent->num_lod_ - 1), index_buffer_(NULL), direction_(direction), parent_(parent) { vertices_ = new Vector[size_*size_]; InitFromParent(); Refine(2, roughness); FixEdges(north, west); InitChildren(roughness, north, west); }
void AdaptiveSparseGrid::BuildFirstLevel() { AdaptiveARRAY<int>* px1 = AdaptiveCoordAllocator.NewItem(dim); AdaptiveARRAY<int>* px2 = AdaptiveCoordAllocator.NewItem(dim); px1 -> fill(1); px2 -> fill(0); //! The first level is always a single point. AdaptiveARRAY<double> x; x.redim(dim); x.fill(0.5); L = 0; //! For the fisrt point, we always assign it to rank 0 if (rank == 0) { EvaluateFunctionAtThisPoint(&x); AdaptiveData* pData = AdaptiveDataAllocator.NewItem(); AdaptiveNodeData* pNodeData = AdaptiveNodeDataAllocator.NewItem(); pData->index = px1; pNodeData->index = px2; pNodeData->surplus = new double[TotalDof]; for ( int i = 0; i < TotalDof; i++) { pNodeData->surplus[i] = surplus[i]; } pData->NodeData.insert(pNodeData); SparseGrid.push_front(pData); } MPI_Barrier(mpiCOMM); //Generate New sons for each dimension Refine(px1, px2); // Compute the integration value if ( type == 1) { UpdateError(); } if ( rank != 0) { AdaptiveCoordAllocator.DeleteItem(px1); AdaptiveCoordAllocator.DeleteItem(px2); } }
void GenerateIcosphere(Grid& grid, const vector3& center, number radius, int numRefinements, AVector3& aPos, Selector* psel) { Selector defSel; if(!psel){ defSel.assign_grid(grid); psel = &defSel; } Selector& sel = *psel; // enable autoselection bool autoselectionEnabled = sel.autoselection_enabled(); sel.enable_autoselection(true); // clear the selector sel.clear(); // create an icosahedron. All elements of the sphere will be selected, since we // enabled autoselection GenerateIcosahedron(grid, center, radius, aPos); // perform refinement steps // we need a temporary int attachment for the edges AInt aInt; grid.attach_to_edges(aInt); // use a refinement callback to project the new vertices to the sphere SphereProjector sphereProjecton(MakeGeometry3d(grid, aPos), center); for(int i = 0; i < numRefinements; ++i) Refine(grid, sel, aInt, &sphereProjecton); // remove attachments grid.detach_from_edges(aInt); // restore autoselection sel.enable_autoselection(autoselectionEnabled); }
int main(int argc, char **argv) { char dcname[40]; AccMask setmask = 0; AccMask clearmask = 0; char *s; PrgName = argv [0]; if( argc < (1 + 1)) { printf("Usage: %s [[-+=][rwefghvxyzda]] <Objects>\n", PrgName); exit(1); } argv++; s = *argv; if( *s == '+' || *s == '-' || *s == '=' ) { AccMask *mask = &setmask; if( *s == '-' ) mask = &clearmask; elif( *s == '=' ) clearmask = 0xff; s++; while( *s != '\0' ) { int bit = getbit(*s,FileChars); if( bit == 0 ) bit = getbit(*s,DirChars); if( bit == 0 ) printf("invalid bit character %c\n",*s); *mask |= bit; s++; } argv++; } for( ; *argv != NULL; argv++ ) { char *name = *argv; Object *o; word e; o = Locate(CurrentDir,name); if( o == NULL ) { fprintf(stderr,"could not locate %s : %x\n",name,Result2(CurrentDir)); continue; } if( clearmask || setmask ) { AccMask mask = o->Access.Access; mask &= ~clearmask; mask |= setmask; e = Refine(o,mask); if( e < 0 ) fprintf(stderr,"refine of %s failed: %x\n",name,e); } DecodeCapability(dcname,&o->Access); printf("%s%s\n",dcname,o->Name); } return 0; }
/** * Sample from the normal distribution with mean 0 and variance 1. * * @param[out] val the sample from the normal distribution * @param[in,out] r a GMP random generator. * @param[in] round the rounding direction. * @return the MPFR ternary result (±1 if val is larger/smaller than * the exact sample). **********************************************************************/ int operator()(mpfr_t val, gmp_randstate_t r, mpfr_rnd_t round) const { const double s = 0.449871, // Constants from Leva t = -0.386595, a = 0.19600 , b = 0.25472 , r1 = 0.27597 , r2 = 0.27846 , u1 = 0.606530, // sqrt(1/e) rounded down and up u2 = 0.606531, scale = std::pow(2.0, -chunk_); // for turning randoms into doubles while (true) { mpz_urandomb(_vi, r, chunk_); if (mpz_cmp_ui(_vi, m) >= 0) continue; // Very early reject double vf = (mpz_get_ui(_vi) + 0.5) * scale; mpz_urandomb(_ui, r, chunk_); double uf = (mpz_get_ui(_ui) + 0.5) * scale; double x = uf - s, y = vf - t, Q = x*x + y * (a*y - b*x); if (Q >= r2) continue; // Early reject mpfr_set_ui_2exp(_eps, 1u, -chunk_, MPFR_RNDN); mpfr_prec_t prec = chunk_; mpfr_set_prec(_u, prec); mpfr_set_prec(_v, prec); // (u,v) = sw corner of range mpfr_set_z_2exp(_u, _ui, -prec, MPFR_RNDN); mpfr_set_z_2exp(_v, _vi, -prec, MPFR_RNDN); mpfr_set_prec(_up, prec); mpfr_set_prec(_vp, prec); // (up,vp) = ne corner of range mpfr_add(_up, _u, _eps, MPFR_RNDN); mpfr_add(_vp, _v, _eps, MPFR_RNDN); // Estimate how many extra bits will be needed to achieve the desired // precision. mpfr_prec_t prec_guard = 3 + chunk_ - (std::max)(mpz_sizeinbase(_ui, 2), mpz_sizeinbase(_vi, 2)); if (Q > r1) { int reject; while (true) { // Rejection curve v^2 + 4 * u^2 * log(u) < 0 has a peak at u = // exp(-1/2) = 0.60653066. So treat uf in (0.606530, 0.606531) = // (u1, u2) specially // Try for rejection first if (uf <= u1) reject = Reject(_u, _vp, prec, MPFR_RNDU); else if (uf >= u2) reject = Reject(_up, _vp, prec, MPFR_RNDU); else { // u in (u1, u2) mpfr_set_prec(_vx, prec); mpfr_add(_vx, _vp, _eps, MPFR_RNDN); reject = Reject(_u, _vx, prec, MPFR_RNDU); // Could use _up too } if (reject < 0) break; // tried to reject but failed, so accept // Try for acceptance if (uf <= u1) reject = Reject(_up, _v, prec, MPFR_RNDD); else if (uf >= u2) reject = Reject(_u, _v, prec, MPFR_RNDD); else { // u in (u2, u2) mpfr_sub(_vx, _v, _eps, MPFR_RNDN); reject = Reject(_u, _vx, prec, MPFR_RNDD); // Could use _up too } if (reject > 0) break; // tried to accept but failed, so reject prec = Refine(r, prec); // still can't decide, to refine } if (reject > 0) continue; // reject, back to outer loop } // Now evaluate v/u to the necessary precision mpfr_prec_t prec0 = mpfr_get_prec (val); // while (prec < prec0 + prec_guard) prec = Refine(r, prec); if (prec < prec0 + prec_guard) prec = Refine(r, prec, (prec0 + prec_guard - prec + chunk_ - 1) / chunk_); mpfr_set_prec(_x1, prec0); mpfr_set_prec(_x2, prec0); int flag; while (true) { int f1 = mpfr_div(_x1, _v, _up, round), // min slope f2 = mpfr_div(_x2, _vp, _u, round); // max slope if (f1 == f2 && mpfr_equal_p(_x1, _x2)) { flag = f1; break; } prec = Refine(r, prec); } mpz_urandomb(_ui, r, 1); if (mpz_tstbit(_ui, 0)) { flag = -flag; mpfr_neg(val, _x1, MPFR_RNDN); } else mpfr_set(val, _x1, MPFR_RNDN); // std::cerr << uf << " " << vf << " " << Q << "\n"; return flag; } }
void AdaptiveSparseGrid::ConstructAdaptiveSparseGrid() { //! Define a buffer deque to store all of the intermediate information deque<AdaptiveData*> buffer; //! iterator for transverse the active index set<AdaptiveData*, AdaptiveDataCompare>::iterator it1; set<AdaptiveNodeData*, AdaptiveNodeDataCompare>::iterator it2; AdaptiveGrid OldIndex; AdaptiveData* pData ; AdaptiveNodeData* pNodeData; //! Here we still keep a copy of active index for each processor for the purpose //! of the easy implementation of the adaptivity while ( !ActiveIndex.empty() && L <= Lmax ) { int gnumber = NumberOfActivePoints(); if (rank == 0 && print) { cout << "Now, it is in Level: " << L << endl; cout << "The active number of points are: " << gnumber << endl; } //Copy the ActiveIndex to an oldIndex OldIndex = ActiveIndex; ActiveIndex.clear(); //! Define a temporary matrix to store all of the active point for parallel computation Matrix1<double> gpoint; gpoint.redim(gnumber, dim); double time1, time; time1 = MPI_Wtime(); int row = 1; //! Extract the coordiante information for (it1 = OldIndex.begin(); it1 != OldIndex.end(); ++it1) { for (it2 = (*it1)->NodeData.begin(); it2 != (*it1)->NodeData.end(); ++it2) { for ( int i = 1; i <= dim ; i++) { gpoint(row, i) = IndextoCoordinate((*(*it1)->index)(i), (*(*it2)->index)(i)); } row++; } } // Parallel Implementation int node; AdaptiveARRAY<double> px; px.redim(dim); //! Distribute the points among the processors int numNodesPerProcessor = 0; for (int i = 0; i < gnumber; i++) if ( (i % size) == rank) { numNodesPerProcessor++; } int colnumber = TotalDof * numNodesPerProcessor; //!Local value to store function value double* local_value = new double[colnumber]; //! An array to store the nodes which belong to this processor int* mynodes = new int[numNodesPerProcessor]; for ( int no = 1 ; no <= numNodesPerProcessor; no++) { node = rank + size * (no - 1) + 1; mynodes[no - 1] = node; for ( int i = 1 ; i <= dim ; i++) { px(i) = gpoint(node, i); } EvaluateFunctionAtThisPoint(&px); for ( int i = 0; i < TotalDof ; i++) { local_value[(no - 1)*TotalDof + i] = surplus[i] ; } } /** * EDIT BY ARYAN */ MPI_Barrier(mpiCOMM); time = MPI_Wtime(); if (rank == 0 && print ) { cout << "Parallel Calculation using " << time - time1 << endl; } gpoint.cleanup(); //! Set the action before storing the surplus BeforeStoreSurplus(); int index = 1; int cnt = 0, mynode; //! Extract the coordiante information for (it1 = OldIndex.begin(); it1 != OldIndex.end(); ++it1) { int number = (*it1)->NodeData.size(); //! Define a temporary matrix to store all of the active point for parallel computation Matrix1<double> point; point.redim(number, dim); int row = 1; for (it2 = (*it1)->NodeData.begin(); it2 != (*it1)->NodeData.end(); ++it2) { for ( int i = 1; i <= dim ; i++) { point(row, i) = IndextoCoordinate((*(*it1)->index)(i), (*(*it2)->index)(i)); } row++; } //! If there are points in this processor, generate a new data to store information if ( numNodesPerProcessor != 0) { pData = AdaptiveDataAllocator.NewItem(); pData->index = (*it1)->index; buffer.push_front(pData); } double* temp = new double[TotalDof * number]; //! Calculate the hierarchical surplus SpInterpolateLevel(point, temp); //! Calculate the hierarchial surplus and generate the adaptivity information Array<int> local_refine; local_refine.redim(number); local_refine.fill(0); Array<int> global_refine; global_refine.redim(number); int temp_index = index; int temp_cnt = cnt; it2 = (*it1)->NodeData.begin(); for ( int n = 1; n <= number; n++) { if ( (temp_cnt != numNodesPerProcessor) && (temp_index == mynodes[temp_cnt]) ) { for ( int i = 0; i < TotalDof; i++) { local_value[temp_cnt * TotalDof + i] = surplus[i] = local_value[temp_cnt * TotalDof + i] - temp[(n - 1) * TotalDof + i]; } //! Check the adaptivity criteria local_refine(n) = IsRefine(surplus, (*it1)->index, (*it2)->index); temp_cnt ++; } temp_index++; ++it2; } //! Free space delete[] temp; int error = MPI_Allreduce(local_refine.pData, global_refine.pData, number, MPI_INT, MPI_SUM, mpiCOMM); //if (error) { cout << "ERORR 221 : " << error << "|" << rank << endl; } //! Free space local_refine.cleanup(); it2 = (*it1)->NodeData.begin(); // calculate herarchial surplus for each coordinate for ( int n = 1 ; n <= number; n++) { //! If this point belongs to this processor if ( (cnt != numNodesPerProcessor) && (index == mynodes[cnt]) ) { //Copy data to sparse grid pNodeData = (*it2); pNodeData->surplus = new double[TotalDof]; for ( int i = 0; i < TotalDof; i++) { pNodeData->surplus[i] = local_value[cnt * TotalDof + i]; } //! Refinement if ( global_refine(n)) { Refine((*it1)->index, (*it2)->index); } cnt ++; //! Insert the this nodadata to the buffer pData->NodeData.insert(pNodeData); } //! the point doesn't belong to this processor else { if ( global_refine(n)) { Refine((*it1)->index, (*it2)->index); } //! If this point doesn't belong to this processor, delete the point. AdaptiveCoordAllocator.DeleteItem((*it2)->index); AdaptiveNodeDataAllocator.DeleteItem(*it2); } ++it2; index++; } //free space global_refine.cleanup(); //! If there are no point for this processor, delete the data. if ( numNodesPerProcessor == 0) { AdaptiveCoordAllocator.DeleteItem((*it1)->index); AdaptiveDataAllocator.DeleteItem(*it1); } }// End for //free space delete[] local_value; delete[] mynodes; /** * EDIT BY ARYAN */ MPI_Barrier(mpiCOMM); time1 = MPI_Wtime(); if (rank == 0 && print) { cout << "Surplus Calculation using " << time1 - time << endl; } //! Insert all of the active points to the adaptive spare grid. SparseGrid.insert(SparseGrid.begin(), buffer.begin(), buffer.end()); if ( type == 1) { UpdateError(); } //free space buffer.clear(); OldIndex.clear(); L += 1; //! Set the action before storing the surplus { AfterStoreSurplus(); } }//End for }
bool AdaptSurfaceGridToCylinder(Selector& selOut, Grid& grid, Vertex* vrtCenter, const vector3& normal, number radius, number rimSnapThreshold, AInt& aInt, APosition& aPos) { if(!grid.has_vertex_attachment(aPos)) { UG_THROW("Position attachment required!"); } Grid::VertexAttachmentAccessor<APosition> aaPos(grid, aPos); if(rimSnapThreshold < 0) rimSnapThreshold = 0; if(rimSnapThreshold > (radius - SMALL)) rimSnapThreshold = radius - SMALL; const number smallRadius = radius - rimSnapThreshold; const number smallRadiusSq = smallRadius * smallRadius; const number largeRadius = radius + rimSnapThreshold; const number largeRadiusSq = largeRadius * largeRadius; // the cylinder geometry vector3 axis; VecNormalize(axis, normal); vector3 center = aaPos[vrtCenter]; // recursively select all vertices in the cylinder which can be reached from a // selected vertex by following an edge. Start with the given one. // We'll also select edges which connect inner with outer vertices. Note that // some vertices are considered rim-vertices (those with a distance between // smallRadius and largeRadius). Those are neither considered inner nor outer. Selector& sel = selOut; sel.clear(); sel.select(vrtCenter); stack<Vertex*> vrtStack; vrtStack.push(vrtCenter); Grid::edge_traits::secure_container edges; Grid::face_traits::secure_container faces; vector<Quadrilateral*> quads; while(!vrtStack.empty()) { Vertex* curVrt = vrtStack.top(); vrtStack.pop(); // we have to convert associated quadrilaterals to triangles. // Be careful not to alter the array of associated elements while we iterate // over it... quads.clear(); grid.associated_elements(faces, curVrt); for(size_t i = 0; i < faces.size(); ++i) { if(faces[i]->num_vertices() == 4) { Quadrilateral* q = dynamic_cast<Quadrilateral*>(faces[i]); if(q) quads.push_back(q); } } for(size_t i = 0; i < quads.size(); ++i) { Triangulate(grid, quads[i], &aaPos); } // now check whether edges leave the cylinder and mark them accordingly. // Perform projection of vertices to the cylinder rim for vertices which // lie in the threshold area. grid.associated_elements(edges, curVrt); for(size_t i_edge = 0; i_edge < edges.size(); ++i_edge) { Edge* e = edges[i_edge]; Vertex* vrt = GetConnectedVertex(e, curVrt); if(sel.is_selected(vrt)) continue; vector3 p = aaPos[vrt]; vector3 proj; ProjectPointToRay(proj, p, center, axis); number distSq = VecDistanceSq(p, proj); if(distSq < smallRadiusSq) { sel.select(vrt); vrtStack.push(vrt); } else if(distSq < largeRadiusSq) { sel.select(vrt); // cut the ray from center through p with the cylinder hull to calculate // the new position of vrt. vector3 dir; VecSubtract(dir, p, center); number t0, t1; if(RayCylinderIntersection(t0, t1, center, dir, center, axis, radius)) VecScaleAdd(aaPos[vrt], 1., center, t1, dir); } else { // the edge will be refined later on sel.select(e); } } } // refine selected edges and use a special refinement callback, which places // new vertices on edges which intersect a cylinder on the cylinders hull. CylinderCutProjector refCallback(MakeGeometry3d(grid, aPos), center, axis, radius); Refine(grid, sel, aInt, &refCallback); // finally select all triangles which lie in the cylinder sel.clear(); vrtStack.push(vrtCenter); sel.select(vrtCenter); while(!vrtStack.empty()) { Vertex* curVrt = vrtStack.top(); vrtStack.pop(); grid.associated_elements(faces, curVrt); for(size_t i_face = 0; i_face < faces.size(); ++i_face) { Face* f = faces[i_face]; if(sel.is_selected(f)) continue; sel.select(f); for(size_t i = 0; i < f->num_vertices(); ++i) { Vertex* vrt = f->vertex(i); if(!sel.is_selected(vrt)) { number dist = DistancePointToRay(aaPos[vrt], center, axis); if(dist < (radius - SMALL)) { sel.select(vrt); vrtStack.push(vrt); } } } } } sel.clear<Vertex>(); return true; }
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; }