def Mesh2VTKUGrid(mesh):
	vtkcelltypes=((),(vtk.VTK_EMPTY_CELL,vtk.VTK_VERTEX,vtk.VTK_LINE),(vtk.VTK_EMPTY_CELL,vtk.VTK_VERTEX,vtk.VTK_LINE,vtk.VTK_TRIANGLE,vtk.VTK_QUAD,vtk.VTK_POLYGON,vtk.VTK_POLYGON),(vtk.VTK_EMPTY_CELL,vtk.VTK_VERTEX,vtk.VTK_LINE,vtk.VTK_TRIANGLE,vtk.VTK_TETRA,vtk.VTK_CONVEX_POINT_SET,vtk.VTK_CONVEX_POINT_SET,vtk.VTK_CONVEX_POINT_SET,vtk.VTK_HEXAHEDRON))
	npoints=mesh.num_vertices()
	geom=mesh.geometry()
	pts=vtk.vtkPoints()
	pts.SetNumberOfPoints(npoints)
	for i in xrange(npoints):
		p=geom.point(i)
		pts.SetPoint(i,p.x(),p.y(),p.z())
	dim = mesh.topology().dim()
	ncells=mesh.num_cells()
	cells=vtk.vtkCellArray()
	cellTypes=vtk.vtkUnsignedCharArray()
	cellTypes.SetNumberOfTuples(ncells)
	cellLocations=vtk.vtkIdTypeArray()
	cellLocations.SetNumberOfTuples(ncells)
	loc=0
	for (cell,i) in zip(mesh.cells(),xrange(ncells)) :
		ncellpoints=len(cell)
		cells.InsertNextCell(ncellpoints)
		for cpoint in cell:
			cells.InsertCellPoint(cpoint)
		cellTypes.SetTuple1(i,vtkcelltypes[dim][ncellpoints])
		cellLocations.SetTuple1(i,loc)
		loc+=1+ncellpoints
	ugrid = vtk.vtkUnstructuredGrid()
	ugrid.SetPoints(pts)
	ugrid.SetCells(cellTypes,cellLocations,cells)
	return ugrid
def Mesh2VTKUGrid(mesh):
    vtkcelltypes=((),(vtk.VTK_EMPTY_CELL,vtk.VTK_VERTEX,vtk.VTK_LINE),(vtk.VTK_EMPTY_CELL,vtk.VTK_VERTEX,vtk.VTK_LINE,vtk.VTK_TRIANGLE,vtk.VTK_QUAD,vtk.VTK_POLYGON,vtk.VTK_POLYGON),(vtk.VTK_EMPTY_CELL,vtk.VTK_VERTEX,vtk.VTK_LINE,vtk.VTK_TRIANGLE,vtk.VTK_TETRA,vtk.VTK_CONVEX_POINT_SET,vtk.VTK_CONVEX_POINT_SET,vtk.VTK_CONVEX_POINT_SET,vtk.VTK_HEXAHEDRON))
    npoints=mesh.num_vertices()
    geom=mesh.geometry()
    pts=vtk.vtkPoints()
    pts.SetNumberOfPoints(npoints)
    for i in xrange(npoints):
        p=geom.point(i)
        pts.SetPoint(i,p.x(),p.y(),p.z())
    dim = mesh.topology().dim()
    ncells=mesh.num_cells()
    cells=vtk.vtkCellArray()
    cellTypes=vtk.vtkUnsignedCharArray()
    cellTypes.SetNumberOfTuples(ncells)
    cellLocations=vtk.vtkIdTypeArray()
    cellLocations.SetNumberOfTuples(ncells)
    loc=0
    for (cell,i) in zip(mesh.cells(),xrange(ncells)) :
        ncellpoints=len(cell)
        cells.InsertNextCell(ncellpoints)
        for cpoint in cell:
            cells.InsertCellPoint(cpoint)
        cellTypes.SetTuple1(i,vtkcelltypes[dim][ncellpoints])
        cellLocations.SetTuple1(i,loc)
        loc+=1+ncellpoints
    ugrid = vtk.vtkUnstructuredGrid()
    ugrid.SetPoints(pts)
    ugrid.SetCells(cellTypes,cellLocations,cells)
    return ugrid
def parametrize_dataset(dataset, grid):
    from paraview.numpy_support import vtk_to_numpy
    xyz = vtk_to_numpy(dataset.GetPoints().GetData())
    
    from numpy import sqrt
    from numpy import zeros_like
    xrt = zeros_like(xyz)
    xrt[:, 0] = xyz[:, 0]
    xrt[:, 1] = sqrt(xyz[:, 1] ** 2 + xyz[:, 2] ** 2)
    
    from paraview.numpy_support import numpy_to_vtk
    from paraview.vtk import vtkPoints
    points = vtkPoints()
    points.SetData(numpy_to_vtk(xrt, deep=1))
    
    input = vtk.vtkPolyData()
    input.SetPoints(points)
    
    probe = vtk.vtkProbeFilter()
    probe.SetInput(input)
    probe.SetSource(grid)
    probe.Update()
    
    outputPointData = probe.GetOutput().GetPointData()
    pointData = dataset.GetPointData()
    pointData.AddArray(outputPointData.GetArray('hsH'))
    pointData.AddArray(outputPointData.GetArray('xm'))
def parametrize(spline, numberOfPoints=101, relativeExtension=0.1):
    from paraview.vtk import vtkFloatArray
    arrayU = vtkFloatArray()
    arrayV = vtkFloatArray()
    
    arrayU.SetName('hsH')
    arrayV.SetName('xm')
    
    from paraview.vtk import vtkPoints
    points = vtkPoints()
    uvMin = -relativeExtension
    uvMax = 1.0 + relativeExtension
    for _v in linspace(uvMin, uvMax, numberOfPoints):
        for _u in (uvMin, uvMax):
            arrayU.InsertNextTuple1(_u)
            arrayV.InsertNextTuple1(_v)
            
            pnt = spline(_u, _v)
            points.InsertNextPoint(pnt[0], pnt[1], 0.0)

    from paraview.vtk import vtkStructuredGrid
    grid = vtkStructuredGrid()
    grid.SetExtent(1, 2, 1, numberOfPoints, 1, 1)
    grid.SetPoints(points)
    
    pointData = grid.GetPointData()
    pointData.AddArray(arrayU)
    pointData.AddArray(arrayV)
    return grid
    def RequestData(self, request, inInfo, outInfo):
        logger.debug("Requesting data...")
        input = self.GetInputDataObject(0, 0)
        trajectory_data = dsa.WrapDataObject(input)
        output = dsa.WrapDataObject(vtkPolyData.GetData(outInfo))

        # Retrieve current time
        time = timesteps_util.get_timestep(self, logger=logger)

        # Retrieve trajectory data
        trajectory_times = trajectory_data.PointData["Time"]
        trajectory_points = trajectory_data.Points

        # Interpolate along the trajectory to find current position
        current_position = [
            np.interp(time, trajectory_times, trajectory_points[:, i])
            for i in range(3)
        ]

        # Expose to VTK
        points_vtk = vtk.vtkPoints()
        verts_vtk = vtk.vtkCellArray()
        verts_vtk.InsertNextCell(1)
        points_vtk.InsertPoint(0, *current_position)
        verts_vtk.InsertCellPoint(0)
        output.SetPoints(points_vtk)
        output.SetVerts(verts_vtk)

        # Interpolate remaining point data along the trajectory
        for dataset in trajectory_data.PointData.keys():
            if dataset == "Time":
                continue
            point_data = trajectory_data.PointData[dataset]
            data_at_position = np.zeros(point_data.shape[1:])
            if len(data_at_position.shape) > 0:
                for i in itertools.product(
                        *map(range, data_at_position.shape)):
                    point_data_i = point_data[(slice(None), ) + i]
                    if len(trajectory_times) == len(point_data_i):
                        data_at_position[i] = np.interp(
                            time, trajectory_times, point_data_i)
                    else:
                        logger.warning(
                            "Unable to interpolate trajectory dataset"
                            f" {dataset}[{i}]: Length of dataset"
                            f" ({len(point_data_i)}) does not match length of"
                            f" trajectory times ({len(trajectory_times)}).")
            else:
                data_at_position = np.interp(time, trajectory_times,
                                             point_data)
            data_vtk = vtknp.numpy_to_vtk(np.array([data_at_position]))
            data_vtk.SetName(dataset)
            output.GetPointData().AddArray(data_vtk)
        return 1
Beispiel #6
0
def _lattice2poly_data(cuds):
    poly_data = vtk.vtkPolyData()
    points = vtk.vtkPoints()
    coordinates = cuds.get_coordinate

    # copy node data
    point_data = poly_data.GetPointData()
    data_collector = CUBADataAccumulator(container=point_data)
    for node in cuds.iter(item_type=CUBA.NODE):
        points.InsertNextPoint(coordinates(node.index))
        data_collector.append(node.data)

    poly_data.SetPoints(points)
    return poly_data
Beispiel #7
0
def _mesh2unstructured_grid(cuds):
    point2index = {}
    unstructured_grid = vtk.vtkUnstructuredGrid()
    unstructured_grid.Allocate()

    # copy points
    points = vtk.vtkPoints()
    point_data = unstructured_grid.GetPointData()
    data_collector = CUBADataAccumulator(container=point_data)
    for index, point in enumerate(cuds.iter(item_type=CUBA.POINT)):
        point2index[point.uid] = index
        points.InsertNextPoint(*point.coordinates)
        data_collector.append(point.data)

    # prepare to copy elements
    cell_data = unstructured_grid.GetCellData()
    data_collector = CUBADataAccumulator(container=cell_data)

    # copy edges
    mapping = points2edge()
    for edge in cuds.iter(item_type=CUBA.EDGE):
        npoints = len(edge.points)
        ids = vtk.vtkIdList()
        for uid in edge.points:
            ids.InsertNextId(point2index[uid])
        unstructured_grid.InsertNextCell(mapping[npoints], ids)
        data_collector.append(edge.data)

    # copy faces
    mapping = points2face()
    for face in cuds.iter(item_type=CUBA.FACE):
        npoints = len(face.points)
        ids = vtk.vtkIdList()
        for uid in face.points:
            ids.InsertNextId(point2index[uid])
        unstructured_grid.InsertNextCell(mapping[npoints], ids)
        data_collector.append(face.data)

    # copy cells
    mapping = points2cell()
    for cell in cuds.iter(item_type=CUBA.CELL):
        npoints = len(cell.points)
        ids = vtk.vtkIdList()
        for uid in cell.points:
            ids.InsertNextId(point2index[uid])
        unstructured_grid.InsertNextCell(mapping[npoints], ids)
        data_collector.append(cell.data)

    unstructured_grid.SetPoints(points)
    return unstructured_grid
Beispiel #8
0
    def RequestData(self, request, inInfo, outInfo):
        logger.debug("Requesting data...")
        output = dsa.WrapDataObject(vtkPolyData.GetData(outInfo))

        with h5py.File(self._filename, "r") as trajectory_file:
            subfile = trajectory_file[self._subfile]
            coords = np.array(subfile[self._coords_dataset])
        coords[:, 1:] *= self._radial_scale
        logger.debug(f"Loaded coordinates with shape {coords.shape}.")

        # Construct a line of points
        points_vtk = vtk.vtkPoints()
        # Each ID is composed of (1) the order of the point in the line and (2)
        # the index in the `vtkPoints` constructed above
        line_vtk = vtk.vtkPolyLine()
        point_ids = line_vtk.GetPointIds()
        point_ids.SetNumberOfIds(len(coords))
        for i, point in enumerate(coords):
            points_vtk.InsertPoint(i, *point[1:])
            point_ids.SetId(i, i)
        output.SetPoints(points_vtk)
        # Set the line ordering as "cell data"
        output.Allocate(1, 1)
        output.InsertNextCell(line_vtk.GetCellType(), line_vtk.GetPointIds())

        # Add time data to the points
        time = vtknp.numpy_to_vtk(coords[:, 0])
        time.SetName("Time")
        output.GetPointData().AddArray(time)

        # Add remaining datasets from file to trajectory points
        with h5py.File(self._filename, "r") as trajectory_file:
            subfile = trajectory_file[self._subfile]
            for dataset in subfile:
                if dataset == self._coords_dataset:
                    continue
                dataset_vtk = vtknp.numpy_to_vtk(subfile[dataset][:, 1:])
                dataset_vtk.SetName(dataset.replace(".dat", ""))
                output.GetPointData().AddArray(dataset_vtk)
        return 1
Beispiel #9
0
def pvgrid(pvobj, filename):
    """Generate a ParaView source

    This function is not meant to be directly run, but is to be run as a
    ParaView progamable source. In ParaView

    Sources > Programmable Source

    in the properties tab set the Output Data Set to 'vtkUnstructuredGrid' and
    in the script box put

    from mesh.writers import pvgrid
    pvgrid(self, "filename.ext")

    make sure that afepy is on your PYTHONPATH

    """
    from paraview import vtk

    mesh = parse_xml(filename)
    output = pvobj.GetOutput()

    # allocate points
    pts = vtk.vtkPoints()
    for point in mesh.coords:
        if mesh.num_dim == 2:
            point = np.append(point, 0.)
        pts.InsertNextPoint(*point)
    output.SetPoints(pts)

    num_elem, num_node_per_elem = mesh.connect.shape
    output.Allocate(num_elem, 1000)
    for cell in mesh.connect:
        point_ids = vtk.vtkIdList()
        for point_id in range(num_node_per_elem):
            point_ids.InsertId(point_id, int(cell[point_id]))
        cell_type = VTK.vtk_cell_types(mesh.num_dim, num_node_per_elem)
        output.InsertNextCell(cell_type, point_ids)
Beispiel #10
0
def _particles2poly_data(cuds):
    particle2index = {}
    points = vtk.vtkPoints()
    lines = vtk.vtkCellArray()
    poly_data = vtk.vtkPolyData()

    point_data = poly_data.GetPointData()
    data_collector = CUBADataAccumulator(container=point_data)
    for index, particle in enumerate(cuds.iter(item_type=CUBA.PARTICLE)):
        particle2index[particle.uid] = index
        points.InsertPoint(index, *particle.coordinates)
        data_collector.append(particle.data)

    cell_data = poly_data.GetCellData()
    data_collector = CUBADataAccumulator(container=cell_data)
    for bond in cuds.iter(item_type=CUBA.BOND):
        lines.InsertNextCell(len(bond.particles))
        for uuid in bond.particles:
            lines.InsertCellPoint(particle2index[uuid])
        data_collector.append(bond.data)

    poly_data.SetPoints(points)
    poly_data.SetLines(lines)
    return poly_data
Beispiel #11
0
from paraview import vtk
import os
# Set your OpenGeoSys .msh file here.
filename = os.path.normcase("./examples/daejeon-ogs-final.msh")
f = open(filename)
output = self.GetOutput()

# Read everything with no line break but with space. IMPORTANT
contents = f.read().replace('\n', ' ')
words = contents.split()

# Now read point(node) info
numPoints = int(words[words.index('$NODES') + 1])
#print (numPoints)
pts = vtk.vtkPoints()

pos1 = words.index('$NODES') + 2
for node in range(numPoints):
    #    node_idx = words[pos+node*4]
    x = float(words[pos1 + node * 4 + 1])
    y = float(words[pos1 + node * 4 + 2])
    z = float(words[pos1 + node * 4 + 3])
    pts.InsertNextPoint(x, y, z)

#   print x, y, z

output.SetPoints(pts)

# Now read element(cell) info
numCells = int(words[words.index('$ELEMENTS') + 1])
#print (numCells)
Beispiel #12
0
"""
"""
CONVERT COORDINATES AND UNITS

Convert the coordinate XYZ from units of m to km and normalize origin to 0,
Change the units of the output from units of m/s to km/s
I honestly have no idea how I made this work, the documentation for these 
filters is apalling. Wtf paraview.
"""
from paraview import vtk

pdi = self.GetInput()
pdo = self.GetOutput()

numPoints = pdi.GetNumberOfPoints()
newPoints = vtk.vtkPoints()
min_x, _, min_y, _, _, _ = pdi.GetBounds()
for i in range(0, numPoints):
    coords = pdi.GetPoint(i)
    x, y, z = coords[:3]
    x -= min_x
    y -= min_y

    # Convert to units of km
    x *= 1E-3
    y *= 1E-3
    z *= 1E-3
    newPoints.InsertPoint(i, x, y, z)

# Set the new coordinate system
pdo.SetPoints(newPoints)
Beispiel #13
0
    def lire_monobloc(self, acces_fichier, numbloc=None):
        """lecture d'un seul bloc
        
        si numbloc est indique, alors le bloc est stocke comme numbloc 
        et le numero de bloc lu dans le v3d est ignore
        
        """

        dictionnaire_lecture = lire_v3d(
            acces_fichier=acces_fichier,
            fmt_fichier=self.fmt_fichier,
            endian=self.endian,
            precision=self.precision,
            compter_saut_de_ligne=self.compter_saut_de_ligne,
        )
        if numbloc is None:
            numbloc = dictionnaire_lecture["numbloc"] + self.decalage_numbloc_lus

        try:
            bloc_temp = vtk_new_shallowcopy(
                self.output if isinstance(self.output, vtk.vtkStructuredGrid) else self.output.GetBlock(numbloc)
            )
        except:
            bloc_temp = vtk.vtkStructuredGrid()

        # liste des donnees traitees
        donnees_traitees = []

        # GEOMETRIE
        # si des coordonnees (x,y,z) sont comprises dans le fichier lu
        if (
            dictionnaire_lecture["data"].has_key("x")
            and dictionnaire_lecture["data"].has_key("y")
            and dictionnaire_lecture["data"].has_key("z")
        ):
            numpyArrayCoords = numpy.vstack(
                (
                    dictionnaire_lecture["data"]["x"],
                    dictionnaire_lecture["data"]["y"],
                    dictionnaire_lecture["data"]["z"],
                )
            ).transpose(1, 0)
            vtkArray = numpy_support.numpy_to_vtk(numpy.ascontiguousarray(numpyArrayCoords), deep=1)
            points = vtk.vtkPoints()
            points.SetData(vtkArray)
            bloc_temp.SetDimensions(
                dictionnaire_lecture["dims"][0], dictionnaire_lecture["dims"][1], dictionnaire_lecture["dims"][2]
            )
            bloc_temp.SetPoints(points)
            donnees_traitees += ["x", "y", "z"]

        # DONNEES
        if not bloc_temp is None and bloc_temp.GetNumberOfPoints() != 0:
            # si il y a rou rov row
            if (
                dictionnaire_lecture["data"].has_key("rou")
                and dictionnaire_lecture["data"].has_key("rov")
                and dictionnaire_lecture["data"].has_key("row")
                and self.assembler_vecteurs is True
            ):
                momentum = numpy.vstack(
                    (
                        dictionnaire_lecture["data"]["rou"],
                        dictionnaire_lecture["data"]["rov"],
                        dictionnaire_lecture["data"]["row"],
                    )
                ).transpose(1, 0)
                vtkArray = numpy_support.numpy_to_vtk(numpy.ascontiguousarray(momentum), deep=1)
                vtkArray.SetName("momentum")
                self.ajouter_au_bloc(bloc_temp, vtkArray)
                donnees_traitees += ["rou", "rov", "row"]
            # si il y a trois donnees (et seulement trois) du type *_0 *_1 *_2
            liste_temp = [nom[:-2] for nom in dictionnaire_lecture["data"].keys()]
            for key in liste_temp:
                if (
                    numpy.all(
                        [
                            key + "_{0}".format(composante) in dictionnaire_lecture["data"].keys()
                            for composante in range(3)
                        ]
                    )
                    and numpy.all([key + "_{0}".format(composante) not in donnees_traitees for composante in range(3)])
                    and self.assembler_vecteurs is True
                ):
                    vector = numpy.vstack(
                        (
                            dictionnaire_lecture["data"][key + "_0"],
                            dictionnaire_lecture["data"][key + "_1"],
                            dictionnaire_lecture["data"][key + "_2"],
                        )
                    ).transpose(1, 0)
                    vtkArray = numpy_support.numpy_to_vtk(numpy.ascontiguousarray(vector), deep=1)
                    vtkArray.SetName(key)
                    self.ajouter_au_bloc(bloc_temp, vtkArray)
                    donnees_traitees += [key + "_%s" % (composante) for composante in range(3)]
            for key in dictionnaire_lecture["data"]:
                if key not in donnees_traitees:
                    vtkArray = numpy_support.numpy_to_vtk(dictionnaire_lecture["data"][key], deep=1)
                    vtkArray.SetName(key)
                    self.ajouter_au_bloc(bloc_temp, vtkArray)
                    donnees_traitees += [key]
        else:
            print "## IGNORE -- LA GEOMETRIE N'EST PAS CHARGEE"
            bloc_temp = None

        if isinstance(self.output, vtk.vtkStructuredGrid):
            self.output = bloc_temp
        else:
            self.output.SetBlock(numbloc, bloc_temp)
def trouver_centres_spheres_inscrites(surface_1, surface_2, 
        precision=1e-6, pas_initial=10):
    """fonction qui recherche les centrse des spheres inscrites entre les surface_1 et surface_2
    
    le vecteur 'Normals' doit etre present aux noeuds de surface_1
    
    la recherche se fait par trouver_zero_fonction_croissante, pour chacun des points de surface_1
    on cherche un point sur la ligne orthogonale a surface_1, equidistant de surface_1 et surface_2
        --> centre de la sphere inscrite entre surface_1 et surface_2
            passant par le point de surface_1 considere
    
    surface_1 et surface_2 doivent etre des vtkPolyData
    """
    
    # initialisation des outils vtk de calcul des distances
    calcul_distance_1 = vtk.vtkKdTreePointLocator()
    calcul_distance_1.SetDataSet(surface_1)
    calcul_distance_1.BuildLocator()
    calcul_distance_2 = vtk.vtkKdTreePointLocator()
    calcul_distance_2.SetDataSet(surface_2)
    calcul_distance_2.BuildLocator()
    vtkMath = vtk.vtkMath()
    
    # lecture des donnees de la surface
    liste_normals_surface_1 = numpy_support.vtk_to_numpy(surface_1.GetPointData().GetArray('Normals'))
    liste_points_surface_1 = numpy_support.vtk_to_numpy(surface_1.GetPoints().GetData())
    # ACTION
    liste_centres = numpy.empty((0,3))
    
    print "progression ",
    printed = False
    for numero_point_surface_1 in range(0, surface_1.GetNumberOfPoints()):
        progress = ((numero_point_surface_1 + 1) * 100) // surface_1.GetNumberOfPoints()
        if progress % 10 == 0 and printed is False:
            print "{0}%".format(progress), 
            printed = True
        elif progress % 10 != 0:
            printed = False
        """le vecteur normal et les coordonnees de point definissent une ligne
        sur laquelle chercher le centre de la sphere"""
        normal = liste_normals_surface_1[numero_point_surface_1]
        point = liste_points_surface_1[numero_point_surface_1]
        
        def fonction_a_annuler(x):
            centre = point + x * normal
            p1 = surface_1.GetPoint(calcul_distance_1.FindClosestPoint(centre))
            p2 = surface_2.GetPoint(calcul_distance_2.FindClosestPoint(centre))
            dist_1 = vtkMath.Distance2BetweenPoints(p1, centre)
            dist_2 = vtkMath.Distance2BetweenPoints(p2, centre)
            nv_ecart = dist_1 ** (1. / 2) - dist_2 ** (1. / 2)
            return nv_ecart
        
        """ recherche du centre de la sphere inscrite par trouver_zero_fonction_croissante"""
        # il est possible que le pas initial indique soit trop petit
        pas = pas_initial
        while fonction_a_annuler(pas) < 0:
            pas *= 2.
        # recherche par dichotomie
        x_solution = trouver_zero_fonction_croissante(0.0, pas, fonction_a_annuler, precision)
        centre = point + x_solution * normal
        liste_centres = numpy.r_[liste_centres, centre.reshape((1, 3))]
    print "termine"
    
    # creation d'un object vtkPolyData
    vtkPoints_mean = vtk.vtkPoints()
    vtkPoints_mean.SetData(numpy_support.numpy_to_vtk(liste_centres, deep = 1))
    
    surface_moyenne = vtk.vtkPolyData()
    surface_moyenne.SetPoints(vtkPoints_mean)
    surface_moyenne.SetPolys(surface_1.GetPolys())
    surface_moyenne.Update()

    return surface_moyenne
Beispiel #15
0
def calculer_champ_meridien(vtkDataObject, 
        maillage_regulier=None,
        retourner_maillage_regulier=False, 
        hubFileName = "/media/FreeAgent GoFlex Drive/DATA_PI4/hub",
        tipFileName = "/media/FreeAgent GoFlex Drive/DATA_PI4/shroud", 
        stepSize=2.0, relativeExtension=0.1, 
        numberOfPoints_xm = 75, numberOfPoints_h = 10, 
        dtheta = 2 * numpy.pi / (21 * 10)
        ):
    """Fonction qui retourne un plan, contenant le champ meridien
    Le champ est le resultat d'une moyenne azimutale ponderee simple
    """
    #Creation du maillage regulier
    if maillage_regulier is None:
        from UVParametrizationFilter import CreateSpline
        spline, numberOfPoints = CreateSpline(hubFileName, tipFileName, stepSize,
            relativeExtension=relativeExtension)
        
        coords = get_vtk_array_as_numpy_array(vtkDataObject, "coords")
        coordx = coords[:, 0]
        coordy = coords[:, 1]
        coordz = coords[:, 2]
        coordtheta = numpy.arctan2(coordz, coordy)
        
        min_theta = coordtheta.min()
        max_theta = coordtheta.max()
        
        ntheta = int((max_theta - min_theta) // dtheta)
        print "Dimensions du grid ", numberOfPoints_xm, numberOfPoints_h, ntheta
        
        points = vtk.vtkPoints()
        uvMin = -relativeExtension
        uvMax = 1.0 + relativeExtension
        for _v in numpy.linspace(uvMin, uvMax, numberOfPoints_xm):
            print _v
            for _u in numpy.linspace(uvMin, uvMax, numberOfPoints_h):
                for theta in numpy.linspace(min_theta, max_theta, ntheta):
                    pnt = spline(_u, _v)
                    x = pnt[0]
                    y = pnt[1] * numpy.cos(theta)
                    z = pnt[1] * numpy.sin(theta)
                    points.InsertNextPoint(x, y, z)
    
        grid = vtk.vtkStructuredGrid()
        grid.SetDimensions(ntheta, numberOfPoints_h, numberOfPoints_xm)
        grid.SetPoints(points)
        
        #on retourne le maillage_regulier si demande
        if retourner_maillage_regulier == 1:
            return grid
    else:
        grid = maillage_regulier
    
    
    
    #Probe et moyenne azimutale, pour finalement retourner le plan
    grid = VTKProbe(input = grid, source = vtkDataObject)
    
    #pour le plan a retourner, on choisit arbitrairement le plan i=0 du maillage regulier
    plan = Extraction(input = grid, formule_extraction='i=0').get_output()
    
    #moyenne de chacune des grandeurs le long des lignes a x, r, constants
    for nom_grandeur in get_noms_arrays_presents(vtkDataObject):
        grandeur = get_vtk_array_as_numpy_array(grid, nom_grandeur)
        if grandeur.size == grid.GetNumberOfPoints():
            grandeur = grandeur.reshape(grid.GetDimensions()[::-1])
        else:
            grandeur = grandeur.reshape(grid.GetDimensions()[::-1] + (3,))
        grandeur = numpy.ma.masked_less(grandeur, 0.1)
        grandeur = numpy.mean(grandeur, axis=2)
        grandeur = grandeur.ravel()
        plan = ajouter_numpy_array_as_vtk_array(plan, grandeur, nom_grandeur)
    
    return plan
output.RowData.append(max(rtdata), 'max')
###########################################################################
#5.CSV Reader(Source)
#file format:
# x,y,z,velocity
# 1,0,0,1
# 2,0,1,1
# . . .

from paraview import vtk
import os

filepath="/home/jiabin/python/datafile.txt"
filename=os.path.normcase(filepath)

pts=vtk.vtkPoints()
f=open(filename)
pdo=self.GetOutput()

firstline=True
for line in f:
  if firstline:
    firstline=False
    for pos,word in enumerate(line.split(",")):
      if pos > 2:
        newArray = vtk.vtkDoubleArray()
        newArray.SetName(word)
        newArray.SetNumberOfComponents(1)
        pdo.GetPointData().AddArray(newArray)
  else:
    for pos,word in enumerate(line.split(",")):