Geometry Central

https://geometry-central.net/
Admin
Geometry Central is a library offering tools and algorithms for discrete differential geometry,...
Tokens:106,042
Snippets:1,062
Trust Score:6.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Repeated BFF Parameterization Setup

Source: https://geometry-central.net/surface/algorithms/parameterization

Initializes the BFF solver with precomputation for efficient repeated parameterizations of the same mesh. This setup is done once before computing multiple parameterizations.

```cpp
#include "geometrycentral/surface/boundary_first_flattening.h"
#include "geometrycentral/surface/meshio.h"

// Load a mesh
std::unique_ptr<ManifoldSurfaceMesh> mesh;
std::unique_ptr<VertexPositionGeometry> geometry;
std::tie(mesh, geometry) = readManifoldSurfaceMesh(filename);

VertexData<double> boundaryScaleFactors = /* target scale factors */;
VertexData<double> exteriorAngles = /* target exteriorAngles */;

BFF bff(*mesh, *geometry);
VertexData<Vector2> parameterization1 = bff.flattenFromScaleFactors(boundaryScaleFactors);
VertexData<Vector2> parameterization2 = bff.flattenFromExteriorAngles(exteriorAngles);

```

--------------------------------

### Dense Matrix File Format Example

Source: https://geometry-central.net/numerical/linear_algebra_utilities

Shows the format for dense matrices, where each line corresponds to a row in the matrix. Files start with a comment indicating the matrix dimensions.

```plaintext
# dense 1858 3
-0.095724 -0.9734159999999999 -0.244313
-0.105421 -0.984621 -0.301998
-0.003629 -0.979971 -0.245996
...

```

--------------------------------

### Trace Geodesic Path Example

Source: https://geometry-central.net/surface/algorithms/geodesic_paths

Loads a mesh, defines a starting point and a trace vector, and then calls traceGeodesic to find the endpoint of the path. Requires meshio, surface_point, and trace_geodesic headers.

```cpp
#include "geometrycentral/surface/meshio.h"
#include "geometrycentral/surface/surface_point.h"
#include "geometrycentral/surface/trace_geodesic.h"

// Load a mesh
std::unique_ptr<ManifoldSurfaceMesh> mesh;
std::unique_ptr<VertexPositionGeometry> geometry;
std::tie(mesh, geometry) = readManifoldSurfaceMesh(filename);

Vertex v = mesh->vertex(0);
Vector2 traceVec = 3 * Vector2::fromAngle(M_PI/6);
SurfacePoint pathEndpoint = traceGeodesic(*geometry, SurfacePoint(v), traceVec).endPoint;

```

--------------------------------

### Compute and Extract Stripe Pattern Polylines

Source: https://geometry-central.net/surface/algorithms/stripes

This example demonstrates the complete process of generating a stripe pattern and extracting its isolines as polylines. It requires a pre-computed guiding field and specifies a constant frequency for the stripes.

```cpp
#include "geometrycentral/surface/stripe_patterns.h"

// Generate a guiding field
VertexData<Vector2> guideField =
    geometrycentral::surface::computeSmoothestVertexDirectionField(*geometry, 2);

// Compute the stripe pattern
dougle constantFreq = 40.;
VertexData<double> frequencies(*mesh, constantFreq);
CornerData<double> periodicFunc;
FaceData<int> zeroIndices;
FaceData<int> branchIndices;
std::tie(periodicFunc, zeroIndices, branchIndices) =
    computeStripePattern(*geometry, frequencies, guideField);

// Extract isolines
std::vector<Vector3> isolineVerts;
std::vector<std::array<size_t, 2>> isolineEdges;
std::tie(isolineVerts, isolineEdges) = extractPolylinesFromStripePattern(
    *geometry, periodicFunc, zeroIndices, branchIndices, guideField, false);

```

--------------------------------

### L2-Optimal Transfer Setup

Source: https://geometry-central.net/surface/intrinsic_triangulations/function_transfer

Includes necessary headers for L2-optimal function transfer. This method computes an L2-optimal function on the target surface by solving a sparse linear least-squares problem.

```C++
#include "geometrycentral/surface/transfer_functions.h"
```

--------------------------------

### Include Headers and Namespaces

Source: https://geometry-central.net/tutorials/basic_mutation

Includes necessary headers for geometry-central and polyscope, and brings namespaces into scope. This is a standard setup for geometry-central applications.

```cpp
#include "geometrycentral/surface/manifold_surface_mesh.h"
#include "geometrycentral/surface/meshio.h"
#include "geometrycentral/surface/surface_mesh.h"

#include "polyscope/polyscope.h"
#include "polyscope/surface_mesh.h"

using namespace geometrycentral;
using namespace geometrycentral::surface;


```

--------------------------------

### Example: Compute Distance using FMM with Vertices

Source: https://geometry-central.net/surface/algorithms/geodesic_distance

Demonstrates loading a mesh, defining source vertices with initial distances, and computing geodesic distances using the FMM algorithm. Requires meshio and fast_marching_method headers.

```cpp
#include "geometrycentral/surface/fast_marching_method.h"
#include "geometrycentral/surface/meshio.h"

// Load a mesh
std::unique_ptr<SurfaceMesh> mesh;
std::unique_ptr<VertexPositionGeometry> geometry;
std::tie(mesh, geometry) = loadMesh(filename);

// Pick some vertices and initial distances.
std::vector<std::pair<Vertex, double>> initialDistances;
initialDistances.emplace_back(mesh->vertex(7), 0.);
initialDistances.emplace_back(mesh->vertex(8), 0.);

// Compute distance
VertexData<double> dist = FMMDistance(*geometry, initialDistances);
/* do something useful */

```

--------------------------------

### Sparse Matrix File Format Example

Source: https://geometry-central.net/numerical/linear_algebra_utilities

Illustrates the structure of a sparse matrix file. Each line represents a non-zero entry with its row, column, and value. Files begin with a comment specifying dimensions.

```plaintext
# sparse 1858 1858
1 1 3.969412682295582
2 1 -1.010447934542366
3 1 -0.5162236467210192
...

```

--------------------------------

### Use geometry-central as a Bazel Module

Source: https://geometry-central.net/build/building

This example demonstrates how to add geometry-central as a dependency in your Bazel project's MODULE.bazel file and then include its targets in your build rules.

```bazel
cc_binary(
    name = "main",
    srcs = ["main.cpp"],
    data = ["fox.ply"],
    deps = [
        "@geometry-central//:surface",
        "@geometry-central//:utilities",
    ],
)

```

--------------------------------

### Clone and Build geometry-central with CMake

Source: https://geometry-central.net/build/building

This snippet shows the basic terminal commands to clone the geometry-central repository and compile the library using CMake. Ensure you have CMake and a C++ compiler installed.

```bash
git clone --recurse-submodules https://github.com/nmwsharp/geometry-central.git
cd geometry-central
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make -j4

```

--------------------------------

### C++ Geodesic Distance Computation Example

Source: https://geometry-central.net/surface/algorithms/geodesic_distance

This snippet demonstrates loading a mesh, initializing GeodesicAlgorithmExact, defining source points, propagating distances, and querying results like distance, path, gradient, and logarithmic map.

```cpp
#include "geometrycentral/surface/exact_geodesics.h"
#include "geometrycentral/surface/meshio.h"

// Load a mesh
std::unique_ptr<SurfaceMesh> mesh;
std::unique_ptr<VertexPositionGeometry> geometry;
std::tie(mesh, geometry) = readSurfaceMesh(filename);

// Create the GeodesicAlgorithmExact
GeodesicAlgorithmExact mmp(*mesh, *geometry);

// Pick a few points as the source set
std::vector<SurfacePoint> sourcePoints;
Vertex v = /* some vertex */
sourcePoints.push_back(SurfacePoint(v));

Edge e = /* some edge */
double tEdge = /* some coordinate along edge e*/
sourcePoints.push_back(SurfacePoint(e, tEdge));

Face f =  /* some face */;
Vector3 fBary =  /* some barycentric coords in face f */;
sourcePoints.push_back(SurfacePoint(f, fBary));

// Run MMP from these source points
mmp.propagate(sourcePoints);

// Get the distance function at all mesh vertices
VertexData<double> distToSource = mmp.getDistanceFunction();

// Query the distance function at some point
SurfacePoint queryPoint = /* some point on the surface */
double dist = mmp.getDistance(queryPoint);

// Get the geodesic path from a query point to the nearest source
SurfacePoint queryPoint2 = /* some point on the surface */
double pathLength;
std::vector<SurfacePoint> path = mmp.traceBack(queryPoint2, pathLength);

// Get the gradient of the distance function at some point
Vector2 gradDist = mmp.getDistanceGradient(queryPoint);

// Find the tangent vector pointing to a query point from the closest source
Vector2 log_base_source_of_query = mmp.getLog(queryPoint);

```

--------------------------------

### Compute Logarithmic Map with Intrinsic Triangulation

Source: https://geometry-central.net/surface/algorithms/vector_heat_method

This example demonstrates how to compute a logarithmic map using an intrinsic triangulation, specifically a SignpostIntrinsicTriangulation, and ensuring it is Delaunay for improved accuracy. The resulting log map is then restricted back to the input mesh.

```cpp
#include <#include "geometrycentral/surface/signpost_intrinsic_triangulation.h">

// Construct an intrinsic triangulation
SignpostIntrinsicTriangulation signpostTri(*mesh, *geometry);
signpostTri.flipToDelaunay(); // this is the important step, makes it numerically nice!

// Remap the vertex to the intrinsic triangulation, if using
Vertex origSourceVert = /* your vertex */;
Vertex intrinsicSourceVert = signpostTri->equivalentPointOnIntrinsic(SurfacePoint(origSourceVert)).vertex;

// Run the algorithm
VectorHeatMethodSolver solver(signpostTri);
VertexData<Vector2> logmapIntrinsic = solver->computeLogMap(sourceVert, logMapStrategy);

// Copy the logmap back to your original mesh
VertexData<Vector2> logmap = signpostTri->restrictToInput(logmapIntrinsic);

```

--------------------------------

### Compile and Run Tests

Source: https://geometry-central.net/build/tests

Navigate to the test directory, create a build directory, configure the build with CMake, and then compile and run the tests using make.

```bash
cd test
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Debug ..
make -j12 && ./bin/geometry-central-test

```

--------------------------------

### Initialize Point Positions

Source: https://geometry-central.net/pointcloud/geometry

Shows how to construct a PointPositionGeometry object and then set the positions for each point in the cloud.

```cpp
PointPositionGeometry goem(*cloud);
for(Point p : cloud->points()) {
  geom.positions[p] = /* some Vector3 position */;
}

```

--------------------------------

### Basic Point Cloud Geometry Usage

Source: https://geometry-central.net/pointcloud/geometry

Demonstrates creating a point cloud, initializing its geometry with positions, and computing per-point normals and the Laplace matrix. Ensure quantities are required before accessing them.

```cpp
#include "geometrycentral/pointcloud/point_cloud.h"
#include "geometrycentral/pointcloud/point_position_geometry.h"

// create a new cloud & geometry object
size_t nPts = 5000;
PointCloud cloud(nPts);
PointData<Vector3> positions = /* some positions */;
PointPositionGeometry geom(*cloud, positions);

// Per-point normals
geom.requireNormals();
for(Point p : cloud.points()) {
  std::cout << "normal for point " << p << " is " << geom.normals[p] << "\n";
}

// Point cloud Laplace matrix
geom.requireLaplacian();
Eigen::SparseMatrix<double> L = geom.laplacian;

```

--------------------------------

### Get Number of Faces

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the total number of faces in the surface mesh.

```C++
size_t SurfaceMesh::nFaces()
```

--------------------------------

### Basic Usage of PolygonMeshHeatSolver

Source: https://geometry-central.net/surface/algorithms/polygon_heat_solver

Demonstrates how to initialize the solver, define source points and curves, and compute geodesic distance, signed distance, scalar extension, and parallel transport.

```cpp
#include "geometrycentral/surface/polygon_mesh_heat_solver.h"

using namespace geometrycentral;
using namespace geometrycentral::surface;

// Read in a polygon mesh
std::unique_ptr<SurfaceMesh> mesh;
std::unique_ptr<VertexPositionGeometry> geom;
std::tie(mesh, geom) = readSurfaceMesh("my_mesh.obj");

// Create the solver
PolygonMeshHeatSolver solver(*geom);

// Pick a source point or two
Vertex vSource = mesh->vertex(7);
Vertex vSource2 = mesh->vertex(8);

// Pick some source curves
std::vector<std::vector<Vertex>> curves;
curves.push_back({mesh->vertex(11), mesh->vertex(12), mesh->vertex(15), mesh->vertex(14), mesh->vertex(13)});
curves.push_back({mesh->vertex(17), mesh->vertex(18), mesh->vertex(19)});

// Compute geodesic distance
VertexData<double> distance = solver.computeDistance(vSource);

// Compute signed distance to a set of curves.
VertexData<double> signedDistance = solver.computeSignedDistance(curves);

// Compute scalar extension
VertexData<double> extended = solver.extendScalars({{vSource,  3.},
                                                   {vSource2, -5.}});

// Compute parallel transport
Vector2 sourceVec{1, 2};
VertexData<Vector2> transport = solver.transportTangentVector(vSource, sourceVec);

```

--------------------------------

### Get Number of Edges

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the total number of edges in the surface mesh.

```C++
size_t SurfaceMesh::nEdges()
```

--------------------------------

### Get Number of Vertices

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the total number of vertices in the surface mesh.

```C++
size_t SurfaceMesh::nVertices()
```

--------------------------------

### Basic Usage of PointCloudHeatSolver

Source: https://geometry-central.net/pointcloud/algorithms/heat_solver

Demonstrates how to read a point cloud, initialize the solver, and compute various quantities like geodesic distance, signed distance to curves, scalar extension, parallel transport, and the logarithmic map. Ensure necessary geometrycentral headers are included.

```cpp
#include "geometrycentral/pointcloud/point_cloud.h"
#include "geometrycentral/pointcloud/point_position_geometry.h"
#include "geometrycentral/pointcloud/point_cloud_heat_solver.h"
#include "geometrycentral/pointcloud/point_cloud_io.h"

using namespace geometrycentral;
using namespace geometrycentral::pointcloud;

// Read in a point cloud
std::unique_ptr<PointCloud> cloud;
std::unique_ptr<PointPositionGeometry> geom;
std::tie(cloud, geom) = readPointCloud("my_cloud.ply");

// Create the solver
PointCloudHeatSolver solver(*cloud, *geom);

// Pick a source point or two
Point pSource = cloud->point(7);
Point pSource2 = cloud->point(8);

// Pick a source curve or two
std::vector<std::vector<Point>> curves;
curves.push_back({cloud->point(11), cloud->point(12), cloud->point(15), cloud->point(14), cloud->point(13)});
curves.push_back({cloud->point(17), cloud->point(18), cloud->point(19)});

// Compute geodesic distance
PointData<double> distance = solver.computeDistance(pSource);

// Compute signed distance to a set of curves.
PointData<double> signedDistance = solver.computeSignedDistance(curves, pointNormals);

// Compute scalar extension
PointData<double> extended = solver.extendScalars({{pSource,  3.},
                                                   {pSource2, -5.}});

// Compute parallel transport
Vector2 sourceVec{1, 2};
PointData<Vector2> transport = solver.transportTangentVector(pSource, sourceVec);

// Compute the logarithmic map
PointData<Vector2> logmap = solver.computeLogMap(pSource);

```

--------------------------------

### Poisson Disk Sampling on a Surface Mesh

Source: https://geometry-central.net/surface/algorithms/surface_sampling

Demonstrates how to load a mesh, construct a PoissonDiskSampler, and sample points using both default and custom options. Ensure necessary headers are included.

```cpp
#include "geometrycentral/surface/manifold_surface_mesh.h"
#include "geometrycentral/surface/vertex_position_geometry.h"
#include "geometrycentral/surface/meshio.h"
#include "geometrycentral/surface/surface_point.h"
#include "geometrycentral/surface/poisson_disk_sampler.h"


// Load a mesh
std::unique_ptr<ManifoldSurfaceMesh> mesh;
std::unique_ptr<VertexPositionGeometry> geometry;
std::tie(mesh, geometry) = readManifoldSurfaceMesh(filename);

// construct a solver
PoissonDiskSampler poissonSampler(*mesh, *geometry);
std::vector<SurfacePoint> samples = poissonSampler.sample(); // sample using default parameters

// Sample with some different parameters.
PoissonDiskOptions sampleOptions;
sampleOptions.minDist = 2.;
std::vector<SurfacePoint> newSamples = poissonSampler.sample(sampleOptions);

```

--------------------------------

### Get number of vertices in SimplePolygonMesh

Source: https://geometry-central.net/surface/utilities/simple_polygon_mesh

Returns the total number of vertices stored in the mesh.

```cpp
size_t nVertices();

```

--------------------------------

### Get number of faces in SimplePolygonMesh

Source: https://geometry-central.net/surface/utilities/simple_polygon_mesh

Returns the total number of faces stored in the mesh.

```cpp
size_t nFaces();

```

--------------------------------

### Basic Point Cloud Operations

Source: https://geometry-central.net/pointcloud/basics

Demonstrates creating a PointCloud, accessing its properties, iterating through points, storing data, and associating geometric data like positions and normals.

```cpp
#include "geometrycentral/pointcloud/point_cloud.h"
#include "geometrycentral/pointcloud/point_position_geometry.h"

size_t nPts = 5000;

// create a new cloud
PointCloud cloud(nPts);

// access properties of the cloud
std::cout << "cloud has " << cloud.nPoints() << " points.\n";
// Prints "cloud has 5000 points"

// iterate through the points in the cloud
for(Point p : cloud.points()) {
  std::cout << "Hi, I'm point " << p << "\n";
  // Prints "Hi, I'm point p_245" (etc)
}

// store data on a point cloud
PointData<int> values(cloud);
for(Point p : cloud.points()) {
  values[p] = 7;
}

// associate 3D positions with the point cloud
// compute geometric data using the geomety object
PointData<Vector3> positions = /* some positions */;
PointPositionGeometry geom(*cloud, positions);

// for example, compute normals
geom.requireNormals();
for(Point p : cloud.points()) {
  std::cout << "normal for point " << p << " is " << geom.normals[p] << "\n";
}

```

--------------------------------

### Get Number of Boundary Vertices

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the count of vertices that are incident on the mesh boundary.

```C++
size_t SurfaceMesh::nBoundaryVertices()
```

--------------------------------

### Constructing and Reassigning Vector3

Source: https://geometry-central.net/utilities/vector3

Demonstrates how to create and reassign Vector3 objects using brace-initialization syntax. Ensure the geometrycentral namespace is included.

```cpp
#include "geometrycentral/utilities/vector3.h"
using namespace geometrycentral;

Vector3 myVec{3.8, 2.9, 1.1}; //create
myVec = Vector3{1.1, 2.2, 3.3}; // reassign

```

--------------------------------

### Get Number of Interior Vertices

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the count of vertices that are not incident on the mesh boundary.

```C++
size_t SurfaceMesh::nInteriorVertices()
```

--------------------------------

### Vector3 Construction

Source: https://geometry-central.net/utilities/vector3

Demonstrates how to construct Vector3 objects using brace initialization and static factory methods.

```APIDOC
## Vector3 Construction

### Description
`Vector3` is a POD type, so you should use brace-initialization syntax to create instances. Static factory methods are available for common vector values.

### Usage
```cpp
#include "geometrycentral/utilities/vector3.h"
using namespace geometrycentral;

// Brace initialization
Vector3 myVec{3.8, 2.9, 1.1}; 
myVec = Vector3{1.1, 2.2, 3.3}; 

// Factory methods
Vector3 zeroVec = Vector3::zero();
Vector3 constVec = Vector3::constant(5.0);
Vector3 infVec = Vector3::infinity();
Vector3 undefVec = Vector3::undefined();
```
```

--------------------------------

### Get MeshData Default Value

Source: https://geometry-central.net/surface/surface_mesh/containers

Retrieves the current default value for the MeshData container.

```cpp
T MeshData<E,T>::getDefault() const
```

--------------------------------

### Get Number of Exterior Halfedges

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the number of exterior halfedges, which are opposite boundary faces.

```C++
size_t SurfaceMesh::nExteriorHalfedges()
```

--------------------------------

### Create and Reassign Vector2

Source: https://geometry-central.net/utilities/vector2

Demonstrates how to create and reassign a Vector2 object using brace-initialization syntax.

```cpp
#include "geometrycentral/utilities/vector2.h"
using namespace geometrycentral;

Vector2 myVec{3.8, 2.9}; //create
myVec = Vector2{1.1, 2.2}; // reassign

```

--------------------------------

### Get Face Property

Source: https://geometry-central.net/surface/utilities/io

Reads a face property from a loaded file by its user-defined name. Throws if no such property exists.

```cpp
FaceData<T> RichSurfaceMeshData::getFaceProperty<T>(std::string name);
```

--------------------------------

### Get Edge Property

Source: https://geometry-central.net/surface/utilities/io

Reads an edge property from a loaded file by its user-defined name. Throws if no such property exists.

```cpp
EdgeData<T> RichSurfaceMeshData::getEdgeProperty<T>(std::string name);
```

--------------------------------

### Vertex and Face Data Initialization

Source: https://geometry-central.net/surface/surface_mesh/containers

Demonstrates how to initialize VertexData for scalars and FaceData for vectors. Data is accessed using mesh element pointers.

```cpp
VertexData<double> myVertexScalar(mesh);
Vertex v = /* some vertex */;
myVertexScalar[v] = 42.;

FaceData<Vector3> myFaceVector(mesh);
Face f = /* some face */;
myFaceVector[f] = Vector3{1., 2., 3.};

```

--------------------------------

### Get Corner Property

Source: https://geometry-central.net/surface/utilities/io

Reads a corner property from a loaded file by its user-defined name. Throws if no such property exists.

```cpp
CornerData<T> PlyCornerMeshData::getCornerProperty<T>(std::string name);
```

--------------------------------

### Vector2 Construction

Source: https://geometry-central.net/utilities/vector2

Demonstrates how to construct and reassign Vector2 objects using brace-initialization and factory methods.

```APIDOC
## Vector2 Construction

`Vector2` is a POD type, so you should use brace-initialization syntax:

```cpp
#include "geometrycentral/utilities/vector2.h"
using namespace geometrycentral;

Vector2 myVec{3.8, 2.9}; // create
myVec = Vector2{1.1, 2.2}; // reassign
```

Factory methods can construct a few common values:

- `static Vector2 Vector2::zero()`: Returns the zero vector.
- `static Vector2 Vector2::constant(double c)`: Returns a vector with all components set to c.
- `static Vector2 Vector2::infinity()`: Returns the infinite vector (∞,∞).
- `static Vector2 Vector2::undefined()`: Returns the undefined vector (NaN, NaN).
- `static Vector2 Vector2::fromAngle(double theta)`: Returns the vector (cos(θ),sin(θ)).
- `static Vector2 Vector2::fromComplex(std::complex<double> c)`: Converts a `std::complex<double>` to a `Vector2`.
```

--------------------------------

### Get Halfedge Property

Source: https://geometry-central.net/surface/utilities/io

Reads a halfedge property from a loaded file by its user-defined name. Throws if no such property exists.

```cpp
HalfedgeData<T> RichSurfaceMeshData::getHalfedgeProperty<T>(std::string name);
```

--------------------------------

### Get Number of Boundary Loops

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the number of distinct boundary loops in the mesh, each represented as a fictional face.

```C++
size_t SurfaceMesh::nBoundaryLoops()
```

--------------------------------

### Load and Save Sparse and Dense Matrices

Source: https://geometry-central.net/numerical/linear_algebra_utilities

Demonstrates loading sparse and dense matrices from files and then saving modified matrices to new files. Ensure the correct filenames are provided for loading and saving operations.

```cpp
SparseMatrix<double> spMat = loadSparseMatrix<double>(sparseFilename);
DenseMatrix<int> dMat = loadDenseMatrix<int>(denseFilename);

/* do something with matrices */

saveSparseMatrix(newSparseFilename, spMat);
saveDenseMatrix(newDenseFilename, dMat);

```

--------------------------------

### Get Type Name as String (Pointer)

Source: https://geometry-central.net/utilities/miscellaneous

Returns the name of a type as a string using `typeid()`. This overload accepts a pointer.

```C++
std::string typeNameString(T* x)
```

--------------------------------

### Initialize and Visualize Mesh with Polyscope

Source: https://geometry-central.net/tutorials/load_mesh

Initialize the Polyscope GUI, register a surface mesh using vertex positions and face vertex lists, and then show the mesh. Control is passed to the GUI until the user exits.

```cpp
polyscope::init(); // initialize the gui

// add the mesh to the gui
polyscope::registerSurfaceMesh("my mesh", 
    geometry->vertexPositions, mesh->getFaceVertexList());

polyscope::show(); // pass control to the gui until the user exits

```

--------------------------------

### Get Number of Interior Halfedges

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the number of interior halfedges, which are incident on faces. This equals the sum of sides of all faces.

```C++
size_t SurfaceMesh::nInterioHalfedges()
```

--------------------------------

### Nearest Neighbor Queries with KD-Tree

Source: https://geometry-central.net/utilities/nearest_neighbors

Demonstrates how to initialize NearestNeighborFinder and perform k-nearest, k-nearest-neighbors, and radius search queries. The finder is built over a vector of 3D points, and query results are indices into this vector.

```cpp
#include "geometrycentral/utilities/knn.h"
using namespace geometrycentral;

std::vector<Vector3> points = { {0,0,0}, {1,0,0}, {2,0,0}, {3,0,0} };
NearestNeighborFinder finder(points);

// 2 nearest points to a query location
std::vector<size_t> nearest = finder.kNearest({1.1, 0, 0}, 2);

// 2 nearest neighbors of points[1], excluding itself
std::vector<size_t> neighbors = finder.kNearestNeighbors(1, 2);

// all points within radius 1.5 of a query location
std::vector<size_t> inBall = finder.radiusSearch({0, 0, 0}, 1.5);

```

--------------------------------

### Get All Edges as Surface Points

Source: https://geometry-central.net/surface/algorithms/flip_geodesics

Retrieves all edges in the underlying triangulation as a sequence of surface points along the input mesh.

```C++
std::vector<std::vector<SurfacePoint>> FlipEdgeNetwork::getAllEdgePolyline()
```

--------------------------------

### BFF Solver Initialization

Source: https://geometry-central.net/surface/algorithms/parameterization

Constructs a new Boundary First Flattening solver. This constructor performs most of the necessary precomputation for subsequent parameterizations.

```cpp
BFF::BFF(ManifoldSurfaceMesh& mesh, IntrinsicGeometryInterface& geom)

```

--------------------------------

### Quick Solves

Source: https://geometry-central.net/numerical/linear_solvers

One-off routines for solving sparse linear systems Ax=b.

```APIDOC
## solve

### Description
Solves a system with a general sparse matrix using QR decomposition.

### Method
`Vector<T> solve(SparseMatrix<T>& matrix, const Vector<T>& rhs)`

### Parameters
- `matrix` (SparseMatrix<T>) - The coefficient matrix.
- `rhs` (Vector<T>) - The right-hand side vector.

### Response
- Returns a `Vector<T>` representing the solution.

### Warning
The underlying Eigen sparse QR solver can be inefficient and may not perform well for underdetermined systems.
```

```APIDOC
## solveSquare

### Description
Solves a system with a square sparse matrix using LU decomposition.

### Method
`Vector<T> solveSquare(SparseMatrix<T>& matrix, const Vector<T>& rhs)`

### Parameters
- `matrix` (SparseMatrix<T>) - The square coefficient matrix.
- `rhs` (Vector<T>) - The right-hand side vector.

### Response
- Returns a `Vector<T>` representing the solution.
```

```APIDOC
## solvePositiveDefinite

### Description
Solves a system with a symmetric positive (semi-)definite sparse matrix using LDLT decomposition.

### Method
`Vector<T> solvePositiveDefinite(SparseMatrix<T>& matrix, const Vector<T>& rhs)`

### Parameters
- `matrix` (SparseMatrix<T>) - The symmetric positive (semi-)definite coefficient matrix.
- `rhs` (Vector<T>) - The right-hand side vector.

### Response
- Returns a `Vector<T>` representing the solution.
```

--------------------------------

### Get Intrinsic Geometry

Source: https://geometry-central.net/surface/utilities/io

Builds a new geometry object from edge lengths stored in a file, typically added via `addIntrinsicGeometry()`.

```cpp
std::unique_ptr<EdgeLengthGeometry> RichSurfaceMeshData::getIntrinsicGeometry();
```

--------------------------------

### Construct and Use SignedHeatSolver

Source: https://geometry-central.net/surface/algorithms/signed_heat_method

Demonstrates how to construct a SignedHeatSolver and use it to compute distances to curves. Ensure you have your mesh and geometry objects initialized.

```cpp
#include "geometrycentral/surface/signed_heat_method.h"

// your mesh and geometry
VertexPositionGeometry geometry;
SurfaceMesh mesh;

// construct a solver
SignedHeatSolver signedHeatSolver(geometry);

// specify some source geometry
std::vector<Curve> curves;
curves.emplace_back();
curves.back().nodes.emplace_back(mesh.vertex(0));
curves.back().nodes.emplace_back(mesh.edge(5), 0.3);

// solve!
VertexData<double> distance = signedHeatSolver->computeDistance(curves);

```

--------------------------------

### Get Boundary Loop Property

Source: https://geometry-central.net/surface/utilities/io

Reads a boundary loop property from a loaded file by its user-defined name. Throws if no such property exists.

```cpp
BoundaryLoopData<T> RichSurfaceMeshData::getBoundaryLoopProperty<T>(std::string name);
```

--------------------------------

### Get Type Name as String (Value)

Source: https://geometry-central.net/utilities/miscellaneous

Returns the name of a type as a string using `typeid()`. This overload accepts a reference to a value.

```C++
std::string typeNameString(T& x)
```

--------------------------------

### Iterating Over Neighbors

Source: https://geometry-central.net/pointcloud/geometry

Demonstrates how to require neighbor information and iterate through the k-nearest neighbors for each point in the cloud. The number of neighbors is set by `PointPositionGeometry::kNeighborSize`.

```cpp
geom.requireNeighbors();
for (Point p : cloud->points()) {
  std::vector<Point>& neigh = geom.neighbors->neighbors[p];
  size_t M = neigh.size();
  for (size_t iN = 0; iN < M; iN++) {
    Point pN = neigh[iN];
    std::cout << "Point " << p << " has neighbor " << pN << std::endl;
  }
}

```

--------------------------------

### Get Number of Halfedges

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves the total number of halfedges, including interior and exterior ones. This is always twice the number of edges.

```C++
size_t SurfaceMesh::nHalfedges()
```

--------------------------------

### Get Vertex Position Geometry

Source: https://geometry-central.net/surface/utilities/io

Builds a new geometry object from vertex positions stored in a file, typically added via `addGeometry()`.

```cpp
std::unique_ptr<VertexPositionGeometry> RichSurfaceMeshData::getGeometry();
```

--------------------------------

### Immediate Computation vs. Cached Quantities

Source: https://geometry-central.net/surface/geometry/geometry

Demonstrates the difference between computing geometric quantities immediately and using the automatic caching system. Use the cached approach for better performance when quantities are reused.

```C++
VertexPositionGeometry& geometry = /* ... */;

// bad: immediate computation everywhere
for(Face f : mesh->faces()) {
    Vector3 normal = geometry.faceNormal(f);
}

// good: automatic caching and storage
geometry.requireFaceNormals();
for(Face f : mesh->faces()) {
    Vector3 normal = geometry.faceNormals[f];
}
```

--------------------------------

### Get Face Vertex Matrix (int)

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves a dense matrix of vertex indices for each face, with entries as int. Assumes all faces have the same degree.

```cpp
DenseMatrix<int> F = mesh->getFaceVertexMatrix<int>();

```

--------------------------------

### Basic Usage of Cached Vertex Indices

Source: https://geometry-central.net/surface/surface_mesh/indexing

Demonstrates how to obtain and use cached vertex indices. Ensure vertex indices are required before iterating through vertices.

```cpp
SurfaceMesh mesh;
VertexPositionGeometry geometry( mesh );
geometry->requireVertexIndices();
for( Vertex v : mesh->vertices() ) {
   int i = geometry->vertexIndices[v];
   // do science
}

```

--------------------------------

### Get Face Vertex Matrix (size_t)

Source: https://geometry-central.net/surface/surface_mesh/basics

Retrieves a dense matrix of vertex indices for each face, with entries as size_t. Assumes all faces have the same degree.

```cpp
DenseMatrix<size_t> F = mesh->getFaceVertexMatrix<size_t>();

```

--------------------------------

### FlipEdgeNetwork Constructor with Paths

Source: https://geometry-central.net/surface/algorithms/flip_geodesics

Initializes a FlipEdgeNetwork with a given mesh, geometry, and a collection of paths represented by sequences of halfedges. Optionally marks specific vertices where the path should be pinned.

```C++
FlipEdgeNetwork::FlipEdgeNetwork(ManifoldSurfaceMesh& mesh, IntrinsicGeometryInterface& inputGeom, const std::vector<std::vector<Halfedge>>& paths, VertexData<bool> extraMarkedVerts = VertexData<bool>())
```

--------------------------------

### Get Path Polyline in 3D Space

Source: https://geometry-central.net/surface/algorithms/flip_geodesics

Retrieves the path network as a sequence of points in 3D space. Requires the `posGeom` member to be set.

```C++
std::vector<std::vector<Vector3>> FlipEdgeNetwork::getPathPolyline3D()
```

--------------------------------

### Initialize Mesh Data Containers

Source: https://geometry-central.net/tutorials/basic_mutation

Initializes VertexData and EdgeData containers to track original vertices and edges, and prepares a list for edges to be flipped in the next phase.

```cpp
VertexData<bool> isOrigVert(*mesh, true);
EdgeData<bool> isOrigEdge(*mesh, true);
std::vector<Edge> toFlip;


```

--------------------------------

### Iterate Incoming Halfedges to Vertex

Source: https://geometry-central.net/surface/surface_mesh/navigation

Iterate over the halfedges that point inward to a given vertex. Asserts that the twin of the halfedge ends at the starting vertex.

```cpp
for(Halfedge he : vert.incomingHalfedges()) {
  assert(he.twin().vertex() == vert); // true
  // do science here
}
```

--------------------------------

### Get Common Subdivision

Source: https://geometry-central.net/surface/intrinsic_triangulations/basics

Returns the common subdivision of the input and intrinsic meshes. The subdivision is managed by the triangulation and may be deallocated if the triangulation is deleted or mutated.

```APIDOC
## getCommonSubdivision

### Description
Returns the common subdivison of the input and intrisnic meshes. May construct it from scratch if this is the first time it is needed. The intrinsic triangulation manages the lifetime of the subdivision—it will be deallocated if this object is deleted, or the triangulation is mutated, invalidating the common subdivision. Be sure to copy it if you want to retain it through those operations.

### Method
`CommonSubdivision& IntrinsicTriangulation::getCommonSubdivision()`

### Parameters
None
```

--------------------------------

### Get Distance Gradient at Vertex

Source: https://geometry-central.net/surface/algorithms/geodesic_distance

Computes the gradient of the distance function at the given Vertex. This is a unit tangent vector pointing away from the closest source.

```cpp
Vector2 GeodesicAlgorithmExact::getDistanceGradient(const Vertex& v) const
```

--------------------------------

### Get All Edges in 3D Space

Source: https://geometry-central.net/surface/algorithms/flip_geodesics

Retrieves all edges in the underlying intrinsic triangulation as a sequence of points in 3D space. Requires the `posGeom` member to be set.

```C++
std::vector<std::vector<Vector3>> FlipEdgeNetwork::getAllEdgePolyline3D()
```

--------------------------------

### PolygonMeshHeatSolver Constructor

Source: https://geometry-central.net/surface/algorithms/polygon_heat_solver

Creates a new solver for the heat methods. Precomputation is performed at startup and lazily as needed. Algorithm options like tCoef cannot be changed after construction.

```APIDOC
## PolygonMeshHeatSolver::PolygonMeshHeatSolver(EmbeddedGeometryInterface& geom, double tCoef = 1.0)

### Description
Create a new solver for the heat methods. Precomputation is performed at startup and lazily as needed.
  * `geom` is the geometry (and hence mesh) on which to compute. Any embedded geometry object (`VertexPositionGeometry`, etc) can be passed here.
  * `tCoef` is the time to use for short time heat flow, as a factor `m * h^2`, where `h` is the maximum between-point spacing. The default value of `1.0` is almost always sufficient.

Algorithm options (like `tCoef`) cannot be changed after construction; create a new solver object with the new settings.
```

--------------------------------

### Iterate Outgoing Halfedges from Vertex

Source: https://geometry-central.net/surface/surface_mesh/navigation

Iterate over the halfedges that point outward from a given vertex. Asserts that the halfedge's vertex is indeed the starting vertex.

```cpp
for(Halfedge he : vert.outgoingHalfedges()) {
  assert(he.vertex() == vert); // true
  // do science here
}
```

--------------------------------

### PointCloudHeatSolver Constructor

Source: https://geometry-central.net/pointcloud/algorithms/heat_solver

Creates a new solver for heat methods on a point cloud. Precomputation is performed at startup and lazily as needed. Algorithm options cannot be changed after construction.

```APIDOC
## PointCloudHeatSolver::PointCloudHeatSolver

### Description
Creates a new solver for the heat methods. Precomputation is performed at startup and lazily as needed.

### Parameters
* **cloud** (PointCloud&) - The point cloud to operate on.
* **geom** (PointPositionGeometry&) - The geometry (e.g., vertex positions) for the cloud. Can be a `PointPositionFrameGeometry` for tangent-valued data.
* **tCoef** (double) - Optional - The time to use for short time heat flow, as a factor `m * h^2`. Defaults to 1.0.
```

--------------------------------

### Set Eigen Location in CMake

Source: https://geometry-central.net/build/dependencies

When integrating geometry-central into your project, you can specify a custom path to your Eigen installation using the GC_EIGEN_LOCATION CMake cache variable.

```cmake
set(GC_EIGEN_LOCATION "full/path/to/eigen" CACHE PATH "my path")
add_subdirectory(geometry-central)

```

--------------------------------

### Retain Factorization for Multiple Solves

Source: https://geometry-central.net/numerical/linear_solvers

When solving multiple linear systems Ax=b with the same matrix A but different right-hand sides (b), it is more efficient to reuse the matrix factorization. This snippet demonstrates how to initialize a solver, perform multiple solves, and optionally place the solution into an existing vector. It also shows how to query the matrix rank if the solver supports it (e.g., QR-based solvers).

```C++
SparseMatrix<double> A = /* ... some matrix ... */;

// Build the solver
Solver<double> solver(A);

// Solve a problem
Vector<double> rhs1 = /* ... */;
Vector<double> sol = solver.solve(rhs1);

// Solve another problem
Vector<double> rhs2 = /* ... */;
Vector<double> sol2 = solver.solve(rhs2);

// Can place solution in existing vector
Vector<double> rhs3 = /* ... */;
solver.solve(sol, rhs3);

// Some solvers have extra powers.
// Solver<> can compute matrix rank, since it uses QR under the hood.
std::cout << "matrix rank is " << solver.rank() << std::endl;

```

--------------------------------

### Get Distance Gradient at Surface Point

Source: https://geometry-central.net/surface/algorithms/geodesic_distance

Computes the gradient of the distance function at the given SurfacePoint. This is a unit tangent vector pointing away from the closest source.

```cpp
Vector2 GeodesicAlgorithmExact::getDistanceGradient(const SurfacePoint& point) const
```

--------------------------------

### Get Interpolation Matrix to Common Subdivision

Source: https://geometry-central.net/surface/intrinsic_triangulations/function_transfer

Yields a sparse matrix for linearly interpolating data from meshA (or meshB) to the common subdivision. Useful for programmatic interpolation.

```C++
SparseMatrix<double> CommonSubdivison::interpolationMatrixA()
```

```C++
SparseMatrix<double> CommonSubdivison::interpolationMatrixB()
```

--------------------------------

### PoissonDiskSampler Constructor

Source: https://geometry-central.net/surface/algorithms/surface_sampling

Creates a new solver for Poisson disk sampling on a given mesh and its associated geometry. The mesh must be manifold.

```APIDOC
## PoissonDiskSampler::PoissonDiskSampler(ManifoldSurfaceMesh& mesh, VertexPositionGeometry& geometry)

### Description
Create a new solver to Poisson disk-sample on the given mesh with the given geometry.

* `mesh` specifies the mesh. It must be manifold, since the sampling depends on the `traceGeodesic` function.
* `geometry` specifies the `VertexPositionGeometry` needed to describe the positions of vertices in 3D space.

The mesh and geometry cannot be changed after construction.
```

--------------------------------

### Get Path Polyline as Surface Points

Source: https://geometry-central.net/surface/algorithms/flip_geodesics

Retrieves the path network as a sequence of surface points. Each point is either a vertex or a point along an edge in the mesh.

```C++
std::vector<std::vector<SurfacePoint>> FlipEdgeNetwork::getPathPolyline()
```

--------------------------------

### Solve Linear System with General Matrix (QR Decomposition)

Source: https://geometry-central.net/numerical/linear_solvers

Use this for one-off solves of a linear system Ax=b with a general sparse matrix. Internally uses QR decomposition. Be aware that the Eigen QR solver can be inefficient and may not handle underdetermined systems well.

```C++
Vector<T> solve(SparseMatrix<T>& matrix, const Vector<T>& rhs)
```

--------------------------------

### Construct Barycentric Vector from Two Surface Points

Source: https://geometry-central.net/surface/utilities/barycentric_vector

Constructs a barycentric vector as the displacement from a starting surface point (pA) to an ending surface point (pB).

```cpp
BarycentricVector::BarycentricVector(SurfacePoint pA, SurfacePoint pB);
```

--------------------------------

### Load Mesh and Initialize Polyscope

Source: https://geometry-central.net/tutorials/direction_fields

Loads a manifold surface mesh from a file and initializes Polyscope for visualization. Registers the mesh with Polyscope, providing vertex positions and face-vertex connectivity.

```cpp
std::unique_ptr<ManifoldSurfaceMesh> mesh;
std::unique_ptr<VertexPositionGeometry> geometry;
std::tie(mesh, geometry) = readManifoldSurfaceMesh(args::get(inputFilename));

polyscope::init();
auto* psMesh =
    polyscope::registerSurfaceMesh("input mesh",
        geometry->vertexPositions,
        mesh->getFaceVertexList());


```

--------------------------------

### Solver Classes (Retain Factorizations)

Source: https://geometry-central.net/numerical/linear_solvers

Stateful solver classes that store matrix factorizations for efficient solving of multiple systems with the same matrix.

```APIDOC
## Solver<T>

### Description
Solves a system with a general sparse matrix, retaining the QR factorization for multiple solves.

### Constructor
- `Solver(SparseMatrix<T>& mat)`: Constructs the solver from a matrix.

### Methods
- `Vector<T> solve(const Vector<T>& rhs)`: Solves the system and returns the result in a new vector.
- `void solve(Vector<T>& result, const Vector<T>& rhs)`: Solves the system and places the result in the provided `result` vector.
- `size_t rank()`: Reports the rank of the matrix. Note that some solvers may provide an approximate rank.

### Warning
The underlying Eigen sparse QR solver can be inefficient and may not perform well for underdetermined systems.
```

```APIDOC
## SquareSolver<T>

### Description
Solves a system with a square sparse matrix, retaining the LU factorization for multiple solves.

### Constructor
- `SquareSolver(SparseMatrix<T>& mat)`: Constructs the solver from a matrix.

### Methods
- `Vector<T> solve(const Vector<T>& rhs)`: Solves the system and returns the result in a new vector.
- `void solve(Vector<T>& result, const Vector<T>& rhs)`: Solves the system and places the result in the provided `result` vector.
```

```APIDOC
## PositiveDefiniteSolver<T>

### Description
Solves a system with a symmetric positive (semi-)definite sparse matrix, retaining the LDLT factorization for multiple solves.

### Constructor
- `PositiveDefiniteSolver(SparseMatrix<T>& mat)`: Constructs the solver from a matrix.

### Methods
- `Vector<T> solve(const Vector<T>& rhs)`: Solves the system and returns the result in a new vector.
- `void solve(Vector<T>& result, const Vector<T>& rhs)`: Solves the system and places the result in the provided `result` vector.
```

--------------------------------

### Include Headers and Namespaces

Source: https://geometry-central.net/tutorials/direction_fields

Includes necessary headers for mesh processing, direction field computation, and Polyscope visualization. Also brings geometry-central and surface namespaces into scope.

```cpp
#include "geometrycentral/surface/manifold_surface_mesh.h"
#include "geometrycentral/surface/meshio.h"
#include "geometrycentral/surface/surface_mesh.h"
#include "geometrycentral/surface/direction_fields.h"

#include "polyscope/polyscope.h"
#include "polyscope/surface_mesh.h"

using namespace geometrycentral;
using namespace geometrycentral::surface;


```

--------------------------------

### SignedHeatSolver Constructor

Source: https://geometry-central.net/surface/algorithms/signed_heat_method

Creates a new solver for the Signed Heat Method. Precomputation is performed lazily as needed. The diffusion time coefficient can be adjusted.

```APIDOC
## SignedHeatSolver::SignedHeatSolver

### Description
Create a new solver for the Signed Heat Method. Precomputation is performed lazily as needed.

### Parameters
* `geom` (IntrinsicGeometryInterface&): The geometry (and hence mesh) on which to compute. Note that nearly any geometry object (`VertexPositionGeometry`, etc) can be passed here.
* `tCoef` (double): The time to use for short time heat flow `tCoef * h^2`, where `h` is the mean distance between nodes of the mesh. The default value of `1.0` is almost always sufficient.
```

--------------------------------

### Calculating Vector Magnitude (norm)

Source: https://geometry-central.net/utilities/vector3

Demonstrates how to get the magnitude (length) of a Vector3 using the member function `norm()` or the free function `norm(v)`. The squared magnitude can be obtained with `norm2()`.

```cpp
double magnitude = vec.norm();
double squaredMagnitude = vec.norm2();

```

--------------------------------

### Iterating Through Points

Source: https://geometry-central.net/pointcloud/basics

Shows how to iterate over all points within a PointCloud object using a range-based for loop.

```cpp
for(Point p : cloud.points()) {
  // do science
}

```

--------------------------------

### Construct FlipEdgeNetwork from Dijkstra Path

Source: https://geometry-central.net/surface/algorithms/flip_geodesics

Factory method to construct a FlipEdgeNetwork with a single path generated by Dijkstra's algorithm between two specified vertices. Requires the mesh, geometry, and the start and end vertices.

```C++
static std::unique_ptr<FlipEdgeNetwork> FlipEdgeNetwork::constructFromDijkstraPath(ManifoldSurfaceMesh& mesh, IntrinsicGeometryInterface& geom, Vertex startVert, Vertex endVert)
```
Tokens:
Raw