void save(Archive & ar, const unsigned int version) const
{
if (!mesh_pointer)
throw bad_serialization_state_exception( "Mesh not loaded into serialzer object" );
MeshT const & mesh_obj = *mesh_pointer;
// -----------------------------------------------
// the geometry is read and transmitted
//
std::size_t point_size = viennagrid::vertices(mesh_obj).size();
ar & point_size;
ConstVertexRange vertices(mesh_obj);
for (ConstVertexIterator vit = vertices.begin();
vit != vertices.end(); ++vit)
{
for(int d = 0; d < DIMG; d++)
ar & viennagrid::point(*vit)[d];
}
// -----------------------------------------------
// the specific cells are read and transmitted
//
ConstCellRange cells(mesh_obj);
std::size_t cell_size = viennagrid::cells(mesh_obj).size();
ar & cell_size;
for (ConstCellIterator cit = cells.begin();
cit != cells.end(); ++cit)
{
ConstVertexOnCellRange vertices_on_cell(*cit);
for (ConstVertexOnCellIterator vocit = vertices_on_cell.begin();
vocit != vertices_on_cell.end();
++vocit)
{
std::size_t id = vocit->id().get();
ar & id;
}
}
// -----------------------------------------------
}
void project_mesh_impl( InputMeshT const & input_mesh, InputSegmentationT const & input_segmentation,
OutputMeshT & output_mesh, OutputSegmentationT & output_segmentation )
{
typedef typename viennagrid::result_of::point<InputMeshT>::type InputPointType;
typedef typename viennagrid::result_of::point<OutputMeshT>::type OutputPointType;
typedef typename viennagrid::result_of::cell<InputMeshT>::type InputCellType;
typedef typename viennagrid::result_of::cell_id<InputMeshT>::type InputCellIDType;
typedef typename viennagrid::result_of::cell_handle<OutputMeshT>::type OutputCellHandleType;
typedef typename viennagrid::result_of::vertex_id<InputMeshT>::type InputVertexIDType;
typedef typename viennagrid::result_of::vertex_handle<OutputMeshT>::type OutputVertexHandleType;
std::map<InputVertexIDType, OutputVertexHandleType> vertex_map;
typedef typename viennagrid::result_of::const_vertex_range<InputMeshT>::type ConstInputVertexRangeType;
typedef typename viennagrid::result_of::iterator<ConstInputVertexRangeType>::type ConstInputVertexIteratorType;
ConstInputVertexRangeType vertices(input_mesh);
for (ConstInputVertexIteratorType vit = vertices.begin(); vit != vertices.end(); ++vit)
{
InputPointType in_point = viennagrid::point(*vit);
OutputPointType out_point;
for (unsigned int i = 0; i != out_point.size(); ++i)
out_point[i] = in_point[i];
vertex_map[ vit->id() ] = viennagrid::make_vertex( output_mesh, out_point );
}
std::map<InputCellIDType, OutputCellHandleType> cell_map;
typedef typename viennagrid::result_of::segment_handle<InputSegmentationT>::type InputSegmentHandleType;
typedef typename viennagrid::result_of::segment_handle<OutputSegmentationT>::type OutputSegmentHandleType;
for (typename InputSegmentationT::const_iterator sit = input_segmentation.begin(); sit != input_segmentation.end(); ++sit)
{
OutputSegmentHandleType & output_segment = output_segmentation.get_make_segment( sit->id() );
typedef typename viennagrid::result_of::const_cell_range<InputSegmentHandleType>::type ConstInputCellRangeType;
typedef typename viennagrid::result_of::iterator<ConstInputCellRangeType>::type ConstInputCellIteratorType;
ConstInputCellRangeType cells(*sit);
for (ConstInputCellIteratorType cit = cells.begin(); cit != cells.end(); ++cit)
{
typedef typename viennagrid::result_of::const_vertex_range<InputCellType>::type ConstVertexOnInputCellRangeType;
typedef typename viennagrid::result_of::iterator<ConstVertexOnInputCellRangeType>::type ConstVertexOnInputCellIteratorType;
typename std::map<InputCellIDType, OutputCellHandleType>::iterator cmit = cell_map.find( cit->id() );
if (cmit != cell_map.end())
{
viennagrid::add( output_segment, viennagrid::dereference_handle(output_mesh, cmit->second) );
}
else
{
ConstVertexOnInputCellRangeType vertices_on_cell( *cit );
std::vector<OutputVertexHandleType> vertex_handles;
for (ConstVertexOnInputCellIteratorType vit = vertices_on_cell.begin(); vit != vertices_on_cell.end(); ++vit)
vertex_handles.push_back( vertex_map[vit->id()] );
cell_map[ cit->id() ] = viennagrid::make_cell( output_segment, vertex_handles.begin(), vertex_handles.end() );
}
}
}
}
static void apply1(ElementType const & element_in, MeshTypeOut & segment_out,
EdgeRefinementFlagAccessor const edge_refinement_flag_accessor, VertexToVertexHandleAccessor const vertex_to_vertex_handle_accessor, EdgeToVertexHandleAccessor const edge_to_vertex_handle_accessor)
{
typedef typename viennagrid::result_of::const_element_range<ElementType, viennagrid::vertex_tag>::type VertexOnCellRange;
typedef typename viennagrid::result_of::iterator<VertexOnCellRange>::type VertexOnCellIterator;
typedef typename viennagrid::result_of::const_element_range<ElementType, viennagrid::line_tag>::type EdgeOnCellRange;
typedef typename viennagrid::result_of::iterator<EdgeOnCellRange>::type EdgeOnCellIterator;
typedef typename viennagrid::result_of::handle<MeshTypeOut, viennagrid::vertex_tag>::type VertexHandleType;
typedef typename viennagrid::result_of::element<MeshTypeOut, viennagrid::line_tag>::type EdgeType;
const unsigned int num_vertices = boundary_elements<triangle_tag, vertex_tag>::num;
static_array<VertexHandleType, num_vertices+1> vertex_handles;
//
// Step 1: Get vertices on the new mesh
//
//grab existing vertices:
VertexOnCellRange vertices_on_cell(element_in);
VertexOnCellIterator vocit = vertices_on_cell.begin();
vertex_handles[0] = vertex_to_vertex_handle_accessor(*vocit); ++vocit;
vertex_handles[1] = vertex_to_vertex_handle_accessor(*vocit); ++vocit;
vertex_handles[2] = vertex_to_vertex_handle_accessor(*vocit);
//add vertices from edge
EdgeOnCellRange edges_on_cell(element_in);
std::size_t offset = 0;
EdgeOnCellIterator eocit = edges_on_cell.begin();
EdgeType const & e0 = *eocit; ++eocit;
EdgeType const & e1 = *eocit; ++eocit;
EdgeType const & e2 = *eocit;
if ( edge_refinement_flag_accessor(e0) )
{
vertex_handles[3] = edge_to_vertex_handle_accessor(e0);
offset = 0;
}
else if ( edge_refinement_flag_accessor(e1) )
{
vertex_handles[3] = edge_to_vertex_handle_accessor(e1);
offset = 2;
}
else if ( edge_refinement_flag_accessor(e2) )
{
vertex_handles[3] = edge_to_vertex_handle_accessor(e2);
offset = 1;
}
else
{
assert( (2 < 2) && "Logic error: Triangle does not have an edges for bisection!");
}
//
// Step 2: Add new cells to new mesh:
//
//0-3-2
make_refinement_element<ElementType>( segment_out, vertex_handles, (offset + 0) % num_vertices, 3, (offset + 2) % num_vertices );
//3-1-2:
make_refinement_element<ElementType>( segment_out, vertex_handles, 3, (offset + 1) % num_vertices, (offset + 2) % num_vertices );
} //apply1()
