int main() { const int D = 5; // we work in Euclidean 5-space const int N = 100; // we will insert 100 points // - - - - - - - - - - - - - - - - - - - - - - - - STEP 1 CGAL::Random_points_in_cube_d<Triangulation::Point> rand_it(D, 1.0); std::vector<Triangulation::Point> points; CGAL::cpp11::copy_n(rand_it, N, std::back_inserter(points)); Triangulation t(D); // create triangulation CGAL_assertion(t.empty()); t.insert(points.begin(), points.end()); // compute triangulation CGAL_assertion( t.is_valid() ); // - - - - - - - - - - - - - - - - - - - - - - - - STEP 2 typedef Triangulation::Face Face; typedef std::vector<Face> Faces; Faces edges; std::back_insert_iterator<Faces> out(edges); t.tds().incident_faces(t.infinite_vertex(), 1, out); // collect faces of dimension 1 (edges) incident to the infinite vertex std::cout << "There are " << edges.size() << " vertices on the convex hull." << std::endl; #include "triangulation1.cpp" // See below #include "triangulation2.cpp" return 0; }
void MDAL::DriverFlo2D::createMesh( const std::vector<CellCenter> &cells, double half_cell_size ) { // Create all Faces from cell centers. // Vertexs must be also created, they are not stored in FLO-2D files // try to reuse Vertexs already created for other Faces by usage of unique_Vertexs set. Faces faces; Vertices vertices; std::map<Vertex, size_t, VertexCompare> unique_vertices; //vertex -> id size_t vertex_idx = 0; for ( size_t i = 0; i < cells.size(); ++i ) { Face e( 4 ); for ( size_t position = 0; position < 4; ++position ) { Vertex n = createVertex( position, half_cell_size, cells[i] ); const auto iter = unique_vertices.find( n ); if ( iter == unique_vertices.end() ) { unique_vertices[n] = vertex_idx; vertices.push_back( n ); e[position] = vertex_idx; ++vertex_idx; } else { e[position] = iter->second; } } faces.push_back( e ); } mMesh.reset( new MemoryMesh( name(), vertices.size(), faces.size(), 4, //maximum quads computeExtent( vertices ), mDatFileName ) ); mMesh->faces = faces; mMesh->vertices = vertices; }
int incorrect_input(std::string error = "") { std::cerr << "Incorrect input file.\n" << " " << error << "\n"; std::cerr << "So far: " << vertices.size() << " vertices, " << faces.size() << " faces\n"; return EXIT_FAILURE; }
void generateTriangles(const unsigned xdiv, const unsigned ydiv, Faces& faces) { const unsigned xpts(xdiv + 1); // number of points in x const unsigned NF(2 * xdiv * ydiv); // total number of faces faces.reserve(NF); for(unsigned y(0); y != ydiv; ++y) for(unsigned x(0); x != xdiv; ++x) { const unsigned a(y * xpts + x); const unsigned b(a + 1); const unsigned c(b + xdiv); const unsigned d(c + 1); faces.push_back(Trig(a, b, d)); faces.push_back(Trig(a, d, c)); } assert(faces.size() == NF); }
void print() { std::cout << "MeshData:: " << std::endl << "Vertices : " << std::endl; for (int i = 0; i < m_Vertices.size(); i++) { std::cout << i << ": " << m_Vertices[i] << std::endl; } std::cout << "Indices & Normals : " << std::endl; for (int i = 0; i < m_Faces.size(); i++) { std::cout << i << ": " << m_Faces[i] << "\t n:" << m_Normals[i] << std::endl; } };
void draw(const int tex, const Mesh& mesh, const Mesh& tc, const Faces& faces) { assert(tex != 0); assert(not mesh.empty()); assert(mesh.size() == tc.size()); assert(not faces.empty()); const cgl::BindTexture2D bind(tex); glTexCoordPointer(2, GL_FLOAT, 0, &tc.front().x); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glVertexPointer(2, GL_FLOAT, 0, &mesh.front().x); glEnableClientState(GL_VERTEX_ARRAY); glDrawElements(GL_TRIANGLES, faces.size() * 3, GL_UNSIGNED_INT, &faces.front().a); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); }
void writeToLog(Logging::Log* plog) { std::stringstream logmessage; using std::endl; using std::cout; logmessage << "MeshData:: " << std::endl << "Vertices : " << std::endl; for (int i = 0; i < m_Vertices.size(); i++) { logmessage << i << ": " << m_Vertices[i] << endl; } logmessage << "Indices & Normals : " << endl; for (int i = 0; i < m_Faces.size(); i++) { logmessage << i << ": " << m_Faces[i] << "\t n:" << m_Normals[i] << std::endl; } plog->logMessage(logmessage.str()); };
void setup(size_t& vertex_count, Ogre::Vector3* vertices, size_t& index_count, unsigned long* indices, double scale) { // If we add more Objects we need an Offset for the Indices std::size_t indices_offset = m_Vertices.size(); Vector3 temp; for (int i = 0; i < vertex_count; i++) { temp << vertices[i].x / (Ogre::Real)scale, vertices[i].y / (Ogre::Real)scale, vertices[i].z / (Ogre::Real)scale; m_Vertices.push_back(temp); } for (int i = 0; i < index_count; i += 3) { Eigen::Matrix<unsigned long, 3, 1> temp; temp << (unsigned long)(indices[i] + indices_offset), (unsigned long)(indices[i + 1] + indices_offset), (unsigned long)(indices[i + 2] + indices_offset); m_Faces.push_back(temp); // Calculate the normal to each triangle: // m_Normals.push_back(Ogre::Math::calculateBasicFaceNormal(m_Vertices[indices[i]],m_Vertices[indices[i+1]],m_Vertices[indices[i+2]])); } };
void MDAL::Driver3Di::populateFacesAndVertices( Vertices &vertices, Faces &faces ) { assert( vertices.empty() ); size_t faceCount = mDimensions.size( CFDimensions::Face2D ); faces.resize( faceCount ); size_t verticesInFace = mDimensions.size( CFDimensions::MaxVerticesInFace ); size_t arrsize = faceCount * verticesInFace; std::map<std::string, size_t> xyToVertex2DId; // X coordinate int ncidX = mNcFile.getVarId( "Mesh2DContour_x" ); double fillX = mNcFile.getFillValue( ncidX ); std::vector<double> faceVerticesX( arrsize ); if ( nc_get_var_double( mNcFile.handle(), ncidX, faceVerticesX.data() ) ) throw MDAL_Status::Err_UnknownFormat; // Y coordinate int ncidY = mNcFile.getVarId( "Mesh2DContour_y" ); double fillY = mNcFile.getFillValue( ncidY ); std::vector<double> faceVerticesY( arrsize ); if ( nc_get_var_double( mNcFile.handle(), ncidY, faceVerticesY.data() ) ) throw MDAL_Status::Err_UnknownFormat; // now populate create faces and backtrack which vertices // are used in multiple faces for ( size_t faceId = 0; faceId < faceCount; ++faceId ) { Face face; for ( size_t faceVertexId = 0; faceVertexId < verticesInFace; ++faceVertexId ) { size_t arrId = faceId * verticesInFace + faceVertexId; Vertex vertex; vertex.x = faceVerticesX[arrId]; vertex.y = faceVerticesY[arrId]; vertex.z = 0; if ( MDAL::equals( vertex.x, fillX ) || MDAL::equals( vertex.y, fillY ) ) break; size_t vertexId; std::string key = std::to_string( vertex.x ) + "," + std::to_string( vertex.y ); const auto it = xyToVertex2DId.find( key ); if ( it == xyToVertex2DId.end() ) { // new vertex vertexId = vertices.size(); xyToVertex2DId[key] = vertexId; vertices.push_back( vertex ); } else { // existing vertex vertexId = it->second; } face.push_back( vertexId ); } faces[faceId] = face; } // Only now we have number of vertices, since we identified vertices that // are used in multiple faces mDimensions.setDimension( CFDimensions::Vertex2D, vertices.size() ); }
boost_foreach(Faces& entities, find_components_recursively<Faces>( *comp ) ) { entities.create_space(space_lib_name+"."+entities.element_type().shape_name(),*dict); }
void ObjectToFile::readObjects(const char* address){ //FILE * file = fopen(address.c_str(), "rb"); FILE * file = fopen(address, "rb"); char c; float values_x = 0, values_y = 0, values_z = 0; long int v_index[3]={0}, vt_index[3]={0}, vn_index[3]={0}, without_texture; int regular_expression_type = 0; char type; without_texture = -100; string number; Points *point_v, *point_vt, *point_vn; //vertex, texture vertex, normal vertex IntegerPoints *left_index, *middle_index, *right_index; //every IntegerPoint have 3 long it Faces *faces; vector<Points*> vector_v, vector_vt, vector_vn; //Arraylist of Points //VertexBuffer *vertexBuffer; faces = new Faces(); printf("\nLoading object in file..."); if(file == NULL) { printf("Impossible to open the file! Are you in the right path ?\n"); printf("Exit...\n"); } else { printf("\n"); while(!feof(file)){ //Read until end file c = fgetc(file); //get first character //Verify if the line starts with v if(c == 'v') { //get this line in file fscanf(file, "%c %f %f %f", &type, &values_x, &values_y, &values_z); switch(type) {//Verify if type is vertex, vertex texture, vertex normal or face. case 't': //Get the Vertex Texture point_vt = new Points(values_x, values_y, values_z); vector_vt.push_back(point_vt); break;//End vertex texture case 'n': //get the Vertex Normal point_vn = new Points(values_x, values_y, values_z); vector_vn.push_back(point_vn); break; default: //get the Vertex if(type == ' '){//Verifica se o proximo espaço é vazio para não pegar valores errados no arquivo point_v = new Points(values_x, values_y, values_z); vector_v.push_back(point_v); } break; }//end switch }//end get v //check if the head of line is by Face. else if(c == 'f') { c = fgetc(file); if(c == ' '){ //check first line number = selectNumberInLine(file); v_index[0] = atol(number.c_str()); //number.c_str() convert string to const char* number = ""; c = fgetc(file); if(c == '/') { regular_expression_type = 2; fscanf(file, "%ld %ld//%ld %ld//%ld", &vn_index[0], &v_index[1], &vn_index[1], &v_index[2], &vn_index[2]); left_index = new IntegerPoints(v_index[0], without_texture, vn_index[0], regular_expression_type); middle_index = new IntegerPoints(v_index[1], without_texture, vn_index[1], regular_expression_type); right_index = new IntegerPoints(v_index[2], without_texture, vn_index[2], regular_expression_type); faces->addAllGroupsInteger(left_index, middle_index, right_index); } else { number += c; number += selectNumberInLine(file); vt_index[0] = atol(number.c_str()); number = ""; regular_expression_type = 3; fscanf(file, "%ld %ld/%ld/%ld %ld/%ld/%ld", &vn_index[0], &v_index[1], &vt_index[1], &vn_index[1], &v_index[2], &vt_index[2], &vn_index[2]); left_index = new IntegerPoints(v_index[0], vt_index[0], vn_index[0], regular_expression_type); middle_index = new IntegerPoints(v_index[1],vt_index[1], vn_index[1], regular_expression_type); right_index = new IntegerPoints(v_index[2], vt_index[2], vn_index[2], regular_expression_type); faces->addAllGroupsInteger(left_index, middle_index, right_index); }//End else to integers with 3 numbers }//End if to verify the next step is empty space }//End if to "faces" objects }//End to while //Organizing the vertex by Faces setVertex(vector_v); setTextureVertex(vector_vt); setNormalVertex(vector_vn); faces->organizeVertexByFaces(faces, vector_v, vector_vt, vector_vn); setFaces(faces); }//End if read Object }
void test(const int d, const string & type, const int N) { // we must write 'typename' below, because we are in a template-function, // so the parser has no way to know that DC contains sub-types, before // instanciating the function. typedef typename DC::Full_cell_handle Full_cell_handle; typedef typename DC::Face Face; typedef typename DC::Point Point; typedef typename DC::Finite_full_cell_const_iterator Finite_full_cell_const_iterator; typedef typename DC::Finite_vertex_iterator Finite_vertex_iterator; typedef CGAL::Random_points_in_cube_d<Point> Random_points_iterator; DC pc(d); cerr << "\nBuilding Delaunay triangulation of (" << type << d << ") dimension with " << N << " points"; assert(pc.empty()); vector<Point> points; CGAL::Random rng; Random_points_iterator rand_it(d, 2.0, rng); //CGAL::cpp11::copy_n(rand_it, N, back_inserter(points)); vector<int> coords(d); for( int i = 0; i < N; ++i ) { for( int j = 0; j < d; ++j ) coords[j] = rand() % 100000; points.push_back(Point(d, coords.begin(), coords.end())); } pc.insert(points.begin(), points.end()); cerr << "\nChecking topology and geometry..."; assert( pc.is_valid() ); cerr << "\nTraversing finite full_cells... "; size_t nbfs(0), nbis(0); Finite_full_cell_const_iterator fsit = pc.finite_full_cells_begin(); while( fsit != pc.finite_full_cells_end() ) ++fsit, ++nbfs; cerr << nbfs << " + "; vector<Full_cell_handle> infinite_full_cells; pc.tds().incident_full_cells(pc.infinite_vertex(), back_inserter(infinite_full_cells)); nbis = infinite_full_cells.size(); cerr << nbis << " = " << (nbis+nbfs) << " = " << pc.number_of_full_cells(); cerr << "\nThe triangulation has current dimension " << pc.current_dimension(); CGAL_assertion( pc.number_of_full_cells() == nbis+nbfs); cerr << "\nTraversing finite vertices... "; size_t nbfv(0); Finite_vertex_iterator fvit = pc.finite_vertices_begin(); while( fvit != pc.finite_vertices_end() ) ++fvit, ++nbfv; cerr << nbfv <<endl; // Count convex hull vertices: if( pc.maximal_dimension() > 1 ) { typedef vector<Face> Faces; Faces edges; back_insert_iterator<Faces> out(edges); pc.tds().incident_faces(pc.infinite_vertex(), 1, out); cout << "\nThere are " << edges.size() << " vertices on the convex hull."; edges.clear(); } else // pc.maximal_dimension() == 1 { typedef vector<Full_cell_handle> Cells; Cells cells; back_insert_iterator<Cells> out(cells); pc.tds().incident_full_cells(pc.infinite_vertex(), out); cout << "\nThere are " << cells.size() << " vertices on the convex hull."; cells.clear(); } // Remove all ! cerr << "\nBefore removal: " << pc.number_of_vertices() << " vertices. After: "; random_shuffle(points.begin(), points.end()); pc.remove(points.begin(), points.end()); assert( pc.is_valid() ); cerr << pc.number_of_vertices() << " vertices."; // assert( pc.empty() ); NOT YET ! // CLEAR pc.clear(); assert( -1 == pc.current_dimension() ); assert( pc.empty() ); assert( pc.is_valid() ); }
int main(int argc,char *argv[]){ if(argc<2){ std::cerr<< "usage: "<<argv[0]<<" input_file"<<std::endl; exit(-1); } std::fstream infile; Point p; size_t index=0; std::vector<Point> points; #ifdef USE_HASHED_DETERMINANTS HD Pdets; #endif infile.open(argv[1],std::fstream::in); int dim=0; while(infile>>p){ dim=p.dimension(); #ifdef USE_HASHED_DETERMINANTS p.set_index(index++); p.set_hash(&Pdets); #endif points.push_back(p); #ifdef USE_HASHED_DETERMINANTS // now we have to add the point to the hash table std::vector<CGAL::Gmpq> column; for(size_t i=0;i<dim;++i) column.push_back(p[i]); Pdets.add_column(column); #endif } infile.close(); clock_t elapsed_offline,elapsed_online; Triangulation triang_offline(dim),triang_online(dim); clock_t start=clock(); //for(size_t i=0;i<points.size();++i) // triang_offline.insert(points[i]); elapsed_offline=clock()-start; start=clock(); triang_online.insert(points.begin(),points.end()); elapsed_online=clock()-start; typedef Triangulation::Face Face; typedef std::vector<Face> Faces; Faces edges; std::back_insert_iterator<Faces> out(edges); triang_online.incident_faces(triang_online.infinite_vertex(),1,out); std::cerr<<dim<<'\t'<< points.size()<<'\t'<< //(double)elapsed_offline/CLOCKS_PER_SEC<<'\t'<< .0<<'\t'<< (double)elapsed_online/CLOCKS_PER_SEC<<'\t'<< edges.size()<<'\t'<< #ifdef USE_HASHED_DETERMINANTS points[0].hash()->algorithm()<< #else "no_hash"<< #endif std::endl; //edges.clear(); return 0; }
void test(const int d, const string & type) { // we must write 'typename' below, because we are in a template-function, // so the parser has no way to know that TDS contains sub-types, before // instanciating the function. typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Vertex_iterator Vertex_iterator; typedef typename TDS::Full_cell_handle Full_cell_handle; typedef typename TDS::Face Face; typedef typename TDS::Facet Facet; typedef typename TDS::Facet_iterator Facet_iterator; TDS tds(d); cout << "\nChecking Tds of (" << type << ") dimension " << tds.maximal_dimension(); assert(tds.empty()); vector<Vertex_handle> vhs; vhs.push_back(tds.insert_increase_dimension()); assert( tds.is_valid() ); size_t nb_verts = 1; for( int i = 0; i <= d; ++i ) { vhs.push_back(tds.insert_increase_dimension(vhs[0])); ++nb_verts; assert(i == tds.current_dimension()); assert(!tds.is_vertex(Vertex_handle())); assert(!tds.is_full_cell(Full_cell_handle())); assert(tds.is_vertex(vhs[i])); assert(tds.is_full_cell(vhs[i]->full_cell())); if( tds.current_dimension() > 0 ) { //int nbs = tds.number_of_full_cells(); tds.insert_in_full_cell(tds.full_cell(vhs[i+1])); ++nb_verts; //assert((size_t)(nbs+tds.current_dimension())==tds.number_of_full_cells()); } assert( tds.is_valid() ); } assert((nb_verts == tds.number_of_vertices())); if( d > 1 ) { // insert in hole std::vector<Full_cell_handle> simps; simps.push_back(tds.full_cells_begin()); simps.push_back(tds.neighbor(simps[0],0)); tds.insert_in_hole(simps.begin(), simps.end(), Facet(simps[0],1)); } // TEST Faces enumeration typedef std::vector<Face> Faces; Faces faces; for( Vertex_iterator vit = tds.vertices_begin(); vit != tds.vertices_end(); ++vit ) { for( int d = 1; d < tds.current_dimension() - 1; ++d ) { //cout << '\n' << d << "-dimensional faces adjacent to " << &(*vit) // << " ( current dimension is " << tds.current_dimension() << " )"; faces.clear(); std::back_insert_iterator<Faces> out(faces); tds.incident_faces(vit, d, out); typename Faces::iterator fit = faces.begin(); while( fit != faces.end() ) { //cout << '\n'; //for( int i = 0; i <= d; ++i ) // cout << ' ' << &(*fit->vertex(i)); ++fit; } } } // TEST Finite iterators if( tds.current_dimension() > 0 ) { Facet_iterator fit = tds.facets_begin(); size_t nbfft(0); while( fit != tds.facets_end() ) ++fit, ++nbfft; cout << '\n' << tds.number_of_full_cells() << " full cells, "; cout << ' ' << nbfft << " facets."; } // TEST File I/O std::ofstream fo((string("output-tds-")+type).c_str()); if( d % 2 ) CGAL::set_binary_mode(fo); fo << tds; fo.close(); std::ifstream fi((string("output-tds-")+type).c_str()); if( d % 2 ) CGAL::set_binary_mode(fi); TDS input_tds(d); fi >> input_tds; fi.close(); // TEST Copy Constructor TDS tds2(tds); assert( tds2.is_valid() ); assert( tds.current_dimension() == tds2.current_dimension() ); assert( tds.maximal_dimension() == tds2.maximal_dimension() ); assert( tds.number_of_vertices() == tds2.number_of_vertices() ); assert( tds.number_of_full_cells() == tds2.number_of_full_cells() ); // CLEAR tds.clear(); assert(-2==tds.current_dimension()); assert(tds.empty()); assert( tds.is_valid() ); }
int main(int argc, char** argv) { if(argc != 3) return usage(argv[0]); mark_tag vertex_index(1), vertex_x(2), vertex_y(3), vertex_z(4); sregex tface_re = bos >> *space >> "TFACE" >> *space >> eos; sregex vertex_re = bos >> *space >> "VRTX" >> +space >> (vertex_index=+_d) >> +space >> (vertex_x=+(digit|'-'|'+'|'.')) >> +space >> (vertex_y=+(digit|'-'|'+'|'.')) >> +space >> (vertex_z=+(digit|'-'|'+'|'.')) >> eos; sregex triangle_re = bos >> *space >> "TRGL" >> +space >> (s1=+digit) >> +space >> (s2=+digit) >> +space >> (s3=+digit) >> eos; sregex end_re = bos >> *space >> "END" >> *space >> eos; std::ifstream input(argv[1]); std::ofstream output(argv[2]); if(!input) { std::cerr << "Cannot read \"" << argv[1] << "\"!\n"; return EXIT_FAILURE; } if(!output) { std::cerr << "Cannot write to \"" << argv[2] << "\"!\n"; return EXIT_FAILURE; } std::string line; std::getline(input, line); smatch results; while(input && ! regex_match(line, tface_re)) // search line "TFACE" { std::getline(input, line); } std::getline(input, line); while(input && regex_match(line, results, vertex_re)) { vertices.push_back(boost::make_tuple(results[vertex_x], results[vertex_y], results[vertex_z])); std::getline(input, line); } while(input && regex_match(line, results, triangle_re)) { std::stringstream s; int i, j, k; s << results[1] << " " << results[2] << " " << results[3]; s >> i >> j >> k; faces.push_back(boost::make_tuple(i, j, k)); std::getline(input, line); } if(!input || !regex_match(line, end_re)) return incorrect_input("premature end of file!"); output << "OFF " << vertices.size() << " " << faces.size() << " " << "0\n"; for(Vertices::const_iterator vit = vertices.begin(), vend = vertices.end(); vit != vend; ++vit) output << boost::get<0>(*vit) << " " << boost::get<1>(*vit) << " " << boost::get<2>(*vit) << "\n"; for(Faces::const_iterator fit = faces.begin(), fend = faces.end(); fit != fend; ++fit) output << "3 " << boost::get<0>(*fit) << " " << boost::get<1>(*fit) << " " << boost::get<2>(*fit) << "\n"; if(output) return EXIT_SUCCESS; else return EXIT_FAILURE; };
static void validateModel(Faces & facesToBeValidated ) { std::vector<AbsFace*> faces = facesToBeValidated.faces(); std::vector<gml::Point3D> points = facesToBeValidated.points(); bool find=false; std::vector< std::vector<gml::Point3D> > edges; // Edges' construction for (int i=0 ; i<(int) faces.size() ; i++) { std::vector <int> & indexes = *( faces[i]->getIndexes() ); for (int j=0 ; j< (int) indexes.size(); j++) { std::vector <gml::Point3D> temp; temp.push_back( points[ indexes[j] ] ); if (j+1 == (int) (indexes.size()) ) { temp.push_back( points[indexes[0]] ); } else { temp.push_back( points[indexes[j+1]] ); } // Test if the found edge is not already in the vector edges int k=0; while (k<(int)edges.size() && !find) { // Exact comparaison if ((edges[k][0][0] == temp[0][0] && edges[k][0][1] == temp[0][1] && edges[k][0][2] == temp[0][2] && edges[k][1][0] == temp[1][0] && edges[k][1][1] == temp[1][1] && edges[k][1][2] == temp[1][2]) || (edges[k][0][0] == temp[1][0] && edges[k][0][1] == temp[1][1] && edges[k][0][2] == temp[1][2] && edges[k][1][0] == temp[0][0] && edges[k][1][1] == temp[0][1] && edges[k][1][2] == temp[0][2])) { find = true; } else { k++; } } k=0; if (!find) { edges.push_back(temp); } else { find = false; } } } edgesIntersections(edges); facesOnSamePlan(faces, points); edgesCutFaces(faces, edges, points); }
// greebo: TODO: Make this a member method of the Brush class bool Brush_merge(Brush& brush, const BrushPtrVector& in, bool onlyshape) { // gather potential outer faces typedef std::vector<const Face*> Faces; Faces faces; for (BrushPtrVector::const_iterator i(in.begin()); i != in.end(); ++i) { (*i)->getBrush().evaluateBRep(); for (Brush::const_iterator j((*i)->getBrush().begin()); j != (*i)->getBrush().end(); ++j) { if (!(*j)->contributes()) { continue; } const Face& face1 = *(*j); bool skip = false; // test faces of all input brushes //!\todo SPEEDUP: Flag already-skip faces and only test brushes from i+1 upwards. for (BrushPtrVector::const_iterator k(in.begin()); !skip && k != in.end(); ++k) { if (k != i) { // don't test a brush against itself for (Brush::const_iterator l((*k)->getBrush().begin()); !skip && l != (*k)->getBrush().end(); ++l) { const Face& face2 = *(*l); // face opposes another face if (face1.plane3() == -face2.plane3()) { // skip opposing planes skip = true; break; } } } } // check faces already stored for (Faces::const_iterator m = faces.begin(); !skip && m != faces.end(); ++m) { const Face& face2 = *(*m); // face equals another face if (face1.plane3() == face2.plane3()) { // if the texture/shader references should be the same but are not if (!onlyshape && !shader_equal( face1.getFaceShader().getMaterialName(), face2.getFaceShader().getMaterialName() )) { return false; } // skip duplicate planes skip = true; break; } // face1 plane intersects face2 winding or vice versa if (Winding::planesConcave(face1.getWinding(), face2.getWinding(), face1.plane3(), face2.plane3())) { // result would not be convex return false; } } if (!skip) { faces.push_back(&face1); } } } for (Faces::const_iterator i = faces.begin(); i != faces.end(); ++i) { if (!brush.addFace(*(*i))) { // result would have too many sides return false; } } brush.removeEmptyFaces(); return true; }
void SleepDetector::operator()( cv::Mat & src ) { cv::Mat gray; cv::cvtColor(src, gray, CV_BGR2GRAY); cv::equalizeHist(gray, gray); typedef std::vector<cv::Rect> Faces; Faces faces; m_faceCascade.detectMultiScale(gray, faces, 1.1, 3, CV_HAAR_SCALE_IMAGE|CV_HAAR_FIND_BIGGEST_OBJECT, cv::Size(30, 30)); unsigned int subjectiveAlertness = 0; // start out with the lowest alertness. #if defined(NDEBUG) if (!faces.empty()) { subjectiveAlertness += 1; const cv::Mat && faceROI = gray(faces[0]); typedef std::vector<cv::Rect> Eyes; Eyes eyes; m_eyesCascade.detectMultiScale(faceROI, eyes, 1.1, 3, CV_HAAR_SCALE_IMAGE, cv::Size(30, 30)); subjectiveAlertness += eyes.size() > 1 ? 1 : 0; } #else std::for_each( faces.cbegin(), faces.cend(), [&](const Faces::value_type & face) { ++subjectiveAlertness; cv::ellipse( src, cv::Point(face.x + face.width*0.5, face.y + face.height*0.5), cv::Size(face.width*0.5, face.height*0.5), 0, 0, 360, cv::Scalar(0, 255, 127), 4, 8, 0); const cv::Mat && faceROI = gray(face); typedef std::vector<cv::Rect> Eyes; Eyes eyes; m_eyesCascade.detectMultiScale(faceROI, eyes, 1.1, 3, CV_HAAR_SCALE_IMAGE, cv::Size(30, 30)); subjectiveAlertness += eyes.size() > 1 ? 1 : 0; std::for_each( eyes.cbegin(), eyes.cend(), [&](const Eyes::value_type & eye) { cv::circle( src, cv::Point((face.x + eye.x + eye.width*0.5), (face.y + eye.y + eye.height*0.5)), cvRound((eye.width + eye.height) * 0.25), cv::Scalar(127, 0, 127), 4, 8, 0); }); }); #endif switch (subjectiveAlertness) { case 2: m_awareness->onStaring(src); break; case 1: m_awareness->onBlink(src); break; default: m_awareness->onNotLooking(src); break; } }
void Field::writeCellDataToVTK( std::ostream& fs, const Faces& faces ) const { fs << "CELL_DATA " << faces.nActive() << std::endl; fs << "SCALARS " << _name << " double " << _nDim << std::endl; if ( _nDim == 1 ) { for (int i = 0; i < faces.N(); ++i ) { if ( faces.isActive(i) ) { std::vector<int> faceVerts = faces.vertices(i); for ( int j = 0; j < faces.nVerts(i); ++j) { double subTriAvg = scalar[ faces.centerParticle(i) ]; subTriAvg += scalar[ faceVerts[j] ] + scalar[ faceVerts[(j+1)%faces.nVerts(i)] ]; subTriAvg /= 3.0; fs << subTriAvg << std::endl; } } } } else if ( _nDim == 2 ) { for (int i = 0; i < faces.N(); ++i ) { if ( faces.isActive(i) ) { std::vector<int> faceVerts = faces.vertices(i); for ( int j = 0; j < faces.nVerts(i); ++j) { double subTriAvgX = xComp[ faces.centerParticle(i) ]; double subTriAvgY = yComp[ faces.centerParticle(i) ]; subTriAvgX += xComp[ faceVerts[j] ] + xComp[ faceVerts[(j+1)%faces.nVerts(i)] ]; subTriAvgY += yComp[ faceVerts[j] ] + yComp[ faceVerts[(j+1)%faces.nVerts(i)] ]; subTriAvgX /= 3.0; subTriAvgY /= 3.0; fs << subTriAvgX << " " << subTriAvgY << std::endl; } } } } else { for (int i = 0; i < faces.N(); ++i ) { if ( faces.isActive(i) ) { std::vector<int> faceVerts = faces.vertices(i); for ( int j = 0; j < faces.nVerts(i); ++j) { double subTriAvgX = xComp[ faces.centerParticle(i) ]; double subTriAvgY = yComp[ faces.centerParticle(i) ]; double subTriAvgZ = zComp[ faces.centerParticle(i) ]; subTriAvgX += xComp[ faceVerts[j] ] + xComp[ faceVerts[(j+1)%faces.nVerts(i)] ]; subTriAvgY += yComp[ faceVerts[j] ] + yComp[ faceVerts[(j+1)%faces.nVerts(i)] ]; subTriAvgZ += zComp[ faceVerts[j] ] + zComp[ faceVerts[(j+1)%faces.nVerts(i)] ]; subTriAvgX /= 3.0; subTriAvgY /= 3.0; subTriAvgZ /= 3.0; fs << subTriAvgX << " "<< subTriAvgY << " "<< subTriAvgZ << std::endl; } } } } };