Adding a function to sample a mesh. Future possible additions:

• tet meshes (currently only polyline and triangle mesh)
• blue noise (currently only uniform / white noise)

We might want to consider deprecating random_points_on_polyline. For now, I have just updated that function to use sample_mesh.

sample_mesh is also a nice example of how I think we should handle random number generation in the library in the future.

Adding a function "colormap" that works like MATLAB's colormap, and then also "apply_colormap" to apply the colormap to a scalar function. I was not sure what exact interpolation behavior to choose for "apply_colormap", but MATLAB does piecewise constant, so I went with piecewise constant.

So far for triangle meshes only.

I have some confusion with the types that npe generates and the ones used in the Python library by convention. When should our functions return int32, and when should it be int64?

Added the following utility functions:

• halfedges
• halfedge_lengths_squared
• halfedge_lengths
• edges
• boundary_edges
• boundary_loops

Updated the doublearea function to use Kahan's formula.

Added two new meshes as well as mesh credits to the unit test directory.

It seems like the PyPi wheel for gpytoolbox in MacOs fails intermitently (it didn't use to fail, but pushing a trivial commit made it fail one hour after succeeding). It fails at installing numpy!

Sometimes, you'll see that a polyline is given with the last point being equal to the first to denote that it's closed. Currently, signed_distance_polygon does not support this and instead returns nan since it finds an edge with zero length. It'd be nice if the function just ignored zero-length edges instead of giving nans.

Here's a png:

Running

from gpytoolbox import png2poly
poly = png2poly("octopus.png")[0]
import matplotlib.pyplot as plt
plt.plot(poly[:,0],poly[:,1])
plt.show()

for some reason produces a rotated polyline, as if the x and y coordinates were flipped:

Instead of erroring with the C++ error code, the python code now interprets each C++ error code and provides an exception with a useful error message.

Introduced function for solving a linear system with fixed degrees of freedom (the linear system is ignored on the fixed rows). This function attempts to behave similar to how gptoolbox's min_quad_with_fixed would behave on a non-symmetric matrix. In my opinion our min_quad_with_fixed is not the correct place for this functionality, since this is not a quadratic optimization problem with a symmetric matrix.

This function is useful, for example, for finite difference Dirichlet boundary value problems.

This separates all the bindings so that compilation can make use of parallelization. Also, changes some magic words in the numpyeigen calls so that it compiles faster.

This pull request adds a subdivide function that can be used to subdivide polylines and triangle meshes. Supports normal upsampling for polylines and triangle meshes, and loop subdivision for triangle meshes.

Things to add to this in the future:

• Spline subdivision for polylines
• Upsampling for quad meshes
• Catmull-Clark for quads and mixed quad/tri
• Upsampling for tet meshes

The SSL certificate in gmplib.org, from which libigl (and therefore us) downloads gmp, has expired, which causes curl (called to download gmp during our build) to fail. I merged #41 , a hotfix that changes our version of libigl to my PR branch sgsellan/libigl, but I am opening this issue so we have a reminder to revert this in the future when the libigl folks have converged on a solution.

I tried to remesh a non-closed/ watertight mesh with the remesh_botsch algorithm. Compared to a closed mesh (with almost the same size) it takes a lot longer (>100 times) and returns an error by exiting my python console.

• Is your implementation not useable for non-closed meshes? The original paper has options for the boundary.