TEST(BlockTest, FindEdgeRecursive) { // To recurse, need two entries in block map, no instructions in // the block that have a name, a branch instruction to the second // block and a named instruction in the second block. When // calling findEdge with the first block, the id of the // instruction with a name in the second block should be returned. llvm::LLVMContext context; llvm::BasicBlock* fbblock = llvm::BasicBlock::Create(context); llvm::BasicBlock* sbblock = llvm::BasicBlock::Create(context); llvm::BranchInst* finstruction = llvm::BranchInst::Create(sbblock); llvm::BranchInst* sinstruction = llvm::BranchInst::Create(fbblock); pBlock fblock(new Block(0)); pBlock sblock(new Block(1)); pNode fnode(new Node(0)); pNode snode(new Node(1)); fbblock->getInstList().push_back(finstruction); sbblock->getInstList().push_back(sinstruction); fblock->appendNode(fnode); sblock->appendNode(snode); fnode->setInstruction(finstruction); snode->setInstruction(sinstruction); snode->setNodeLabel("test_label"); std::map<llvm::BasicBlock*, pBlock> blocks; blocks.insert(std::pair<llvm::BasicBlock*, pBlock>(fbblock, fblock)); blocks.insert(std::pair<llvm::BasicBlock*, pBlock>(sbblock, sblock)); ASSERT_EQ(1, fblock->findEdge(fbblock, blocks)); }
XmlNode Protocol::goto_doc_node ( const XmlNode& node ) { XmlNode fnode(node); if( !fnode.is_valid() ) throw XmlError(FromHere(), "Node is not valid"); if ( fnode.content->type() == rapidxml::node_document ) { fnode.content = fnode.content->first_node(); if ( !fnode.is_valid() ) throw XmlError( FromHere(), "XML document is empty" ); } if ( fnode.content->type() == rapidxml::node_document ) { fnode.content = fnode.content->next_sibling(); if ( !fnode.is_valid() ) throw XmlError( FromHere(), "No xml nodes after declaration" ); } // find the first doc node if ( strcmp(fnode.content->name() , Tags::node_doc()) ) /* are not equal */ fnode.content = fnode.content->next_sibling( Tags::node_doc() ); if ( !fnode.is_valid() ) throw common::XmlError( FromHere(), "No xml doc found" ); return fnode; }
// sequencer_node behaves like a queueing node, but requires a different constructor. void TestSequencerNode() { tbb::flow::graph g; tbb::flow::sequencer_node<int> bnode(g, seq_body()); REMARK("Testing sequencer_node:"); tbb::flow::function_node<int> fnode(g, tbb::flow::serial, serial_fn_body<int>(serial_fn_state0)); REMARK("Testing sequencer_node:"); serial_fn_state0 = 0; // reset to waiting state. REMARK(" make_edge"); tbb::flow::make_edge(bnode, fnode); ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after make_edge"); REMARK(" try_put"); bnode.try_put(0); // will forward to the fnode BACKOFF_WAIT( serial_fn_state0 == 0, "timeout waiting for function_node"); // wait for the function_node to fire up ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after forwarding message"); serial_fn_state0 = 0; g.wait_for_all(); REMARK(" remove_edge"); tbb::flow::remove_edge(bnode, fnode); ASSERT(bnode.my_successors.empty(), "buffering node has a successor after remove_edge"); tbb::flow::join_node<tbb::flow::tuple<int,int>,tbb::flow::reserving> jnode(g); tbb::flow::make_edge(bnode, tbb::flow::input_port<0>(jnode)); // will spawn a task g.wait_for_all(); ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after attaching to join"); REMARK(" reverse"); bnode.try_put(3); // the edge should reverse g.wait_for_all(); ASSERT(bnode.my_successors.empty(), "buffering node has a successor after reserving"); REMARK(" reset()"); g.wait_for_all(); g.reset(); // should be in forward direction again ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after reset()"); #if TBB_PREVIEW_FLOW_GRAPH_FEATURES REMARK(" remove_edge"); g.reset(tbb::flow::rf_extract); // should be in forward direction again ASSERT(bnode.my_successors.empty(), "buffering node has a successor after reset(rf_extract)"); ASSERT(fnode.my_predecessors.empty(), "buffering node reversed after reset(rf_extract)"); #endif REMARK(" done\n"); g.wait_for_all(); }
void TestBufferingNode(const char * name) { tbb::flow::graph g; B bnode(g); tbb::flow::function_node<int,int,tbb::flow::rejecting> fnode(g, tbb::flow::serial, serial_fn_body<int>(serial_fn_state0)); REMARK("Testing %s:", name); for(int icnt = 0; icnt < 2; icnt++) { bool reverse_edge = (icnt & 0x2) != 0; serial_fn_state0 = 0; // reset to waiting state. REMARK(" make_edge"); tbb::flow::make_edge(bnode, fnode); ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after make_edge"); REMARK(" try_put"); bnode.try_put(1); // will forward to the fnode BACKOFF_WAIT(serial_fn_state0 == 0, "Timed out waiting for first put"); if(reverse_edge) { REMARK(" try_put2"); bnode.try_put(2); // will reverse the edge // cannot do a wait_for_all here; the function_node is still executing BACKOFF_WAIT(!bnode.my_successors.empty(), "Timed out waiting after 2nd put"); // at this point the only task running is the one for the function_node. ASSERT(bnode.my_successors.empty(), "successor not removed"); } else { ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after forwarding message"); } serial_fn_state0 = 0; // release the function_node. if(reverse_edge) { // have to do a second release because the function_node will get the 2nd item BACKOFF_WAIT( serial_fn_state0 == 0, "Timed out waiting after 2nd put"); serial_fn_state0 = 0; // release the function_node. } g.wait_for_all(); REMARK(" remove_edge"); tbb::flow::remove_edge(bnode, fnode); ASSERT(bnode.my_successors.empty(), "buffering node has a successor after remove_edge"); } tbb::flow::join_node<tbb::flow::tuple<int,int>,tbb::flow::reserving> jnode(g); tbb::flow::make_edge(bnode, tbb::flow::input_port<0>(jnode)); // will spawn a task g.wait_for_all(); ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after attaching to join"); REMARK(" reverse"); bnode.try_put(1); // the edge should reverse g.wait_for_all(); ASSERT(bnode.my_successors.empty(), "buffering node has a successor after reserving"); REMARK(" reset()"); g.wait_for_all(); g.reset(); // should be in forward direction again ASSERT(!bnode.my_successors.empty(), "buffering node has no successor after reset()"); REMARK(" remove_edge"); g.reset(tbb::flow::rf_clear_edges); ASSERT(bnode.my_successors.empty(), "buffering node has a successor after reset(rf_clear_edges)"); tbb::flow::make_edge(bnode, tbb::flow::input_port<0>(jnode)); // add edge again // reverse edge by adding to buffer. bnode.try_put(1); // the edge should reverse g.wait_for_all(); ASSERT(bnode.my_successors.empty(), "buffering node has a successor after reserving"); REMARK(" remove_edge(reversed)"); g.reset(tbb::flow::rf_clear_edges); ASSERT(bnode.my_successors.empty(), "buffering node has no successor after reset()"); ASSERT(tbb::flow::input_port<0>(jnode).my_predecessors.empty(), "predecessor not reset"); REMARK(" done\n"); g.wait_for_all(); }
bool MeshTablesVolume<PFP>::importNodeWithELERegions(const std::string& filenameNode, const std::string& filenameELE, std::vector<std::string>& attrNames) { VertexAttribute<VEC3> position = m_map.template getAttribute<VEC3, VERTEX>("position") ; if (!position.isValid()) position = m_map.template addAttribute<VEC3, VERTEX>("position") ; attrNames.push_back(position.name()) ; AttributeContainer& container = m_map.template getAttributeContainer<VERTEX>() ; //open file std::ifstream fnode(filenameNode.c_str(), std::ios::in); if (!fnode.good()) { CGoGNerr << "Unable to open file " << filenameNode << CGoGNendl; return false; } std::ifstream fele(filenameELE.c_str(), std::ios::in); if (!fele.good()) { CGoGNerr << "Unable to open file " << filenameELE << CGoGNendl; return false; } std::string line; //Reading NODE file //First line: [# of points] [dimension (must be 3)] [# of attributes] [# of boundary markers (0 or 1)] unsigned int nbe; { do { std::getline(fnode,line); }while(line.size() == 0); std::stringstream oss(line); oss >> m_nbVertices; oss >> nbe; oss >> nbe; oss >> nbe; } //Reading number of tetrahedra in ELE file unsigned int nbv; { do { std::getline(fele,line); }while(line.size() == 0); std::stringstream oss(line); oss >> m_nbVolumes; oss >> nbv ; oss >> nbv; } //Reading vertices std::map<unsigned int,unsigned int> verticesMapID; for(unsigned int i = 0 ; i < m_nbVertices ; ++i) { do { std::getline(fnode,line); }while(line.size() == 0); std::stringstream oss(line); int idv; oss >> idv; float x,y,z; oss >> x; oss >> y; oss >> z; //we can read colors informations if exists VEC3 pos(x,y,z); unsigned int id = container.insertLine(); position[id] = pos; verticesMapID.insert(std::pair<unsigned int, unsigned int>(idv,id)); } // reading tetrahedra m_nbFaces.reserve(m_nbVolumes*4); m_emb.reserve(m_nbVolumes*12); for(unsigned i = 0; i < m_nbVolumes ; ++i) { do { std::getline(fele,line); } while(line.size() == 0); std::stringstream oss(line); oss >> nbe; m_nbFaces.push_back(4); int s0,s1,s2,s3; oss >> s0; oss >> s1; oss >> s2; oss >> s3; typename PFP::VEC3 P = position[verticesMapID[s0]]; typename PFP::VEC3 A = position[verticesMapID[s1]]; typename PFP::VEC3 B = position[verticesMapID[s2]]; typename PFP::VEC3 C = position[verticesMapID[s3]]; if (Geom::testOrientation3D<typename PFP::VEC3>(P,A,B,C) == Geom::UNDER) { int ui= s0; s0 = s3; s3 = s2; s2 = s1; s1 = ui; } m_emb.push_back(verticesMapID[s0]); m_emb.push_back(verticesMapID[s1]); m_emb.push_back(verticesMapID[s2]); m_emb.push_back(verticesMapID[s3]); } fnode.close(); fele.close(); return true; }
void ExportACache::save(const char* filename, int frameNumber, char bfirst) { MStatus status; FXMLScene xml_f; xml_f.begin(filename, frameNumber, bfirst); for(unsigned it=0; it<m_mesh_list.length(); it++) { m_mesh_list[it].extendToShape(); MString surface = m_mesh_list[it].partialPathName(); AHelper::validateFilePath(surface); MFnDependencyNode fnode(m_mesh_list[it].node()); MString smsg("prtMsg"); MStatus hasMsg; MPlug pmsg = fnode.findPlug( smsg, 1, &hasMsg ); char bNoChange = 0; if(hasMsg) { MObject oattrib; AHelper::getConnectedNode(oattrib, pmsg); fnode.setObject(oattrib); bool iattr = 0; AHelper::getBoolAttributeByName(fnode, "noChange", iattr); if(iattr) bNoChange = 1; } xml_f.meshBegin(surface.asChar(), bNoChange); MFnMesh meshFn(m_mesh_list[it], &status ); MItMeshPolygon faceIter(m_mesh_list[it], MObject::kNullObj, &status ); MItMeshVertex vertIter(m_mesh_list[it], MObject::kNullObj, &status); MItMeshEdge edgeIter(m_mesh_list[it], MObject::kNullObj, &status); int n_tri = 0; float f_area = 0; double area; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); n_tri += vexlist.length() - 2; faceIter.getArea( area, MSpace::kWorld ); f_area += (float)area; } xml_f.triangleInfo(n_tri, f_area); float avg_grid = sqrt(f_area/n_tri)/2; double light_intensity = 1.0; if(hasMsg) { MObject oattrib; AHelper::getConnectedNode(oattrib, pmsg); fnode.setObject(oattrib); bool iattr = 0; AHelper::getBoolAttributeByName(fnode, "noChange", iattr); if(iattr) xml_f.addAttribute("noChange", 1); AHelper::getBoolAttributeByName(fnode, "skipIndirect", iattr); if(iattr) xml_f.addAttribute("skipIndirect", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "skipScatter", iattr); if(iattr) xml_f.addAttribute("skipScatter", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "skipBackscatter", iattr); if(iattr) xml_f.addAttribute("skipBackscatter", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "asLightsource", iattr); if(iattr) xml_f.addAttribute("asLightsource", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "asGhost", iattr); if(iattr) xml_f.addAttribute("invisible", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "castNoShadow", iattr); if(iattr) xml_f.addAttribute("noShadow", 1); double td; if(AHelper::getDoubleAttributeByName(fnode, "lightIntensity", td)) light_intensity = td; fnode.setObject(m_mesh_list[it].node()); } xml_f.staticBegin(); int n_poly = meshFn.numPolygons(); int n_vert = meshFn.numVertices(); int* polycount = new int[n_poly]; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) polycount[ faceIter.index() ] = faceIter.polygonVertexCount(); xml_f.addFaceCount(n_poly, polycount); delete[] polycount; int n_facevertex = meshFn.numFaceVertices(); int* polyconnect = new int[n_facevertex]; int acc = 0; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); for( int i=vexlist.length()-1; i >=0; i-- ) { polyconnect[acc] = vexlist[i]; acc++; } } xml_f.addFaceConnection(n_facevertex, polyconnect); delete[] polyconnect; int* triconnect = new int[3*n_tri]; acc = 0; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); for( int i=vexlist.length()-2; i >0; i-- ) { triconnect[acc] = vexlist[vexlist.length()-1]; acc++; triconnect[acc] = vexlist[i]; acc++; triconnect[acc] = vexlist[i-1]; acc++; } } xml_f.addTriangleConnection(3*n_tri, triconnect); delete[] triconnect; if(meshFn.numUVSets() > 0) { MStringArray setNames; meshFn.getUVSetNames(setNames); for(unsigned i=0; i< setNames.length(); i++) { float* scoord = new float[n_facevertex]; float* tcoord = new float[n_facevertex]; acc = 0; faceIter.reset(); MFloatArray uarray, varray; if(faceIter.hasUVs (setNames[i], &status)) { for( ; !faceIter.isDone(); faceIter.next() ) { faceIter.getUVs ( uarray, varray, &setNames[i] ); for( int j=uarray.length()-1; j >=0 ; j-- ) { scoord[acc] = uarray[j]; tcoord[acc] = 1.0 - varray[j]; acc++; } } if(setNames[i] == "map1") { xml_f.uvSetBegin(setNames[i].asChar()); xml_f.addS("facevarying float s", meshFn.numFaceVertices(), scoord); xml_f.addT("facevarying float t", meshFn.numFaceVertices(), tcoord); xml_f.uvSetEnd(); } else { xml_f.uvSetBegin(setNames[i].asChar()); std::string paramname("facevarying float u_"); paramname.append(setNames[i].asChar()); xml_f.addS(paramname.c_str(), meshFn.numFaceVertices(), scoord); paramname = "facevarying float v_"; paramname.append(setNames[i].asChar()); xml_f.addT(paramname.c_str(), meshFn.numFaceVertices(), tcoord); xml_f.uvSetEnd(); } } else MGlobal::displayWarning(MString("Skip empty uv set: ") + setNames[i]); delete[] scoord; delete[] tcoord; } } MStringArray colorSetNames; meshFn.getColorSetNames (colorSetNames); for(unsigned int i=0; i<colorSetNames.length(); i++) { MStatus hasColor; XYZ *colors = new XYZ[n_vert]; vertIter.reset(); MString aset = colorSetNames[i]; MColor col; for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray conn_face; vertIter.getConnectedFaces(conn_face); vertIter.getColor(col, conn_face[0], &aset); colors[i].x = col.r*light_intensity; colors[i].y = col.g*light_intensity; colors[i].z = col.b*light_intensity; } xml_f.addVertexColor(aset.asChar(), n_vert, colors); delete[] colors; } //if(!bNoChange) { //} MPointArray p_vert; meshFn.getPoints ( p_vert, MSpace::kWorld ); MPoint corner_l(10e6, 10e6, 10e6); MPoint corner_h(-10e6, -10e6, -10e6); for( unsigned int i=0; i<p_vert.length(); i++) { if( p_vert[i].x < corner_l.x ) corner_l.x = p_vert[i].x; if( p_vert[i].y < corner_l.y ) corner_l.y = p_vert[i].y; if( p_vert[i].z < corner_l.z ) corner_l.z = p_vert[i].z; if( p_vert[i].x > corner_h.x ) corner_h.x = p_vert[i].x; if( p_vert[i].y > corner_h.y ) corner_h.y = p_vert[i].y; if( p_vert[i].z > corner_h.z ) corner_h.z = p_vert[i].z; } XYZ *cv = new XYZ[n_vert]; for( unsigned int i=0; i<p_vert.length(); i++) { cv[i].x = p_vert[i].x; cv[i].y = p_vert[i].y; cv[i].z= p_vert[i].z; } //if(!bNoChange) //else xml_f.addStaticP(n_vert, cv); XYZ *nor = new XYZ[n_vert]; XYZ *tang = new XYZ[n_vert]; vertIter.reset(); MVector vnor; for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { vertIter.getNormal(vnor, MSpace::kWorld); vnor.normalize(); nor[i].x = vnor.x; nor[i].y = vnor.y; nor[i].z = vnor.z; } MString uvset("map1"); vertIter.reset(); for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray conn_face; vertIter.getConnectedFaces(conn_face); MVector ctang(0,0,0); MVector ttang; for(unsigned j = 0; j<conn_face.length(); j++) { meshFn.getFaceVertexTangent (conn_face[j], i, ttang, MSpace::kWorld, &uvset); ttang.normalize(); ctang += ttang; } ctang.normalize(); tang[i].x = ctang.x; tang[i].y = ctang.y; tang[i].z = ctang.z; tang[i] = nor[i].cross(tang[i]); tang[i].normalize(); } //if(!bNoChange) //else xml_f.addStaticN(n_vert, nor); //xml_f.addTangent(n_vert, tang); // export per-vertex thickness float* vgrd = new float[n_vert]; int pidx; vertIter.reset(); for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray connfaces; vertIter.getConnectedFaces( connfaces ); float connarea = 0; for(unsigned j=0; j<connfaces.length(); j++) { faceIter.setIndex(connfaces[j], pidx); faceIter.getArea(area, MSpace::kWorld ); connarea += (float)area/faceIter.polygonVertexCount(); } vgrd[i] = sqrt(connarea)/2; if(vgrd[i] > avg_grid) vgrd[i] = avg_grid; } //if(!bNoChange) //else xml_f.addStaticGridSize(n_vert, vgrd); // //else xml_f.staticEnd(); if(!bNoChange) { xml_f.dynamicBegin(); xml_f.addP(n_vert, cv); xml_f.addN(n_vert, nor); xml_f.addGridSize(n_vert, vgrd); xml_f.dynamicEnd(); } delete[] cv; delete[] tang; delete[] nor; delete[] vgrd; xml_f.addBBox(corner_l.x, corner_l.y, corner_l.z, corner_h.x, corner_h.y, corner_h.z); xml_f.meshEnd(bNoChange); } /* disable nurbs for now float aspace[4][4]; for(unsigned it=0; it<m_nurbs_list.length(); it++) { MVector scale = AHelper::getTransformWorldNoScale(m_nurbs_list[it].fullPathName(), aspace); MString surfacename = m_nurbs_list[it].fullPathName(); AHelper::validateFilePath(surfacename); xml_f.transformBegin(surfacename.asChar(), aspace); xml_f.addScale(scale.x, scale.y, scale.z); m_nurbs_list[it].extendToShape(); surfacename = m_nurbs_list[it].fullPathName(); AHelper::validateFilePath(surfacename); MFnNurbsSurface fsurface(m_nurbs_list[it]); int degreeU = fsurface.degreeU(); int degreeV = fsurface.degreeV(); int formU, formV; if(fsurface.formInU() == MFnNurbsSurface::kOpen ) formU = 0; else if(fsurface.formInU() == MFnNurbsSurface::kClosed ) formU = 1; else formU = 2; if(fsurface.formInV() == MFnNurbsSurface::kOpen ) formV = 0; else if(fsurface.formInV() == MFnNurbsSurface::kClosed ) formV = 1; else formV = 2; xml_f.nurbssurfaceBegin(surfacename.asChar(), degreeU, degreeV, formU, formV); xml_f.staticBegin(); MPointArray p_cvs; fsurface.getCVs( p_cvs, MSpace::kObject ); unsigned n_cvs = p_cvs.length(); XYZ *cv = new XYZ[n_cvs]; for(unsigned i=0; i<n_cvs; i++) { cv[i].x = p_cvs[i].x; cv[i].y = p_cvs[i].y; cv[i].z= p_cvs[i].z; } xml_f.addStaticVec("cvs", n_cvs, cv); delete[] cv; MDoubleArray knotu, knotv; fsurface.getKnotsInU(knotu); fsurface.getKnotsInV(knotv); unsigned n_ku = knotu.length(); unsigned n_kv = knotv.length(); float *ku = new float[n_ku]; for(unsigned i=0; i<n_ku; i++) ku[i] = knotu[i]; float *kv = new float[n_kv]; for(unsigned i=0; i<n_kv; i++) kv[i] = knotv[i]; xml_f.addStaticFloat("knotu", n_ku, ku); xml_f.addStaticFloat("knotv", n_kv, kv); delete[] ku; delete[] kv; xml_f.staticEnd(); xml_f.nurbssurfaceEnd(); xml_f.transformEnd(); } */ xml_f.cameraBegin("backscat_camera", m_space); xml_f.cameraEnd(); xml_f.cameraBegin("eye_camera", m_eye); p_eye.extendToShape(); MFnCamera feye(p_eye); xml_f.addAttribute("focal_length", (float)feye.focalLength()); xml_f.addAttribute("horizontal_film_aperture", (float)feye.horizontalFilmAperture()); xml_f.addAttribute("vertical_film_aperture", (float)feye.verticalFilmAperture()); xml_f.addAttribute("near_clipping_plane", (float)feye.nearClippingPlane()); xml_f.addAttribute("far_clipping_plane", (float)feye.farClippingPlane()); xml_f.cameraEnd(); xml_f.end(filename); }
bool importNodeWithELERegions(typename PFP::MAP& map, const std::string& filenameNode, const std::string& filenameELE, std::vector<std::string>& attrNames) { typedef typename PFP::VEC3 VEC3; VertexAttribute<VEC3> position = map.template addAttribute<VEC3, VERTEX>("position") ; attrNames.push_back(position.name()) ; AttributeContainer& container = map.template getAttributeContainer<VERTEX>() ; unsigned int m_nbVertices = 0, m_nbFaces = 0, m_nbEdges = 0, m_nbVolumes = 0; VertexAutoAttribute< NoMathIONameAttribute< std::vector<Dart> > > vecDartsPerVertex(map, "incidents"); //open file std::ifstream fnode(filenameNode.c_str(), std::ios::in); if (!fnode.good()) { CGoGNerr << "Unable to open file " << filenameNode << CGoGNendl; return false; } std::ifstream fele(filenameELE.c_str(), std::ios::in); if (!fele.good()) { CGoGNerr << "Unable to open file " << filenameELE << CGoGNendl; return false; } std::string line; // do // { // std::getline(fnode,line); // }while(line.rfind("#") == 0); //Reading NODE file //First line: [# of points] [dimension (must be 3)] [# of attributes] [# of boundary markers (0 or 1)] unsigned int nbe; { do { std::getline(fnode,line); }while(line.size() == 0); std::stringstream oss(line); oss >> m_nbVertices; oss >> nbe; oss >> nbe; oss >> nbe; } //Reading number of tetrahedra in ELE file unsigned int nbv; { do { std::getline(fele,line); }while(line.size() == 0); std::stringstream oss(line); oss >> m_nbVolumes; oss >> nbv ; oss >> nbv; } CGoGNout << "nb points = " << m_nbVertices << " / nb faces = " << m_nbFaces << " / nb edges = " << m_nbEdges << " / nb tet = " << m_nbVolumes << CGoGNendl; //Reading vertices //Remaining lines: [point #] [x] [y] [z] [optional attributes] [optional boundary marker] std::vector<unsigned int> verticesID; verticesID.reserve(m_nbVertices); for(unsigned int i = 0 ; i < m_nbVertices ; ++i) { do { std::getline(fnode,line); }while(line.size() == 0); std::stringstream oss(line); int idv; oss >> idv; float x,y,z; oss >> x; oss >> y; oss >> z; //we can read colors informations if exists VEC3 pos(x,y,z); unsigned int id = container.insertLine(); position[id] = pos; verticesID.push_back(id); } std::vector<std::vector<Dart> > vecDartPtrEmb; vecDartPtrEmb.reserve(m_nbVertices); DartMarkerNoUnmark m(map) ; //Read and embed tetrahedra TODO for(unsigned i = 0; i < m_nbVolumes ; ++i) { do { std::getline(fele,line); } while(line.size() == 0); std::stringstream oss(line); oss >> nbe; Dart d = Algo::Modelisation::createTetrahedron<PFP>(map); Geom::Vec4ui pt; oss >> pt[0]; --(pt[0]); oss >> pt[1]; --(pt[1]); oss >> pt[2]; --(pt[2]); oss >> pt[3]; --(pt[3]); //regions ? //oss >> nbe; // Embed three vertices for(unsigned int j = 0 ; j < 3 ; ++j) { FunctorSetEmb<typename PFP::MAP, VERTEX> fsetemb(map, verticesID[pt[2-j]]); map.template foreach_dart_of_orbit<PFP::MAP::VERTEX_OF_PARENT>(d, fsetemb); //store darts per vertices to optimize reconstruction Dart dd = d; do { m.mark(dd) ; vecDartsPerVertex[pt[2-j]].push_back(dd); dd = map.phi1(map.phi2(dd)); } while(dd != d); d = map.phi1(d); } //Embed the last vertex d = map.phi_1(map.phi2(d)); FunctorSetEmb<typename PFP::MAP, VERTEX> fsetemb(map, verticesID[pt[3]]); map.template foreach_dart_of_orbit<PFP::MAP::VERTEX_OF_PARENT>(d, fsetemb); //store darts per vertices to optimize reconstruction Dart dd = d; do { m.mark(dd) ; vecDartsPerVertex[pt[3]].push_back(dd); dd = map.phi1(map.phi2(dd)); } while(dd != d); } fnode.close(); fele.close(); //Association des phi3 unsigned int nbBoundaryFaces = 0 ; for (Dart d = map.begin(); d != map.end(); map.next(d)) { if (m.isMarked(d)) { std::vector<Dart>& vec = vecDartsPerVertex[map.phi1(d)]; Dart good_dart = NIL; for(typename std::vector<Dart>::iterator it = vec.begin(); it != vec.end() && good_dart == NIL; ++it) { if(map.template getEmbedding<VERTEX>(map.phi1(*it)) == map.template getEmbedding<VERTEX>(d) && map.template getEmbedding<VERTEX>(map.phi_1(*it)) == map.template getEmbedding<VERTEX>(map.phi_1(d)) /*&& map.template getEmbedding<VERTEX>(*it) == map.template getEmbedding<VERTEX>(map.phi1(d)) */) { good_dart = *it ; } } if (good_dart != NIL) { map.sewVolumes(d, good_dart, false); m.template unmarkOrbit<FACE>(d); } else { m.unmarkOrbit<PFP::MAP::FACE_OF_PARENT>(d); ++nbBoundaryFaces; } } } if (nbBoundaryFaces > 0) { std::cout << "closing" << std::endl ; map.closeMap(); CGoGNout << "Map closed (" << nbBoundaryFaces << " boundary faces)" << CGoGNendl; } return true; }