De retour de la surface du triangle de la 3D scipy.spatiales.Delaunay

J'ai ce problème. J'essaie de combiner les points de cloud par scipy.spatiales.Delaunay. J'ai utilisé:

tri = Delaunay(points) # points: np.array() of 3d points 
indices = tri.simplices
vertices = points[indices]

Mais, ce code de retour du tétraèdre. Comment est-il possible de retourner le triangle de la surface uniquement?

Grâce

OriginalL'auteur s.t.e.a.l.t.h | 2014-10-17

7

Pour qu'il fonctionne que sous forme de code, vous devez paramétrer la surface 2D. Par exemple, dans le cas de la boule (r,theta, psi), le rayon est constant (drop out) et les points sont donnés par (theta,psi) qui est en 2D.

Scipy Delaunay est à N dimensions de la triangulation, donc si vous donnez des points 3D il renvoie les objets 3D. Donner 2D des points et il renvoie à des objets 2D.

Ci-dessous est un script que j'ai utilisé pour créer des polyèdres pour openSCAD. U et V sont mes paramétrisation (x et y) et ce sont les coordonnées que je donne à Delaunay. Notez que la "triangulation de Delaunay" propriétés s'appliquent uniquement dans u,v de coordonnées (les angles sont maximisés dans l'espace uv pas xyz -espace, etc).

L'exemple est une copie modifiée de http://matplotlib.org/1.3.1/mpl_toolkits/mplot3d/tutorial.html qui, à l'origine utilise Triangulation fonction (cartes à Delaunay finalement?)
```
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.tri as mtri
from scipy.spatial import Delaunay

# u, v are parameterisation variables
u = np.array([0,0,0.5,1,1]) 
v = np.array([0,1,0.5,0,1]) 

x = u
y = v
z = np.array([0,0,1,0,0])

# Triangulate parameter space to determine the triangles
#tri = mtri.Triangulation(u, v)
tri = Delaunay(np.array([u,v]).T)

print 'polyhedron(faces = ['
#for vert in tri.triangles:
for vert in tri.simplices:
    print '[%d,%d,%d],' % (vert[0],vert[1],vert[2]),
print '], points = ['
for i in range(x.shape[0]):
    print '[%f,%f,%f],' % (x[i], y[i], z[i]),
print ']);'


fig = plt.figure()
ax = fig.add_subplot(1, 1, 1, projection='3d')

# The triangles in parameter space determine which x, y, z points are
# connected by an edge
#ax.plot_trisurf(x, y, z, triangles=tri.triangles, cmap=plt.cm.Spectral)
ax.plot_trisurf(x, y, z, triangles=tri.simplices, cmap=plt.cm.Spectral)


plt.show()
```
Ci-dessous le (un peu plus structuré) texte de sortie:
```
polyhedron(
    faces = [[2,1,0], [3,2,0], [4,2,3], [2,4,1], ], 

    points = [[0.000000,0.000000,0.000000], 
              [0.000000,1.000000,0.000000], 
              [0.500000,0.500000,1.000000], 
              [1.000000,0.000000,0.000000], 
              [1.000000,1.000000,0.000000], ]);
```
Excellent exemple. Elle ne génère pas une "surface fermée" bien que la face inférieure (2 triangles) est manquant. Est-il un moyen de l'enfermer complètement avec les triangles?
Cette question se rapporte à la façon de créer une surface 2D en 3D. C'est un problème commun (ou fonction) dans la création de maillages. Il n'y a aucun moyen que vous pouvez mapper une surface 2D à la 3D sans objet la création d'une sorte de point ou des points ou de lignes. Par exemple, pensez à la façon terres de latitude et de longitude sont définis. Ils sont parfaitement 2d en équateur et complètement les écrous dans les pôles. Latitude = 90 degrés définit le pôle nord et au pôle nord, vous pouvez aller de longitude 15 de longitude 67 ou à la longitude 87 en douceur et en continu. Le point est qu'il n'y a pas moyen de faire ce que vous demandez.
Je voudrais diviser le problème en deux (ou plus) parties et créer deux surfaces. Sinon, il pourrait être possible de créer en 3D de triangulation et d'obtenir les surfaces extérieures des triangles. Si vous trouvez une bonne façon de le faire, faites le moi savoir. C'est un très commun de problème pratique.
Mon point est le résultat de construit sur mesure scanner 3d. J'ai réalisé que j'ai des groupes de points communs z de la valeur que je pourrais connecter ensemble. Ensuite, je peux probablement juste de trianguler entre chaque paire de lignes parallèles

OriginalL'auteur Juha
4

Il semble que vous voulez calculer le l'enveloppe convexe de votre nuage de points. Je pense que c'est ce que vous voulez faire:
```
from scipy.spatial import ConvexHull

hull = ConvexHull(points)
indices = hull.simplices
vertices = points[indices]
```
Dans cette image lien vous pouvez voir ce nuage de points, je tiens à trianguler. Quand j'essaie de faire de l'enveloppe convexe, je serai à la triangulation comme dans l'image. Je voudrais connecter le plus proche des points de triangle seulement
Vous ne serez pas en mesure d'utiliser le scipy.spatial fonctions à faire ce que vous demandez, puisque c'est basé sur qhull qui "ne prend pas en charge la triangulation de non-surfaces convexes...". Vous pourriez peut-être briser vos points en plusieurs surfaces convexes.
Oui, merci, j'ai résolu ce problème en CGAL poisson de reconstruction.

OriginalL'auteur Jaime

Suivantes Jaime réponse, mais d'élaborer un peu plus avec un exemple:

import matplotlib as mpl
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d as a3
import numpy as np
import scipy as sp
from scipy import spatial as sp_spatial
def icosahedron():
h = 0.5*(1+np.sqrt(5))
p1 = np.array([[0, 1, h], [0, 1, -h], [0, -1, h], [0, -1, -h]])
p2 = p1[:, [1, 2, 0]]
p3 = p1[:, [2, 0, 1]]
return np.vstack((p1, p2, p3))
def cube():
points = np.array([
[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1],
[1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1],
])
return points
points = icosahedron()
# points = cube()
hull = sp_spatial.ConvexHull(points)
indices = hull.simplices
faces = points[indices]
print('area: ', hull.area)
print('volume: ', hull.volume)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.dist = 30
ax.azim = -140
ax.set_xlim([0, 2])
ax.set_ylim([0, 2])
ax.set_zlim([0, 2])
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
for f in faces:
face = a3.art3d.Poly3DCollection([f])
face.set_color(mpl.colors.rgb2hex(sp.rand(3)))
face.set_edgecolor('k')
face.set_alpha(0.5)
ax.add_collection3d(face)
plt.show()

Qui devrait représenter la figure suivante:

De retour de la surface du triangle de la 3D scipy.spatiales.Delaunay

OriginalL'auteur gmagno

Vous devez vous connecter pour publier un commentaire.