def read_vtk(self, to_polydata=False):
     # Read the source file.
     reader = vtk.vtkDataReader()
     reader.SetFileName('.'.join([self.filename, self.input_type]))
     reader.Update()
     print('Case ID : {}, input type: {}'.format(self.filename,
                                                 self.input_type))
     if reader.IsFileUnstructuredGrid():
         print('Reading Unstructured Grid...')
         reader = vtk.vtkUnstructuredGridReader()
     elif reader.IsFilePolyData():
         print('Reading Polygonal Mesh...')
         reader = vtk.vtkPolyDataReader()
     elif reader.IsFileStructuredGrid():
         print('Reading Structured Grid...')
         reader = vtk.vtkStructuredGridReader()
     elif reader.IsFileStructuredPoints():
         print('Reading Structured Points...')
         reader = vtk.vtkStructuredPointsReader()
     elif reader.IsFileRectilinearGrid():
         print('Reading Rectilinear Grid...')
         reader = vtk.vtkRectilinearGridReader()
     else:
         print('Data format unknown...')
     reader.SetFileName(self.filename + '.' + self.input_type)
     reader.Update()  # Needed because of GetScalarRange
     scalar_range = reader.GetOutput().GetScalarRange()
     if to_polydata and not reader.IsFilePolyData():
         print('Transform to Polygonal Mesh')
         reader = self.unstructured_grid_to_poly_data(reader)
     print('Scalar range: \n{}'.format(scalar_range))
     return reader, scalar_range
def main():
    filename = get_program_parameters()

    # Read the file
    reader = vtk.vtkStructuredGridReader()
    reader.SetFileName(filename)
    reader.Update()

    geometry_filter = vtk.vtkStructuredGridGeometryFilter()
    geometry_filter.SetInputConnection(reader.GetOutputPort())
    geometry_filter.Update()

    # Visualize
    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(geometry_filter.GetOutputPort())

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)

    renderer = vtk.vtkRenderer()
    render_window = vtk.vtkRenderWindow()
    render_window.AddRenderer(renderer)
    render_window_interactor = vtk.vtkRenderWindowInteractor()
    render_window_interactor.SetRenderWindow(render_window)

    renderer.AddActor(actor)

    named_colors = vtk.vtkNamedColors()
    renderer.SetBackground(named_colors.GetColor3d("Green"))

    render_window.Render()
    render_window_interactor.Start()
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkStructuredGridReader(), 'Reading vtkStructuredGrid.',
         (), ('vtkStructuredGrid',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
Example #4
0
def loadStructuredGrid(filename):  # not tested
    '''Load a vtkStructuredGrid object from file and return a vtkActor.'''
    reader = vtk.vtkStructuredGridReader()
    reader.SetFileName(filename)
    reader.Update()
    gf = vtk.vtkStructuredGridGeometryFilter()
    gf.SetInputConnection(reader.GetOutputPort())
    gf.Update()
    return Actor(gf.GetOutput())
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(self,
                                       module_manager,
                                       vtk.vtkStructuredGridReader(),
                                       'Reading vtkStructuredGrid.', (),
                                       ('vtkStructuredGrid', ),
                                       replaceDoc=True,
                                       inputFunctions=None,
                                       outputFunctions=None)
Example #6
0
 def chooseReader(self, file_format, vtk_dataset_type=None):
     """
     Return a reader based on file_format and possibly vtk_dataset_type.
     @param vtk_dataset_type, None or one of the VTK_DATASET_TYPES
     """
     # Handle .ply files.
     if file_format == 'ply':
         return vtk.vtkPLYReader()
     # Handle .vtk files.
     if vtk_dataset_type == 'STRUCTURED_GRID':
         return vtk.vtkStructuredGridReader()
     elif vtk_dataset_type == 'POLYDATA':
         return vtk.vtkPolyDataReader()
     elif vtk_dataset_type == 'UNSTRUCTURED_GRID':
         return vtk.vtkUnstructuredGridReader()
    def extract_data(self):
        """
        Extract the data from the VTK file using the python-vtk library
        The data is passed to numpy arrays for better manipulation
        """

        # Check the type of file to load it according to its grid structure
        # which was specified when calling the class These dictionary entries
        # return the corresponding VTK Reader functions, so they can be easily
        # called according to the class argument
        reader_type = {
            'XMLUnstructuredGrid': lambda: vtk.vtkXMLUnstructuredGridReader(),
            'XMLStructuredGrid': lambda: vtk.vtkXMLStructuredGridReader(),
            'UnstructuredGrid': lambda: vtk.vtkUnstructuredGridReader(),
            'StructuredGrid': lambda: vtk.vtkStructuredGridReader(),
            }

        if self.vtkfiletype.startswith('XML'):
            # Load the vtk file from the input file
            self.reader = reader_type[self.vtkfiletype]()
            self.reader.SetFileName(self.vtk_file)
        else:
            # Load the vtk file from the input file
            self.reader = reader_type[self.vtkfiletype]()
            self.reader.SetFileName(self.vtk_file)
            # For Non XML vtk files:
            self.reader.ReadAllVectorsOn()
            self.reader.ReadAllScalarsOn()

        self.reader.Update()

        # Get the coordinates of the nodes in the mesh
        nodes_vtk_array = self.reader.GetOutput().GetPoints().GetData()

        # Get The vector field (data of every node)
        vf_vtk_array = self.reader.GetOutput().GetPointData().GetArray(0)

        # Transform the coordinates of the nodes to a Numpy array and
        # save them to the corresponding class objects
        nodes_numpy_array = vtk_to_numpy(nodes_vtk_array)
        self.x, self.y, self.z = (nodes_numpy_array[:, 0],
                                  nodes_numpy_array[:, 1],
                                  nodes_numpy_array[:, 2]
                                  )

        # Transform the magnetisation data to a Numpy array and save
        vf_numpy_array = vtk_to_numpy(vf_vtk_array)
        self.vf = vf_numpy_array
Example #8
0
    def create_reader (self): 
        "Create the corresponding reader."
        debug ("In VtkDataReader::create_reader ()")
        # set up the reader     
        if self.file_name == "":
            raise IOError, "No filename specifed for the data handler!"

        self.grid_type = find_data_type (self.file_name)
        if self.grid_type == "STRUCTURED_GRID":
            self.reader = vtk.vtkStructuredGridReader ()
        elif self.grid_type == "STRUCTURED_POINTS":
            self.reader = vtk.vtkStructuredPointsReader ()
        elif self.grid_type == "RECTILINEAR_GRID":
            self.reader = vtk.vtkRectilinearGridReader ()
        elif self.grid_type == "POLYDATA":
            self.reader = vtk.vtkPolyDataReader ()
        elif self.grid_type == "UNSTRUCTURED_GRID":
            self.reader = vtk.vtkUnstructuredGridReader () 
Example #9
0
    def load_object_3d(self, path, viewer_3d):
        generic_reader = vtkDataReader()
        generic_reader.SetFileName(path)

        if generic_reader.OpenVTKFile() and generic_reader.ReadHeader():
            if generic_reader.IsFileStructuredPoints():
                raise Exception("Cannot read VTK structured points")
            elif generic_reader.IsFilePolyData():
                reader = vtkPolyDataReader()
                reader.SetFileName(path)
                object_3d = Object3D(reader.GetOutput(), path)
            elif generic_reader.IsFileStructuredGrid():
                reader = vtkStructuredGridReader()
                reader.SetFileName(path)
                object_3d = Object3D(reader.GetOutput(), path)
            elif generic_reader.IsFileUnstructuredGrid():
                reader = vtkUnstructuredGridReader()
                reader.SetFileName(path)
                object_3d = Object3D(reader.GetOutput(), path)
            elif generic_reader.IsFileRectilinearGrid():
                reader = vtkRectilinearGridReader()
                reader.SetFileName(path)
                object_3d = Object3D(reader.GetOutput(), path)
            else:
                raise Exception("Cannot read VTK file containing type %i" %
                                generic_reader.GetFileType())
            viewer_3d.objects_3d.append(object_3d)
        else:
            importer = vtkVRMLImporter()
            importer.SetFileName(path)
            importer.Update()
            actors = importer.GetRenderer().GetActors()
            number_of_actors = actors.GetNumberOfItems()
            actors.InitTraversal()
            for i in range(number_of_actors):
                actor = actors.GetNextItem()
                object_3d = Object3D(path + ", %i" % i)
                object_3d.actor.SetProperty(actor.GetProperty())
                object_3d.actor.SetMapper(actor.GetMapper())
                viewer_3d.objects_3d.append(object_3d)
Example #10
0
def solve():
    print(diffusion.solve(0.0, 0.25, 0.5, 1.0))
    reader = vtkStructuredGridReader()
    reader.SetFileName('../sol/solution0.vtk')
    reader.ReadAllVectorsOn()
    reader.ReadAllScalarsOn()
    reader.Update()

    data = reader.GetOutput()

    dim = data.GetDimensions()
    vec = list(dim)
    vec = [i-1 for i in dim]
    vec.append(3)

    x = np.zeros(data.GetNumberOfPoints())
    y = np.zeros(data.GetNumberOfPoints())
    z = np.zeros(data.GetNumberOfPoints())
    c = data.GetPointData().GetArray('Val')

    for i in range(data.GetNumberOfPoints()):
            x[i], y[i], z[i] = data.GetPoint(i)

    x = x.reshape(dim[0:2], order='F')
    y = y.reshape(dim[0:2], order='F')
    z = z.reshape(dim[0:2], order='F')
    c = VN.vtk_to_numpy(data.GetPointData().GetArray('Val'))
    c = c.reshape(dim[0:2], order='F')

    fig = Figure()
    axis = fig.add_subplot(111)

    # TODO: Set equal aspect ratio axes
    # axis.set_aspect('equal')
    axis.contourf(x, y, c)
    canvas = FigureCanvas(fig)
    output = io.BytesIO()
    canvas.print_png(output)
    fig.savefig('./static/img/img.png')
    return output
Example #11
0
    def _load_file(self, filename):
        """
        Load a structured grid from a file.

        The file extension will select the type of reader to use.  A .vtk
        extension will use the legacy reader, while .vts will select the VTK
        XML reader.

        Parameters
        ----------
        filename : str
            Filename of grid to be loaded.

        """
        filename = os.path.abspath(os.path.expanduser(filename))
        # check file exists
        if not os.path.isfile(filename):
            raise Exception('{} does not exist'.format(filename))

        # Check file extention
        if '.vts' in filename:
            legacy_writer = False
        elif '.vtk' in filename:
            legacy_writer = True
        else:
            raise Exception(
                'Extension should be either ".vts" (xml) or ".vtk" (legacy)')

        # Create reader
        if legacy_writer:
            reader = vtk.vtkStructuredGridReader()
        else:
            reader = vtk.vtkXMLStructuredGridReader()

        # load file to self
        reader.SetFileName(filename)
        reader.Update()
        grid = reader.GetOutput()
        self.ShallowCopy(grid)
def readSGrid(
        filename,
        verbose=0):

    mypy.my_print(verbose, "*** readSGrid: "+filename+" ***")

    assert (os.path.isfile(filename)), "Wrong filename (\""+filename+"\"). Aborting."

    if   (filename.endswith("vtk")):
        sgrid_reader = vtk.vtkStructuredGridReader()
    elif (filename.endswith("vts")):
        sgrid_reader = vtk.vtkXMLStructuredGridReader()
    else:
        assert 0, "File must be .vtk or .vts. Aborting."

    sgrid_reader.SetFileName(filename)
    sgrid_reader.Update()
    sgrid = sgrid_reader.GetOutput()

    mypy.my_print(verbose-1, "n_points = "+str(sgrid.GetNumberOfPoints()))
    mypy.my_print(verbose-1, "n_cells = "+str(sgrid.GetNumberOfCells()))

    return sgrid
Example #13
0
def furniture():
    # generate a whole bunch of planes which correspond to
    # the geometry in the analysis; tables, bookshelves and so on.

    from vedo import datadir
    reader = vtk.vtkStructuredGridReader()
    reader.SetFileName(datadir + "office.binary.vtk")
    reader.Update()
    sgrid = reader.GetOutput()

    table1 = vtk.vtkStructuredGridGeometryFilter()
    table1.SetInputData(sgrid)
    table1.SetExtent(11, 15, 7, 9, 8, 8)
    mapTable1 = vtk.vtkPolyDataMapper()
    mapTable1.SetInputConnection(table1.GetOutputPort())
    mapTable1.ScalarVisibilityOff()
    table1Actor = vtk.vtkActor()
    table1Actor.SetMapper(mapTable1)
    table1Actor.GetProperty().SetColor(.59, .427, .392)

    table2 = vtk.vtkStructuredGridGeometryFilter()
    table2.SetInputData(sgrid)
    table2.SetExtent(11, 15, 10, 12, 8, 8)
    mapTable2 = vtk.vtkPolyDataMapper()
    mapTable2.SetInputConnection(table2.GetOutputPort())
    mapTable2.ScalarVisibilityOff()
    table2Actor = vtk.vtkActor()
    table2Actor.SetMapper(mapTable2)
    table2Actor.GetProperty().SetColor(.59, .427, .392)

    FilingCabinet1 = vtk.vtkStructuredGridGeometryFilter()
    FilingCabinet1.SetInputData(sgrid)
    FilingCabinet1.SetExtent(15, 15, 7, 9, 0, 8)
    mapFilingCabinet1 = vtk.vtkPolyDataMapper()
    mapFilingCabinet1.SetInputConnection(FilingCabinet1.GetOutputPort())
    mapFilingCabinet1.ScalarVisibilityOff()
    FilingCabinet1Actor = vtk.vtkActor()
    FilingCabinet1Actor.SetMapper(mapFilingCabinet1)
    FilingCabinet1Actor.GetProperty().SetColor(.8, .8, .6)

    FilingCabinet2 = vtk.vtkStructuredGridGeometryFilter()
    FilingCabinet2.SetInputData(sgrid)
    FilingCabinet2.SetExtent(15, 15, 10, 12, 0, 8)
    mapFilingCabinet2 = vtk.vtkPolyDataMapper()
    mapFilingCabinet2.SetInputConnection(FilingCabinet2.GetOutputPort())
    mapFilingCabinet2.ScalarVisibilityOff()
    FilingCabinet2Actor = vtk.vtkActor()
    FilingCabinet2Actor.SetMapper(mapFilingCabinet2)
    FilingCabinet2Actor.GetProperty().SetColor(.8, .8, .6)

    bookshelf1Top = vtk.vtkStructuredGridGeometryFilter()
    bookshelf1Top.SetInputData(sgrid)
    bookshelf1Top.SetExtent(13, 13, 0, 4, 0, 11)
    mapBookshelf1Top = vtk.vtkPolyDataMapper()
    mapBookshelf1Top.SetInputConnection(bookshelf1Top.GetOutputPort())
    mapBookshelf1Top.ScalarVisibilityOff()
    bookshelf1TopActor = vtk.vtkActor()
    bookshelf1TopActor.SetMapper(mapBookshelf1Top)
    bookshelf1TopActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf1Bottom = vtk.vtkStructuredGridGeometryFilter()
    bookshelf1Bottom.SetInputData(sgrid)
    bookshelf1Bottom.SetExtent(20, 20, 0, 4, 0, 11)
    mapBookshelf1Bottom = vtk.vtkPolyDataMapper()
    mapBookshelf1Bottom.SetInputConnection(bookshelf1Bottom.GetOutputPort())
    mapBookshelf1Bottom.ScalarVisibilityOff()
    bookshelf1BottomActor = vtk.vtkActor()
    bookshelf1BottomActor.SetMapper(mapBookshelf1Bottom)
    bookshelf1BottomActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf1Front = vtk.vtkStructuredGridGeometryFilter()
    bookshelf1Front.SetInputData(sgrid)
    bookshelf1Front.SetExtent(13, 20, 0, 0, 0, 11)
    mapBookshelf1Front = vtk.vtkPolyDataMapper()
    mapBookshelf1Front.SetInputConnection(bookshelf1Front.GetOutputPort())
    mapBookshelf1Front.ScalarVisibilityOff()
    bookshelf1FrontActor = vtk.vtkActor()
    bookshelf1FrontActor.SetMapper(mapBookshelf1Front)
    bookshelf1FrontActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf1Back = vtk.vtkStructuredGridGeometryFilter()
    bookshelf1Back.SetInputData(sgrid)
    bookshelf1Back.SetExtent(13, 20, 4, 4, 0, 11)
    mapBookshelf1Back = vtk.vtkPolyDataMapper()
    mapBookshelf1Back.SetInputConnection(bookshelf1Back.GetOutputPort())
    mapBookshelf1Back.ScalarVisibilityOff()
    bookshelf1BackActor = vtk.vtkActor()
    bookshelf1BackActor.SetMapper(mapBookshelf1Back)
    bookshelf1BackActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf1LHS = vtk.vtkStructuredGridGeometryFilter()
    bookshelf1LHS.SetInputData(sgrid)
    bookshelf1LHS.SetExtent(13, 20, 0, 4, 0, 0)
    mapBookshelf1LHS = vtk.vtkPolyDataMapper()
    mapBookshelf1LHS.SetInputConnection(bookshelf1LHS.GetOutputPort())
    mapBookshelf1LHS.ScalarVisibilityOff()
    bookshelf1LHSActor = vtk.vtkActor()
    bookshelf1LHSActor.SetMapper(mapBookshelf1LHS)
    bookshelf1LHSActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf1RHS = vtk.vtkStructuredGridGeometryFilter()
    bookshelf1RHS.SetInputData(sgrid)
    bookshelf1RHS.SetExtent(13, 20, 0, 4, 11, 11)
    mapBookshelf1RHS = vtk.vtkPolyDataMapper()
    mapBookshelf1RHS.SetInputConnection(bookshelf1RHS.GetOutputPort())
    mapBookshelf1RHS.ScalarVisibilityOff()
    bookshelf1RHSActor = vtk.vtkActor()
    bookshelf1RHSActor.SetMapper(mapBookshelf1RHS)
    bookshelf1RHSActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf2Top = vtk.vtkStructuredGridGeometryFilter()
    bookshelf2Top.SetInputData(sgrid)
    bookshelf2Top.SetExtent(13, 13, 15, 19, 0, 11)
    mapBookshelf2Top = vtk.vtkPolyDataMapper()
    mapBookshelf2Top.SetInputConnection(bookshelf2Top.GetOutputPort())
    mapBookshelf2Top.ScalarVisibilityOff()
    bookshelf2TopActor = vtk.vtkActor()
    bookshelf2TopActor.SetMapper(mapBookshelf2Top)
    bookshelf2TopActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf2Bottom = vtk.vtkStructuredGridGeometryFilter()
    bookshelf2Bottom.SetInputData(sgrid)
    bookshelf2Bottom.SetExtent(20, 20, 15, 19, 0, 11)
    mapBookshelf2Bottom = vtk.vtkPolyDataMapper()
    mapBookshelf2Bottom.SetInputConnection(bookshelf2Bottom.GetOutputPort())
    mapBookshelf2Bottom.ScalarVisibilityOff()
    bookshelf2BottomActor = vtk.vtkActor()
    bookshelf2BottomActor.SetMapper(mapBookshelf2Bottom)
    bookshelf2BottomActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf2Front = vtk.vtkStructuredGridGeometryFilter()
    bookshelf2Front.SetInputData(sgrid)
    bookshelf2Front.SetExtent(13, 20, 15, 15, 0, 11)
    mapBookshelf2Front = vtk.vtkPolyDataMapper()
    mapBookshelf2Front.SetInputConnection(bookshelf2Front.GetOutputPort())
    mapBookshelf2Front.ScalarVisibilityOff()
    bookshelf2FrontActor = vtk.vtkActor()
    bookshelf2FrontActor.SetMapper(mapBookshelf2Front)
    bookshelf2FrontActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf2Back = vtk.vtkStructuredGridGeometryFilter()
    bookshelf2Back.SetInputData(sgrid)
    bookshelf2Back.SetExtent(13, 20, 19, 19, 0, 11)
    mapBookshelf2Back = vtk.vtkPolyDataMapper()
    mapBookshelf2Back.SetInputConnection(bookshelf2Back.GetOutputPort())
    mapBookshelf2Back.ScalarVisibilityOff()
    bookshelf2BackActor = vtk.vtkActor()
    bookshelf2BackActor.SetMapper(mapBookshelf2Back)
    bookshelf2BackActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf2LHS = vtk.vtkStructuredGridGeometryFilter()
    bookshelf2LHS.SetInputData(sgrid)
    bookshelf2LHS.SetExtent(13, 20, 15, 19, 0, 0)
    mapBookshelf2LHS = vtk.vtkPolyDataMapper()
    mapBookshelf2LHS.SetInputConnection(bookshelf2LHS.GetOutputPort())
    mapBookshelf2LHS.ScalarVisibilityOff()
    bookshelf2LHSActor = vtk.vtkActor()
    bookshelf2LHSActor.SetMapper(mapBookshelf2LHS)
    bookshelf2LHSActor.GetProperty().SetColor(.8, .8, .6)

    bookshelf2RHS = vtk.vtkStructuredGridGeometryFilter()
    bookshelf2RHS.SetInputData(sgrid)
    bookshelf2RHS.SetExtent(13, 20, 15, 19, 11, 11)
    mapBookshelf2RHS = vtk.vtkPolyDataMapper()
    mapBookshelf2RHS.SetInputConnection(bookshelf2RHS.GetOutputPort())
    mapBookshelf2RHS.ScalarVisibilityOff()
    bookshelf2RHSActor = vtk.vtkActor()
    bookshelf2RHSActor.SetMapper(mapBookshelf2RHS)
    bookshelf2RHSActor.GetProperty().SetColor(.8, .8, .6)

    window = vtk.vtkStructuredGridGeometryFilter()
    window.SetInputData(sgrid)
    window.SetExtent(20, 20, 6, 13, 10, 13)
    mapWindow = vtk.vtkPolyDataMapper()
    mapWindow.SetInputConnection(window.GetOutputPort())
    mapWindow.ScalarVisibilityOff()
    windowActor = vtk.vtkActor()
    windowActor.SetMapper(mapWindow)
    windowActor.GetProperty().SetColor(.3, .3, .5)

    outlet = vtk.vtkStructuredGridGeometryFilter()
    outlet.SetInputData(sgrid)
    outlet.SetExtent(0, 0, 9, 10, 14, 16)
    mapOutlet = vtk.vtkPolyDataMapper()
    mapOutlet.SetInputConnection(outlet.GetOutputPort())
    mapOutlet.ScalarVisibilityOff()
    outletActor = vtk.vtkActor()
    outletActor.SetMapper(mapOutlet)
    outletActor.GetProperty().SetColor(1, 1, 1)

    inlet = vtk.vtkStructuredGridGeometryFilter()
    inlet.SetInputData(sgrid)
    inlet.SetExtent(0, 0, 9, 10, 0, 6)
    mapInlet = vtk.vtkPolyDataMapper()
    mapInlet.SetInputConnection(inlet.GetOutputPort())
    mapInlet.ScalarVisibilityOff()
    inletActor = vtk.vtkActor()
    inletActor.SetMapper(mapInlet)
    inletActor.GetProperty().SetColor(1, 1, 1)

    outline = vtk.vtkStructuredGridOutlineFilter()
    outline.SetInputData(sgrid)
    mapOutline = vtk.vtkPolyDataMapper()
    mapOutline.SetInputConnection(outline.GetOutputPort())
    outlineActor = vtk.vtkActor()
    outlineActor.SetMapper(mapOutline)
    outlineActor.GetProperty().SetColor(1, 1, 1)

    acts = []
    acts.append(table1Actor)
    acts.append(table2Actor)
    acts.append(FilingCabinet1Actor)
    acts.append(FilingCabinet2Actor)
    acts.append(bookshelf1TopActor)
    acts.append(bookshelf1BottomActor)
    acts.append(bookshelf1FrontActor)
    acts.append(bookshelf1BackActor)
    acts.append(bookshelf1LHSActor)
    acts.append(bookshelf1RHSActor)
    acts.append(bookshelf2TopActor)
    acts.append(bookshelf2BottomActor)
    acts.append(bookshelf2FrontActor)
    acts.append(bookshelf2BackActor)
    acts.append(bookshelf2LHSActor)
    acts.append(bookshelf2RHSActor)
    acts.append(windowActor)
    acts.append(outletActor)
    acts.append(inletActor)
    acts.append(outlineActor)

    return acts
Example #14
0
import vtk

objectPath = r"./assets/density.vtk"

reader = vtk.vtkStructuredGridReader()
reader.SetFileName(objectPath)
reader.Update()

plane = vtk.vtkPlane()
plane.SetOrigin(reader.GetOutput().GetCenter())
plane.SetNormal(0.5, 0.5, 0.5)

planeCut = vtk.vtkCutter()
planeCut.SetInputConnection(reader.GetOutputPort())
planeCut.SetCutFunction(plane)

cutMapper = vtk.vtkPolyDataMapper()
cutMapper.SetInputConnection(planeCut.GetOutputPort())
cutMapper.SetScalarRange(reader.GetOutput().GetScalarRange())

actor = vtk.vtkActor()
actor.SetMapper(cutMapper)

# Create a rendering window and renderer

renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()

renderWindow.AddRenderer(renderer)

# Create a renderwindowinteractor
Example #15
0
def loadStructuredGrid(filename):
    """Load a ``vtkStructuredGrid`` object from file."""
    reader = vtk.vtkStructuredGridReader()
    reader.SetFileName(filename)
    reader.Update()
    return reader.GetOutput()
Example #16
0
    # Create a reader and write out the field
    comb = vtk.vtkMultiBlockPLOT3DReader()
    comb.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin")
    comb.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin")
    comb.SetScalarFunctionNumber(100)
    comb.Update()

    output = comb.GetOutput().GetBlock(0)

    wsg = vtk.vtkStructuredGridWriter()
    wsg.SetInputData(output)
    wsg.SetFileTypeToBinary()
    wsg.SetFileName("combsg.vtk")
    wsg.Write()

    pl3d = vtk.vtkStructuredGridReader()
    pl3d.SetFileName("combsg.vtk")

    ds2do = vtk.vtkDataSetToDataObjectFilter()
    ds2do.SetInputConnection(pl3d.GetOutputPort())

    writer = vtk.vtkDataObjectWriter()
    writer.SetInputConnection(ds2do.GetOutputPort())
    writer.SetFileName("SGridField.vtk")
    writer.Write()

    # read the field
    dor = vtk.vtkDataObjectReader()
    dor.SetFileName("SGridField.vtk")

    do2ds = vtk.vtkDataObjectToDataSetFilter()
Example #17
0
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

# read data
#
reader = vtk.vtkStructuredGridReader()
reader.SetFileName(VTK_DATA_ROOT + "/Data/office.binary.vtk")
reader.Update()

# force a read to occur
# to add coverage for vtkOnePieceExtentTranslator
translator = vtk.vtkOnePieceExtentTranslator()
reader.GetExecutive().SetExtentTranslator(0, translator)

length = reader.GetOutput().GetLength()
maxVelocity = reader.GetOutput().GetPointData().GetVectors().GetMaxNorm()
maxTime = 35.0 * length / maxVelocity

table1 = vtk.vtkStructuredGridGeometryFilter()
table1.SetInputConnection(reader.GetOutputPort())
table1.SetExtent(11, 15, 7, 9, 8, 8)
mapTable1 = vtk.vtkPolyDataMapper()
Example #18
0
def getOutputVTKwithPointDataFromFile(fileName):
    """
    Uses the correct VTK reader to obtain a VTK output object so that one can
    work with the data in *fileName*.
    NOTE : the cell data are transfered to the nodes.  

    Parameters
    ----------
    fileName : string
        The .vt* file to open

    Returns
    -------
    data_outVTK : VTK output object from a VTK reader
        VTK output object associated to the file type of *fileName*

    """

    # function display
    print '\n---- DAEPy::getOutputVTKwithPointDataFromFile ----'

    # test if the file exists
    print '\n--> Reading', fileName
    if not os.path.isfile(fileName):
        raise ValueError("Error : file does not exists")

    extension = os.path.splitext(fileName)[-1]
    if extension == '.vtu':
        reader = vtk.vtkXMLUnstructuredGridReader()
    elif extension == '.vtk':
        reader = vtk.vtkStructuredGridReader()
    elif extension == '.pvtu':
        reader = vtk.vtkXMLPUnstructuredGridReader()
    elif extension == '.vtp':
        reader = vtk.vtkXMLPolyDataReader()
    elif extension == '.vtm':
        # TODO : To check
        reader = vtk.vtkXMLMultiBlockDataReader()
        reader = vtk.MergeBlocks(reader)
    else:
        raise ValueError("Error: unknown extension of file " + fileName)

    reader.SetFileName(fileName)

    reader.ReadAllScalarsOn()
    reader.ReadAllVectorsOn()

    reader.Update()
    data_outVTK = reader.GetOutput()

    #    # All the data are transfered to the nodes
    #    c2p = vtk.vtkCellDataToPointData()
    #    c2p.SetInputData(data_outVTK)
    #    c2p.Update()
    #    data_outVTK = c2p.GetOutput()

    # list the fields available

    n_fields = data_outVTK.GetPointData().GetNumberOfArrays()

    print '\n--> Available:', n_fields, 'fields\n'

    for i in range(n_fields):
        print '        -', data_outVTK.GetPointData().GetArrayName(i)

    print ''
    return data_outVTK
Example #19
0
    # Create a reader and write out the field
    comb = vtk.vtkMultiBlockPLOT3DReader()
    comb.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin")
    comb.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin")
    comb.SetScalarFunctionNumber(100)
    comb.Update()

    output = comb.GetOutput().GetBlock(0)

    wsg = vtk.vtkStructuredGridWriter()
    wsg.SetInputData(output)
    wsg.SetFileTypeToBinary()
    wsg.SetFileName("combsg.vtk")
    wsg.Write()

    pl3d = vtk.vtkStructuredGridReader()
    pl3d.SetFileName("combsg.vtk")

    ds2do = vtk.vtkDataSetToDataObjectFilter()
    ds2do.SetInputConnection(pl3d.GetOutputPort())

    writer = vtk.vtkDataObjectWriter()
    writer.SetInputConnection(ds2do.GetOutputPort())
    writer.SetFileName("SGridField.vtk")
    writer.Write()

    # read the field
    dor = vtk.vtkDataObjectReader()
    dor.SetFileName("SGridField.vtk")

    do2ds = vtk.vtkDataObjectToDataSetFilter()
Example #20
0
    def extract_data(self, rotate=None):
        """

        Extract the data from the VTK file using the python-vtk library
        The data is passed to numpy arrays for better manipulation

        """

        # Check the type of file to load it according to its grid structure
        # which was specified when calling the class These dictionary entries
        # return the corresponding VTK Reader functions, so they can be easily
        # called according to the class argument
        #
        # Rotate argument is a rotation in the x-y plane. To use, set rotate
        # equal to an angle in radians.
        reader_type = {
            'XMLUnstructuredGrid': lambda: vtk.vtkXMLUnstructuredGridReader(),
            'XMLStructuredGrid': lambda: vtk.vtkXMLStructuredGridReader(),
            'UnstructuredGrid': lambda: vtk.vtkUnstructuredGridReader(),
            'StructuredGrid': lambda: vtk.vtkStructuredGridReader(),
        }

        if self.vtkfiletype.startswith('XML'):
            # Load the vtk file from the input file
            self.reader = reader_type[self.vtkfiletype]()
            self.reader.SetFileName(self.vtk_file)
        else:
            # Load the vtk file from the input file
            self.reader = reader_type[self.vtkfiletype]()
            self.reader.SetFileName(self.vtk_file)
            # For Non XML vtk files:
            self.reader.ReadAllVectorsOn()
            self.reader.ReadAllScalarsOn()

        self.reader.Update()

        # Get the coordinates of the nodes in the mesh
        nodes_vtk_array = self.reader.GetOutput().GetPoints().GetData()

        # Get The vector field (data of every node)
        vf_vtk_array = self.reader.GetOutput().GetPointData().GetArray(0)

        # Transform the coordinates of the nodes to a Numpy array and
        # save them to the corresponding class objects

        nodes = vtk_to_numpy(nodes_vtk_array)
        if rotate:
            self.x = nodes[:, 0]*np.cos(rotate) - nodes[:, 1]*np.sin(rotate)
            self.y = nodes[:, 0]*np.sin(rotate) + nodes[:, 1]*np.cos(rotate)
            self.z = nodes[:, 2]
        else:
            self.x, self.y, self.z = (nodes[:, 0],
                                      nodes[:, 1],
                                      nodes[:, 2]
                                      )

        # Transform the magnetisation data to a Numpy array and save
        if rotate:
            vf = vtk_to_numpy(vf_vtk_array)
            vfx = vf[:, 0]*np.cos(rotate) - vf[:, 1]*np.sin(rotate)
            vfy = vf[:, 0]*np.sin(rotate) + vf[:, 1]*np.cos(rotate)
            vfz = vf[:, 2]
            self.vf = np.zeros_like(vf)
            self.vf[:, 0] = vfx
            self.vf[:, 1] = vfy
            self.vf[:, 2] = vfz
        else:
            self.vf = vtk_to_numpy(vf_vtk_array)
Example #21
0
def read_polydata(filename, datatype=None):
    """
    Load the given file, and return a vtkPolyData object for it.

    Args:
        filename (str): Path to input file.
        datatype (str): Additional parameter for vtkIdList objects.

    Returns:
        polyData (vtkSTL/vtkPolyData/vtkXMLStructured/
                    vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/
                    vtkXMLImage/Tecplot): Output data.
    """

    # Check if file exists
    if not path.exists(filename):
        raise RuntimeError("Could not find file: %s" % filename)

    # Check filename format
    fileType = filename.split(".")[-1]
    if fileType == '':
        raise RuntimeError('The file does not have an extension')

    # Get reader
    if fileType == 'stl':
        reader = vtk.vtkSTLReader()
        reader.MergingOn()
    elif fileType == 'vtk':
        # Read header
        with open(filename, "rb") as f:
            head = list(islice(f, 10))
        head = "".join([l.decode('utf-8', 'backslashreplace')
                        for l in head]).lower()

        # Set reader based on header
        if "unstructured_grid" in head:
            reader = vtk.vtkUnstructuredGridReader()
        elif "structured_grid" in head:
            reader = vtk.vtkStructuredGridReader()
        elif "rectilinear_grid" in head:
            reader = vtk.vtkRectilinearGridReader()
        elif "structured_points" in head:
            reader = vtk.vtkStructuredPointsReader()
        elif "polydata" in head:
            reader = vtk.vtkPolyDataReader()
    elif fileType == 'vtp':
        reader = vtk.vtkXMLPolyDataReader()
    elif fileType == 'vts':
        reader = vtk.vtkXMLStructuredGridReader()
    elif fileType == 'vtr':
        reader = vtk.vtkXMLRectilinearGridReader()
    elif fileType == 'vtu':
        reader = vtk.vtkXMLUnstructuredGridReader()
    elif fileType == "vti":
        reader = vtk.vtkXMLImageDataReader()
    elif fileType == "np" and datatype == "vtkIdList":
        result = np.load(filename).astype(np.int)
        id_list = vtk.vtkIdList()
        id_list.SetNumberOfIds(result.shape[0])
        for i in range(result.shape[0]):
            id_list.SetId(i, result[i])
        return id_list
    else:
        raise RuntimeError('Unknown file type %s' % fileType)

    # Read
    reader.SetFileName(filename)
    reader.Update()
    polydata = reader.GetOutput()

    return polydata
Example #22
0
    def __init__(self, dataDir='data', fileName='save.vtk'):
        """
        Reads the parameters.
        
        call signature:
        
          readParams(dataDir = 'data', fileName = 'save.vtk')
                    
        Keyword arguments:
        
         *dataDir*:
            Data directory.
            
         *fileName*:
            Name of the dump file.
        """

        reader = vtkStructuredGridReader()

        if (dataDir[-1] == '/'):
            dataDir = dataDir[:-1]

        try:
            reader.SetFileName(dataDir + '/' + fileName)
        except IOError:
            return -1

        reader.ReadAllVectorsOn()
        reader.ReadAllScalarsOn()
        reader.Update()

        output = reader.GetOutput()
        data = output.GetPointData()

        field = output.GetFieldData()
        nArrays = field.GetNumberOfArrays()
        for i in range(nArrays):
            arrayName = field.GetArrayName(i)
            tmp = VN.vtk_to_numpy(field.GetArray(arrayName))
            if (arrayName == 'nx_ny_nz'):
                setattr(self, 'nx', tmp[0])
                setattr(self, 'ny', tmp[1])
                setattr(self, 'nz', tmp[2])
            elif (arrayName == 'Lx_Ly_Lz'):
                setattr(self, 'Lx', tmp[0])
                setattr(self, 'Ly', tmp[1])
                setattr(self, 'Lz', tmp[2])
            elif (arrayName == 'Ox_Oy_Oz'):
                setattr(self, 'Ox', tmp[0])
                setattr(self, 'Oy', tmp[1])
                setattr(self, 'Oz', tmp[2])
            elif (arrayName == 'dx_dy_dz'):
                setattr(self, 'dx', tmp[0])
                setattr(self, 'dy', tmp[1])
                setattr(self, 'dz', tmp[2])
            elif (arrayName == 'rxhalf_ryhalf'):
                setattr(self, 'rxhalf', tmp[0])
                setattr(self, 'ryhalf', tmp[1])
            elif (arrayName == 'phi1_phi2'):
                setattr(self, 'phi1', tmp[0])
                setattr(self, 'phi2', tmp[1])
            else:
                setattr(self, arrayName, tmp[0])

        reader.CloseVTKFile()
Example #23
0
    def __init__(self, dataDir='data', fileName='save.vtk'):
        """
        Reads the dump file.
        
        call signature:
        
          readDump(dataDir = 'data', fileName = 'save.vtk')
          
        Keyword arguments:
        
         *dataDir*:
            Data directory.
            
         *fileName*:
            Name of the dump file.
        """

        reader = vtkStructuredGridReader()

        if (dataDir[-1] == '/'):
            dataDir = dataDir[:-1]

        try:
            reader.SetFileName(dataDir + '/' + fileName)
        except IOError:
            return -1

        reader.ReadAllVectorsOn()
        reader.ReadAllScalarsOn()
        reader.Update()

        output = reader.GetOutput()
        dim = output.GetDimensions()
        data = output.GetPointData()

        nArrays = data.GetNumberOfArrays()
        for i in range(nArrays):
            arrayName = data.GetArrayName(i)
            tmp = VN.vtk_to_numpy(data.GetArray(arrayName))
            if (tmp.ndim == 2):
                tmp = tmp.reshape(dim[2], dim[1], dim[0], 3)
                tmp = np.swapaxes(tmp, 0, 3)
                tmp = np.swapaxes(tmp, 1, 2)
            else:
                tmp = tmp.reshape(dim[2], dim[1], dim[0])
                tmp = np.swapaxes(tmp, 0, 2)
            setattr(self, arrayName, tmp)
            del (tmp)

        # read the grid coordinates
        points = output.GetPoints()
        grid = VN.vtk_to_numpy(points.GetData())
        grid = grid.reshape(dim[2], dim[1], dim[0], 3)
        grid = np.swapaxes(grid, 0, 3)
        grid = np.swapaxes(grid, 1, 2)
        setattr(self, 'grid', grid)
        del (grid)

        # read the parameters
        p = readParams(dataDir=dataDir, fileName=fileName)
        setattr(self, 'p', p)

        reader.CloseVTKFile()
Example #24
0
def main():
    fileName = get_program_parameters()

    colors = vtk.vtkNamedColors()

    # Set the furniture colors.
    colors.SetColor("Furniture", [204, 204, 153, 255])

    scalarRange = [0.0, 0.0]
    maxTime = 0

    aren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(aren)

    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    #
    # Read the data.
    #
    reader = vtk.vtkStructuredGridReader()
    reader.SetFileName(fileName)
    reader.Update()  # Force a read to occur.
    reader.GetOutput().GetLength()

    if reader.GetOutput().GetPointData().GetScalars():
        reader.GetOutput().GetPointData().GetScalars().GetRange(scalarRange)

    if reader.GetOutput().GetPointData().GetVectors():
        maxVelocity = reader.GetOutput().GetPointData().GetVectors(
        ).GetMaxNorm()
        maxTime = 4.0 * reader.GetOutput().GetLength() / maxVelocity

    #
    # Outline around the data.
    #
    outlineF = vtk.vtkStructuredGridOutlineFilter()
    outlineF.SetInputConnection(reader.GetOutputPort())
    outlineMapper = vtk.vtkPolyDataMapper()
    outlineMapper.SetInputConnection(outlineF.GetOutputPort())
    outline = vtk.vtkActor()
    outline.SetMapper(outlineMapper)
    outline.GetProperty().SetColor(colors.GetColor3d("LampBlack"))

    #
    # Set up shaded surfaces (i.e., supporting geometry).
    #
    doorGeom = vtk.vtkStructuredGridGeometryFilter()
    doorGeom.SetInputConnection(reader.GetOutputPort())
    doorGeom.SetExtent(27, 27, 14, 18, 0, 11)
    mapDoor = vtk.vtkPolyDataMapper()
    mapDoor.SetInputConnection(doorGeom.GetOutputPort())
    mapDoor.ScalarVisibilityOff()
    door = vtk.vtkActor()
    door.SetMapper(mapDoor)
    door.GetProperty().SetColor(colors.GetColor3d("Burlywood"))

    window1Geom = vtk.vtkStructuredGridGeometryFilter()
    window1Geom.SetInputConnection(reader.GetOutputPort())
    window1Geom.SetExtent(0, 0, 9, 18, 6, 12)
    mapWindow1 = vtk.vtkPolyDataMapper()
    mapWindow1.SetInputConnection(window1Geom.GetOutputPort())
    mapWindow1.ScalarVisibilityOff()
    window1 = vtk.vtkActor()
    window1.SetMapper(mapWindow1)
    window1.GetProperty().SetColor(colors.GetColor3d("SkyBlue"))
    window1.GetProperty().SetOpacity(.6)

    window2Geom = vtk.vtkStructuredGridGeometryFilter()
    window2Geom.SetInputConnection(reader.GetOutputPort())
    window2Geom.SetExtent(5, 12, 23, 23, 6, 12)
    mapWindow2 = vtk.vtkPolyDataMapper()
    mapWindow2.SetInputConnection(window2Geom.GetOutputPort())
    mapWindow2.ScalarVisibilityOff()
    window2 = vtk.vtkActor()
    window2.SetMapper(mapWindow2)
    window2.GetProperty().SetColor(colors.GetColor3d("SkyBlue"))
    window2.GetProperty().SetOpacity(.6)

    klower1Geom = vtk.vtkStructuredGridGeometryFilter()
    klower1Geom.SetInputConnection(reader.GetOutputPort())
    klower1Geom.SetExtent(17, 17, 0, 11, 0, 6)
    mapKlower1 = vtk.vtkPolyDataMapper()
    mapKlower1.SetInputConnection(klower1Geom.GetOutputPort())
    mapKlower1.ScalarVisibilityOff()
    klower1 = vtk.vtkActor()
    klower1.SetMapper(mapKlower1)
    klower1.GetProperty().SetColor(colors.GetColor3d("EggShell"))

    klower2Geom = vtk.vtkStructuredGridGeometryFilter()
    klower2Geom.SetInputConnection(reader.GetOutputPort())
    klower2Geom.SetExtent(19, 19, 0, 11, 0, 6)
    mapKlower2 = vtk.vtkPolyDataMapper()
    mapKlower2.SetInputConnection(klower2Geom.GetOutputPort())
    mapKlower2.ScalarVisibilityOff()
    klower2 = vtk.vtkActor()
    klower2.SetMapper(mapKlower2)
    klower2.GetProperty().SetColor(colors.GetColor3d("EggShell"))

    klower3Geom = vtk.vtkStructuredGridGeometryFilter()
    klower3Geom.SetInputConnection(reader.GetOutputPort())
    klower3Geom.SetExtent(17, 19, 0, 0, 0, 6)
    mapKlower3 = vtk.vtkPolyDataMapper()
    mapKlower3.SetInputConnection(klower3Geom.GetOutputPort())
    mapKlower3.ScalarVisibilityOff()
    klower3 = vtk.vtkActor()
    klower3.SetMapper(mapKlower3)
    klower3.GetProperty().SetColor(colors.GetColor3d("EggShell"))

    klower4Geom = vtk.vtkStructuredGridGeometryFilter()
    klower4Geom.SetInputConnection(reader.GetOutputPort())
    klower4Geom.SetExtent(17, 19, 11, 11, 0, 6)
    mapKlower4 = vtk.vtkPolyDataMapper()
    mapKlower4.SetInputConnection(klower4Geom.GetOutputPort())
    mapKlower4.ScalarVisibilityOff()
    klower4 = vtk.vtkActor()
    klower4.SetMapper(mapKlower4)
    klower4.GetProperty().SetColor(colors.GetColor3d("EggShell"))

    klower5Geom = vtk.vtkStructuredGridGeometryFilter()
    klower5Geom.SetInputConnection(reader.GetOutputPort())
    klower5Geom.SetExtent(17, 19, 0, 11, 0, 0)
    mapKlower5 = vtk.vtkPolyDataMapper()
    mapKlower5.SetInputConnection(klower5Geom.GetOutputPort())
    mapKlower5.ScalarVisibilityOff()
    klower5 = vtk.vtkActor()
    klower5.SetMapper(mapKlower5)
    klower5.GetProperty().SetColor(colors.GetColor3d("EggShell"))

    klower6Geom = vtk.vtkStructuredGridGeometryFilter()
    klower6Geom.SetInputConnection(reader.GetOutputPort())
    klower6Geom.SetExtent(17, 19, 0, 7, 6, 6)
    mapKlower6 = vtk.vtkPolyDataMapper()
    mapKlower6.SetInputConnection(klower6Geom.GetOutputPort())
    mapKlower6.ScalarVisibilityOff()
    klower6 = vtk.vtkActor()
    klower6.SetMapper(mapKlower6)
    klower6.GetProperty().SetColor(colors.GetColor3d("EggShell"))

    klower7Geom = vtk.vtkStructuredGridGeometryFilter()
    klower7Geom.SetInputConnection(reader.GetOutputPort())
    klower7Geom.SetExtent(17, 19, 9, 11, 6, 6)
    mapKlower7 = vtk.vtkPolyDataMapper()
    mapKlower7.SetInputConnection(klower7Geom.GetOutputPort())
    mapKlower7.ScalarVisibilityOff()
    klower7 = vtk.vtkActor()
    klower7.SetMapper(mapKlower7)
    klower7.GetProperty().SetColor(colors.GetColor3d("EggShell"))

    hood1Geom = vtk.vtkStructuredGridGeometryFilter()
    hood1Geom.SetInputConnection(reader.GetOutputPort())
    hood1Geom.SetExtent(17, 17, 0, 11, 11, 16)
    mapHood1 = vtk.vtkPolyDataMapper()
    mapHood1.SetInputConnection(hood1Geom.GetOutputPort())
    mapHood1.ScalarVisibilityOff()
    hood1 = vtk.vtkActor()
    hood1.SetMapper(mapHood1)
    hood1.GetProperty().SetColor(colors.GetColor3d("Silver"))

    hood2Geom = vtk.vtkStructuredGridGeometryFilter()
    hood2Geom.SetInputConnection(reader.GetOutputPort())
    hood2Geom.SetExtent(19, 19, 0, 11, 11, 16)
    mapHood2 = vtk.vtkPolyDataMapper()
    mapHood2.SetInputConnection(hood2Geom.GetOutputPort())
    mapHood2.ScalarVisibilityOff()
    hood2 = vtk.vtkActor()
    hood2.SetMapper(mapHood2)
    hood2.GetProperty().SetColor(colors.GetColor3d("Furniture"))

    hood3Geom = vtk.vtkStructuredGridGeometryFilter()
    hood3Geom.SetInputConnection(reader.GetOutputPort())
    hood3Geom.SetExtent(17, 19, 0, 0, 11, 16)
    mapHood3 = vtk.vtkPolyDataMapper()
    mapHood3.SetInputConnection(hood3Geom.GetOutputPort())
    mapHood3.ScalarVisibilityOff()
    hood3 = vtk.vtkActor()
    hood3.SetMapper(mapHood3)
    hood3.GetProperty().SetColor(colors.GetColor3d("Furniture"))

    hood4Geom = vtk.vtkStructuredGridGeometryFilter()
    hood4Geom.SetInputConnection(reader.GetOutputPort())
    hood4Geom.SetExtent(17, 19, 11, 11, 11, 16)
    mapHood4 = vtk.vtkPolyDataMapper()
    mapHood4.SetInputConnection(hood4Geom.GetOutputPort())
    mapHood4.ScalarVisibilityOff()
    hood4 = vtk.vtkActor()
    hood4.SetMapper(mapHood4)
    hood4.GetProperty().SetColor(colors.GetColor3d("Furniture"))

    hood6Geom = vtk.vtkStructuredGridGeometryFilter()
    hood6Geom.SetInputConnection(reader.GetOutputPort())
    hood6Geom.SetExtent(17, 19, 0, 11, 16, 16)
    mapHood6 = vtk.vtkPolyDataMapper()
    mapHood6.SetInputConnection(hood6Geom.GetOutputPort())
    mapHood6.ScalarVisibilityOff()
    hood6 = vtk.vtkActor()
    hood6.SetMapper(mapHood6)
    hood6.GetProperty().SetColor(colors.GetColor3d("Furniture"))

    cookingPlateGeom = vtk.vtkStructuredGridGeometryFilter()
    cookingPlateGeom.SetInputConnection(reader.GetOutputPort())
    cookingPlateGeom.SetExtent(17, 19, 7, 9, 6, 6)
    mapCookingPlate = vtk.vtkPolyDataMapper()
    mapCookingPlate.SetInputConnection(cookingPlateGeom.GetOutputPort())
    mapCookingPlate.ScalarVisibilityOff()
    cookingPlate = vtk.vtkActor()
    cookingPlate.SetMapper(mapCookingPlate)
    cookingPlate.GetProperty().SetColor(colors.GetColor3d("Tomato"))

    filterGeom = vtk.vtkStructuredGridGeometryFilter()
    filterGeom.SetInputConnection(reader.GetOutputPort())
    filterGeom.SetExtent(17, 19, 7, 9, 11, 11)
    mapFilter = vtk.vtkPolyDataMapper()
    mapFilter.SetInputConnection(filterGeom.GetOutputPort())
    mapFilter.ScalarVisibilityOff()
    sgfilter = vtk.vtkActor()
    sgfilter.SetMapper(mapFilter)
    sgfilter.GetProperty().SetColor(colors.GetColor3d("Furniture"))
    #
    # regular streamlines
    #
    line = vtk.vtkLineSource()
    line.SetResolution(39)
    line.SetPoint1(0.08, 2.50, 0.71)
    line.SetPoint2(0.08, 4.50, 0.71)
    rakeMapper = vtk.vtkPolyDataMapper()
    rakeMapper.SetInputConnection(line.GetOutputPort())
    rake = vtk.vtkActor()
    rake.SetMapper(rakeMapper)

    streamers = vtk.vtkStreamTracer()
    # streamers.DebugOn()
    streamers.SetInputConnection(reader.GetOutputPort())
    streamers.SetSourceConnection(line.GetOutputPort())
    streamers.SetMaximumPropagation(maxTime)
    streamers.SetInitialIntegrationStep(.5)
    streamers.SetMinimumIntegrationStep(.1)
    streamers.SetIntegratorType(2)
    streamers.Update()

    streamersMapper = vtk.vtkPolyDataMapper()
    streamersMapper.SetInputConnection(streamers.GetOutputPort())
    streamersMapper.SetScalarRange(scalarRange)

    lines = vtk.vtkActor()
    lines.SetMapper(streamersMapper)
    lines.GetProperty().SetColor(colors.GetColor3d("Black"))

    aren.TwoSidedLightingOn()

    aren.AddActor(outline)
    aren.AddActor(door)
    aren.AddActor(window1)
    aren.AddActor(window2)
    aren.AddActor(klower1)
    aren.AddActor(klower2)
    aren.AddActor(klower3)
    aren.AddActor(klower4)
    aren.AddActor(klower5)
    aren.AddActor(klower6)
    aren.AddActor(klower7)
    aren.AddActor(hood1)
    aren.AddActor(hood2)
    aren.AddActor(hood3)
    aren.AddActor(hood4)
    aren.AddActor(hood6)
    aren.AddActor(cookingPlate)
    aren.AddActor(sgfilter)
    aren.AddActor(lines)
    aren.AddActor(rake)

    aren.SetBackground(colors.GetColor3d("SlateGray"))

    aCamera = vtk.vtkCamera()
    aren.SetActiveCamera(aCamera)
    aren.ResetCamera()

    aCamera.SetFocalPoint(3.505, 2.505, 1.255)
    aCamera.SetPosition(3.505, 24.6196, 1.255)
    aCamera.SetViewUp(0, 0, 1)
    aCamera.Azimuth(60)
    aCamera.Elevation(30)
    aCamera.Dolly(1.5)
    aren.ResetCameraClippingRange()

    renWin.SetSize(640, 512)
    renWin.Render()

    # interact with data
    iren.Start()