Example #1
0
    def pushConcentration(self, ecoSlimFile):
        if os.path.exists(ecoSlimFile):
            if self.vtkReader:
                self.vtkReader.SetFileName(ecoSlimFile)
            else:
                self.vtkReader = vtk.vtkDataSetReader()
                self.vtkReader.SetFileName(ecoSlimFile)

            self.vtkReader.Update()
            imageData = self.vtkReader.GetOutput()

            if imageData:
                array = imageData.GetCellData().GetArray('Concentration')
                dataRange = array.GetRange(0)

                print('push concentration: %s' % ecoSlimFile)
                self.publish(
                    'parflow.sandtank.concentration', {
                        'time': self.lastEcoSLIMTimestep,
                        'range': dataRange,
                        'array': self.addAttachment(
                            memoryview(array).tobytes())
                    })
            elif self.lastEcoSLIMTimestep > -1:
                self.lastEcoSLIMTimestep -= 1
Example #2
0
def show_vtk_file(path):
	# open vtk file from arglist
	reader = vtk.vtkDataSetReader()
	reader.SetFileName(path)
	reader.Update()
	# read out data and scalarrange
	output = reader.GetOutput()
	scalarrange = output.GetScalarRange()
	# generate Mapper and set DataSource
	mapper = vtk.vtkDataSetMapper()
	mapper.SetInput(output)
	mapper.SetScalarRange(scalarrange)
	# create actor
	actor = vtk.vtkActor()
	actor.SetMapper(mapper)
	# build renderer
	renderer = vtk.vtkRenderer()
	window = vtk.vtkRenderWindow()
	window.AddRenderer(renderer)
	# create interaction
	interaction = vtk.vtkRenderWindowInteractor()
	interaction.SetRenderWindow(window)
	# add actor
	renderer.AddActor(actor)
	# show window and start inteaction and renderer
	interaction.Initialize()
	window.Render()
	interaction.Start()
Example #3
0
def vtkDatasetFromHdf5(g):
    """
    extract a vtkDataset Object from a text file representation stored in a
    hdf5 character array dataset g. The concrete returned type depends on the
    content of the file.
  """
    gridtype2vtureader = {
        'vtkImageData': vtk.vtkXMLImageDataReader,
        'vtkPolyData': vtk.vtkXMLPolyDataReader,
        'vtkUnstructuredGrid': vtk.vtkXMLUnstructuredGridReader,
    }
    filetype = g.attrs["TYPE"]
    if filetype == 'VTK_FILE':  # shit! i used vtu files at first before i noticed that the legacy vtk format is much easier to deal with ...
        reader = vtk.vtkDataSetReader()
        reader.ReadFromInputStringOn()
        reader.SetInputString(np.asarray(g).tostring())
        reader.Update()
    else:
        probable_vtk_dataset_type = g.attrs.get('VTK_DATASET_TYPE',
                                                'vtkUnstructuredGrid')
        import mkstemp  # my stuff
        tf = mkstemp.File(suffix=".vtx")
        f = open(tf.filename, 'wb')
        f.write(np.asarray(g).tostring())
        f.close()
        reader = gridtype2vtureader[probable_vtk_dataset_type]()
        reader.SetFileName(tf.filename)
        reader.Update()
        tf.remove()
    return reader.GetOutput()
Example #4
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkDataSetReader(), 'Reading vtkDataSet.',
         (), ('vtkDataSet',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
def load_vtk(t, case="free"):
    f = "rvat-log-" + case + "/velocity/"+str(t)+".vtk"
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(f)
    reader.Update()
    data = reader.GetOutput()
    
    npoints = data.GetNumberOfPoints()
    point = data.GetPoint(0)
    d = data.GetPointData()
    
    array = d.GetArray("Velocity")
    
    u = np.zeros(npoints)
    v = np.zeros(npoints)
    w = np.zeros(npoints)
    x = np.zeros(npoints)
    y = np.zeros(npoints)
    z = np.zeros(npoints)
    
    for n in range(npoints):
        x[n], y[n], z[n] = data.GetPoint(n)
        u[n], v[n], w[n] = array.GetTuple(n)
        
    u = u[np.where(x==1.0)[0]]
    v = v[np.where(x==1.0)[0]]
    w = w[np.where(x==1.0)[0]]
    y = y[np.where(x==1.0)[0]]
    z = z[np.where(x==1.0)[0]]
        
    yarray, zarray, [uarray, varray, warray] = ts.build_plane_arrays(y, z,
                                                                    [u, v, w])
    return yarray, zarray, uarray, varray, warray
Example #6
0
    def _read_polydata(self):
        """
        This private method reads the given `filename` and return a vtkPolyData
        object containing all informations about file; to avoid useless IO
        operation on the same file, it stores polydata of the last file parsed
        and if user ask for this file, the polydata previously stored is
        returned.

        :return: polydata containing information about file.
        :rtype: vtkPolyData
        """
        # Polydata from `filename` is allready loaded; return it
        if self._cached_data is not None:
            return self._cached_data

        if not os.path.isfile(self._filename):
            raise RuntimeError("{0!s} doesn't exist".format(
                os.path.abspath(self._filename)))

        reader = vtk.vtkDataSetReader()
        reader.SetFileName(self._filename)
        reader.Update()
        data = reader.GetOutput()

        self._cached_data = data

        return data
Example #7
0
def get_tensor_array(filename):
    """Returns vtk tensor array object which can have 'GetTuple9(i)' called on it."""
    print "Reading " + filename
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.Update()

    output = reader.GetOutput()
    print 'npoints:', output.GetNumberOfPoints()
    print 'ncells:', output.GetNumberOfCells()
    print 'nscalars:', reader.GetNumberOfScalarsInFile()
    print 'ntensors:', reader.GetNumberOfTensorsInFile()
    print 'ScalarName:', reader.GetScalarsNameInFile(0)
    print 'TensorName:', reader.GetTensorsNameInFile(0)

    output = reader.GetOutput()
    pointdata = output.GetPointData()
    #scalar_array = pointdata.GetArray('scalar')
    tensor_array = pointdata.GetTensors()
    if not tensor_array:
        tensor_array = pointdata.GetArray('tensor')
    if not tensor_array:
        tensor_array = pointdata.GetArray('tensors')
    if not tensor_array:
        tensor_array = pointdata.GetArray('Tensors_')
    if not tensor_array:
        tensor_array = pointdata.GetArray('tensor1')
    if not tensor_array:
        print "Cannot find tensors in %s" % filename
        sys.exit(1)
    return tensor_array
Example #8
0
    def _read_polydata(self):
        """
        This private method reads the given `filename` and return a vtkPolyData
        object containing all informations about file; to avoid useless IO
        operation on the same file, it stores polydata of the last file parsed
        and if user ask for this file, the polydata previously stored is
        returned.

        :return: polydata containing information about file.
        :rtype: vtkPolyData
        """
        # Polydata from `filename` is allready loaded; return it
        if self._cached_data is not None:
            return self._cached_data

        if not os.path.isfile(self._filename):
            raise RuntimeError("{0!s} doesn't exist".format(
                os.path.abspath(self._filename)))

        reader = vtk.vtkDataSetReader()
        reader.SetFileName(self._filename)
        reader.Update()
        data = reader.GetOutput()

        self._cached_data = data

        return data
Example #9
0
    def write(self, mesh_points, filename):
        """
        Writes a vtk file, called filename, copying all the
        structures from self.filename but the coordinates.
        `mesh_points` is a matrix that contains the new coordinates
        to write in the vtk file.

        :param numpy.ndarray mesh_points: it is a `n_points`-by-3
            matrix containing the coordinates of the points of the
            mesh
        :param string filename: name of the output file.
        """
        self._check_filename_type(filename)
        self._check_extension(filename)
        self._check_infile_instantiation()

        self.outfile = filename

        reader = vtk.vtkDataSetReader()
        reader.SetFileName(self.infile)
        reader.ReadAllVectorsOn()
        reader.ReadAllScalarsOn()
        reader.Update()
        data = reader.GetOutput()

        points = vtk.vtkPoints()
        for i in range(data.GetNumberOfPoints()):
            points.InsertNextPoint(mesh_points[i, :])

        data.SetPoints(points)

        writer = vtk.vtkDataSetWriter()
        writer.SetFileName(self.outfile)
        writer.SetInputData(data)
        writer.Write()
Example #10
0
def get_tensor_array(filename):
    """Returns vtk tensor array object which can have 'GetTuple9(i)' called on it."""
    print("Reading " + filename)
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.Update()

    output = reader.GetOutput()
    print('npoints:', output.GetNumberOfPoints())
    print('ncells:', output.GetNumberOfCells())
    print('nscalars:', reader.GetNumberOfScalarsInFile())
    print('ntensors:', reader.GetNumberOfTensorsInFile())
    print('ScalarName:', reader.GetScalarsNameInFile(0))
    print('TensorName:', reader.GetTensorsNameInFile(0))

    output = reader.GetOutput()
    pointdata = output.GetPointData()
    #scalar_array = pointdata.GetArray('scalar')
    tensor_array = pointdata.GetTensors()
    if not tensor_array:
        tensor_array = pointdata.GetArray('tensor')
    if not tensor_array:
        tensor_array = pointdata.GetArray('tensors')
    if not tensor_array:
        tensor_array = pointdata.GetArray('Tensors_')
    if not tensor_array:
        tensor_array = pointdata.GetArray('tensor1')
    if not tensor_array:
        print("Cannot find tensors in %s" % filename)
        sys.exit(1)
    return tensor_array
Example #11
0
	def parse(self, filename):
		"""
		Method to parse the file `filename`. It returns a matrix with all the coordinates.

		:param string filename: name of the input file.

		:return: mesh_points: it is a `n_points`-by-3 matrix containing the coordinates of
			the points of the mesh
		:rtype: numpy.ndarray

		.. todo::

			- specify when it works
		"""
		self._check_filename_type(filename)
		self._check_extension(filename)

		self.infile = filename

		reader = vtk.vtkDataSetReader()
		reader.SetFileName(self.infile)
		reader.ReadAllVectorsOn()
		reader.ReadAllScalarsOn()
		reader.Update()
		data = reader.GetOutput()

		n_points = data.GetNumberOfPoints()
		mesh_points = np.zeros([n_points, 3])

		for i in range(n_points):
			mesh_points[i][0], mesh_points[i][1], mesh_points[i][2] = data.GetPoint(i)

		return mesh_points
Example #12
0
def getReaderWriter(file_name, out_dir=None):
    r = vtk.vtkDataSetReader()
    r.SetFileName(file_name)
    f_base = os.path.splitext(file_name)[0]
    r.Update()
    reader = None
    writer = None
    xmlsuffix = '.xml'
    map = {'StructuredPoints': '.vti', 'StructuredGrid': '.vts',
           'RectilinearGrid': '.vtr', 'UnstructuredGrid': '.vtu',
           'PolyData': '.vtp'}
    for i in ['StructuredPoints', 'StructuredGrid', 'RectilinearGrid',
              'UnstructuredGrid', 'PolyData']:
        if eval('r.IsFile%s()'%i):
            reader = eval('vtk.vtk%sReader()'%i)
            if i == 'StructuredPoints':
                writer = eval('vtk.vtkXMLImageDataWriter()')
            else:
                writer = eval('vtk.vtkXML%sWriter()'%i)
            xmlsuffix = map[i]
            break
    if not reader:
        return None, None

    reader.SetFileName(file_name)
    reader.Update()

    out_file = f_base + xmlsuffix
    if out_dir:
        out_file = os.path.join(out_dir,
                                os.path.basename(f_base) + xmlsuffix)
    writer.SetFileName(out_file)
    return reader, writer
Example #13
0
def vtk_bin_to_ascii(fin, fout, origin, spacing):
    """Convert VTK file to ascii format.

    Intended for VTK files with 3D voxel data. Also adjusts origin and spacing.

    Args:
        fin (str): input filename
        fout (str): output filename
        origin (list): origin of coordinate system
        spacing (list): distance between the nodes in structured mesh
    """
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(fin)
    reader.Update()
    data = vtk.vtkImageData()
    data.ShallowCopy(reader.GetOutput())
    data.SetOrigin(origin)
    data.SetSpacing(spacing)
    writer = vtk.vtkStructuredPointsWriter()
    if vtk.VTK_MAJOR_VERSION <= 5:
        writer.SetInputConnection(data.GetProducerPort())
    else:
        writer.SetInputData(data)
    writer.SetFileName(fout)
    writer.Write()
Example #14
0
    def parse(self, filename):
        """
		Method to parse the file `filename`. It returns a matrix with all the coordinates.

		:param string filename: name of the input file.

		:return: mesh_points: it is a `n_points`-by-3 matrix containing the coordinates of
			the points of the mesh
		:rtype: numpy.ndarray

		.. todo::

			- specify when it works
		"""
        self._check_filename_type(filename)
        self._check_extension(filename)

        self.infile = filename

        reader = vtk.vtkDataSetReader()
        reader.SetFileName(self.infile)
        reader.ReadAllVectorsOn()
        reader.ReadAllScalarsOn()
        reader.Update()
        data = reader.GetOutput()

        n_points = data.GetNumberOfPoints()
        mesh_points = np.zeros([n_points, 3])

        for i in range(n_points):
            mesh_points[i][0], mesh_points[i][1], mesh_points[i][
                2] = data.GetPoint(i)

        return mesh_points
Example #15
0
def read_points(filename):
    """
    Load points of a VTK surface file.

    Parameters
    ----------
    filename : string
        path/filename of a VTK format file

    Returns
    -------
    points : list of lists of floats
        each element is a list of 3-D coordinates of a surface mesh vertex

    """
    import vtk

    Reader = vtk.vtkDataSetReader()
    Reader.SetFileName(filename)
    Reader.ReadAllScalarsOn()  # Activate the reading of all scalars
    Reader.Update()

    Data = Reader.GetOutput()
    points = [list(Data.GetPoint(point_id))
              for point_id in range(Data.GetNumberOfPoints())]

    return points
Example #16
0
    def write(self, mesh_points, filename):
        """
        Writes a vtk file, called filename, copying all the
        structures from self.filename but the coordinates.
        `mesh_points` is a matrix that contains the new coordinates
        to write in the vtk file.

        :param numpy.ndarray mesh_points: it is a `n_points`-by-3
            matrix containing the coordinates of the points of the
            mesh
        :param string filename: name of the output file.
        """
        self._check_filename_type(filename)
        self._check_extension(filename)
        self._check_infile_instantiation()

        self.outfile = filename

        reader = vtk.vtkDataSetReader()
        reader.SetFileName(self.infile)
        reader.ReadAllVectorsOn()
        reader.ReadAllScalarsOn()
        reader.Update()
        data = reader.GetOutput()

        points = vtk.vtkPoints()
        for i in range(data.GetNumberOfPoints()):
            points.InsertNextPoint(mesh_points[i, :])

        data.SetPoints(points)

        writer = vtk.vtkDataSetWriter()
        writer.SetFileName(self.outfile)
        writer.SetInputData(data)
        writer.Write()
Example #17
0
def readCellsFromFile(cells, path, iteration, rank):
    import vtk
    import os.path
    filename = path.replace('__ITERATION__',
                            str(iteration)).replace('__RANK__', str(rank))

    if os.path.exists(filename):
        reader = vtk.vtkDataSetReader()
        reader.SetFileName(filename)
        reader.SetReadAllScalars(True)
        reader.Update()

        grid = reader.GetOutput()

        numberOfCells = grid.GetNumberOfCells()
        cellData = grid.GetCellData()
        qs = cellData.GetScalars("q0")

        for cellId in xrange(numberOfCells):
            vtkCell = grid.GetCell(cellId)

            q = qs.GetTuple(cellId)[0]
            cells.append(Cell(vtkCell, vtkCell.GetBounds()[:], q))

        return numberOfCells
    else:
        return 0
Example #18
0
def ConvertVTKMatlab(input_filename, output_filename):
    import vtk.util.numpy_support as vtkNumPy
    import numpy
    import scipy.io as scipyio

    extension = input_filename.split('.').pop()
    vtkReader = None
    if extension == 'vtk':
        vtkReader = vtk.vtkDataSetReader()
    elif extension == 'vti':
        vtkReader = vtk.vtkXMLImageDataReader()
    else:
        raise RuntimeError('unknown file type %s ' % input_filename)
    vtkReader.SetFileName("%s" % (input_filename))
    vtkReader.Update()
    imageDataVTK = vtkReader.GetOutput()
    dimensions = imageDataVTK.GetDimensions()
    spacing = imageDataVTK.GetSpacing()
    origin = imageDataVTK.GetOrigin()
    print spacing, origin, dimensions
    #fem.SetImagingDimensions( dimensions ,origin,spacing)

    image_point_data = imageDataVTK.GetPointData()
    image_data = vtkNumPy.vtk_to_numpy(image_point_data.GetArray(0))
    # write numpy to disk in matlab
    #  indexing is painful.... reshape to dimensions and transpose 2d dimensions only
    scipyio.savemat(
        output_filename, {
            'spacing': spacing,
            'origin': origin,
            'image': image_data.reshape(dimensions, order='F').transpose(
                1, 0, 2)
        })
Example #19
0
def load_vtk(filepath):
    file_extension = osp.splitext(filepath)[1]
    if file_extension == '.vtu':
        reader = vtk.vtkXMLUnstructuredGridReader()
        reader.SetFileName(filepath)
        reader.Update()
        grid = reader.GetOutput()

        return grid
    elif file_extension == '.vtk':
        reader = vtk.vtkDataSetReader()
        reader.SetFileName(filepath)
        reader.Update()

        if reader.GetUnstructuredGridOutput() is not None:
            return reader.GetUnstructuredGridOutput()

        elif reader.GetPolyDataOutput() is not None:
            return reader.GetPolyDataOutput()

        elif reader.GetStructuredPointsOutput() is not None:
            raise RuntimeError('StructuredPoints not supported (yet?)')

        elif reader.GetStructuredGridOutput() is not None:
            filtered = append_filter(reader.GetStructuredGridOutput())
            return filtered

        elif reader.GetRectilinearGridOutput() is not None:
            raise RuntimeError('RectilinearGrid not supported (yet?)')

        else:
            raise RuntimeError('Unrecognized data type')
    else:
        raise RuntimeError('Unknown file type {}'.format(file_extension))
Example #20
0
def getReaderWriter(file_name, out_dir=None):
    r = vtk.vtkDataSetReader()
    r.SetFileName(file_name)
    f_base = os.path.splitext(file_name)[0]
    r.Update()
    reader = None
    writer = None
    xmlsuffix = '.xml'
    map = {'StructuredPoints': '.vti', 'StructuredGrid': '.vts',
           'RectilinearGrid': '.vtr', 'UnstructuredGrid': '.vtu',
           'PolyData': '.vtp'}
    for i in ['StructuredPoints', 'StructuredGrid', 'RectilinearGrid',
              'UnstructuredGrid', 'PolyData']:
        if eval('r.IsFile%s()'%i):
            reader = eval('vtk.vtk%sReader()'%i)
            if i == 'StructuredPoints':
                writer = eval('vtk.vtkXMLImageDataWriter()')
            else:
                writer = eval('vtk.vtkXML%sWriter()'%i)
            xmlsuffix = map[i]
            break
    if not reader:
        return None, None
    
    reader.SetFileName(file_name)
    reader.Update()

    out_file = f_base + xmlsuffix
    if out_dir:
        out_file = os.path.join(out_dir,
                                os.path.basename(f_base) + xmlsuffix)
    writer.SetFileName(out_file)
    return reader, writer
Example #21
0
def read_vtk_vector(filename):
    """
    Summary:
        Much of this code was taken from Matthew Priddy's example
        file.
    Inputs:
    Outputs:
    """

    # Initialize the reading of the VTK microstructure created by Dream3D
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.ReadAllTensorsOn()
    reader.ReadAllVectorsOn()
    reader.ReadAllScalarsOn()
    reader.Update()
    data = reader.GetOutput()
    dim = data.GetDimensions()
    vec = list(dim)
    vec = [i - 1 for i in dim]

    el = vec[0]

    Euler = data.GetCellData().GetArray(reader.GetVectorsNameInFile(0))

    euler_py = np.zeros([3, el**3])

    for ii in xrange(el**3):
        euler_py[0, ii] = Euler.GetValue(ii * 3 + 0)
        euler_py[1, ii] = Euler.GetValue(ii * 3 + 1)
        euler_py[2, ii] = Euler.GetValue(ii * 3 + 2)

    return euler_py
Example #22
0
def read_vertices(Filename):
    """
    Load VERTICES segment from a VTK file (actually contains indices to vertices)

    Parameters
    ----------
    Filename : string
        The path/filename of a VTK format file.

    Returns
    -------
    indices : a list of integers
        Each element is an integer defined in VERTICES segment of the VTK file.
        The integer is an index referring to a point defined in POINTS segment of the VTK file.

    Notes ::

        We assume that VERTICES segment is organized as one line,
        the first column of which is the number of vertices.
        Vertices here are as vertices in VTK terminology. It may not be the vertices in your 3-D surface.

    """
    import vtk

    Reader = vtk.vtkDataSetReader()
    Reader.SetFileName(Filename)
    Reader.Update()

    Data = Reader.GetOutput()

    Vrts = Data.GetVerts()
    indices = [Vrts.GetData().GetValue(i) for i in range(1, Vrts.GetSize())]

    return indices
def read_vtk_scalar(filename):
    """
    Summary:
        Much of this code was taken from Matthew Priddy's example file.
    Inputs:
    Outputs:
    """

    # Initialize the reading of the VTK microstructure created by Dream3D
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.ReadAllTensorsOn()
    reader.ReadAllVectorsOn()
    reader.ReadAllScalarsOn()
    reader.Update()
    data = reader.GetOutput()
    dim = data.GetDimensions()
    vec = list(dim)
    vec = [i-1 for i in dim]

    el = vec[0]

    # Calculate the total number of elements
    el_total = el**3

    Scalar = data.GetCellData().GetArray(reader.GetScalarsNameInFile(0))

    scalar_py = zeros([el_total])

    for ii in xrange(el_total):
        scalar_py[ii] = Scalar.GetValue(ii)

    return scalar_py
Example #24
0
def Test3(datadir):
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(datadir + "/Data/blow.vtk")
    reader.UpdateInformation();
    reader.ReadAllScalarsOn()
    reader.ReadAllVectorsOn()

    dssf = vtk.vtkDataSetSurfaceFilter()
    dssf.SetInputConnection(reader.GetOutputPort())

    stripper = vtk.vtkStripper()
    stripper.SetInputConnection(dssf.GetOutputPort())

    f = vtk.vtkIntegrateAttributes()
    f.SetInputConnection(stripper.GetOutputPort())
    f.Update()

    result = f.GetOutputDataObject(0)
    val = result.GetPointData().GetArray("displacement1").GetValue(0)
    assert (val > 463.64 and val < 463.642)

    val = result.GetPointData().GetArray("thickness3").GetValue(0)
    assert (val > 874.61 and val < 874.618)

    val = result.GetCellData().GetArray("Area").GetValue(0)
    assert (val > 1145.405 and val < 1145.415)
Example #25
0
    def _ReadFile(self,**kw):
        """Read in a VTK data structure from a vtk data file
        """


        fd = open( self.filepath, 'r' )
        
        # Instantiate the field object
        field = objects.field.Field()
        
        reader = vtk.vtkDataSetReader()
        reader.SetFileName(self.filepath)
        #field.vtkdata = reader.GetStructuredPointsOutput()

        data = reader.GetOutput()
        # Need to update so that the data gets pulled through.
        data.Update()
        if not data:
            raise Exception,"VTK_IO no data found while reading file: %s" % self.filepath

        if not data.GetClassName() == 'vtkStructuredPoints':
            raise Exception,"VTK_IO someone needs to tell me how to read something other than Structured Points!"


        field.dim = data.GetDimensions()
        #print data.GetDataDimension()
        origin =  data.GetOrigin()
        field.origin = objects.vector.Vector( origin )
        
        field.vtkdata = data
        field.title = self.name
        field.name = self.name
        self.fields.append(field)
Example #26
0
def get_tensor_array(filename):
    """Returns vtk tensor array object which can have 'GetTuple9(i)' called on it."""
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.Update()

    output = reader.GetOutput()
    npoints = output.GetNumberOfPoints()
    print 'npoints:', npoints
    ncells = output.GetNumberOfCells()
    print 'ncells:', ncells
    nscalars = reader.GetNumberOfScalarsInFile()
    print 'nscalars:', nscalars
    print reader.GetScalarsNameInFile(0)
    ntensors = reader.GetNumberOfTensorsInFile()
    print 'ntensors:', ntensors
    print reader.GetTensorsNameInFile(0)

    output = reader.GetOutput()
    point_data = output.GetPointData()
    scalar_array = point_data.GetArray('scalar')
    tensor_array = point_data.GetArray('tensor')
    if not tensor_array:
        tensor_array = point_data.GetArray('tensors')
    return tensor_array
def ConvertVTKMatlab(input_filename,output_filename):
  import vtk.util.numpy_support as vtkNumPy 
  import numpy
  import scipy.io as scipyio
 
  extension = input_filename.split('.').pop()
  vtkReader = None
  if extension == 'vtk':
    vtkReader = vtk.vtkDataSetReader() 
  elif extension == 'vti':
    vtkReader = vtk.vtkXMLImageDataReader() 
  else:
    raise RuntimeError('unknown file type %s ' % input_filename)
  vtkReader.SetFileName( "%s" % (input_filename) ) 
  vtkReader.Update()
  imageDataVTK = vtkReader.GetOutput()
  dimensions = imageDataVTK.GetDimensions()
  spacing = imageDataVTK.GetSpacing()
  origin  = imageDataVTK.GetOrigin()
  print spacing, origin, dimensions
  #fem.SetImagingDimensions( dimensions ,origin,spacing) 

  image_point_data = imageDataVTK.GetPointData() 
  image_data       = vtkNumPy.vtk_to_numpy( image_point_data.GetArray(0) ) 
  # write numpy to disk in matlab
  #  indexing is painful.... reshape to dimensions and transpose 2d dimensions only
  scipyio.savemat( output_filename, {'spacing':spacing, 'origin':origin,'image':image_data.reshape(dimensions,order='F').transpose(1,0,2)})
Example #28
0
	def plot(self, plot_file=None, save_fig=False):
		"""
		Method to plot a vtk file. If `plot_file` is not given it plots `self.infile`.

		:param string plot_file: the vtk filename you want to plot.
		:param bool save_fig: a flag to save the figure in png or not. If True the
			plot is not shown.
			
		:return: figure: matlplotlib structure for the figure of the chosen geometry
		:rtype: matplotlib.pyplot.figure
		"""
		if plot_file is None:
			plot_file = self.infile
		else:
			self._check_filename_type(plot_file)

		# Read the source file.		
		reader = vtk.vtkDataSetReader()
		reader.SetFileName(plot_file)
		reader.Update()

		data = reader.GetOutput()
		points = data.GetPoints()
		ncells = data.GetNumberOfCells()

		# for each cell it contains the indeces of the points that define the cell
		figure = plt.figure()
		axes = a3.Axes3D(figure)
		vtx = np.zeros((ncells, 3, 3))
		for i in range(0, ncells):
			for j in range(0, 3):
				cell = data.GetCell(i).GetPointId(j)
				vtx[i][j][0], vtx[i][j][1], vtx[i][j][2] = points.GetPoint(int(cell))
			tri = a3.art3d.Poly3DCollection([vtx[i]])
			tri.set_color('b')
			tri.set_edgecolor('k')
			axes.add_collection3d(tri)
		
		## Get the limits of the axis and center the geometry
		max_dim = np.array([np.max(vtx[:,:,0]), \
						np.max(vtx[:,:,1]), \
						np.max(vtx[:,:,2])])
		min_dim = np.array([np.min(vtx[:,:,0]), \
						np.min(vtx[:,:,1]), \
						np.min(vtx[:,:,2])])
		
		max_lenght = np.max(max_dim - min_dim)
		axes.set_xlim(-.6*max_lenght + (max_dim[0]+min_dim[0])/2, .6*max_lenght + (max_dim[0]+min_dim[0])/2)
		axes.set_ylim(-.6*max_lenght + (max_dim[1]+min_dim[1])/2, .6*max_lenght + (max_dim[1]+min_dim[1])/2)
		axes.set_zlim(-.6*max_lenght + (max_dim[2]+min_dim[2])/2, .6*max_lenght + (max_dim[2]+min_dim[2])/2)

		# Show the plot to the screen
		if not save_fig:
			plt.show()
		else:
			figure.savefig(plot_file.split('.')[0] + '.png')
			
		return figure
Example #29
0
    def testGlyphs(self):
        '''Test if the glyphs are created nicely.'''
        reader = vtk.vtkDataSetReader()

        data_file = os.path.join(Testing.VTK_DATA_ROOT, "Data", "tensors.vtk")

        reader.SetFileName(data_file)

        g1 = SimpleGlyph(reader)
        g1.glyph.ColorGlyphsOff()
        g1.Update()

        g2 = SimpleGlyph(reader)
        g2.glyph.ExtractEigenvaluesOff()
        g2.Update()
        g2.SetPosition((2.0, 0.0, 0.0))

        g3 = SimpleGlyph(reader)
        g3.glyph.SetColorModeToEigenvalues()
        g3.glyph.ThreeGlyphsOn()
        g3.Update()
        g3.SetPosition((0.0, 2.0, 0.0))

        g4 = SimpleGlyph(reader)
        g4.glyph.SetColorModeToEigenvalues()
        g4.glyph.ThreeGlyphsOn()
        g4.glyph.SymmetricOn()
        g4.Update()
        g4.SetPosition((2.0, 2.0, 0.0))

        # 6Components symetric tensor
        g5 = SimpleGlyph(reader)
        g5.glyph.SetInputArrayToProcess(0, 0, 0, 0, "symTensors1")
        g5.SetPosition((4.0, 2.0, 0.0))
        g5.Update()

        ren = vtk.vtkRenderer()
        for i in (g1, g2, g3, g4, g5):
            for j in i.GetActors():
                ren.AddActor(j)

        ren.ResetCamera();

        cam = ren.GetActiveCamera()
        cam.Azimuth(-20)
        cam.Elevation(20)
        cam.Zoom(1.1)

        ren.SetBackground(0.5, 0.5, 0.5)

        renWin = vtk.vtkRenderWindow()
        renWin.AddRenderer(ren)
        renWin.Render()

        img_file = "TestTensorGlyph.png"
        Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
        Testing.interact()
Example #30
0
def unpickle_vtk_2(filename):
    with open(filename, 'rb') as handle:
        to_deserialize = pickle.load(handle)

    reader = vtk.vtkDataSetReader()
    reader.ReadFromInputStringOn()
    reader.SetInputString(to_deserialize)
    reader.Update()
    return pv.wrap(reader.GetOutput())
Example #31
0
    def testGlyphs(self):
        '''Test if the glyphs are created nicely.'''
        reader = vtk.vtkDataSetReader()

        data_file = os.path.join(Testing.VTK_DATA_ROOT, "Data", "tensors.vtk")

        reader.SetFileName(data_file)

        g1 = SimpleGlyph(reader)
        g1.glyph.ColorGlyphsOff()
        g1.Update()

        g2 = SimpleGlyph(reader)
        g2.glyph.ExtractEigenvaluesOff()
        g2.Update()
        g2.SetPosition((2.0, 0.0, 0.0))

        g3 = SimpleGlyph(reader)
        g3.glyph.SetColorModeToEigenvalues()
        g3.glyph.ThreeGlyphsOn()
        g3.Update()
        g3.SetPosition((0.0, 2.0, 0.0))

        g4 = SimpleGlyph(reader)
        g4.glyph.SetColorModeToEigenvalues()
        g4.glyph.ThreeGlyphsOn()
        g4.glyph.SymmetricOn()
        g4.Update()
        g4.SetPosition((2.0, 2.0, 0.0))

        # 6Components symetric tensor
        g5 = SimpleGlyph(reader)
        g5.glyph.SetInputArrayToProcess(0, 0, 0, 0, "symTensors1")
        g5.SetPosition((4.0, 2.0, 0.0))
        g5.Update()

        ren = vtk.vtkRenderer()
        for i in (g1, g2, g3, g4, g5):
            for j in i.GetActors():
                ren.AddActor(j)

        ren.ResetCamera()

        cam = ren.GetActiveCamera()
        cam.Azimuth(-20)
        cam.Elevation(20)
        cam.Zoom(1.1)

        ren.SetBackground(0.5, 0.5, 0.5)

        renWin = vtk.vtkRenderWindow()
        renWin.AddRenderer(ren)
        renWin.Render()

        img_file = "TestTensorGlyph.png"
        Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
        Testing.interact()
Example #32
0
def readDataSet(fileName, **kwargs):
    """Read the dataset from a file. The reader type used is determined from the file extension.

	Returns:
		+------------+----------------------+
		| File ext.  | Return type          |
		+============+======================+
		| .vtp       | vtkPolyData          |
		+------------+----------------------+
		| .vtu       | vtkUnstructuredGrid  |
		+------------+----------------------+
		| .vti       | vtkImageData         |
		+------------+----------------------+
		| .stl       | vtkPolyData          |
		+------------+----------------------+
		| .case      | vtkMultiBlockDataSet |
		+------------+----------------------+

	"""
    if not os.path.isfile(fileName):
        raise RuntimeError('The file', fileName, 'did not exist')

    filePrefix, fileExtension = os.path.splitext(fileName)
    if fileExtension == '.vtp':
        reader = vtk.vtkXMLPolyDataReader()
    elif fileExtension == '.vtu':
        reader = vtk.vtkXMLUnstructuredGridReader()
    elif fileExtension == '.vti':
        reader = vtk.vtkXMLImageDataReader()
    elif fileExtension == '.vtm':
        reader = vtk.vtkXMLMultiBlockDataReader()
    elif fileExtension == '.stl':
        reader = vtk.vtkSTLReader()
    elif fileExtension == '.vtk':
        #reader = _createVTKReader(fileName)
        reader = vtk.vtkDataSetReader()
    elif fileExtension == '.case':
        reader = vtk.vtkEnSightGoldBinaryReader()
        for k, v in kwargs.items():
            if k == 'disableCellArrays':
                for arrName in v:
                    reader.GetCellDataArraySelection().DisableArray(arrName)
            elif k == 'disablePointArrays':
                for arrName in v:
                    reader.GetPointDataArraySelection().DisableArray(arrName)
            else:
                raise RuntimeError('Unknown keyword argument' + str(k))
    else:
        raise RuntimeError('Unknown file extension', fileExtension)

    if fileExtension == '.case':
        reader.SetCaseFileName(fileName)
    else:
        reader.SetFileName(fileName)

    reader.Update()
    return reader.GetOutput()
def read_vtk_tensor(filename, tensor_id, comp):
    """

    Summary:

        Much of this code was taken from Matthew Priddy's example file.

    Inputs:

    Outputs:

    """

    # Initialize the reading of the VTK microstructure created by Dream3D

    reader = vtk.vtkDataSetReader()

    reader.SetFileName(filename)

    reader.ReadAllTensorsOn()

    reader.ReadAllVectorsOn()

    reader.ReadAllScalarsOn()

    reader.Update()

    data = reader.GetOutput()

    dim = data.GetDimensions()

    vec = list(dim)

    vec = [i - 1 for i in dim]

    el = vec[0]

    # Calculate the total number of elements

    el_total = el**3

    meas = data.GetCellData().GetArray(reader.GetTensorsNameInFile(tensor_id))

    # if tensor_id == 0, we read the stress tensor

    # if tensor_id == 1, we read the strain tensor

    # if tensor_id == 2, we read the plastic strain tensor

    meas_py = np.zeros([el_total])

    for ii in xrange(el_total):

        meas_py[ii] = meas.GetValue(ii * 9 + comp)

    return meas_py
Example #34
0
def get_num_fibers(filename):
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.Update()

    output = reader.GetOutput()
    #import pudb
    #pudb.set_trace()
    nlines = reader.GetOutput().GetNumberOfLines()
    return nlines
Example #35
0
def read(filename):
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.ReadAllScalarsOn()
    reader.Update()
    data = reader.GetOutput()
    header = reader.GetHeader()
    no_nodes = data.GetNumberOfPoints()
    no_connections = data.GetNumberOfCells()
    return (data, header, no_nodes, no_connections)
    def _create_vtk_reader(self,url,type):
        if type==1:
            self.reader=vtk.vtkDataSetReader()
            self.reader.SetFileName(url)
            self.reader.Update()
            print "zrobilem vtk readera"
        if type==0:
			print "convert_dat_file_to_vtk_reader(url)"
			
			self.reader=self.convert_dat_file_to_vtk_reader(url)
def read_vtk_struct(filename):
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.ReadAllFieldsOn()
    reader.Update()
    polydata = reader.GetOutput()
    points = vtk_to_numpy(polydata.GetPoints().GetData())
    cells = vtk_to_numpy(polydata.GetCells().GetData())
    cells = reshape_cells(cells)
    return cells, points
Example #38
0
def load_vtk_cloud(vtk_cloud_file):
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(vtk_cloud_file)
    reader.Update()

    actor = vtk.vtkActor()
    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(reader.GetOutputPort())
    actor.SetMapper(mapper)

    return actor
Example #39
0
    def write(self,
              output_values,
              filename,
              output_name=None,
              write_bin=False):
        """
		Writes a mat file, called filename. output_values is a matrix that contains the new values of the output 
		to write in the mat file.

		:param numpy.ndarray output_values: it is a `n_points`-by-1 matrix containing the values of the chosen output.
		:param string filename: name of the output file.
		:param string output_name: name of the output of interest inside the mat file. 
			If it is not passed, it is equal to self.output_name.
		:param bool write_bin: flag to write in the binary format. Default is False.
		"""

        self._check_filename_type(filename)
        self._check_extension(filename)
        self._check_infile_instantiation(self.infile)

        if output_name is None:
            output_name = self.output_name
        else:
            self._check_filename_type(output_name)

        reader = vtk.vtkDataSetReader()
        reader.SetFileName(self.infile)
        reader.ReadAllVectorsOn()
        reader.ReadAllScalarsOn()
        reader.Update()
        data = reader.GetOutput()

        output_array = ns.numpy_to_vtk(num_array=output_values,
                                       array_type=vtk.VTK_DOUBLE)
        output_array.SetName(output_name)

        if self.cell_data is True:
            data.GetCellData().AddArray(output_array)
        else:
            data.GetPointData().AddArray(output_array)

        writer = vtk.vtkDataSetWriter()

        if write_bin:
            writer.SetFileTypeToBinary()

        writer.SetFileName(filename)

        if vtk.VTK_MAJOR_VERSION <= 5:
            writer.SetInput(data)
        else:
            writer.SetInputData(data)

        writer.Write()
Example #40
0
def load_vtk_cloud(vtk_cloud_file):
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(vtk_cloud_file)
    reader.Update()

    actor = vtk.vtkActor()
    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(reader.GetOutputPort())
    actor.SetMapper(mapper)

    return actor
Example #41
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self,
         module_manager,
         vtk.vtkDataSetReader(),
         "Reading vtkDataSet.",
         (),
         ("vtkDataSet",),
         replaceDoc=True,
         inputFunctions=None,
         outputFunctions=None,
     )
Example #42
0
def vtk_points(offset, filenameout='data'):

    filename = ''.join([filenameout, repr(offset), '.vtk'])

    datareader = v.vtkDataSetReader()
    datareader.SetFileName(filename)
    datareader.Update()
    data = datareader.GetOutput()

    vtk_points = data.GetPoints().GetData()
    points = ah.vtk2array(vtk_points)
    return points
Example #43
0
def vtk_points(offset,filenameout='data'):

    filename=''.join([filenameout,repr(offset),'.vtk'])

    datareader = v.vtkDataSetReader()
    datareader.SetFileName(filename)
    datareader.Update()
    data = datareader.GetOutput()
    
    vtk_points=data.GetPoints().GetData()
    points=ah.vtk2array(vtk_points)
    return points
Example #44
0
def vtk2stl(fn_in, fn_out):

    reader = vtk.vtkDataSetReader()
    reader.SetFileName(fn_in)
    reader.Update()

    gfilter = vtk.vtkGeometryFilter()
    gfilter.SetInput(reader.GetOutput())

    writer = vtk.vtkSTLWriter()
    writer.SetFileName(fn_out)
    writer.SetInput(gfilter.GetOutput())
    writer.Write()
Example #45
0
def vtk2stl(fn_in, fn_out):

    reader = vtk.vtkDataSetReader()
    reader.SetFileName(fn_in)
    reader.Update()

    gfilter = vtk.vtkGeometryFilter()
    gfilter.SetInput(reader.GetOutput())

    writer = vtk.vtkSTLWriter()
    writer.SetFileName(fn_out)
    writer.SetInput(gfilter.GetOutput())
    writer.Write()
Example #46
0
def main(filenameIn, filenameOut, origin, spacing):
    r = vtk.vtkDataSetReader()
    r.SetFileName(filenameIn)
    r.Update()
    data = vtk.vtkImageData()
    data.ShallowCopy(r.GetOutput())
    data.SetOrigin(origin)
    data.SetSpacing(spacing)
    data.Update()
    w = vtk.vtkStructuredPointsWriter()
    w.SetInput(data)
    w.SetFileName(filenameOut)
    w.Write()
Example #47
0
def main(filenameIn,filenameOut,origin,spacing):
    r = vtk.vtkDataSetReader()
    r.SetFileName(filenameIn)
    r.Update()
    data = vtk.vtkImageData()
    data.ShallowCopy(r.GetOutput())
    data.SetOrigin(origin)
    data.SetSpacing(spacing)
    data.Update()
    w = vtk.vtkStructuredPointsWriter()
    w.SetInput(data)
    w.SetFileName(filenameOut)
    w.Write()
Example #48
0
    def __setstate__(self, state):
        """Support unpickle."""
        vtk_serialized = state.pop('vtk_serialized')
        self.__dict__.update(state)

        reader = vtk.vtkDataSetReader()
        reader.ReadFromInputStringOn()
        reader.SetInputString(vtk_serialized)
        reader.Update()
        mesh = pyvista.wrap(reader.GetOutput())

        # copy data
        self.copy_structure(mesh)
        self.copy_attributes(mesh)
Example #49
0
	def write(self, output_values, filename, output_name=None, write_bin=False):
		"""
		Writes a mat file, called filename. output_values is a matrix that contains the new values of the output 
		to write in the mat file.

		:param numpy.ndarray output_values: it is a `n_points`-by-1 matrix containing the values of the chosen output.
		:param string filename: name of the output file.
		:param string output_name: name of the output of interest inside the mat file. 
			If it is not passed, it is equal to self.output_name.
		:param bool write_bin: flag to write in the binary format. Default is False.
		"""
		
		self._check_filename_type(filename)
		self._check_extension(filename)
		self._check_infile_instantiation(self.infile)
		
		if output_name is None:
			output_name = self.output_name
		else:
			self._check_filename_type(output_name)
		
		reader = vtk.vtkDataSetReader()
		reader.SetFileName(self.infile)
		reader.ReadAllVectorsOn()
		reader.ReadAllScalarsOn()
		reader.Update()
		data = reader.GetOutput()
	
		output_array = ns.numpy_to_vtk(num_array=output_values,array_type=vtk.VTK_DOUBLE)
		output_array.SetName(output_name)
		
		if self.cell_data is True:
			data.GetCellData().AddArray(output_array)
		else:
			data.GetPointData().AddArray(output_array)	
	
		writer = vtk.vtkDataSetWriter()
		
		if write_bin:
			writer.SetFileTypeToBinary()
		
		writer.SetFileName(filename)
		
		if vtk.VTK_MAJOR_VERSION <= 5:
			writer.SetInput(data)
		else:
			writer.SetInputData(data)
	
		writer.Write()
Example #50
0
def read_legacy(filename):
    """Use VTK's legacy reader to read a file."""
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    # Ensure all data is fetched with poorly formatted legacy files
    reader.ReadAllScalarsOn()
    reader.ReadAllColorScalarsOn()
    reader.ReadAllNormalsOn()
    reader.ReadAllTCoordsOn()
    reader.ReadAllVectorsOn()
    # Perform the read
    output = standard_reader_routine(reader, None)
    if output is None:
        raise RuntimeError('No output when using VTKs legacy reader')
    return output
Example #51
0
def unpickle_vtk(data):
    unpickled_data = pickle.loads(
        data)  # data is a result of writer.GetOutputString()
    reader = vtk.vtkDataSetReader()

    # Which one to use?
    # reader.SetReadFromInputString(True)
    reader.ReadFromInputStringOn()
    reader.SetInputString(unpickled_data)
    # reader.ReadAllVectorsOn()
    # reader.ReadAllScalarsOn()
    reader.Update()
    data = pv.wrap(reader.GetOutput())

    return data  # this is a vtk object being returned
Example #52
0
def main(filenameIn,filenameOut,dx,dy,dz,vx,vy,vz):
    r = vtk.vtkDataSetReader()
    r.SetFileName(filenameIn)
    r.Update()
    data = vtk.vtkImageData()
    data.ShallowCopy(r.GetOutput())
    data.SetOrigin(dx,dy,dz)
    data.SetSpacing(dx/vx,dy/vy,dz/vz)
    data.Update()
    #w = vtk.vtkDataSetWriter()
    w = vtk.vtkStructuredPointsWriter()
    # w.SetInputConnection(data.GetProducerPort())
    w.SetInput(data)
    w.SetFileName(filenameOut)
    w.Write()
Example #53
0
	def parse(self, filename, output_name=None):
		"""
		Method to parse the `filename`. It returns a vector (matrix with one column) with all the values of the chosen output.
		If `output_name` is not given it is set to the default value.

		:param string filename: name of the input file.
		:param string output_name: name of the output of interest inside the mat file. 
			If it is not passed, it is equal to self.output_name.
		
		:return: output_values: it is a `n_points`-by-1 matrix containing the values of the chosen output
		:rtype: numpy.ndarray
		"""
		
		if output_name is None:
			output_name = self.output_name
		else:
			self._check_filename_type(output_name)
		
		self._check_filename_type(filename)
		self._check_extension(filename)

		self.infile = filename

		reader = vtk.vtkDataSetReader()
		reader.SetFileName(filename)
		reader.ReadAllVectorsOn()
		reader.ReadAllScalarsOn()
		reader.Update()
		data = reader.GetOutput()

		extracted_data_cell  = data.GetCellData().GetArray(output_name)
		extracted_data_point = data.GetPointData().GetArray(output_name)
		
		if extracted_data_cell is None:
			extracted_data = extracted_data_point
			self.cell_data = False
		else:
			extracted_data = extracted_data_cell
			self.cell_data = True
		
		# TODO: check if the output is a scalar or vector
		data_dim = extracted_data.GetSize()
		output_values = np.zeros([data_dim,1])

		for i in range (0,data_dim):
			output_values[i] = extracted_data.GetValue(i)

		return output_values
Example #54
0
    def parse(self, filename, output_name=None):
        """
		Method to parse the `filename`. It returns a vector (matrix with one column) with all the values of the chosen output.
		If `output_name` is not given it is set to the default value.

		:param string filename: name of the input file.
		:param string output_name: name of the output of interest inside the mat file. 
			If it is not passed, it is equal to self.output_name.
		
		:return: output_values: it is a `n_points`-by-1 matrix containing the values of the chosen output
		:rtype: numpy.ndarray
		"""

        if output_name is None:
            output_name = self.output_name
        else:
            self._check_filename_type(output_name)

        self._check_filename_type(filename)
        self._check_extension(filename)

        self.infile = filename

        reader = vtk.vtkDataSetReader()
        reader.SetFileName(filename)
        reader.ReadAllVectorsOn()
        reader.ReadAllScalarsOn()
        reader.Update()
        data = reader.GetOutput()

        extracted_data_cell = data.GetCellData().GetArray(output_name)
        extracted_data_point = data.GetPointData().GetArray(output_name)

        if extracted_data_cell is None:
            extracted_data = extracted_data_point
            self.cell_data = False
        else:
            extracted_data = extracted_data_cell
            self.cell_data = True

        # TODO: check if the output is a scalar or vector
        data_dim = extracted_data.GetSize()
        output_values = np.zeros([data_dim, 1])

        for i in range(0, data_dim):
            output_values[i] = extracted_data.GetValue(i)

        return output_values
Example #55
0
def read_faces_points(filename):
    """
    Load points and faces of a VTK surface file.

    Parameters
    ----------
    filename : string
        path/filename of a VTK format file

    Returns
    -------
    faces : list of lists of integers
        each element is list of 3 indices of vertices that form a face
        on a surface mesh
    points : list of lists of floats
        each element is a list of 3-D coordinates of a surface mesh vertex
    npoints : integer
        number of points

    Examples
    --------
    >>> import os
    >>> from mindboggle.utils.io_vtk import read_faces_points
    >>> path = os.environ['MINDBOGGLE_DATA']
    >>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
    >>> faces, points, npoints = read_faces_points(folds_file)

    """
    import vtk

    Reader = vtk.vtkDataSetReader()
    Reader.SetFileName(filename)
    Reader.ReadAllScalarsOn()  # Activate the reading of all scalars
    Reader.Update()

    Data = Reader.GetOutput()
    points = [list(Data.GetPoint(point_id))
              for point_id in range(Data.GetNumberOfPoints())]
    npoints = len(points)

    if Data.GetNumberOfPolys() > 0:
        faces = [[int(Data.GetPolys().GetData().GetValue(j))
                  for j in range(i*4 + 1, i*4 + 4)]
                  for i in range(Data.GetPolys().GetNumberOfCells())]
    else:
        faces = []

    return faces, points, npoints
Example #56
0
File: sv_io.py Project: ohinds/sv
def read_vtk(filename):

    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.Update()

    out = reader.GetOutput()
    verts = np.zeros((out.GetNumberOfPoints(), 3))
    for i in xrange(out.GetNumberOfPoints()):
        verts[i] = np.array(out.GetPoint(i))

    faces = np.zeros((out.GetPolys().GetNumberOfCells(), 3))
    for i in xrange(out.GetPolys().GetNumberOfCells()):
        faces[i] = np.array([int(out.GetPolys().GetData().GetValue(j))
                             for j in range(4 * i + 1, 4 * i + 4)])

    return verts, faces
Example #57
0
 def ReadLegacyVTK(file_name):
     reader = vtk.vtkDataSetReader()
     reader.SetFileName(file_name)
     reader.Update()
     if None != reader.GetPolyDataOutput():
         polyData = vtk.vtkPolyData()
         polyData.ShallowCopy(reader.GetPolyDataOutput())
         return polyData
     if None != reader.GetUnstructuredGridOutput():
         return VTKViewer.ConvertDataSetToSurface(reader.GetOutputPort())
     if None != reader.GetStructuredPointsOutput():
         return VTKViewer.ConvertDataSetToSurface(reader.GetOutputPort())
     if None != reader.GetStructuredGridOutput():
         return VTKViewer.ConvertDataSetToSurface(reader.GetOutputPort())
     if None != reader.GetRectilinearGridOutput():
         return VTKViewer.ConvertDataSetToSurface(reader.GetOutputPort())
     else:
         raise Exception("unsupported: ????????\n")
Example #58
-4
def readCellsFromFile(cells, path, iteration, rank):
  import vtk
  import os.path
  filename = path.replace('__ITERATION__', str(iteration)).replace('__RANK__', str(rank))
  
  if os.path.exists(filename):
    reader = vtk.vtkDataSetReader()
    reader.SetFileName(filename)
    reader.SetReadAllScalars(True)
    reader.Update()

    grid = reader.GetOutput()
    
    numberOfCells = grid.GetNumberOfCells()
    cellData = grid.GetCellData()
    qs = cellData.GetScalars("q0")

    for cellId in xrange(numberOfCells):
      vtkCell = grid.GetCell(cellId)
      
      q = qs.GetTuple(cellId)[0]
      cells.append(Cell(vtkCell, vtkCell.GetBounds()[:], q))
      
    return numberOfCells
  else:
    return 0