random_points_on_mesh

random_points_on_mesh(V, F, n, rng=np.random.default_rng(), color='white', per_element_likelihood=None, return_indices=False)

Samples a mesh V,F according to a given distribution. Valid meshes are polylines or triangle meshes.

Parameters:

Name	Type	Description	Default
V	(n_v,d) numpy array	vertex list of vertex positions	required
F	(m,k) numpy int array	if k==2, interpret input as ordered polyline; if k==3 numpy int array, interpred as face index list of a triangle mesh	required
rng	numpy rng, optional (default: new `np.random.default_rng()`)	which numpy random number generator to use	default_rng()
n	int	how many points to sample	required
color		"Noise color" of the distribution used for sampling. Right now, only "white" is supported, which corresponds to a uniform distribution.	'white'
per_element_likelihood		If given, the likelihood of sampling a point from each element (does not need to be normalized). If not given, all elements are equally likely.	None
return_indices	bool, optional (default: False)	Whether to return the indices for each element along with the barycentric coordinates of the sampled points within each element	False

Returns:

Name	Type	Description
x	(n,d) numpy array	the n sampled points
I	(n,) numpy int array	element indices where sampled points lie (if requested)
u	(n,k) numpy array	barycentric coordinates for sampled points in I

Examples:

import numpy as np
import gpytoolbox as gpy
# Sample 100 points uniformly on a triangle mesh
V, F = gpy.read_mesh("test/unit_tests_data/cube.obj")
rng = np.random.default_rng(0)
x = gpy.random_points_on_mesh(V, F, 100, rng=rng)
# Also return the element indices and barycentric coordinates,
# so that x == sum_d u[:,d] * V[F[I,d],:]
x, I, u = gpy.random_points_on_mesh(V, F, 100, rng=rng,
                                    return_indices=True)

Source code in src/gpytoolbox/random_points_on_mesh.py

def random_points_on_mesh(V,F,
    n,
    rng=np.random.default_rng(),
    color='white',
    per_element_likelihood=None,
    return_indices=False):
    """Samples a mesh V,F according to a given distribution.
    Valid meshes are polylines or triangle meshes.

    Parameters
    ----------
    V : (n_v,d) numpy array
        vertex list of vertex positions
    F : (m,k) numpy int array
        if k==2, interpret input as ordered polyline;
        if k==3 numpy int array, interpred as face index list of a triangle
        mesh
    rng : numpy rng, optional (default: new `np.random.default_rng()`)
        which numpy random number generator to use
    n : int
        how many points to sample
    color: str
        "Noise color" of the distribution used for sampling. Right now, only "white" is supported, which corresponds to a uniform distribution.
    per_element_likelihood: (m,) numpy double array, optional (default: None)
        If given, the likelihood of sampling a point from each element (does not need to be normalized). If not given, all elements are equally likely.
    return_indices : bool, optional (default: False)
        Whether to return the indices for each element along with the
        barycentric coordinates of the sampled points within each element

    Returns
    -------
    x : (n,d) numpy array
        the n sampled points
    I : (n,) numpy int array
        element indices where sampled points lie (if requested)
    u : (n,k) numpy array
        barycentric coordinates for sampled points in I


    Examples
    --------
    ```python
    import numpy as np
    import gpytoolbox as gpy
    # Sample 100 points uniformly on a triangle mesh
    V, F = gpy.read_mesh("test/unit_tests_data/cube.obj")
    rng = np.random.default_rng(0)
    x = gpy.random_points_on_mesh(V, F, 100, rng=rng)
    # Also return the element indices and barycentric coordinates,
    # so that x == sum_d u[:,d] * V[F[I,d],:]
    x, I, u = gpy.random_points_on_mesh(V, F, 100, rng=rng,
                                        return_indices=True)
    ```
    """


    if per_element_likelihood is None:
        per_element_likelihood = np.ones(F.shape[0])

    assert n>=0
    assert color=='white', "Only white noise is supported right now"

    if n==0:
        if return_indices:
            return np.zeros((0,), dtype=V.dtype), \
            np.zeros((0,), dtype=F.dtype), \
            np.zeros((0,), dtype=V.dtype)
        else:
            return np.zeros((0,), dtype=V.dtype)

    k = F.shape[1]
    if k==2:
        I,u = _uniform_sample_polyline(V,F,n,rng,per_element_likelihood)
        x = u[:,0][:,None]*V[F[I,0],:] + \
        u[:,1][:,None]*V[F[I,1],:]
    elif k==3:
        I,u = _uniform_sample_triangle_mesh(V,F,n,rng,per_element_likelihood)
        x = u[:,0][:,None]*V[F[I,0],:] + \
        u[:,1][:,None]*V[F[I,1],:] + \
        u[:,2][:,None]*V[F[I,2],:]
    else:
        assert False, "Only polylines and triangles supported"

    if return_indices:
        return x, I, u
    else:
        return x