[vtk] Paysages fractals - Segmentation fault depuis une utilisation python

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:
https://sourceforge.net/projects/mmw..._landscape.jpg

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:

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')