Polyline creation

[danwbean]

Add polyline creation?

Currently MeshLab and PyMeshLab can internally generate polylines from edges or selection perimeters. These are very useful.

Could PyMeshLab include the ability for the user to create polylines? (given edge_matrix and vertex_matrix arrays).

[jmespadero]

You can create edge meshes as in the next example:

import pymeshlab
import numpy

# create a numpy 8x3 array of vertices
verts = numpy.array([
        [-0.5, -0.5, -0.5],
        [0.5, -0.5, -0.5],
        [-0.5, 0.5, -0.5],
        [0.5, 0.5, -0.5],
        [-0.5, -0.5, 0.5],
        [0.5, -0.5, 0.5],
        [-0.5, 0.5, 0.5],
        [0.5, 0.5, 0.5]])

# create a numpy 7x2 array of edges
edges = numpy.array([
        [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]])

# create a new Mesh with the two arrays
m = pymeshlab.Mesh(vertex_matrix=verts, edge_matrix=edges)

But it is true that you can only apply a small set of filters to that mesh. Mainly, compute geometric statistics.
Also, trying to export this to ply file will ignore edges and create a vertex-only file

ms = pymeshlab.MeshSet()
ms.add_mesh(m, "edge_mesh")
ms.save_current_mesh("my_edgeMesh.ply", binary=False)

will produce this file

ply
format ascii 1.0
comment VCGLIB generated
element vertex 8
property double x
property double y
property double z
property uchar red
property uchar green
property uchar blue
property uchar alpha
property double quality
element face 0
property list uchar int vertex_indices
end_header
-0.5 -0.5 -0.5 255 255 255 255 0 
0.5 -0.5 -0.5 255 255 255 255 0 
-0.5 0.5 -0.5 255 255 255 255 0 
0.5 0.5 -0.5 255 255 255 255 0 
-0.5 -0.5 0.5 255 255 255 255 0 
0.5 -0.5 0.5 255 255 255 255 0 
-0.5 0.5 0.5 255 255 255 255 0 
0.5 0.5 0.5 255 255 255 255 0 

[danwbean]

Thank you for the edge example. I was not clear enough in the question.

Most of the time I am interested in extracting polylines resulting from borders or sections (rather than edges).

For example starting with a mesh with a border:

ms.apply_filter('generate_polyline_from_selection_perimeter')
m = ms.current_mesh()
polyline_vertices = m.vertex_matrix()

The (unordered) vertices are returned above. The issue is preserving vertex order. The order of the array is not the sequential order of the vertices in the polyline. I am currently reassembling the polyline from the unsorted vertices.

Is there a way to recover the vertex order of the polyline vertices?

In my application I am starting with a watertight mesh representing an
archaeological stone projectile point. I use polylines in two main ways:

• I split the watertight mesh into top and bottom faces based on face
  normals selection and create the selection border polyline
• I generate cross-sections of the mesh using compute_planar_section.

In each case I need the vertices in polyline order. How do I accomplish this?

Thanks

Dan Bean
Corvallis, OR, USA

[jmespadero]

I see... m.edge_matrix() return a list of (unsorted) edges that sometimes are in reverse order.
I would file a bug for this behaviour, but in the meanwhile you can sort the edges manually

import pymeshlab as ml
import numpy

ms = ml.MeshSet()
ms.apply_filter("create_sphere")
m = ms.current_mesh()
print(m.vertex_number(), "vertices in sphere " )

ms.generate_polyline_from_planar_section(planeaxis = 'Z Axis', planeoffset = 0)
m = ms.current_mesh()
m.compact()
print(m.vertex_number(), "vertices", m.edge_number(), "edges in polyline " )
print(m.vertex_matrix())

print("Unsorted edges: ", m.edge_matrix().tolist())

#manually sort the list of edges
edges=m.edge_matrix().tolist()
sortedEdges=[]
foundVertex=set()
while edges:
  nextVertex = edges[0][0]
  while nextVertex not in foundVertex:
    for e in edges:
      if e[0] == nextVertex:
         sortedEdges.append(e)
         foundVertex.add(nextVertex)
         nextVertex = e[1]
         edges.remove(e)
         break
      if e[1] == nextVertex:
         sortedEdges.append([e[1],e[0]])
         foundVertex.add(nextVertex)
         nextVertex = e[0]
         edges.remove(e)
         break

print("Sorted edges: ", sortedEdges)
vertices = m.vertex_matrix()
print("Sorted Vertex: ", [vertices[e[0]] for e in sortedEdges])
 

you could adapt this code depending if you are interested on a chained list of edges, sorted list of indexes to vertex, or sorted list of vertex coordinates. I prefer chained list of edges because it allows woring with boundaries consisting in more than one polylines

[jmespadero]

I have done a pull request to VCGLib to maintain the coherence in the polyline edge orientation.

cnr-isti-vclab/vcglib#215

[danwbean]

Creating a boundary polyline and using a chained list of its edge_matrix to reassemble the boundary vertices in the proper order works. Note that small loops may occur in the polyline and must be handled. Returning a polyline as a 1-D array of ordered vertex indices would be much simpler for the user.