Can MeshPy create triangular mesh using a given set and boundary points and interior points, without the generation of additional points?

[luan-th-nguyen]

I am not sure if MeshPy can create a mesh by using the user input points only, without the generation of additional points.
The input points are boundary points that define the boundary facets, which can be a non-convex hull.
The interior points are any arbitrary points inside the defined boundary.

I test the following example, but the result is not satisfactory. There are points inside and on the boundary that are addionally generated.

Solutions/ suggestions are much appreciated!

import matplotlib.pyplot as plt
import meshpy.triangle as triangle
import numpy as np

def round_trip_connect(start, end):
    return [(i, i + 1) for i in range(start, end)] + [(end, start)]

def split_line_in_segments(start_point, end_point, n_segments):
    """ Plits a line into a number of equi-distant segements
    Args:
        start_point: start point
        end_point: end point
        n_segments: number of segments
    Return: list of segmented lines
    """
    x_delta = (end_point[0] - start_point[0]) / float(n_segments)
    y_delta = (end_point[1] - start_point[1]) / float(n_segments)
    points = []
    for i in range(1, n_segments):
        points.append((start_point[0] + i * x_delta, start_point[1] + i * y_delta))
    return [start_point] + points + [end_point]

def mesh_triangle(points_np, user_boundary_points=[], grid_size=1000.0):
    """ Generates triangular mesh
    Args
        points_np
        grid_size in [m]
    """

    edge_points = user_boundary_points
    inner_points = points_np
    edge_points_idx_list_closed = edge_points


    info = triangle.MeshInfo()
    info.set_points(edge_points + list(inner_points))
    info.set_facets(round_trip_connect(0, len(edge_points_idx_list_closed) - 1))

    if grid_size > 0.0:
        mesh = triangle.build(info, max_volume=(grid_size)**2, min_angle=15)
    else:
        mesh = triangle.build(info)

    mesh_points = np.array(mesh.points)
    mesh_tris = np.array(mesh.elements)

    return mesh_points, mesh_tris


def main():
      
    inner_points = np.array([[46676.50053,  11007.9141  ],
                             [19552.31636,   5488.913548],
                             [38289.53715,  12708.45606 ],
                             [31297.4717,    9417.00375 ],
                             [44828.73105,   8294.997493],
                             [  561.998012,  1060.294171],
                             [ 3821.163327, 10017.40466 ],
                             [20026.65243,  24900.83767 ],
                             [11068.71237,  28916.44972 ],
                             [15661.39326,  15913.15997 ],
                             [29864.53727,  15192.94863 ],
                             [41038.28589,  20077.08127 ],
                             [36335.02888,   4634.216521],
                             [49446.41786,  26873.29722 ],
                             [ 5356.950043,  6934.798822],
                             [22246.59216,   1596.815375],
                             [26749.99315,  26199.54452 ],
                             [ 7704.695132, 14363.74565 ],
                             [42347.07384,  22880.4608  ],
                             [32447.93361,  22293.98956 ],
                             [13444.73782,  17587.21683 ],
                             [34976.71836,  18349.47748 ],
                             [17047.04067,   2757.51361 ],
                             [25149.42495,  28068.72278 ],
                             [ 9424.204365, 21369.58492 ]])
    
    
    user_boundary_points = [(-4438, -3939),
                            (54446, -3939),
                            (45000, 0),
                            (54446, 33916),
                            (-4438, 33916)]
    
    
    # Add additinal points along boundary facets
    boundary_points = []
    n_edge_line_segments = 3
    if len(user_boundary_points) > 2:
        for point_i, point in enumerate(user_boundary_points[:-1]):
            point_start = point
            point_end = user_boundary_points[point_i+1]
            boundary_points_segment = split_line_in_segments(point_start, point_end, n_edge_line_segments)
            boundary_points += boundary_points_segment
        # the last line segment
        boundary_points += split_line_in_segments(user_boundary_points[-1], user_boundary_points[0], n_edge_line_segments)
        
        
    # Triangulate
    mesh_points, mesh_tris = mesh_triangle(inner_points, boundary_points, 0.0)

    # Plot mesh
    fig1 = plt.figure()
    ax1 = fig1.add_subplot(1, 1, 1)
    ax1.set_aspect('equal')
    ax1.triplot(mesh_points[:, 0], mesh_points[:, 1], mesh_tris)
    ax1.scatter(inner_points[:, 0], inner_points[:, 1], marker='o', c='red', s=10, label='interior points')
    ax1.scatter(np.array(boundary_points)[:, 0], np.array(boundary_points)[:, 1], marker='o', c='black', s=10, label='boundary points')
    ax1.legend()
    plt.show()


if __name__ == "__main__":
    main()

[inducer]

Look at the docs for Triangle on how to disable the creation of Steiner points.

[luan-th-nguyen]

Thank you for your quick answer!
Setting allow_boundary_steiner=False is effective. No additional points are generated along the boundary.
Setting allow_volumne_steiner=False, additional points are still generated in the interior of the mesh.
By using quality_mesh=False, I see to additional points are generated inside the boundary.

This is considered as the current solution.
mesh = triangle.build(info, allow_boundary_steiner=False, allow_volume_steiner=False, quality_meshing=False)