Meshes

Hi all,

I am a python user(beginner) trying to understand meshes and meshing algorithms like Marching cubes, Ball Pivot and Marching tetrahedra. I saw basic example provided with rhinoscriptsyntax, It was hard to imagine how hard it was to make mesh faces assigned from points. One way i could think of not Reinventing the wheel was to call mesh from points commands in python . I needs some direction to head towards creating meshes in rhino

I was suggested Libraries but i not smart enough to figure out how to or where to use them exactly.

Replies to This Discussion

Permalink Reply by Nik Willmore on July 10, 2015 at 8:29am

Since marching cubes scripts online had too many big ugly arrays of numbers I grabbed an elegant marching tetrahedrons script instead, here:

Start Small: Marching Tetrahedrons in Python

However, it is set up to manipulate strings into an STL file that is quite different from how Grasshopper defines meshes, in that an STL seems to define each face by XYZ points, Grasshopper wants a single list of all vertex points and then has an allied lists of topological connectivity according to vertex number, so for now I just hacked it to spit out points minus so many duplicates it generates for STL:

Right now it has an internal 3D trigonometric function I added input sliders to control, that creates surfaces that look a lot like molecular orbitals.

So how do I make a mesh? I failed to make a single mesh face from each STL face since AddMesh seems to want a list, so I tried making a single list and matching it with a simple ((1,2,3),(4,5,6),(7,8,9)...) array of connectivity but it hasn't worked yet since the STL list of vertices has duplicates that won't work for Grasshopper and removing the duplicates scrambles the connectivity relation.

After some work on this and seeing the output, I figure I could just randomly populate the mathematical function with points instead, unless it really gives a better mesh result than other routines. I'm not sure what to do with it yet, even if I get the mesh figured out.

import rhinoscriptsyntax
import Rhino

POINTS_CONTAINER =[]
POINTS = []

class Vector: # struct XYZ
def __init__(self,x,y,z):
self.x=x
self.y=y
self.z=z

def __str__(self):
return str(self.x)+" "+str(self.y)+" "+str(self.z)

class Gridcell: # struct GRIDCELL
def __init__(self,p,n,val):
self.p   = p   # p=[8]
self.n   = n   # n=[8]
self.val = val # val=[8]

class Triangle: # struct TRIANGLE
def __init__(self,p1,p2,p3):
self.p = [p1, p2, p3] # vertices

# HACK TO GRAB VERTICES FOR PYTHON OUTPUT
POINTS_CONTAINER.append( (p1.x,p1.y,p1.z)   )
POINTS_CONTAINER.append( (p2.x,p2.y,p2.z)   )
POINTS_CONTAINER.append( (p3.x,p3.y,p3.z)   )

# return a 3d list of values
def readdata(f=lambda x,y,z:x*x+y*y+z*z,size=5.0,steps=11):
m=int(steps/2)
ki = []
for i in range(steps):
kj = []
for j in range(steps):
   kd=[]
   for k in range(steps):
    kd.append(f(size*(i-m)/m,size*(j-m)/m,size*(k-m)/m))
   kj.append(kd)
ki.append(kj)
return ki

from math import sin,cos,exp,atan2

def lobes(x,y,z):
try:
theta = atan2(x,y)         # sin t = o
except:
theta = 0
try:
phi = atan2(z,y)
except:
phi = 0
r = x*x+y*y+z*z
ct=cos(PARAMETER_A * theta)
cp=cos(PARAMETER_B * phi)
return ct*ct*cp*cp*exp(-r/10)

def main():

data = readdata(lobes,10,40)
isolevel = 0.1

#print(data)

triangles=[]
for i in range(len(data)-1):
for j in range(len(data[i])-1):
   for k in range(len(data[i][j])-1):
    p=[None]*8
    val=[None]*8
    #print(i,j,k)
    p[0]=Vector(i,j,k)
    val[0] = data[i][j][k]
    p[1]=Vector(i+1,j,k)
    val[1] = data[i+1][j][k]
    p[2]=Vector(i+1,j+1,k)
    val[2] = data[i+1][j+1][k]
    p[3]=Vector(i,j+1,k)
    val[3] = data[i][j+1][k]
    p[4]=Vector(i,j,k+1)
    val[4] = data[i][j][k+1]
    p[5]=Vector(i+1,j,k+1)
    val[5] = data[i+1][j][k+1]
    p[6]=Vector(i+1,j+1,k+1)
    val[6] = data[i+1][j+1][k+1]
    p[7]=Vector(i,j+1,k+1)
    val[7] = data[i][j+1][k+1]

    grid=Gridcell(p,[],val)
    triangles.extend(PolygoniseTri(grid,isolevel,0,2,3,7))
    triangles.extend(PolygoniseTri(grid,isolevel,0,2,6,7))
    triangles.extend(PolygoniseTri(grid,isolevel,0,4,6,7))
    triangles.extend(PolygoniseTri(grid,isolevel,0,6,1,2))
    triangles.extend(PolygoniseTri(grid,isolevel,0,6,1,4))
    triangles.extend(PolygoniseTri(grid,isolevel,5,6,1,4))

def t000F(g, iso, v0, v1, v2, v3):
return []

def t0E01(g, iso, v0, v1, v2, v3):
return [Triangle(
VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]),
VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]),
VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3]))
]

def t0D02(g, iso, v0, v1, v2, v3):
return [Triangle(
VertexInterp(iso,g.p[v1],g.p[v0],g.val[v1],g.val[v0]),
VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3]),
VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2]))
]

def t0C03(g, iso, v0, v1, v2, v3):
tri=Triangle(
VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3]),
VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]),
VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3]))
return [tri,Triangle(
tri.p[2],
VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2]),
tri.p[1])
]

def t0B04(g, iso, v0, v1, v2, v3):
return [Triangle(
VertexInterp(iso,g.p[v2],g.p[v0],g.val[v2],g.val[v0]),
VertexInterp(iso,g.p[v2],g.p[v1],g.val[v2],g.val[v1]),
VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3]))
]

def t0A05(g, iso, v0, v1, v2, v3):
tri = Triangle(
VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]),
VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3]),
VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3]))
return [tri,Triangle(
tri.p[0],
VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2]),
tri.p[1])
]

def t0906(g, iso, v0, v1, v2, v3):
tri=Triangle(
VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]),
VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3]),
VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3]))
return [tri,
Triangle(
tri.p[0],
VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]),
tri.p[2])
]

def t0708(g, iso, v0, v1, v2, v3):
return [Triangle(
VertexInterp(iso,g.p[v3],g.p[v0],g.val[v3],g.val[v0]),
VertexInterp(iso,g.p[v3],g.p[v2],g.val[v3],g.val[v2]),
VertexInterp(iso,g.p[v3],g.p[v1],g.val[v3],g.val[v1]))
]

trianglefs = {7:t0708,8:t0708,9:t0906,6:t0906,10:t0A05,5:t0A05,11:t0B04,4:t0B04,12:t0C03,3:t0C03,13:t0D02,2:t0D02,14:t0E01,1:t0E01,0:t000F,15:t000F}

def PolygoniseTri(g, iso, v0, v1, v2, v3):
triangles = []

#   Determine which of the 16 cases we have given which vertices
#   are above or below the isosurface

triindex = 0;
if g.val[v0] < iso: triindex |= 1
if g.val[v1] < iso: triindex |= 2
if g.val[v2] < iso: triindex |= 4
if g.val[v3] < iso: triindex |= 8

return trianglefs[triindex](g, iso, v0, v1, v2, v3)

def VertexInterp(isolevel,p1,p2,valp1,valp2):
if abs(isolevel-valp1) < 0.00001 :
return(p1);
if abs(isolevel-valp2) < 0.00001 :
return(p2);
if abs(valp1-valp2) < 0.00001 :
return(p1);
mu = (isolevel - valp1) / (valp2 - valp1)
return Vector(p1.x + mu * (p2.x - p1.x), p1.y + mu * (p2.y - p1.y), p1.z + mu * (p2.z - p1.z))

if __name__ == "__main__":
main()

# GRASSHOPPER PYTHON OUTPUT

POINTS = rhinoscriptsyntax.AddPoints(POINTS_CONTAINER)
POINTS = rhinoscriptsyntax.CullDuplicatePoints(POINTS)

Attachments:

Marching Tetrahedra NIK DISTILLED A.gh, 5 KB

Permalink Reply by Nik Willmore on July 10, 2015 at 9:33am

Yeah, so Rhino's downloadable MeshFromPoints command is not very good at surfacing these point clouds that should have the same positions as marching tetrahedrons output, even after filling mesh holes which left plenty of holes:

If it worked well I could issue direct Rhino command line commands from Python as needed if I couldn't find the associated Rhinocommon command to use natively as Rhinoscript.

Permalink Reply by Nik Willmore on July 10, 2015 at 10:13am

I can make lines instead since the script deals with single faces at a time defined by three points but removing the duplicates is tough since lines have two directions so Python can't easily spot them and the Grasshopper RemoveDuplicateLines component is terribly slow (2-3 minutes), but I found a second RemoveDuplicateLines in Grasshopper that is fast, so then Weaverbird can make a real mesh out of the lines:

But there are some stringy artifacts:

Attachments:

Marching Tetrahedra NIK DISTILLED B.gh, 7 KB

Permalink Reply by Shridhar Mamidalaa on July 10, 2015 at 10:47am

Ahh sweet ... Thank u Nik.

Permalink Reply by Shridhar Mamidalaa on July 10, 2015 at 11:08am

"Mesh from patch " results

Permalink Reply by Nik Willmore on July 10, 2015 at 11:16am

What actual command or component?

Permalink Reply by David Stasiuk on July 10, 2015 at 10:26am

Hi Nik-

If you're interested, there are some resources here for looking at directly meshing the results from the marching tetrahedra algorithm: http://www.grasshopper3d.com/profiles/blogs/metaball-meshing

Permalink Reply by Shridhar Mamidalaa on July 10, 2015 at 10:48am

Thank u David . Always there for help.

Permalink Reply by Nik Willmore on July 10, 2015 at 10:57am

NURBS to the rescue. Since the script creates one face at a time, and I had trouble creating single mesh faces since AddMesh wants a list of more than one face, I just made single NURBS faces, and the duplicate points or lines problem went away, for a speedy result that can then externally be converted to single mesh faces and joined (welding failed) into a real mesh that could then be smoothed as needed:

The few stringy artifacts are part of the marching cubes after all, not a meshing issue.

Attachments:

Marching Tetrahedra NIK DISTILLED C NURBS FACES.gh, 7 KB

Permalink Reply by Shridhar Mamidalaa on July 10, 2015 at 11:16am

My idea was to *slice point list
*find 2 closest points
*form close polyline
* add mesh face

Permalink Reply by David Stasiuk on July 10, 2015 at 11:17am

You can build this entirely from individual mesh faces. For each face from the marching tetrahedra:

1. Create a new mesh

2. add the vertices

3. add a face with vertices 0,1,2

then you append this mesh to your full mesh. After you've appended all of the faces, you can call Vertices.CombineIdentical(true, true) to make it one, seamless mesh.

Permalink Reply by Nik Willmore on July 10, 2015 at 11:25am

I had trouble getting rhinoscriptsyntax.AddMesh to accept only a single face like that in Python, which asks for four numbers that you repeat the last one of for a triangle:

or...

AddMesh

Adds a mesh object to the document.

Syntax

rhinoscriptsyntax.AddMesh ( vertices, face_vertices, vertex_normals=None, texture_coordinates=None, vertex_colors=None )

rhinoscript.mesh.AddMesh ( vertices, face_vertices, vertex_normals=None, texture_coordinates=None, vertex_colors=None )

Parameters

vertices	Required. List. A list of 3-D points defining the vertices of the mesh.
face_vertices	Required. List. A list containing lists of four numbers that define the vertex indices for each face of the mesh. If the third and forth vertex indices of a face are identical, a triangular face will be created. Otherwise a quad face will be created.