Mesh_Ptr Mesh_File_Reader::read( const Label & name, bool load_vertices, bool load_triangles, bool load_triangle_strips, bool load_mapping ) /* throw IO_Error */ { Mesh_Ptr mesh_ptr(new Mesh()); Mesh &mesh = *mesh_ptr.get(); Filename binary_filename(_mesh_path / (name + ".bin")); if(!boost::filesystem::exists(binary_filename)) { Filename vertex_filename, triangle_filename, triangle_strip_filename, mapping_filename; if (load_vertices) vertex_filename = _mesh_path / (name + ".vert"); if (load_triangles) triangle_filename = _mesh_path / (name + ".tri"); if (load_triangle_strips) triangle_strip_filename = _mesh_path / (name + ".strip"); if (load_mapping) mapping_filename = _mesh_path / (name + ".map"); Mesh_ASCII_File_Parser parser; parser.read_mesh( vertex_filename, triangle_filename, triangle_strip_filename, mapping_filename, vertex_count(mesh), triangle_count(mesh), triangle_strip_length(mesh), vertices(mesh), vertex_sections(mesh), vertex_relative_distances(mesh), triangles(mesh), triangle_strip(mesh)); } else { Mesh_Binary_File_Parser parser; parser.read_mesh( binary_filename, load_vertices, load_triangles, load_triangle_strips, load_mapping, vertex_count(mesh), triangle_count(mesh), triangle_strip_length(mesh), vertices(mesh), vertex_sections(mesh), vertex_relative_distances(mesh), triangles(mesh), triangle_strip(mesh)); } return mesh_ptr; }
/* Checks whether the graph is connected. * For directed graphs, it returns false. * Complexity: O(|V| + |E|); since it uses BFS algorithm. */ bool graph_using_AL::is_connected() { /* Return false if the graph is a directed graph. */ if(d_type == directed_graph) return false; map<string, string> parent ; map<string, int> distance; /* Let us start from any arbitrary vertex. */ string start_vertex = data.begin()->first; /* Construct the BFS tree. * If it contains all the vertices of the graph, then the graph is connected. * Complexity: O(|V| + |E|). */ BFS_visit(parent, distance, start_vertex); /* Check how many nodes have non-null parents. */ int temp_counter = 0; for(map<string, string>::iterator p_itr = parent.begin(); p_itr != parent.end(); p_itr++) { if(debug_flag) cout << p_itr->first << " <-- " << p_itr->second << endl; if(p_itr->second != "") { temp_counter ++; } } if(debug_flag) cout << "temp_counter: " << temp_counter << endl; /* '+1' because, for the start vertex, the parent will be Null/Empty. */ return ((temp_counter + 1) == vertex_count()); }
void attrib_values(vertex_attrib_kind attr, const span<float>& dest) override { delegated_gen::attrib_values(attr, dest); if(attr == vertex_attrib_kind::position) { for(unsigned v=0, n=vertex_count(); v<n; ++v) for(unsigned c=0, m=values_per_vertex(attr); c<m; ++c) { dest[v*m+c] += _d[c]; } } }
//--------------------------------------------------------------------- void PFile::addGroup( const Group &group, ManualObject &mo ,const String &sub_name, const String &material_base_name ,const Ogre::Bone *bone ) const { size_t material_index( 0 ); if( group.has_texture ) { material_index = group.texture_index + 1; } String material_name( material_base_name + "/" + Ogre::StringConverter::toString( material_index ) ); const uint16 bone_handle( bone->getHandle() ); const Ogre::Vector3 bone_position( getPosition( bone ) ); size_t index( 0 ); size_t vertex_count( group.num_polygons * 3 ); size_t index_count( vertex_count ); size_t polygon_end_index( group.polygon_start_index + group.num_polygons ); mo.begin( sub_name, material_name, vertex_count, index_count ); for( size_t p( group.polygon_start_index ); p < polygon_end_index; ++p ) { const PolygonDefinition& polygon( m_polygon_definitions[p] ); for( int i(3); i--; ) { uint32 v( group.vertex_start_index +polygon.vertex[i] ) ,n( 0 + polygon.normal[i] ) ,t( group.texture_coordinate_start_index +polygon.vertex[i] ); Ogre::Vector3 pos( m_vertices[ v ] ); mo.position((STATIC_ROTATION * (pos / HRCFile::kDownScaler)) + bone_position); mo.colour( m_vertex_colors[ v ] ); mo.normal( STATIC_ROTATION * m_normals[ n ] ); if( group.has_texture ) { mo.textureCoord(m_texture_coordinates[t]); } mo.bone( index, bone_handle ); mo.index( index++ ); } } mo.end(); }
//--------------------------------------------------------------------- bool PFile::isPolygonDefinitionListValid( void ) { Ogre::Log::Stream log( Ogre::LogManager::getSingleton().stream() ); size_t vertex_count( m_vertices.size() ) ,normal_count( m_normals.size() ) ,edge_count ( m_edges.size() ); for( size_t p( m_polygon_definitions.size() ); p--; ) { PolygonDefinition& def( m_polygon_definitions[p] ); for( int i(3); i--; ) { if( def.vertex[i] >= vertex_count ) { log << "Error: index to vertex is out of Bounds " << " m_polygon_definitions[" << p << "]" << ".vertex[" << i << "]: " << def.vertex[i]; return false; } if( def.normal[i] >= normal_count ) { log << "Error: index to normal is out of Bounds " << " m_polygon_definitions[" << p << "]" << ".normal[" << i << "]: " << def.normal[i]; return false; } if( def.edge[i] >= edge_count ) { log << "Error: index to edge is out of Bounds " << " m_polygon_definitions[" << p << "]" << ".edge[" << i << "]: " << def.edge[i]; return false; } } } return true; }
unsigned value_count(vertex_attrib_kind attr) { return vertex_count()*values_per_vertex(attr); }
/* To find the minimum spanning tree using Kruskal's algorithm. * The mst_tree_edges will be populated by the MST edges. */ void graph_using_AL::find_MST_using_Kruskal(vector<pair<string, string> > &mst_tree_edges) { list<set<string> > forest ; set<string> temp_set ; map<string, set<string> >::iterator map_itr ; /* Populate forest. Each vertex is separte tree. */ for(map_itr = data.begin(); map_itr != data.end(); map_itr ++) { temp_set.insert(map_itr->first); forest.push_back(temp_set); temp_set.clear(); } /* Sorting based on weight. * Create a map with weight as the key and the edge as the value. */ multimap<int, pair<string, string> > temp_edge_weights ; map<pair<string, string>, int>::iterator w_itr ; typedef multimap<int, pair<string, string> >::iterator mm_itr ; /* For each edge in the graph. */ for(w_itr = edge_weights.begin(); w_itr != edge_weights.end(); w_itr++) { if(d_type == undirected_graph) { /* Find the list of edges with this weight. */ pair<mm_itr, mm_itr> mm_itr_pair = temp_edge_weights.equal_range(w_itr->second); /* Make sure the find is successful. */ if(mm_itr_pair.first != mm_itr_pair.second) { if(debug_flag) cout << "Weight found: " << w_itr->second << endl; /* Traverse each edge with this weight. */ bool found_flag = false; for(mm_itr mm_itr_1 = mm_itr_pair.first; mm_itr_1 != mm_itr_pair.second; mm_itr_1 ++) { if(debug_flag) cout << "Comparing: " << mm_itr_1->second.first << ", " << w_itr->first.second << endl; if(debug_flag) cout << "Comparing: " << mm_itr_1->second.second << ", " << w_itr->first.first << endl; if((mm_itr_1->second.first == w_itr->first.second) && (mm_itr_1->second.second == w_itr->first.first)) { found_flag = true; break; } } /* Check if found. */ if(found_flag == false) { /* None of the edge matched. */ if(debug_flag) cout << "inserting " << w_itr->second << ", " << w_itr->first.first << ", " << w_itr->first.second << endl; temp_edge_weights.insert(pair<int, pair<string, string> >(w_itr->second, w_itr->first)); } else { /* One of the edge matched. */ if(debug_flag) cout << "Edge " << w_itr->first.first << ", " << w_itr->first.second << " need not be inserted" << endl; } } else { /* Find is unsuccessful. */ if(debug_flag) cout << "Weight not found: " << w_itr->second << endl; if(debug_flag) cout << "inserting " << w_itr->second << ", " << w_itr->first.first << ", " << w_itr->first.second << endl; /* Insert the new edge. */ temp_edge_weights.insert(pair<int, pair<string, string> >(w_itr->second, w_itr->first)); } } else { /* Directed graph; so insert both pair of edges. */ temp_edge_weights.insert(pair<int, pair<string, string> >(w_itr->second, w_itr->first)); } } /* Printing the sorted list. */ multimap<int, pair<string, string> >::iterator w_temp_itr; if(debug_flag) { cout << "Sorted list of edges: " << endl; for(w_temp_itr = temp_edge_weights.begin(); w_temp_itr != temp_edge_weights.end(); w_temp_itr ++) { cout << w_temp_itr->second.first << "->" << w_temp_itr->second.second << ": " << w_temp_itr->first << endl; } } /* Printing forest. */ if(debug_flag) { cout << "Current forest: " << endl; for(list<set<string> >::iterator f_itr = forest.begin(); f_itr != forest.end(); f_itr ++) { if(! f_itr->empty()) { cout << "{"; for(set<string>::iterator set_string_itr = f_itr->begin(); set_string_itr != f_itr->end(); set_string_itr ++) { cout << *set_string_itr << " "; } cout << "} " << endl; } } } /* For each edge in increasing order of weight. */ for(w_temp_itr = temp_edge_weights.begin(); w_temp_itr != temp_edge_weights.end(); w_temp_itr ++) { if(debug_flag) { cout << "Testing edge " << w_temp_itr->second.first << " -> " << w_temp_itr->second.second; cout << " (" << w_temp_itr->first << ")" << endl; } if(debug_flag) cout << "Checking whether in same set: " << w_temp_itr->second.first << ", " << w_temp_itr->second.second << endl; list<set<string> >::iterator itr_1, itr_2; set<string> ::iterator itr_3, itr_4; bool found_flag = false; /* Find the set of the first element. */ found_flag = false; for(itr_1 = forest.begin(); itr_1 != forest.end(); itr_1 ++) { itr_3 = itr_1->find(w_temp_itr->second.first); if(itr_3 != itr_1->end()) { found_flag = true; break; } } assert(found_flag == true); /* Find the set of the second element. */ for(itr_2 = forest.begin(); itr_2 != forest.end(); itr_2 ++) { itr_4 = itr_2->find(w_temp_itr->second.second); if(itr_4 != itr_2->end()) { found_flag = true; break; } } assert(found_flag == true); /* See if they are in the same set or not. */ if(itr_1 != itr_2) { /* They are in different trees. */ if(debug_flag) cout << "They are in different trees. " << endl; /* Add them to the set of edges in the MST. */ if(debug_flag) cout << "Adding the edges " << *itr_3 << ", " << *itr_4 << " to the MST. " << endl; mst_tree_edges.push_back(pair<string, string>(*itr_3, *itr_4)); /* Combine them into a single tree (set). */ for(set<string>::iterator itr_5 = itr_2->begin(); itr_5 != itr_2->end(); itr_5++) { itr_1->insert(*itr_5); } itr_2->clear(); } else { if(debug_flag) cout << "They are in the same tree. So cannot be added" << endl; } if(debug_flag) { for(vector<pair<string, string> >::iterator te_itr = mst_tree_edges.begin(); te_itr != mst_tree_edges.end(); te_itr ++) { cout << te_itr->first << ", " << te_itr->second << endl; } } /* If all the edges are added, you can stop. * For a graph with n vertices, its MST will contain (n-1) edges. */ if(mst_tree_edges.size() == vertex_count() - 1) { if(debug_flag) cout << "All the edges have been added. " << endl; break; } /* Printing forest. */ if(debug_flag) { cout << "Current forest: " << endl; for(list<set<string> >::iterator f_itr = forest.begin(); f_itr != forest.end(); f_itr ++) { if(! f_itr->empty()) { cout << "{"; for(set<string>::iterator set_string_itr = f_itr->begin(); set_string_itr != f_itr->end(); set_string_itr ++) { cout << *set_string_itr << " "; } cout << "} " << endl; } } } } return; }
void Mesh_File_Reader::insert_new_or_updated (const std::string & name, Meshes & final_meshes, Meshes & meshes, bool load_vertices, bool load_triangles, bool load_triangle_strips, bool load_mapping) { Mesh_Ptr mesh; // Serching if the mesh already exists Meshes::iterator old_mesh = final_meshes.find(name); if (old_mesh != final_meshes.end()) { bool needs_vertices = load_vertices && old_mesh->vertices().pointer() == 0; bool needs_triangles = load_triangles && old_mesh->triangles().pointer() == 0; bool needs_triangle_strips = load_triangle_strips && old_mesh->triangle_strip().pointer() == 0; bool needs_mapping = load_mapping && old_mesh->vertex_sections().pointer() == 0; if (needs_vertices || needs_triangles || needs_triangle_strips || needs_mapping) { // Loading missing datasets into mesh variable mesh = read(name, needs_vertices, needs_triangles, needs_triangle_strips, needs_mapping); // Add data not loaded from original mesh (if it has it) if (!needs_vertices) { vertices(*mesh) = vertices(*old_mesh); vertex_count(*mesh) = vertex_count(*old_mesh); } if (!needs_triangles) { triangles(*mesh) = triangles(*old_mesh); triangle_count(*mesh) = triangle_count(*old_mesh); } if (!needs_triangle_strips) { triangles(*mesh) = triangles(*old_mesh); triangle_count(*mesh) = triangle_count(*old_mesh); } if (!needs_mapping) { vertex_sections(*mesh) = vertex_sections(*old_mesh); vertex_relative_distances(*mesh) = vertex_relative_distances(*old_mesh); } normals(*mesh) = normals(*old_mesh); } } else { mesh = read(name, load_vertices, load_triangles, load_triangle_strips, load_mapping); } // Checking if something new has been read if (mesh.get() == 0) return; // computing additionnal data from the raw data if needed if (mesh->vertices().pointer() != 0 && (mesh->triangles().pointer() != 0 || mesh->triangle_strip().pointer() != 0) && mesh->normals().pointer() == 0) { compute_per_vertex_normals(*mesh); } // Writing binary file if the whole mesh has been loaded and the binary // file doesn't exist yet. Filename binary_filename(_mesh_path / (name + ".bin")); if(!boost::filesystem::exists(binary_filename)) { if (mesh->vertices().pointer() != 0 && mesh->triangles().pointer() != 0 && mesh->triangle_strip().pointer() != 0 && mesh->vertex_sections().pointer() != 0) { try { Mesh_Binary_File_Writer writer; writer.write_mesh(binary_filename, *mesh); } catch (IO_Error) { std::cerr << "Error when writing the Binary file !\n"; } } } if (old_mesh == final_meshes.end()) { final_meshes.insert(name, mesh); } else { vertices(*old_mesh) = vertices(*mesh); vertex_count(*old_mesh) = vertex_count(*mesh); triangles(*old_mesh) = triangles(*mesh); triangle_count(*old_mesh) = triangle_count(*mesh); vertex_sections(*old_mesh) = vertex_sections(*mesh); vertex_relative_distances(*old_mesh) = vertex_relative_distances(*mesh); normals(*old_mesh) = normals(*mesh); } }