Ejemplo n.º 1
0
def convertir_surface_en_polydata(surface, nettoyage_tolerance=5e-2):
    """fonction de conversion d'une surface en polydata
    avec fusion des blocs si surface est un multiblock
    """
    # si surface est un multiblock, il faut les regrouper en un seul polydata
    if isinstance(surface, vtk.vtkMultiBlockDataSet):
        appendFilter = vtk.vtkAppendPolyData()
        appendFilter.MergePointsOn()
        iter = surface.NewIterator()
        iter.UnRegister(None)
        iter.InitTraversal()
        while not iter.IsDoneWithTraversal():
            curInput = iter.GetCurrentDataObject()
            if not isinstance(curInput, vtk.vtkPolyData):
                conversion = vtk.vtkGeometryFilter()
                conversion.SetInput(curInput)
                conversion.Update()
                appendFilter.AddInput(conversion.GetOutput())
            else:
                appendFilter.AddInput(curInput)
            iter.GoToNextItem()
        appendFilter.Update()
        surface = appendFilter.GetOutput()
    
    # si surface n'est pas un multiblock, il faut simplemement le convertir en vtkPolyData
    elif not isinstance(surface, vtk.vtkPolyData):
        conversion = vtk.vtkGeometryFilter()
        conversion.SetInput(surface)
        conversion.Update()
        surface = conversion.GetOutput()
    
    #LA PARTIE SUIVANTE N'EST PAS NECESSAIRE LORSQUE L'ON UTILISE MERGEPOINTSON DE L'APPENDFILTER
    # nettoyage des points confondus (aux frontieres entre les blocs)
    #nettoyage = vtk.vtkCleanPolyData()
    #nettoyage.SetInput(surface)
    #nettoyage.Update()
    #surface = nettoyage.GetOutput()
    
    return surface
Ejemplo n.º 2
0
def moyenne_sur_epaisseur(paroi, data, liste_ep):
    """Fonction qui realise la moyenne des donnees presentes aux points
    sur plusieurs nappes decalees par rapport a la premiere le long du vecteur 'Normals'
    
    utilise fonctions_basiques.VTKProbe pour prober mono/multi-blocs
    si paroi est un vtkStructuredGrid, alors il est transforme en vtkPolyData en utilisant
    le filtre vtkGeometryFilter, avant d'entrer dans le vtkProbleFilter
    """
    paroi.GetPointData().SetActiveVectors('Normals')
    for nom_array in get_noms_arrays_presents(paroi, 'points'):
        if nom_array != 'Normals':
            paroi.GetPointData().RemoveArray(nom_array)
    for nom_array in get_noms_arrays_presents(paroi, 'cellules'):
        paroi.GetCellData().RemoveArray(nom_array)
    
    liste_noms_arrays = get_noms_arrays_presents(data, loc = 'points')
    dict_data = dict.fromkeys(liste_noms_arrays)
    
    f = vtk.vtkGeometryFilter()
    f.SetInput(paroi)
    f.Update()
    paroi = f.GetOutput()
    
    for ep in liste_ep:
        print "epaisseur ", ep
        warp = vtk.vtkWarpVector()
        warp.SetInput(paroi)
        warp.SetScaleFactor(ep)
        warp.Update()
        warp = warp.GetOutput()
       
        warp = VTKProbe(input = warp, source = data)
        for array in liste_noms_arrays:
            if dict_data[array] is None:
                dict_data[array] = get_vtk_array_as_numpy_array(warp, array, True).reshape(
                    warp.GetPointData().GetArray(array).GetNumberOfTuples(), 
                    warp.GetPointData().GetArray(array).GetNumberOfComponents())
            else:
                dict_data[array] += get_vtk_array_as_numpy_array(warp, array, True).reshape(
                    warp.GetPointData().GetArray(array).GetNumberOfTuples(), 
                    warp.GetPointData().GetArray(array).GetNumberOfComponents())
    for array in dict_data:
        dict_data[array] /= len(liste_ep)
        varray = numpy_support.numpy_to_vtk(dict_data[array], deep = 1)
        varray.SetName(array)
        paroi.GetPointData().AddArray(varray)
    
    return paroi