40 #ifndef GEOGRAM_MESH_MESH
41 #define GEOGRAM_MESH_MESH
57 static constexpr
index_t NO_VERTEX = NO_INDEX;
58 static constexpr
index_t NO_EDGE = NO_INDEX;
59 static constexpr
index_t NO_FACET = NO_INDEX;
60 static constexpr
index_t NO_CELL = NO_INDEX;
61 static constexpr
index_t NO_CORNER = NO_INDEX;
132 bool keep_attributes,
bool keep_memory =
false
150 resize_store(nb + nb_to_reserve);
161 if(nb_ + nb > attributes_.size()) {
164 new_capacity = std::max(
index_t(16),attributes_.size());
165 while(new_capacity < nb_ + nb) {
169 attributes_.reserve(new_capacity);
172 attributes_.resize(nb_);
183 if(attributes_.capacity() < nb_) {
185 std::max(
index_t(16),attributes_.capacity()*2);
186 attributes_.reserve(new_capacity);
188 attributes_.resize(nb_);
202 attributes_.resize(nb_);
216 bool copy_attributes =
true
219 if(copy_attributes) {
220 attributes_.copy(rhs.attributes_);
222 attributes_.clear(
false,
false);
223 attributes_.resize(rhs.attributes_.
size());
259 bool remove_isolated_vertices=
true
286 bool keep_attributes=
true,
bool keep_memory=
false
315 class MeshFacetCornersStore;
316 class MeshCellCornersStore;
360 coords < point_ptr(0) ||
361 coords >= point_ptr(0) + nb() * dimension()
363 index_t result = create_vertex();
364 for(
index_t c=0; c<dimension(); ++c) {
365 point_ptr(result)[c] = coords[c];
380 bool keep_attributes=
true,
bool keep_memory=
false
409 return point_fp32_.is_bound();
420 return point_.is_bound();
430 point_fp32_.dimension() :
441 if(single_precision()) {
442 point_fp32_.redim(dim);
458 return &point_[v*point_.dimension()];
471 return &point_[v*point_.dimension()];
486 return *(
vec3*)(&point_[v*point_.dimension()]);
500 return *(
const vec3*)(&point_[v*point_.dimension()]);
513 return &point_fp32_[v*point_fp32_.dimension()];
526 return &point_fp32_[v*point_fp32_.dimension()];
559 bool keep_attributes,
bool keep_memory =
false
564 void bind_point_attribute(
index_t dim,
bool single_precision=
false);
568 if(point_fp32_.is_bound()) {
569 point_fp32_.destroy();
571 if(point_.is_bound()) {
576 point_fp32_.bind_if_is_defined(attributes(),
"point_fp32");
577 if(!point_fp32_.is_bound()) {
578 point_fp32_.create_vector_attribute(
579 attributes(),
"point_fp32", dim
583 point_.bind_if_is_defined(attributes(),
"point");
584 if(!point_.is_bound()) {
585 point_.create_vector_attribute(
586 attributes(),
"point", dim
592 if(!copy_attributes) {
595 single_precision_point_ptr(0),
610 MeshFacetCornersStore& facet_corners_;
611 MeshCellCornersStore& cell_corners_;
612 Attribute<double> point_;
613 Attribute<float> point_fp32_;
616 friend class GeogramIOHandler;
640 return edge_vertex_[2*e+lv];
652 edge_vertex_[2*e+lv] = v;
664 return &(edge_vertex_[c]);
675 return &(edge_vertex_[c]);
683 return create_sub_element();
692 return create_sub_elements(nb);
701 index_t result = create_edge();
702 set_vertex(result,0,v1);
703 set_vertex(result,1,v2);
714 bool keep_attributes=
true,
bool keep_memory=
false
721 bool keep_attributes,
bool keep_memory =
false
727 edge_vertex_.push_back(NO_VERTEX);
728 edge_vertex_.push_back(NO_VERTEX);
733 edge_vertex_.resize(2*(nb()+nb_in),NO_VERTEX);
737 void copy(
const MeshEdges& rhs,
bool copy_attributes=
true) {
739 edge_vertex_ = rhs.edge_vertex_;
742 vector<index_t> edge_vertex_;
744 friend class GeogramIOHandler;
765 return (is_simplicial_ ? 3*f : facet_ptr_[f]);
776 return (is_simplicial_ ? 3*(f+1): facet_ptr_[f+1]);
786 return (is_simplicial_ ? 3 : facet_ptr_[f+1] - facet_ptr_[f]);
799 return corners_begin(f)+lv;
810 return is_simplicial_;
822 return &facet_ptr_[f];
827 bool keep_attributes,
bool keep_memory =
false
833 if(!is_simplicial_) {
834 facet_ptr_.push_back(NO_CORNER);
840 if(!is_simplicial_) {
842 facet_ptr_.push_back(NO_CORNER);
848 void copy(
const MeshFacetsStore& rhs,
bool copy_attributes=
true) {
850 is_simplicial_ = rhs.is_simplicial_;
851 facet_ptr_ = rhs.facet_ptr_;
856 vector<index_t> facet_ptr_;
858 friend class GeogramIOHandler;
878 return corner_vertex_[c];
889 return corner_adjacent_facet_[c];
901 return &corner_adjacent_facet_[c];
914 return &corner_adjacent_facet_[c];
926 corner_vertex_[c] = v;
941 corner_vertex_[c] = v;
953 corner_adjacent_facet_[c] = f;
965 return &(corner_vertex_[c]);
977 return &(corner_vertex_[c]);
982 bool keep_attributes,
bool keep_memory =
false
988 corner_vertex_.push_back(v);
989 corner_adjacent_facet_.push_back(f);
995 corner_vertex_.push_back(NO_VERTEX);
998 corner_adjacent_facet_.push_back(NO_FACET);
1004 const MeshFacetCornersStore& rhs,
bool copy_attributes=
true
1007 corner_vertex_ = rhs.corner_vertex_;
1008 corner_adjacent_facet_ = rhs.corner_adjacent_facet_;
1012 MeshVertices& vertices_;
1013 MeshFacetsStore& facets_;
1014 vector<index_t> corner_vertex_;
1015 vector<index_t> corner_adjacent_facet_;
1017 friend class MeshFacets;
1019 friend class GeogramIOHandler;
1044 return nb_corners(f);
1055 return facet_corners_.vertex(corner(f,lv));
1066 facet_corners_.set_vertex(corner(f,lv),v);
1077 for(
index_t lv=0; lv<nb_vertices(f); ++lv) {
1078 if(vertex(f,lv) == v) {
1092 for(
index_t lv=0; lv<nb_vertices(f1); ++lv) {
1094 if(find_vertex(f2,v) != NO_VERTEX) {
1109 return facet_corners_.adjacent_facet(corner(f,le));
1120 for(
index_t le=0; le<nb_vertices(f); ++le) {
1121 if(adjacent(f,le) == f2) {
1136 facet_corners_.set_adjacent_facet(corner(f,le),f2);
1149 return c + 1 == corners_end(f) ? corners_begin(f) : c + 1;
1162 return c == corners_begin(f) ? corners_end(f) - 1 : c - 1;
1173 for(
index_t c1 = corners_begin(f); c1 != corners_end(f); ++c1) {
1174 index_t c2 = next_corner_around_facet(f,c1);
1176 facet_corners_.vertex(c1) == v1 &&
1177 facet_corners_.vertex(c2) == v2
1179 return c1 - corners_begin(f);
1187 bool remove_isolated_vertices=
true
1193 bool keep_attributes=
true,
bool keep_memory=
false
1206 if(nb_vertices_per_polygon != 3) {
1207 is_not_simplicial();
1211 index_t co = facet_corners_.nb();
1212 facet_corners_.create_sub_elements(
1213 nb_facets*nb_vertices_per_polygon
1215 index_t result = create_sub_elements(nb_facets);
1217 if(!is_simplicial_) {
1218 for(
index_t f=first_facet; f<=first_facet+nb_facets; ++f) {
1220 co += nb_vertices_per_polygon;
1234 facet_corners_.reserve_store(nb_to_reserve*3);
1235 this->reserve_store(nb_to_reserve);
1244 return create_facets(nb_triangles, 3);
1253 return create_facets(nb_quads, 4);
1265 facet_corners_.create_sub_element(v1);
1266 facet_corners_.create_sub_element(v2);
1267 facet_corners_.create_sub_element(v3);
1268 index_t result = create_sub_element();
1269 if(!is_simplicial_) {
1270 facet_ptr_[result+1] = facet_corners_.nb();
1283 is_not_simplicial();
1284 facet_corners_.create_sub_element(v1);
1285 facet_corners_.create_sub_element(v2);
1286 facet_corners_.create_sub_element(v3);
1287 facet_corners_.create_sub_element(v4);
1288 index_t result = create_sub_element();
1289 facet_ptr_[result+1] = facet_corners_.nb();
1301 if(nb_vertices != 3) {
1302 is_not_simplicial();
1304 for(
index_t i=0; i<nb_vertices; ++i) {
1305 facet_corners_.create_sub_element(NO_VERTEX);
1307 index_t result = create_sub_element();
1308 if(!is_simplicial_) {
1309 facet_ptr_[result+1] = facet_corners_.nb();
1323 if(nb_vertices != 3) {
1324 is_not_simplicial();
1326 for(
index_t i=0; i<nb_vertices; ++i) {
1327 facet_corners_.create_sub_element(vertices[i]);
1329 index_t result = create_sub_element();
1330 if(!is_simplicial_) {
1331 facet_ptr_[result+1] = facet_corners_.nb();
1345 return create_polygon(vertices.
size(), vertices.
data());
1400 void assign_triangle_mesh(
1426 if(!is_simplicial_) {
1427 is_simplicial_ =
true;
1428 facet_ptr_.resize(1);
1440 if(is_simplicial_) {
1441 is_simplicial_ =
false;
1442 facet_ptr_.resize(nb()+1);
1443 for(
index_t f=0; f<facet_ptr_.size(); ++f) {
1444 facet_ptr_[f] = 3*f;
1453 friend class GeogramIOHandler;
1467 MESH_NB_CELL_TYPES = 5
1512 namespace MeshCellDescriptors {
1542 return is_simplicial_;
1553 return is_simplicial_ ? MESH_TET : MeshCellType(cell_type_[c]);
1566 return is_simplicial_ ? MeshCellDescriptors::tet_descriptor :
1597 return descriptor(c).nb_vertices;
1608 return is_simplicial_ ? 4*c : cell_ptr_[c];
1619 return is_simplicial_ ? 4*(c+1) : cell_ptr_[c] + nb_corners(c);
1632 #ifndef GEO_OS_WINDOWS
1635 return corners_begin(c) + lv;
1645 return descriptor(c).nb_facets;
1656 return is_simplicial_ ? 4*c : cell_ptr_[c];
1667 return is_simplicial_ ? 4*(c+1) : cell_ptr_[c] + nb_facets(c);
1679 return facets_begin(c) + lf;
1688 return descriptor(c).nb_edges;
1693 bool keep_attributes,
bool keep_memory =
false
1698 index_t create_sub_element(MeshCellType type) {
1699 if(!is_simplicial_) {
1700 cell_ptr_.push_back(NO_CORNER);
1707 if(!is_simplicial_) {
1709 cell_ptr_.push_back(NO_CORNER);
1717 const MeshCellsStore& rhs,
bool copy_attributes=
true
1720 is_simplicial_ = rhs.is_simplicial_;
1721 cell_type_ = rhs.cell_type_;
1722 cell_ptr_ = rhs.cell_ptr_;
1726 bool is_simplicial_;
1727 vector<Numeric::uint8> cell_type_;
1728 vector<index_t> cell_ptr_;
1732 friend class GeogramIOHandler;
1752 return corner_vertex_[c];
1763 corner_vertex_[c] = v;
1775 return &(corner_vertex_[c]);
1787 return &(corner_vertex_[c]);
1792 bool keep_attributes,
bool keep_memory =
false
1798 corner_vertex_.push_back(v);
1804 corner_vertex_.push_back(NO_VERTEX);
1810 const MeshCellCornersStore& rhs,
bool copy_attributes=
true
1813 corner_vertex_ = rhs.corner_vertex_;
1817 MeshVertices& vertices_;
1818 vector<index_t> corner_vertex_;
1820 friend class MeshCells;
1822 friend class GeogramIOHandler;
1847 return adjacent_cell_[f];
1860 adjacent_cell_[f] = c;
1871 return &adjacent_cell_[f];
1882 return &adjacent_cell_[f];
1887 bool keep_attributes,
bool keep_memory =
false
1893 adjacent_cell_.push_back(c);
1899 adjacent_cell_.push_back(NO_CELL);
1905 const MeshCellFacetsStore& rhs,
bool copy_attributes=
true
1908 adjacent_cell_ = rhs.adjacent_cell_;
1912 MeshVertices& vertices_;
1913 MeshCellsStore& cells_;
1914 vector<index_t> adjacent_cell_;
1916 friend class MeshCells;
1918 friend class GeogramIOHandler;
1941 return nb_corners(c);
1951 return cell_corners_.vertex(corner(c,lv));
1961 cell_corners_.set_vertex(corner(c,lv),v);
1972 return cell_facets_.adjacent_cell(facet(c,lf));
1983 cell_facets_.set_adjacent_cell(facet(c,lf),c2);
1994 return descriptor(c).nb_vertices_in_facet[lf];
2007 return cell_corners_.vertex(
2008 corner(c, descriptor(c).facet_vertex[lf][lv])
2021 return corner(c, descriptor(c).facet_vertex[lf][lc]);
2035 return cell_corners_.vertex(
2036 corner(c,descriptor(c).edge_vertex[le][lv])
2053 return descriptor(c).edge_adjacent_facet[le][lf];
2070 bool keep_attributes=
true,
bool keep_memory=
false
2075 bool remove_isolated_vertices=
true
2095 if(type != MESH_TET) {
2096 is_not_simplicial();
2107 index_t co = cell_corners_.nb();
2109 cell_corners_.create_sub_elements(
2113 cell_facets_.create_sub_elements(
2117 index_t result = create_sub_elements(nb_cells, type);
2119 if(!is_simplicial_) {
2120 for(
index_t c=first_cell; c<=first_cell+nb_cells; ++c) {
2139 return create_cells(nb_tets, MESH_TET);
2148 return create_cells(nb_hexes, MESH_HEX);
2157 return create_cells(nb_prisms, MESH_PRISM);
2166 return create_cells(nb_pyramids, MESH_PYRAMID);
2184 cell_corners_.create_sub_element(v1);
2185 cell_corners_.create_sub_element(v2);
2186 cell_corners_.create_sub_element(v3);
2187 cell_corners_.create_sub_element(v4);
2188 cell_facets_.create_sub_element(adj1);
2189 cell_facets_.create_sub_element(adj2);
2190 cell_facets_.create_sub_element(adj3);
2191 cell_facets_.create_sub_element(adj4);
2192 index_t result = create_sub_element(MESH_TET);
2193 if(!is_simplicial_) {
2194 cell_ptr_[nb()] = cell_corners_.nb();
2219 is_not_simplicial();
2220 cell_corners_.create_sub_element(v1);
2221 cell_corners_.create_sub_element(v2);
2222 cell_corners_.create_sub_element(v3);
2223 cell_corners_.create_sub_element(v4);
2224 cell_corners_.create_sub_element(v5);
2225 cell_corners_.create_sub_element(v6);
2226 cell_corners_.create_sub_element(v7);
2227 cell_corners_.create_sub_element(v8);
2228 cell_facets_.create_sub_element(adj1);
2229 cell_facets_.create_sub_element(adj2);
2230 cell_facets_.create_sub_element(adj3);
2231 cell_facets_.create_sub_element(adj4);
2232 cell_facets_.create_sub_element(adj5);
2233 cell_facets_.create_sub_element(adj6);
2234 cell_facets_.create_sub_element(NO_CELL);
2235 cell_facets_.create_sub_element(NO_CELL);
2236 index_t result = create_sub_element(MESH_HEX);
2237 cell_ptr_[nb()] = cell_corners_.nb();
2261 is_not_simplicial();
2262 cell_corners_.create_sub_element(v1);
2263 cell_corners_.create_sub_element(v2);
2264 cell_corners_.create_sub_element(v3);
2265 cell_corners_.create_sub_element(v4);
2266 cell_corners_.create_sub_element(v5);
2267 cell_corners_.create_sub_element(v6);
2268 cell_facets_.create_sub_element(adj1);
2269 cell_facets_.create_sub_element(adj2);
2270 cell_facets_.create_sub_element(adj3);
2271 cell_facets_.create_sub_element(adj4);
2272 cell_facets_.create_sub_element(adj5);
2273 cell_facets_.create_sub_element(NO_CELL);
2274 index_t result = create_sub_element(MESH_PRISM);
2275 cell_ptr_[nb()] = cell_corners_.nb();
2297 is_not_simplicial();
2298 cell_corners_.create_sub_element(v1);
2299 cell_corners_.create_sub_element(v2);
2300 cell_corners_.create_sub_element(v3);
2301 cell_corners_.create_sub_element(v4);
2302 cell_corners_.create_sub_element(v5);
2303 cell_facets_.create_sub_element(adj1);
2304 cell_facets_.create_sub_element(adj2);
2305 cell_facets_.create_sub_element(adj3);
2306 cell_facets_.create_sub_element(adj4);
2307 cell_facets_.create_sub_element(adj5);
2308 index_t result = create_sub_element(MESH_PYRAMID);
2309 cell_ptr_[nb()] = cell_corners_.nb();
2332 is_not_simplicial();
2333 cell_corners_.create_sub_element(v1);
2334 cell_corners_.create_sub_element(v2);
2335 cell_corners_.create_sub_element(v3);
2336 cell_corners_.create_sub_element(v4);
2337 cell_facets_.create_sub_element(adj1);
2338 cell_facets_.create_sub_element(adj2);
2339 cell_facets_.create_sub_element(adj3);
2340 cell_facets_.create_sub_element(NO_CELL);
2341 index_t result = create_sub_element(MESH_CONNECTOR);
2342 cell_ptr_[nb()] = cell_corners_.nb();
2358 bool remove_trivial_slivers =
true,
bool verbose_if_OK=
false
2412 return cell_facets_.adjacent_cell_[4*t+lf];
2419 for(
index_t lf=0; lf<4; ++lf) {
2420 if(cell_facets_.adjacent_cell_[4*t+lf] == t2) {
2431 return cell_corners_.corner_vertex_[4*t+lv];
2438 for(
index_t lv=0; lv<4; ++lv) {
2439 if(cell_corners_.corner_vertex_[4*t+lv] == v) {
2463 return cell_corners_.vertex(
2464 4 * t + local_tet_facet_vertex_index(lf,lv)
2485 for(
index_t lf = 0; lf < 4; ++lf) {
2486 index_t w1 = tet_facet_vertex(t, lf, 0);
2487 index_t w2 = tet_facet_vertex(t, lf, 1);
2488 index_t w3 = tet_facet_vertex(t, lf, 2);
2490 (v1 == w1 && v2 == w2 && v3 == w3) ||
2491 (v1 == w2 && v2 == w3 && v3 == w1) ||
2492 (v1 == w3 && v2 == w1 && v3 == w2)
2511 return MeshCellDescriptors::tet_descriptor.facet_vertex[lf][lv];
2523 if(is_simplicial_) {
2524 is_simplicial_ =
false;
2525 cell_ptr_.resize(nb()+1);
2526 cell_type_.assign(nb(), MESH_TET);
2527 for(
index_t c=0; c<cell_ptr_.size(); ++c) {
2559 for(
index_t lv=0; lv<nb_vertices(c); ++lv) {
2560 if(vertex(c,lv) == v) {
2581 for(
index_t f1=0; f1<nb_facets(c1); ++f1) {
2582 if(facets_match(c1,f1,c2,f2)) {
2646 const std::vector< std::pair<index_t, index_t> >& matches
2660 friend class GeogramIOHandler;
2678 MESH_ALL_ELEMENTS = 15,
2679 MESH_FACET_CORNERS = 16,
2680 MESH_CELL_CORNERS = 32,
2681 MESH_CELL_FACETS = 64,
2682 MESH_ALL_SUBELEMENTS = 65
2727 void clear(
bool keep_attributes=
true,
bool keep_memory=
false);
2757 bool copy_attributes=
true,
2841 const std::string& name
2859 const std::string& full_attribute_name,
2861 std::string& attribute_name,
2874 const std::string& tag,
const std::string& subelement_name,
2895 const Mesh& operator=(
const Mesh& rhs);
#define geo_assert(x)
Verifies that a condition is met.
#define geo_debug_assert(x)
Verifies that a condition is met.
Generic mechanism for attributes.
Managers a set of attributes attached to an object.
index_t size() const
Gets the size.
Stores the cell facets of a mesh (low-level store)
index_t adjacent_cell(index_t f) const
Gets a cell adjacent to a facet.
const index_t * adjacent_cell_ptr(index_t f) const
Gets a const pointer to a cell adjacent to a facet.
void resize_store(index_t new_size) override
Resizes this MeshSubElementsStore.
index_t * adjacent_cell_ptr(index_t f)
Gets a pointer to a cell adjacent to a facet.
void clear_store(bool keep_attributes, bool keep_memory=false) override
Removes all the elements and attributes.
MeshCellFacetsStore(Mesh &mesh)
MeshCellFacetsStore constructor.
void set_adjacent_cell(index_t f, index_t c)
Sets a cell adjacent to a facet.
Stores the cells of a mesh (low-level store)
index_t facet(index_t c, index_t lf) const
Gets a facet of a cell by local facet index.
bool are_simplices() const
Tests whether all the cells are tetrahedra.
index_t corner(index_t c, index_t lv) const
Gets a corner of a cell by local vertex index.
index_t nb_facets(index_t c) const
Gets the number of facets of a cell.
index_t corners_end(index_t c) const
Gets the upper limit for iterating over the corners of a cell.
MeshCellType type(index_t c) const
Gets the type of a cell.
index_t facets_end(index_t c) const
Gets the upper limit for iterating over the facets of a cell.
const CellDescriptor & descriptor(index_t c) const
Gets the descriptor of a cell.
index_t nb_corners(index_t c) const
Gets the number of corners of a cell.
index_t corners_begin(index_t c) const
Gets the first element for iterating over the corners of a cell.
void resize_store(index_t new_size) override
Resizes this MeshSubElementsStore.
index_t nb_edges(index_t c) const
Gets the number of edges in a cell.
static const CellDescriptor & cell_type_to_cell_descriptor(MeshCellType t)
Gets a descriptor by cell type.
void clear_store(bool keep_attributes, bool keep_memory=false) override
Removes all the elements and attributes.
index_t facets_begin(index_t c) const
Gets the first element for iterating over the facets of a cell.
index_t create_cells(index_t nb_cells, MeshCellType type)
Creates a contiguous chunk of cells of the same type.
void pop() override
Removes the last element.
void compute_borders()
Replaces the surfacic part of this mesh with the borders of the volumetric part.
void set_vertex(index_t c, index_t lv, index_t v)
Sets a vertex of a cell by local vertex index.
index_t create_pyramids(index_t nb_pyramids)
Creates a contiguous chunk of pyramids.
void assign_tet_mesh(vector< index_t > &tets, bool steal_args)
Copies a tetrahedron mesh into this Mesh.
index_t adjacent(index_t c, index_t lf) const
Gets a cell adjacent to another one by local facet index.
void assign_tet_mesh(coord_index_t dim, vector< double > &vertices, vector< index_t > &tets, bool steal_args)
Copies a tetrahedron mesh into this Mesh.
bool triangular_facets_have_common_edge(index_t c1, index_t f1, index_t c2, index_t f2, index_t &e1, index_t &e2) const
Tests whether two triangular cell facets have a common edge.
bool facets_match(index_t c1, index_t f1, index_t c2, index_t f2) const
Tests whether two cell facets can be connected.
index_t create_connector(index_t v1, index_t v2, index_t v3, index_t v4, index_t adj1=NO_CELL, index_t adj2=NO_CELL, index_t adj3=NO_CELL)
Creates a connector.
index_t tet_facet_vertex(index_t t, index_t lf, index_t lv) const
Gets a vertex of a tetrahedron by local facet index and local vertex index in facet.
index_range corners(index_t c) const
Gets the corners of a cell.
MeshCells(Mesh &mesh)
MeshCells constructor.
index_t edge_vertex(index_t c, index_t le, index_t lv) const
Gets a cell vertex by local edge index and local vertex index in the edge.
void connect(bool remove_trivial_slivers=true, bool verbose_if_OK=false)
Connects the cells.
static index_t local_tet_facet_vertex_index(index_t lf, index_t lv)
Gives the local index of a vertex in a tetrahedron from its facet and vertex local indices.
index_t create_prism(index_t v1, index_t v2, index_t v3, index_t v4, index_t v5, index_t v6, index_t adj1=NO_CELL, index_t adj2=NO_CELL, index_t adj3=NO_CELL, index_t adj4=NO_CELL, index_t adj5=NO_CELL)
Creates a prism.
index_t nb_vertices(index_t c) const
Gets the number of vertices of a cell.
index_t facet_vertex(index_t c, index_t lf, index_t lv) const
Gets a vertex of a cell by local facet index and local vertex index in the facet.
void delete_elements(vector< index_t > &to_delete, bool remove_isolated_vertices=true) override
Deletes a set of elements.
index_t create_pyramid(index_t v1, index_t v2, index_t v3, index_t v4, index_t v5, index_t adj1=NO_CELL, index_t adj2=NO_CELL, index_t adj3=NO_CELL, index_t adj4=NO_CELL, index_t adj5=NO_CELL)
Creates a pyramid.
index_t find_tet_facet(index_t t, index_t v1, index_t v2, index_t v3) const
Finds the local index of a facet in a tetrahedron by the global indices of its vertices.
void permute_elements(vector< index_t > &permutation) override
Applies a permutation to the elements and their attributes.
void is_not_simplicial()
Indicates that the stored elements are no longer only tetrahedra.
index_t facet_corner(index_t c, index_t lf, index_t lc) const
Gets a corner of a cell by local facet index and local corner index in the facet.
index_t find_cell_vertex(index_t c, index_t v) const
Finds the local index of a vertex in a cell.
index_t create_hexes(index_t nb_hexes)
Creates a contiguous chunk of hexahedra.
index_t create_tets(index_t nb_tets)
Creates a contiguous chunk of tetrahedra.
index_t edge_adjacent_facet(index_t c, index_t le, index_t lf) const
Gets a cell local facet index by local edge index and local facet index in the edge.
void compute_borders(Attribute< index_t > &facet_cell)
Replaces the surfacic part of this mesh with the borders of the volumetric part.
bool create_connector(index_t c1, index_t lf1, const std::vector< std::pair< index_t, index_t > > &matches)
Creates a connector between a quadrandular facet and two triangular facets.
void set_adjacent(index_t c, index_t lf, index_t c2)
Sets a cell adjacent to another one by local facet index.
void clear(bool keep_attributes=true, bool keep_memory=false) override
Removes all the elements and attributes.
index_t create_prisms(index_t nb_prisms)
Creates a contiguous chunk of prisms.
index_t create_tet(index_t v1, index_t v2, index_t v3, index_t v4, index_t adj1=NO_CELL, index_t adj2=NO_CELL, index_t adj3=NO_CELL, index_t adj4=NO_CELL)
Creates a tetrahedron.
index_t create_hex(index_t v1, index_t v2, index_t v3, index_t v4, index_t v5, index_t v6, index_t v7, index_t v8, index_t adj1=NO_CELL, index_t adj2=NO_CELL, index_t adj3=NO_CELL, index_t adj4=NO_CELL, index_t adj5=NO_CELL, index_t adj6=NO_CELL)
Creates an hexahedron.
void connect_tets()
Optimized implementation of connect() used when the mesh is simplicial.
index_t facet_nb_vertices(index_t c, index_t lf) const
Gets the number of vertices in a cell facet.
bool triangular_facet_matches_quad_facet(index_t c1, index_t lf1, index_t c2, index_t lf2) const
Tests whether a triangular facet matches a quad facet.
index_t find_cell_facet(index_t c1, index_t c2, index_t f2) const
Finds the local index of a facet in a cell that can be connected to a facet of another cell.
index_t vertex(index_t c, index_t lv) const
Gets a vertex of a cell by local vertex index.
index_t vertex(index_t e, index_t lv) const
Gets the index of an edge vertex.
void clear_store(bool keep_attributes, bool keep_memory=false) override
Removes all the elements and attributes.
void pop() override
Removes the last element.
void clear(bool keep_attributes=true, bool keep_memory=false) override
Removes all the elements and attributes.
index_t create_edge(index_t v1, index_t v2)
Creates a new edge.
index_t create_edge()
Creates a new edge.
void permute_elements(vector< index_t > &permutation) override
Applies a permutation to the elements and their attributes.
index_t * vertex_index_ptr(index_t c)
Gets a pointer to a vertex index by corner index.
const index_t * vertex_index_ptr(index_t c) const
Gets a pointer to a vertex index by corner index.
index_t create_edges(index_t nb)
Creates a batch of edges.
void resize_store(index_t new_size) override
Resizes this MeshSubElementsStore.
void delete_elements(vector< index_t > &to_delete, bool remove_isolated_vertices=true) override
Deletes a set of elements.
void set_vertex(index_t e, index_t lv, index_t v)
Sets a vertex of an edge.
Base class for mesh elements.
virtual void delete_elements(vector< index_t > &to_delete, bool remove_isolated_vertices=true)=0
Deletes a set of elements.
static bool has_non_zero(const GEO::vector< index_t > &I)
Tests whether a vector contains a non-zero value.
virtual void clear(bool keep_attributes=true, bool keep_memory=false)=0
Removes all the elements and attributes.
virtual void pop()=0
Removes the last element.
virtual void permute_elements(vector< index_t > &permutation)=0
Applies a permutation to the elements and their attributes.
Stores the facets of a mesh (low-level store)
index_t corner(index_t f, index_t lv) const
Gets a corner by facet and local vertex index.
index_t corners_end(index_t f) const
Gets the upper limit for iterating over the corners of a facet.
index_t nb_corners(index_t f) const
Gets the number of corners in a facet.
void clear_store(bool keep_attributes, bool keep_memory=false) override
Removes all the elements and attributes.
void resize_store(index_t new_size) override
Resizes this MeshSubElementsStore.
bool are_simplices() const
Tests whether all the facets are triangles.
const index_t * corners_begin_ptr(index_t f) const
Gets a pointer to the first element for iterating over the corners of a facet.
index_t corners_begin(index_t f) const
Gets the first element for iterating over the corners of a facet.
index_t create_triangle(index_t v1, index_t v2, index_t v3)
Creates a triangle.
void compute_borders()
Replaces the edges of this mesh with the borders of the surfacic part.
void clear(bool keep_attributes=true, bool keep_memory=false) override
Removes all the elements and attributes.
index_t create_quad(index_t v1, index_t v2, index_t v3, index_t v4)
Creates a quad.
index_t create_polygon(const vector< index_t > &vertices)
Creates a polygonal facet.
void is_not_simplicial()
Indicates that the stored elements are no longer only triangles.
void triangulate()
Triangulates the facets.
MeshFacets(Mesh &mesh)
MeshFacets constructor.
index_t vertex(index_t f, index_t lv) const
Gets a vertex by facet and local vertex index.
index_t find_edge(index_t f, index_t v1, index_t v2)
Finds an edge by vertex indices.
void reserve(index_t nb_to_reserve)
Reserves space for new facets.
void permute_elements(vector< index_t > &permutation) override
Applies a permutation to the elements and their attributes.
index_t nb_vertices(index_t f) const
Gets the number of vertices of a facet.
void is_simplicial()
Indicates that the stored elements are only triangles.
void delete_elements(vector< index_t > &to_delete, bool remove_isolated_vertices=true) override
Deletes a set of elements.
void connect()
Connects the facets.
void flip(index_t f)
Flips a facet.
index_t create_polygon(index_t nb_vertices)
Creates a polygonal facet.
index_t create_polygon(index_t nb_vertices, const index_t *vertices)
Creates a polygonal facet.
void set_vertex(index_t f, index_t lv, index_t v)
Sets a vertex by facet and local vertex index.
index_t find_common_vertex(index_t f1, index_t f2) const
finds a common vertex shared by two facets
index_range corners(index_t f) const
Gets the corners of a facet.
void pop() override
Removes the last element.
index_t find_vertex(index_t f, index_t v) const
Gets the local index of a vertex in a facet.
index_t find_adjacent(index_t f, index_t f2) const
Gets the local index of a facet adjacent to another one.
index_t prev_corner_around_facet(index_t f, index_t c) const
Gets the predecessor of a corner around a facet.
void assign_triangle_mesh(coord_index_t dim, vector< double > &vertices, vector< index_t > &triangles, bool steal_args)
Copies a triangle mesh into this Mesh.
index_t create_quads(index_t nb_quads)
Creates a contiguous chunk of quads.
index_t create_facets(index_t nb_facets, index_t nb_vertices_per_polygon)
Creates a contiguous chunk of facets.
index_t adjacent(index_t f, index_t le) const
Gets an adjacent facet by facet and local edge index.
void set_adjacent(index_t f, index_t le, index_t f2)
Sets an adjacent facet by facet and local edge index.
index_t create_triangles(index_t nb_triangles)
Creates a contiguous chunk of triangles.
index_t next_corner_around_facet(index_t f, index_t c) const
Gets the successor of a corner around a facet.
Base class for mesh sub-element storage.
index_as_iterator begin() const
Used by range-based for.
virtual ~MeshSubElementsStore()
MeshElementStore destructor.
MeshSubElementsStore(Mesh &mesh)
Constructs a new MeshSubElementStore.
index_t create_sub_element()
Creates attributes for a sub-element.
virtual void clear_store(bool keep_attributes, bool keep_memory=false)
Removes all the elements and attributes.
index_t create_sub_elements(index_t nb)
Creates a contiguous chunk of attributes for sub-elements.
index_t nb() const
Gets the number of (sub-)elements.
void reserve_store(index_t nb_to_reserve)
Reserves space for new elements.
index_as_iterator end() const
Used by range-based for.
void copy(const MeshSubElementsStore &rhs, bool copy_attributes=true)
Copies a MeshSubElementsStore into this one.
void adjust_store()
Makes the size of the store tightly match the number of the elements.
AttributesManager & attributes() const
Gets the attributes manager.
virtual void resize_store(index_t new_size)
Resizes this MeshSubElementsStore.
void pop() override
Removes the last element.
void resize_store(index_t new_size) override
Resizes this MeshSubElementsStore.
const double * point_ptr(index_t v) const
Gets a point.
void clear(bool keep_attributes=true, bool keep_memory=false) override
Removes all the elements and attributes.
float * single_precision_point_ptr(index_t v)
Gets a (single-precision) point.
index_t create_vertex(const double *coords)
Creates a new vertex.
void assign_points(const double *points, index_t dim, index_t nb_pts)
Assigns all the points.
const vec3 & point(index_t v) const
Gets a point.
void remove_isolated()
Removes the vertices that have no mesh element incident to them.
void set_dimension(index_t dim)
Sets the dimension of the vertices.
void set_double_precision()
Sets double precision mode.
void clear_store(bool keep_attributes, bool keep_memory=false) override
Removes all the elements and attributes.
const float * single_precision_point_ptr(index_t v) const
Gets a (single-precision) point.
void permute_elements(vector< index_t > &permutation) override
Applies a permutation to the elements and their attributes.
void assign_points(vector< double > &points, index_t dim, bool steal_arg)
Assigns all the points.
bool double_precision() const
Tests whether vertices are stored in double-precision mode.
bool single_precision() const
Tests whether vertices are stored in single-precision mode.
index_t dimension() const
Gets the dimension of the vertices.
index_t create_vertices(index_t nb)
Creates a contiguous chunk of vertices.
double * point_ptr(index_t v)
Gets a point.
void set_single_precision()
Sets single precision mode.
vec3 & point(index_t v)
Gets a point.
index_t create_vertex()
Creates a new vertex.
void delete_elements(vector< index_t > &to_delete, bool remove_isolated_vertices=true) override
Deletes a set of elements.
const MeshSubElementsStore & get_subelements_by_index(index_t i) const
Gets a MeshSubElementsStore by index.
Mesh(index_t dimension=3, bool single_precision=false)
Mesh constructor.
void copy(const Mesh &rhs, bool copy_attributes=true, MeshElementsFlags what=MESH_ALL_ELEMENTS)
Copies a mesh onto this one.
MeshElementsFlags
Indicates the mesh elements (vertices, facets or cells) present in a mesh.
index_t nb_subelements_types() const
Gets the number of subelements types.
void assert_is_valid()
Does some validity checks.
MeshSubElementsStore & get_subelements_by_type(MeshElementsFlags what)
Gets a MeshSubElementsStore by subelements type.
static std::string subelements_type_to_name(MeshElementsFlags what)
Gets a subelement name by subelement type.
void clear(bool keep_attributes=true, bool keep_memory=false)
Removes all the elements and attributes of this mesh.
virtual ~Mesh()
Mesh destructor.
std::string get_attributes() const
Gets the list of all attributes.
static bool parse_attribute_name(const std::string &full_attribute_name, MeshElementsFlags &where, std::string &attribute_name, index_t &component)
Extracts localisation, name and optional component from an attribute name.
void display_attributes(const std::string &tag, const std::string &subelement_name, const MeshSubElementsStore &subelements) const
Displays the list of attributes to the Logger.
MeshSubElementsStore & get_subelements_by_index(index_t i)
Gets a MeshSubElementsStore by index.
const MeshSubElementsStore & get_subelements_by_type(MeshElementsFlags what) const
Gets a MeshSubElementsStore by subelements type.
std::string get_vector_attributes(index_t max_dim=0) const
Gets the list of all vector attributes.
std::string get_scalar_attributes() const
Gets the list of all scalar attributes.
static MeshElementsFlags name_to_subelements_type(const std::string &name)
Gets a subelement type by subelement name.
void show_stats(const std::string &tag="Mesh") const
Displays number of vertices, facets and borders.
Wraps an integer to be used with the range-based for construct.
A generic index_range bounded by two "non-iterators".
T * data()
Gets a pointer to the array of elements.
index_t size() const
Gets the number of elements.
Common include file, providing basic definitions. Should be included before anything else by all head...
Geometric functions in 2d and 3d.
void copy(void *to, const void *from, size_t size)
Copies a memory block.
CellDescriptor * cell_type_to_cell_descriptor[GEO::MESH_NB_CELL_TYPES]
Maps a cell type to the associated cell descriptor.
Global Vorpaline namespace.
geo_index_t index_t
The type for storing and manipulating indices.
void tessellate_facets(Mesh &M, index_t max_nb_vertices)
Subdivides the facets with more than nb_vertices.
geo_coord_index_t coord_index_t
The type for storing coordinate indices, and iterating on the coordinates of a point.
C++-20 like helpers for manipulating ranges of integers.
Lookup tables that describe the combinatorics of each cell type.
index_t nb_vertices_in_facet[6]
index_t facet_vertex[6][4]
index_t edge_adjacent_facet[12][2]
index_t edge_vertex[12][2]