add indexsize functions

Author: nmwsharp

include/geometrycentral/surface/surface_mesh.h

@@ -203,11 +203,26 @@ class SurfaceMesh {
   // Check capacity. Needed when implementing expandable containers for mutable meshes to ensure the contain can
   // hold a sufficient number of elements before the next resize event.
   size_t nHalfedgesCapacity() const;
+  size_t nCornersCapacity() const;
   size_t nVerticesCapacity() const;
   size_t nEdgesCapacity() const;
   size_t nFacesCapacity() const;
   size_t nBoundaryLoopsCapacity() const;
 
+  // Return the size corresponding to the largest raw index in the mesh (except corners, see below). That is, the
+  // maximum value of he.getIndex()+1 for all halfedges, etc. This may differ from `nHalfedges()` or
+  // `nHalfedgesCapacity()` for non-compressed meshes. It also may differ for corners even in the case of a compressed
+  // mesh. These values may change after any mutation, not just on resize events.
+  //
+  // Due to implementaiton constraints, for corners the guarantee is slightly weaker: this value may be one greater than
+  // the largest index of any corner.
+  size_t halfedgeIndexSize() const;
+  size_t cornerIndexSize() const; // NOTE: this one is not tight like the others
+  size_t vertexIndexSize() const;
+  size_t edgeIndexSize() const;
+  size_t faceIndexSize() const;
+  size_t boundaryLoopIndexSize() const;
+
   // == Debugging, etc
 
   // Performs a sanity checks on halfedge structure; throws on fail

include/geometrycentral/surface/surface_mesh.ipp

@@ -19,11 +19,20 @@ inline size_t SurfaceMesh::nBoundaryLoops()     const { return nBoundaryLoopsCou
 
 // Capacities
 inline size_t SurfaceMesh::nHalfedgesCapacity()        const { return nHalfedgesCapacityCount; }
+inline size_t SurfaceMesh::nCornersCapacity()          const { return nHalfedgesCapacityCount; }
 inline size_t SurfaceMesh::nVerticesCapacity()         const { return nVerticesCapacityCount; }
 inline size_t SurfaceMesh::nEdgesCapacity()            const { return nEdgesCapacityCount; }
 inline size_t SurfaceMesh::nFacesCapacity()            const { return nFacesCapacityCount - nBoundaryLoopsFillCount; }
 inline size_t SurfaceMesh::nBoundaryLoopsCapacity()    const { return nFacesCapacityCount - nFacesFillCount; }
 
+// Index size
+inline size_t SurfaceMesh::halfedgeIndexSize()        const { return nHalfedgesFillCount; }
+inline size_t SurfaceMesh::cornerIndexSize()          const { return nHalfedgesFillCount; }
+inline size_t SurfaceMesh::vertexIndexSize()          const { return nVerticesFillCount; }
+inline size_t SurfaceMesh::edgeIndexSize()            const { return nEdgesFillCount; }
+inline size_t SurfaceMesh::faceIndexSize()            const { return nFacesFillCount; }
+inline size_t SurfaceMesh::boundaryLoopIndexSize()    const { return nBoundaryLoopsFillCount; }
+
 // Connectivity
 inline size_t SurfaceMesh::heNext(size_t iHe)               const { return heNextArr[iHe]; }
 inline size_t SurfaceMesh::heTwin(size_t iHe)               const { if(usesImplicitTwin()) return heTwinImplicit(iHe); 

test/src/halfedge_mesh_test.cpp

@@ -1,4 +1,3 @@
-
 #include "geometrycentral/surface/manifold_surface_mesh.h"
 #include "geometrycentral/surface/meshio.h"
 #include "geometrycentral/surface/rich_surface_mesh_data.h"
@@ -237,6 +236,66 @@ TEST_F(HalfedgeMeshSuite, IterateBoundaryLoopsTest) {
 }
 
 
+// ============================================================
+// =============== Counts and internals
+// ============================================================
+
+TEST_F(HalfedgeMeshSuite, IndexCountTest) {
+  for (MeshAsset& a : allMeshes()) {
+    a.printThyName();
+    
+    { // Vertices
+      bool maxSeen = false;
+      for (Vertex v : a.mesh->vertices()) {
+        EXPECT_LT(v.getIndex(), a.mesh->vertexIndexSize());
+        if ((v.getIndex() + 1) == a.mesh->vertexIndexSize()) maxSeen = true;
+      }
+      EXPECT_TRUE(maxSeen);
+    }
+
+    { // Halfedges
+      bool maxSeen = false;
+      for (Halfedge he : a.mesh->halfedges()) {
+        EXPECT_LT(he.getIndex(), a.mesh->halfedgeIndexSize());
+        if ((he.getIndex() + 1) == a.mesh->halfedgeIndexSize()) maxSeen = true;
+      }
+      EXPECT_TRUE(maxSeen);
+    }
+    
+    { // Corners
+      bool maxSeen = false;
+      for (Corner c : a.mesh->corners()) {
+        EXPECT_LT(c.getIndex(), a.mesh->cornerIndexSize());
+
+        // special case for corners, they have a weaker guarantee and 
+        // cornerIndexSize() may be not-tight by 1
+        if ((c.getIndex() + 1) == a.mesh->cornerIndexSize()) maxSeen = true;
+        if ((c.getIndex() + 2) == a.mesh->cornerIndexSize()) maxSeen = true;
+      }
+      EXPECT_TRUE(maxSeen);
+    }
+    
+    { // Edges
+      bool maxSeen = false;
+      for (Edge e : a.mesh->edges()) {
+        EXPECT_LT(e.getIndex(), a.mesh->edgeIndexSize());
+        if ((e.getIndex() + 1) == a.mesh->edgeIndexSize()) maxSeen = true;
+      }
+      EXPECT_TRUE(maxSeen);
+    }
+    
+    { // Faces
+      bool maxSeen = false;
+      for (Face f : a.mesh->faces()) {
+        EXPECT_LT(f.getIndex(), a.mesh->faceIndexSize());
+        if ((f.getIndex() + 1) == a.mesh->faceIndexSize()) maxSeen = true;
+      }
+      EXPECT_TRUE(maxSeen);
+    }
+  }
+}
+
+
 // ============================================================
 // =============== Utility and status functions
 // ============================================================
@@ -764,7 +823,6 @@ TEST_F(HalfedgeMeshSuite, EdgeDiamondNavigator) {
   }
 }
 
-
 // ============================================================
 // =============== Utilities
 // ============================================================