Discussion :

[Loïc B.]

Bonjour,

récemment, je me suis amusé à développer une routine générant des paysages fractals à partir de la méthode des triangles. Ca fait intervenir la triangulation de Delaunay. Au début, j'ai fait ça avec scipy.spatial, puis j'ai essayé d'améliorer les performances avec la lib vtk wrappée en python.

Au passage, un screenshot, ça fait plaisir:


Mauvaise surprise, la méthode est beaucoup moins robuste, et un segmentation fault apparaît dès que l'on descend trop en précision, alors que ça n'arrivait pas avec matplotlib.

Du coup j'ai deux questions:
- a voir le code, voyez vous une erreur d'utilisation
- comment tracer cette segmentation fault et savoir d'où vient le problème dans la lib vtk ?


Je vous met le code incriminé (le segfault apparaît en ligne 36):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# Standard library imports
import random
import sys
# Related third party imports
import numpy
import vtk.util.numpy_support
 
# Local application/library specific imports
 
 
class Landscape(object):
    def __init__(self, depth):
        # Initiate triangulation
        # Set VTK points
        points = numpy.array([[0., 0., 0.],
                              [0., 1., 0.],
                              [1., 1., 0.],
                              [1., 0., 0.]])
        self.__vtk_points =  vtk.vtkPoints()        
        self.__vtk_points.SetData(vtk.util.numpy_support.numpy_to_vtk(points))
        # Perform triangulation
        self.update_triangulated_set()
        # Launch full generation
        self.generate(depth)
 
    def update_triangulated_set(self):
        # Create polydata with those points
        vtk_polydata = vtk.vtkPolyData()
        vtk_polydata.SetPoints(self.__vtk_points)
        # Perform Delaunay on this polydata
        vtk_delaunay = vtk.vtkDelaunay2D()
        # Empirical setting to get convex hull
        vtk_delaunay.SetOffset(100.)
        vtk_delaunay.SetInput(vtk_polydata)         
        print self.__vtk_points.GetNumberOfPoints()
        vtk_delaunay.Update() #FIXME: segfault for max_deep = 10 at that step. No segfault if coordinates are random                  
        self.__triangulated_set = vtk_delaunay.GetOutput()
 
 
    def generate(self, max_depth):
        for depth in range(max_depth):
            # Loop on each polygon (ie triangle as resulting from Delaunay)
            for cell_id in range(self.__triangulated_set.GetNumberOfCells()):
                # Retrieve triangle vertices 
                point_array = vtk.util.numpy_support.vtk_to_numpy(self.__triangulated_set.GetCell(cell_id).GetPoints().GetData())
                # Compute barycenter
                barycenter = numpy.mean(point_array, axis = 0)
                # Choose a random value for altitude
                rand_alt =  (random.random() * 2 - 1)/3. * 1/2.**depth 
                # Add barycenter to set of points                
                self.__vtk_points.InsertNextPoint(barycenter[0], barycenter[1], barycenter[2]+rand_alt)
            # Perform triangulation
            self.update_triangulated_set()
 
    def export_to_vtk(self, filename):
        # Write polydata object to file
        vtk_polydata_writer = vtk.vtkPolyDataWriter()
        vtk_polydata_writer.SetInput(self.__triangulated_set)
        vtk_polydata_writer.SetFileName(filename)
        vtk_polydata_writer.Write()
 
 
myLandscape = Landscape(10)
myLandscape.export_to_vtk('fractal_landscape.vtk')

[Loïc B.]

Bon, gros succès mon post !

Quand j'ai vu qu'il remontait premier dans mes requêtes google pour trouver une réponse, j'ai compris que ça sentait pas bon ...

Concernant sa résolution, de ce que j'ai compris, mon implémentation de la méthode du "middle point displacement" menait à des triangles dégénérés, et des points très proches les uns des autres. Et ça vtk ne semblait pas l'accepter.

Après implémentation correcte, ça fonctionne beaucoup mieux et je peux réaliser des triangulations beaucoup plus fines.

Problème restant: la triangulation de delaunay de matplotlib est plus robuste face aux triangles dégénérés que celle de vtk.