bool MeshImplData::vertex_is_fixed( size_t index, MsqError& err ) const
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return false;
}
return vertexList[index].fixed;
}
const std::vector<size_t>& MeshImplData::vertex_adjacencies( size_t index, MsqError& err ) const
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return dummy_list;
}
return vertexList[index].adjacencies;
}
const Vector3D& MeshImplData::get_vertex_coords( size_t index, MsqError& err ) const
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return dummy_vtx;
}
return vertexList[index].coords;
}
void MeshImplData::set_vertex_byte( size_t index, unsigned char value, MsqError& err )
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return;
}
vertexList[index].byte = value;
}
unsigned char MeshImplData::get_vertex_byte( size_t index, MsqError& err ) const
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return 0;
}
return vertexList[index].byte;
}
void MeshImplData::fix_vertex( size_t index, bool flag, MsqError& err )
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return;
}
vertexList[index].fixed = flag;
}
void MeshImplData::delete_vertex( size_t index, MsqError& err )
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return;
}
vertexList[index].valid = false;
deletedVertexList.push_back( index );
}
void MeshImplData::set_vertex_coords( size_t index,
const Vector3D& coords,
MsqError& err )
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return;
}
vertexList[index].coords = coords;
}
bool MeshImplData::vertex_is_slaved( size_t index, MsqError& err ) const
{
if (!is_vertex_valid( index ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return false;
}
if (!have_slaved_flags())
{
MSQ_SETERR(err)("Slave flags not set", MsqError::INVALID_STATE);
return false;
}
return vertexList[index].slaved;
}
void MeshImplData::get_adjacent_elements(
std::vector<size_t>::const_iterator node_iter,
std::vector<size_t>::const_iterator node_end,
std::vector<size_t>& elems, MsqError& err )
{
if (node_iter == node_end || !is_vertex_valid( *node_iter ))
{
MSQ_SETERR(err)(MsqError::INVALID_ARG);
return;
}
// Get list of elements adjacent to first node
elems = vertexList[*node_iter].adjacencies;
// For each aditional node, intersect elems with elements adjacent to node
for (++node_iter; node_iter != node_end; ++node_iter)
{
std::vector<size_t>::iterator elem_iter = elems.begin();
while (elem_iter != elems.end())
{
std::vector<size_t>::const_iterator adj_iter = vertexList[*node_iter].adjacencies.begin();
const std::vector<size_t>::const_iterator adj_end = vertexList[*node_iter].adjacencies.end();
for (; adj_iter != adj_end; ++adj_iter)
if (*elem_iter == *adj_iter)
break;
if (adj_iter == adj_end)
{
*elem_iter = elems[elems.size()-1];
elems.pop_back();
}
else
{
++elem_iter;
}
}
}
}
void MeshImplData::set_element( size_t index,
const std::vector<size_t>& vertices,
EntityTopology topology,
MsqError& err )
{
if (index >= elementList.size())
{
MSQ_SETERR(err)("Invalid element handle", MsqError::INVALID_ARG);
return;
}
elementList[index].connectivity = vertices;
elementList[index].topology = topology;
for (std::vector<size_t>::const_iterator iter = vertices.begin();
iter != vertices.end(); ++iter)
{
if (!is_vertex_valid( *iter ))
{
MSQ_SETERR(err)("Invalid vertex handle", MsqError::INVALID_ARG);
return;
}
std::vector<size_t>& adj = vertexList[*iter].adjacencies;
for (std::vector<size_t>::iterator iter2 = adj.begin();
iter2 != adj.end(); ++iter2)
if (*iter2 == index)
return;
adj.push_back( index );
}
unsigned numvert = TopologyInfo::corners( elementList[index].topology );
if (numvert)
for (unsigned i = numvert; i < elementList[index].connectivity.size(); ++i)
++vertexList[elementList[index].connectivity[i]].midcount;
}
bool MeshImplData::is_corner_node( size_t index ) const
{
return is_vertex_valid(index) && vertexList[index].midcount < vertexList[index].adjacencies.size();
}
bool MeshImplData::is_mid_node( size_t index ) const
{
return is_vertex_valid(index) && vertexList[index].midcount > 0;
}
void MeshImplData::copy_higher_order( std::vector<size_t>& mid_nodes,
std::vector<size_t>& vertices,
std::vector<size_t>& vertex_indices,
std::vector<size_t>& index_offsets,
MsqError& err )
{
mid_nodes.clear();
vertices.clear();
vertex_indices.clear();
index_offsets.clear();
// Create a map of from vertex handle to index in "vertices"
// Use vertexList.size() to mean uninitialized.
size_t v;
std::vector<size_t> vert_map( vertexList.size() );
for (v = 0; v < vertexList.size(); ++v)
vert_map[v] = vertexList.size();
// Loop over all mid-side vertices
for (v = 0; v < vertexList.size(); ++v)
{
const Vertex& vert = vertexList[v];
// Not a mid-side vertex, skip it
if (!vert.valid || !vert.midcount)
continue;
// Populate "verts" with the handles of all adjacent corner vertices
assert( vert.adjacencies.size() ); // shouldn't be able to fail if vert.midcount > 0
int elem_indx = vert.adjacencies[0];
Element& elem = elementList[elem_indx];
// Find index of node in elem's connectivity list
unsigned index;
for (index = 0; index < elem.connectivity.size(); ++index)
if (elem.connectivity[index] == v)
break;
if (index == elem.connectivity.size())
{
MSQ_SETERR(err)("Inconsistent data.", MsqError::INTERNAL_ERROR);
return;
}
// Given the index in the element's connectivity list,
// get the side of the element containing the mid-node.
unsigned side_dim, side_num;
TopologyInfo::side_number( elem.topology, elem.connectivity.size(),
index, side_dim, side_num, err ); MSQ_ERRRTN(err);
if (!side_dim) // Not a mid-side node
{
MSQ_SETERR(err)(MsqError::INVALID_STATE,"Improperly connected mesh.");
return;
}
// Get the adjacent corner vertices from the element side.
unsigned num_corners;
const unsigned* corner_indices = TopologyInfo::side_vertices(
elem.topology, side_dim, side_num, num_corners, err ); MSQ_ERRRTN(err);
// Add the mid-side node to the output list
mid_nodes.push_back( v );
// Store offset at which the indices of the corner
// vertices adjacent to this mid-side node will be
// stored in "vertex_indices".
index_offsets.push_back( vertex_indices.size() );
// For each adjacent corner vertex, if the vertex is not
// already in "vertices" add it, and add the index to
// the adjacency list for this mid-side node.
for (unsigned i = 0; i < num_corners; ++i)
{
size_t vert_idx = elem.connectivity[corner_indices[i]];
assert( is_vertex_valid(vert_idx) );
if (vert_map[vert_idx] == vertexList.size())
{
vert_map[vert_idx] = vertices.size();
vertices.push_back( vert_idx );
}
vertex_indices.push_back( vert_map[vert_idx] );
}
}
index_offsets.push_back( vertex_indices.size() );
}
BOOST_AUTO_TEST_CASE_TEMPLATE( intint_bgl_mutable_graph_test, Graph, intint_graphtest_types )
{
typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename boost::graph_traits<Graph>::vertex_iterator VertexIter;
typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
typedef typename boost::graph_traits<Graph>::edge_iterator EdgeIter;
typedef typename boost::graph_traits<Graph>::out_edge_iterator OutEdgeIter;
typedef typename boost::graph_traits<Graph>::in_edge_iterator InEdgeIter;
Graph g;
Vertex v_root = Vertex();
BOOST_CHECK_NO_THROW( v_root = add_vertex(g) );
BOOST_CHECK_EQUAL( num_vertices(g), 1);
BOOST_CHECK_NO_THROW( remove_vertex(v_root,g) );
BOOST_CHECK_EQUAL( num_vertices(g), 0);
BOOST_CHECK_NO_THROW( v_root = add_vertex(1, g) );
g[v_root] = 1;
BOOST_CHECK_EQUAL( g[v_root], 1 );
int vp_rc[] = {2,3,4,5};
int ep_rc[] = {1002,1003,1004,1005};
Vertex v_rc[4];
Edge e_rc[4];
for(int i = 0; i < 4; ++i) {
BOOST_CHECK_NO_THROW( v_rc[i] = add_vertex(g) );
g[ v_rc[i] ] = vp_rc[i];
BOOST_CHECK_EQUAL( g[ v_rc[i] ], vp_rc[i] );
bool edge_added_success = false;
BOOST_CHECK_NO_THROW( boost::tie(e_rc[i],edge_added_success) = add_edge(v_root, v_rc[i], g) );
BOOST_CHECK( edge_added_success );
g[ e_rc[i] ] = ep_rc[i];
BOOST_CHECK_EQUAL( g[ e_rc[i] ], ep_rc[i] );
};
BOOST_CHECK_EQUAL( num_vertices(g), 5 );
int vp_rc1c[] = {6,7,8,9};
int ep_rc1c[] = {2006,2007,2008,2009};
Vertex v_rc1c[4];
Edge e_rc1c[4];
for(std::size_t i = 0; i < 4; ++i) {
BOOST_CHECK_NO_THROW( v_rc1c[i] = add_vertex(vp_rc1c[i], g) );
BOOST_CHECK_EQUAL( g[ v_rc1c[i] ], vp_rc1c[i] );
bool edge_added_success = false;
BOOST_CHECK_NO_THROW( boost::tie(e_rc1c[i],edge_added_success) = add_edge(v_rc[0], v_rc1c[i], ep_rc1c[i], g) );
BOOST_CHECK( edge_added_success );
BOOST_CHECK_EQUAL( g[ e_rc1c[i] ], ep_rc1c[i] );
};
BOOST_CHECK_EQUAL( num_vertices(g), 9 );
BOOST_CHECK_EQUAL( g[v_root], 1 );
{
OutEdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_root,g) );
std::vector<int> e_list;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list.push_back(g[*ei]);
};
};
std::sort(e_list.begin(), e_list.end());
BOOST_CHECK_EQUAL( e_list[0], 1002);
BOOST_CHECK_EQUAL( e_list[1], 1003);
BOOST_CHECK_EQUAL( e_list[2], 1004);
BOOST_CHECK_EQUAL( e_list[3], 1005);
InEdgeIter iei, iei_end;
BOOST_CHECK_NO_THROW( boost::tie(iei, iei_end) = in_edges(v_rc[0], g) );
BOOST_CHECK( iei != iei_end );
BOOST_CHECK_EQUAL( g[*iei], 1002);
++iei;
BOOST_CHECK( iei == iei_end );
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_rc[0],g) );
std::vector<int> e_list2;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list2.push_back(g[*ei]);
};
};
std::sort(e_list2.begin(), e_list2.end());
BOOST_CHECK_EQUAL( e_list2[0], 2006);
BOOST_CHECK_EQUAL( e_list2[1], 2007);
BOOST_CHECK_EQUAL( e_list2[2], 2008);
BOOST_CHECK_EQUAL( e_list2[3], 2009);
};
int vp_rc2c[] = {10,11,12,13};
int ep_rc2c[] = {3010,3011,3012,3013};
Vertex v_rc2c[4];
Edge e_rc2c[4];
for(std::size_t i = 0; i < 4; ++i) {
#ifdef RK_ENABLE_CXX0X_FEATURES
BOOST_CHECK_NO_THROW( v_rc2c[i] = add_vertex(std::move(vp_rc2c[i]), g) );
#else
BOOST_CHECK_NO_THROW( v_rc2c[i] = add_vertex(vp_rc2c[i], g) );
#endif
bool edge_added_success = false;
#ifdef RK_ENABLE_CXX0X_FEATURES
BOOST_CHECK_NO_THROW( boost::tie(e_rc2c[i],edge_added_success) = add_edge(v_rc[1], v_rc2c[i], ep_rc2c[i], g) );
#else
BOOST_CHECK_NO_THROW( boost::tie(e_rc2c[i],edge_added_success) = add_edge(v_rc[1], v_rc2c[i], ep_rc2c[i], g) );
#endif
BOOST_CHECK( edge_added_success );
};
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
OutEdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_rc[1],g) );
std::vector<int> e_list;
std::vector<int> vp_list;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list.push_back(g[*ei]);
vp_list.push_back(g[target(*ei,g)]);
};
};
std::sort(e_list.begin(), e_list.end());
BOOST_CHECK_EQUAL( e_list[0], 3010);
BOOST_CHECK_EQUAL( e_list[1], 3011);
BOOST_CHECK_EQUAL( e_list[2], 3012);
BOOST_CHECK_EQUAL( e_list[3], 3013);
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 10);
BOOST_CHECK_EQUAL( vp_list[1], 11);
BOOST_CHECK_EQUAL( vp_list[2], 12);
BOOST_CHECK_EQUAL( vp_list[3], 13);
};
BOOST_CHECK_NO_THROW( clear_vertex(v_rc[0],g) );
BOOST_CHECK_EQUAL( out_degree(v_rc[0], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc[0], g), 0 );
BOOST_CHECK_EQUAL( out_degree(v_root, g), 3 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[0], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[1], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[2], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[3], g), 0 );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi)
if( is_vertex_valid(*vi, g) )
vp_list.push_back( g[*vi] );
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 7 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei)
if( is_edge_valid(*ei, g) )
ep_list.push_back( g[*ei] );
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
BOOST_CHECK_EQUAL( ep_list[5], 3012 );
BOOST_CHECK_EQUAL( ep_list[6], 3013 );
};
BOOST_CHECK_NO_THROW( remove_edge(v_rc[1], v_rc2c[2], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 6 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
BOOST_CHECK_EQUAL( ep_list[5], 3013 );
};
BOOST_CHECK_NO_THROW( remove_edge(e_rc2c[3], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 5 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
};
BOOST_CHECK_NO_THROW( clear_vertex(v_rc2c[0], g) );
BOOST_CHECK_NO_THROW( remove_vertex(v_rc2c[0], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 12 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 11 );
BOOST_CHECK_EQUAL( vp_list[10], 12 );
BOOST_CHECK_EQUAL( vp_list[11], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 4 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3011 );
};
};
