Exemple #1
0
    def __init__ (self, mod_m): 
        debug ("In CustomGridPlane::__init__ ()")
        Common.state.busy ()
        Base.Objects.Module.__init__ (self, mod_m)
        self.act = None
        out = self.mod_m.GetOutput ()
        if out.IsA('vtkStructuredGrid'):
            self.plane = vtk.vtkStructuredGridGeometryFilter ()
        elif out.IsA ('vtkStructuredPoints') or out.IsA('vtkImageData'):
            if hasattr (vtk, 'vtkImageDataGeometryFilter'):
                self.plane = vtk.vtkImageDataGeometryFilter ()
            else:
                self.plane = vtk.vtkStructuredPointsGeometryFilter ()
        elif out.IsA ('vtkRectilinearGrid'):
            self.plane = vtk.vtkRectilinearGridGeometryFilter ()
        else:
            msg = "This module does not support the %s dataset."%(out.GetClassName())
            raise Base.Objects.ModuleException, msg

        self.cont_fil = vtk.vtkContourFilter ()
        self.mapper = self.map = vtk.vtkPolyDataMapper ()
        self.actor = self.act = vtk.vtkActor ()
        self._initialize ()
        self._gui_init ()
        self.renwin.Render ()
        Common.state.idle ()
Exemple #2
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkRectilinearGridGeometryFilter(), 'Processing.',
         ('vtkRectilinearGrid',), ('vtkPolyData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
Exemple #3
0
    def __init__(self, startX, startY, endX, endY, zValue=0, nPoints=20):

        self.xCoords = vtk.vtkFloatArray()
        self.yCoords = vtk.vtkFloatArray()
        self.zCoords = vtk.vtkFloatArray()

        for x in np.linspace(startX, endX, nPoints):
            self.xCoords.InsertNextValue(x)

        for y in np.linspace(startY, endY, nPoints):
            self.yCoords.InsertNextValue(y)

        for z in [zValue]:
            self.zCoords.InsertNextValue(z)

        self.rgrid = vtk.vtkRectilinearGrid()
        self.rgrid.SetDimensions(nPoints, nPoints, 1)
        self.rgrid.SetXCoordinates(self.xCoords)
        self.rgrid.SetYCoordinates(self.yCoords)
        self.rgrid.SetZCoordinates(self.zCoords)

        self.plane = vtk.vtkRectilinearGridGeometryFilter()
        self.plane.SetInputData(self.rgrid)
        self.plane.SetExtent(0, nPoints - 1, 0, nPoints - 1, 0, 0)

        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputConnection(self.plane.GetOutputPort())

        self.actor = vtk.vtkActor()
        self.actor.SetMapper(self.mapper)
        self.actor.GetProperty().SetRepresentationToWireframe()
        self.actor.GetProperty().SetColor((0, 0, 0))
        self.actor.GetProperty().EdgeVisibilityOn()

        return
Exemple #4
0
    def _set_input (self):        
        """ This function tries its best to generate an appropriate
        input for the Normals.  If one has an input StructuredGrid or
        StructuredPoints or even a RectilinearGrid the PolyDataNormals
        will not work.  In order for it to work an appropriate
        intermediate filter is used to create the correct output."""        
        debug ("In PolyDataNormals::_set_input ()")
        out = self.prev_fil.GetOutput ()
        f = None
        if out.IsA ('vtkStructuredGrid'):
            f = vtk.vtkStructuredGridGeometryFilter ()
        elif out.IsA ('vtkRectilinearGrid'):
            f = vtk.vtkRectilinearGridGeometryFilter ()
        elif out.IsA ('vtkStructuredPoints') or out.IsA('vtkImageData'):
            if hasattr (vtk, 'vtkImageDataGeometryFilter'):
                f = vtk.vtkImageDataGeometryFilter ()
            else:
                f = vtk.vtkStructuredPointsGeometryFilter ()
        elif out.IsA('vtkUnstructuredGrid'):
            f = vtk.vtkGeometryFilter()
        elif out.IsA('vtkPolyData'):
            f = None
        else:
            msg = "This module does not support the given "\
                  "output - %s "%(out.GetClassName ())
            raise Base.Objects.ModuleException, msg

        if f:
            f.SetInput (out)
            self.fil.SetInput (f.GetOutput ())
        else:
            self.fil.SetInput(out)
Exemple #5
0
def loadRectilinearGrid(filename):  # not tested
    '''Load a vtkRectilinearGrid object from file and return a vtkActor.'''
    reader = vtk.vtkRectilinearGridReader()
    reader.SetFileName(filename)
    reader.Update()
    gf = vtk.vtkRectilinearGridGeometryFilter()
    gf.SetInputConnection(reader.GetOutputPort())
    gf.Update()
    return Actor(gf.GetOutput())
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self,
         module_manager,
         vtk.vtkRectilinearGridGeometryFilter(),
         "Processing.",
         ("vtkRectilinearGrid",),
         ("vtkPolyData",),
         replaceDoc=True,
         inputFunctions=None,
         outputFunctions=None,
     )
Exemple #7
0
    def set_vtk_data(self):
        """

        :return:
        """
        div1 = np.linspace(self.x_min, self.x_max, self.N)
        div2 = np.linspace(self.y_min, self.y_max, self.N)
        self.n3 = np.zeros_like(div1)
        self.n1, self.n2 = np.meshgrid(div1, div2)
        self.grid_nodes = np.array([
            self.n1,
            self.n2,
        ])

        #   predefine vtk array
        x = vtk.vtkFloatArray()
        y = vtk.vtkFloatArray()
        z = vtk.vtkFloatArray()

        N = len(self.n1.flatten())

        for n1_i in self.n1.flatten():
            x.InsertNextValue(n1_i)

        for n2_i in self.n2.flatten():
            y.InsertNextValue(n2_i)

        for n3_i in self.n3.flatten():
            z.InsertNextValue(n3_i)

        self.vtk_grid = vtk.vtkRectilinearGrid()
        self.vtk_grid.SetDimensions(N, N, N)
        self.vtk_grid.SetXCoordinates(x)
        self.vtk_grid.SetYCoordinates(y)
        self.vtk_grid.SetZCoordinates(z)

        #   extract a plane from the grid to see what we've got
        self.vtk_plane = vtk.vtkRectilinearGridGeometryFilter()
        self.vtk_plane.SetInputData(self.vtk_grid)
        self.vtk_plane.SetExtent(0, N - 1, 0, N - 1, 0, 0)

        self.vtk_mapper = vtk.vtkPolyDataMapper()
        self.vtk_mapper.SetInputConnection(self.vtk_plane.GetOutputPort())

        self.vtk_actor = vtk.vtkActor()
        self.vtk_actor.SetMapper(self.vtk_mapper)
        self.vtk_actor.GetProperty().SetRepresentationToWireframe()
        # self.vtk_actor.GetProperty().SetColor(self.color)
        self.vtk_actor.GetProperty().SetColor(.5, .5, .5)
Exemple #8
0
def build_plane(position, params, colour):
    """
    Generates floor plane using individual layered rectilinear grids   
    """
    x = np.arange(params[0], params[1], params[2])
    y = np.arange(params[0], params[1], params[2])
    z = np.arange(params[0], params[1], params[2])

    # Create a rectilinear grid by defining three arrays specifying the
    # coordinates in the x-y-z directions.
    x_coords = vtk.vtkFloatArray()
    for i in x:
        x_coords.InsertNextValue(i)
    
    y_coords = vtk.vtkFloatArray()
    for i in y:
        y_coords.InsertNextValue(i)
        
    z_coords = vtk.vtkFloatArray()
    for i in z:
        z_coords.InsertNextValue(i)
    
    # The coordinates are assigned to the rectilinear grid. Make sure that
    # the number of values in each of the XCoordinates, YCoordinates,
    # and ZCoordinates is equal to what is defined in SetDimensions().
    rgrid = vtk.vtkRectilinearGrid()
    rgrid.SetDimensions(len(x), len(y), len(z))
    rgrid.SetXCoordinates(x_coords)
    rgrid.SetYCoordinates(y_coords)
    rgrid.SetZCoordinates(z_coords)
    
    # Extract a plane from the grid
    plane = vtk.vtkRectilinearGridGeometryFilter()
    plane.SetInputData(rgrid)
    plane.SetExtent(0, 46, 0, 46, 0, 0)

    rgrid_mapper = vtk.vtkPolyDataMapper()
    rgrid_mapper.SetInputConnection(plane.GetOutputPort())
    
    wire_actor = vtk.vtkActor()
    wire_actor.SetMapper(rgrid_mapper)
    wire_actor.GetProperty().SetRepresentationToWireframe()
    wire_actor.GetProperty().SetColor(colour)
    wire_actor.SetOrientation(0, 0, 90)
    wire_actor.GetProperty().LightingOff()
    wire_actor.SetPosition(3000, -2000, position)
    
    return wire_actor
Exemple #9
0
    def do_contour (self, event=None):
        debug ("In BandedSurfaceMap::do_contour ()")
        Common.state.busy ()
        if self.contour_on.get ():
            if not self.mod_m.get_scalar_data_name ():
                self.contour_on.set (0)
                msg = "Warning: No scalar data present to contour!"
                Common.print_err (msg)
                Common.state.idle ()
                return
            out = self.mod_m.GetOutput ()

            if out.IsA('vtkPolyData'):
                f = None
            elif out.IsA ('vtkStructuredGrid'):
                f = vtk.vtkStructuredGridGeometryFilter ()
            elif out.IsA ('vtkRectilinearGrid'):
                f = vtk.vtkRectilinearGridGeometryFilter ()
            elif out.IsA ('vtkStructuredPoints') or \
                 out.IsA('vtkImageData'):
                if hasattr (vtk, 'vtkImageDataGeometryFilter'):
                    f = vtk.vtkImageDataGeometryFilter ()
                else:
                    f = vtk.vtkStructuredPointsGeometryFilter ()
            elif out.IsA('vtkUnstructuredGrid'):
                f = vtk.vtkGeometryFilter()
            else:
                msg = "This module does not support the given "\
                      "output - %s "%(out.GetClassName ())
                raise Base.Objects.ModuleException, msg

            if f:
                f.SetInput (out)
                self.cont_fil.SetInput (f.GetOutput())
            else:
                self.cont_fil.SetInput (out)                

            self.map.SetInput (self.cont_fil.GetOutput ())
            self.map.SetScalarModeToUseCellData()
        else:
            self.map.SetInput (self.mod_m.GetOutput ())
            self.map.SetScalarModeToDefault()
        self.change_contour ()
        Common.state.idle ()
Exemple #10
0
#help(vtk.vtkRectilinearGridReader())

rectGridReader = vtk.vtkRectilinearGridReader()
rectGridReader.SetFileName("data/jet4_0.500.vtk")
# do not forget to call "Update()" at the end of the reader
rectGridReader.Update()

rectGridOutline = vtk.vtkRectilinearGridOutlineFilter()
rectGridOutline.SetInputData(rectGridReader.GetOutput())

# New vtkRectilinearGridGeometryFilter() goes here:
#
#
#
#
plane = vtk.vtkRectilinearGridGeometryFilter()
plane.SetInputData(rectGridReader.GetOutput())

rectGridOutlineMapper = vtk.vtkPolyDataMapper()
rectGridOutlineMapper.SetInputConnection(rectGridOutline.GetOutputPort())

rectGridGeomMapper = vtk.vtkPolyDataMapper()
rectGridGeomMapper.SetInputConnection(plane.GetOutputPort())
#

outlineActor = vtk.vtkActor()
outlineActor.SetMapper(rectGridOutlineMapper)
outlineActor.GetProperty().SetColor(0, 0, 0)

gridGeomActor = vtk.vtkActor()
gridGeomActor.SetMapper(rectGridGeomMapper)
Exemple #11
0
This is a temporary script file.
"""

#==============================================================================
# Challenge 1: Adding a new Filter+Mapper+Actor to visualize the grid
#==============================================================================
import vtk

rectGridReader = vtk.vtkRectilinearGridReader()
rectGridReader.SetFileName("data/jet4_0.500.vtk")
rectGridReader.Update()

rectGridOutline = vtk.vtkRectilinearGridOutlineFilter()
rectGridOutline.SetInputData(rectGridReader.GetOutput())

rectGridGeom = vtk.vtkRectilinearGridGeometryFilter()
rectGridGeom.SetInputData(rectGridReader.GetOutput())

rectGridOutlineMapper = vtk.vtkPolyDataMapper()
rectGridOutlineMapper.SetInputConnection(rectGridOutline.GetOutputPort())

rectGridGeomMapper = vtk.vtkPolyDataMapper()
rectGridGeomMapper.SetInputConnection(rectGridGeom.GetOutputPort())

outlineActor = vtk.vtkActor()
outlineActor.SetMapper(rectGridOutlineMapper)
outlineActor.GetProperty().SetColor(1, 1, 1)

wireActor = vtk.vtkActor()
wireActor.SetMapper(rectGridGeomMapper)
wireActor.GetProperty().SetRepresentationToWireframe()
def main():
    colors = vtk.vtkNamedColors()

    # Create polydata to slice the grid with. In this case, use a cone. This could
    # be any polydata including a stl file.
    cone = vtk.vtkConeSource()
    cone.SetResolution(20)
    cone.Update()

    # implicit function that will be used to slice the mesh
    implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance()
    implicitPolyDataDistance.SetInput(cone.GetOutput())

    # create a grid
    xCoords = vtk.vtkFloatArray()
    for x, i in enumerate(np.linspace(-1.0, 1.0, 15)):
        xCoords.InsertNextValue(i)

    yCoords = vtk.vtkFloatArray()
    for y, i in enumerate(np.linspace(-1.0, 1.0, 15)):
        yCoords.InsertNextValue(i)

    zCoords = vtk.vtkFloatArray()
    for z, i in enumerate(np.linspace(-1.0, 1.0, 15)):
        zCoords.InsertNextValue(i)

    # The coordinates are assigned to the rectilinear grid. Make sure that
    # the number of values in each of the XCoordinates, YCoordinates,
    # and ZCoordinates is equal to what is defined in SetDimensions().
    rgrid = vtk.vtkRectilinearGrid()
    rgrid.SetDimensions(x + 1, y + 1, z + 1)
    rgrid.SetXCoordinates(xCoords)
    rgrid.SetYCoordinates(yCoords)
    rgrid.SetZCoordinates(zCoords)

    # Create an array to hold distance information
    signedDistances = vtk.vtkFloatArray()
    signedDistances.SetNumberOfComponents(1)
    signedDistances.SetName("SignedDistances")

    # Evaluate the signed distance function at all of the grid points
    for pointId in range(rgrid.GetNumberOfPoints()):
        p = rgrid.GetPoint(pointId)
        signedDistance = implicitPolyDataDistance.EvaluateFunction(p)
        signedDistances.InsertNextValue(signedDistance)

    # add the SignedDistances to the grid
    rgrid.GetPointData().SetScalars(signedDistances)

    # use vtkClipDataSet to slice the grid with the polydata
    clipper = vtk.vtkClipDataSet()
    clipper.SetInputData(rgrid)
    clipper.InsideOutOn()
    clipper.SetValue(0.0)
    clipper.Update()

    # --- mappers, actors, render, etc. ---
    # mapper and actor to view the cone
    coneMapper = vtk.vtkPolyDataMapper()
    coneMapper.SetInputConnection(cone.GetOutputPort())
    coneActor = vtk.vtkActor()
    coneActor.SetMapper(coneMapper)

    # geometry filter to view the background grid
    geometryFilter = vtk.vtkRectilinearGridGeometryFilter()
    geometryFilter.SetInputData(rgrid)
    geometryFilter.SetExtent(0, x + 1, 0, y + 1, (z + 1) // 2, (z + 1) // 2)
    geometryFilter.Update()

    rgridMapper = vtk.vtkPolyDataMapper()
    rgridMapper.SetInputConnection(geometryFilter.GetOutputPort())

    wireActor = vtk.vtkActor()
    wireActor.SetMapper(rgridMapper)
    wireActor.GetProperty().SetRepresentationToWireframe()
    wireActor.GetProperty().SetColor(colors.GetColor3d('Black'))

    # mapper and actor to view the clipped mesh
    clipperMapper = vtk.vtkDataSetMapper()
    clipperMapper.SetInputConnection(clipper.GetOutputPort())

    clipperActor = vtk.vtkActor()
    clipperActor.SetMapper(clipperMapper)
    clipperActor.GetProperty().SetRepresentationToWireframe()
    clipperActor.GetProperty().SetColor(colors.GetColor3d('Black'))

    # A renderer and render window
    renderer = vtk.vtkRenderer()
    renderer.SetBackground(colors.GetColor3d('White'))

    # add the actors
    # renderer.AddActor(coneActor)
    renderer.AddActor(wireActor)
    renderer.AddActor(clipperActor)

    renwin = vtk.vtkRenderWindow()
    renwin.AddRenderer(renderer)

    # An interactor
    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renwin)

    # Start
    interactor.Initialize()
    renwin.Render()
    renderer.GetActiveCamera().SetPosition(0, -1, 0)
    renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
    renderer.GetActiveCamera().SetViewUp(0, 0, 1)
    renderer.GetActiveCamera().Azimuth(30)
    renderer.GetActiveCamera().Elevation(30)
    renderer.ResetCamera()
    renwin.Render()
    interactor.Start()
Exemple #13
0
def main():
    colors = vtk.vtkNamedColors()

    x = [-1.22396, -1.17188, -1.11979, -1.06771, -1.01562, -0.963542, -0.911458, -0.859375, -0.807292, -0.755208,
         -0.703125, -0.651042, -0.598958, -0.546875, -0.494792, -0.442708, -0.390625, -0.338542, -0.286458, -0.234375,
         -0.182292, -0.130209, -0.078125, -0.026042, 0.0260415, 0.078125, 0.130208, 0.182291, 0.234375, 0.286458,
         0.338542, 0.390625, 0.442708, 0.494792, 0.546875, 0.598958, 0.651042, 0.703125, 0.755208, 0.807292, 0.859375,
         0.911458, 0.963542, 1.01562, 1.06771, 1.11979, 1.17188]
    y = [-1.25, -1.17188, -1.09375, -1.01562, -0.9375, -0.859375, -0.78125, -0.703125, -0.625, -0.546875, -0.46875,
         -0.390625, -0.3125, -0.234375, -0.15625, -0.078125, 0, 0.078125, 0.15625, 0.234375, 0.3125, 0.390625, 0.46875,
         0.546875, 0.625, 0.703125, 0.78125, 0.859375, 0.9375, 1.01562, 1.09375, 1.17188, 1.25]
    z = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.75, 0.8, 0.9, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.75, 1.8, 1.9, 2,
         2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.75, 2.8, 2.9, 3, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.75, 3.8, 3.9]
    print(len(x), len(y), len(z))

    # Create a rectilinear grid by defining three arrays specifying the
    # coordinates in the x-y-z directions.
    xCoords = vtk.vtkDoubleArray()
    for i in range(0, len(x)):
        xCoords.InsertNextValue(x[i])
    yCoords = vtk.vtkDoubleArray()
    for i in range(0, len(y)):
        yCoords.InsertNextValue(y[i])
    zCoords = vtk.vtkDoubleArray()
    for i in range(0, len(z)):
        zCoords.InsertNextValue(z[i])

    # The coordinates are assigned to the rectilinear grid. Make sure that
    # the number of values in each of the XCoordinates, YCoordinates,
    # and ZCoordinates is equal to what is defined in SetDimensions().
    #
    rgrid = vtk.vtkRectilinearGrid()
    rgrid.SetDimensions(len(x), len(y), len(z))
    rgrid.SetXCoordinates(xCoords)
    rgrid.SetYCoordinates(yCoords)
    rgrid.SetZCoordinates(zCoords)

    # Extract a plane from the grid to see what we've got.
    plane = vtk.vtkRectilinearGridGeometryFilter()
    plane.SetInputData(rgrid)
    plane.SetExtent(0, len(x) - 1, 16, 16, 0, len(z) - 1)

    rgridMapper = vtk.vtkPolyDataMapper()
    rgridMapper.SetInputConnection(plane.GetOutputPort())

    wireActor = vtk.vtkActor()
    wireActor.SetMapper(rgridMapper)
    wireActor.GetProperty().SetColor(colors.GetColor3d("Banana"))
    wireActor.GetProperty().EdgeVisibilityOn()

    # Create the usual rendering stuff.
    renderer = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(renderer)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    renderer.AddActor(wireActor)
    renderer.SetBackground(colors.GetColor3d("Beige"))
    renderer.ResetCamera()
    renderer.GetActiveCamera().Elevation(60.0)
    renderer.GetActiveCamera().Azimuth(30.0)
    renderer.GetActiveCamera().Zoom(1.0)

    renWin.SetSize(640, 480)

    # Interact with the data.
    renWin.Render()
    iren.Start()
Exemple #14
0
    do2ds.SetPointComponent(2, "ZCoordinates", 0)
    do2ds.Update()

    fd2ad = vtk.vtkFieldDataToAttributeDataFilter()
    fd2ad.SetInputData(do2ds.GetRectilinearGridOutput())
    fd2ad.SetInputFieldToDataObjectField()
    fd2ad.SetOutputAttributeDataToPointData()
    fd2ad.SetVectorComponent(0, "vectors", 0)
    fd2ad.SetVectorComponent(1, "vectors", 1)
    fd2ad.SetVectorComponent(2, "vectors", 2)
    fd2ad.SetScalarComponent(0, "scalars", 0)
    fd2ad.Update()

    # create pipeline
    #
    plane = vtk.vtkRectilinearGridGeometryFilter()
    plane.SetInputData(fd2ad.GetRectilinearGridOutput())
    plane.SetExtent(0, 100, 0, 100, 15, 15)

    warper = vtk.vtkWarpVector()
    warper.SetInputConnection(plane.GetOutputPort())
    warper.SetScaleFactor(0.05)

    planeMapper = vtk.vtkDataSetMapper()
    planeMapper.SetInputConnection(warper.GetOutputPort())
    planeMapper.SetScalarRange(0.197813, 0.710419)

    planeActor = vtk.vtkActor()
    planeActor.SetMapper(planeMapper)

    cutPlane = vtk.vtkPlane()
def main(args):
    
    
    # Load config file
    config_module = imp.load_source('config', args.config_path)
    
    # Get cfg dict
    cfg = config_module.cfg
    
    # Get model
    model = config_module.get_model(interp=True)
    
    # Compile functions
    print('Compiling theano functions...')
    tfuncs, tvars = make_test_functions(cfg, model)
    
    # Load model weights
    print('Loading weights from {}'.format(args.weights_fname))
    checkpoints.load_weights(args.weights_fname, model['l_latents'])
    checkpoints.load_weights(args.weights_fname, model['l_out'])
    
    # prepare data loader
    loader = (data_loader(cfg, args.testing_fname))

    
    # Load test set into local memory and get inferred latent values for each
    # element of the test set. Consider not doing this if you have limited RAM.
    print('Evaluating on test set')
    ygnd = np.empty([1,1,32,32,32],dtype=np.uint8)
    cc = np.empty([1,10],dtype=np.float32)
    counter = 0
    for x_shared, y_shared in loader:
        ygnd = np.append(ygnd,x_shared,axis=0)
        cc = np.append(cc,y_shared,axis=0) 

    # Get rid of first entries. Yeah, you could do this better by starting with a regular ole' python list,
    # appending inside the for loop and then just calling np.asarray, but I didn't really know any python
    # when I wrote this. Sue me.*
    #
    # *Please don't sue me
    ygnd = np.delete(ygnd,0,axis=0)
    cc = np.delete(cc,0,axis=0)
    
    print('Test set evaluation complete, render time!')
    
    # Total number of models loaded and encoded
    num_instances = len(ygnd)-1;
    
    # Seed the rng for repeatable operation
    np.random.seed(1)
    
    # Index of shuffled data
    display_ix = np.random.choice(len(ygnd), num_instances,replace=False)

    # Resolution: Number of blocks per side on each voxel. Setting this to less than 3
    # results in some ugly renderings, though it will be faster. Setting it higher makes it
    # prettier but can slow it down. With this setting, I can run interpolation in real-time on
    # a laptop with 16GB RAM and a GT730M. A setup with a real graphics card should be able to do
    # much, much more.
    v_res = 3
    
    # Dimensionality of the voxel grid
    dim = 32

    # Function to produce the data matrix for rendering. 
    def make_data_matrix(x,intensity):  
        return intensity*np.repeat(np.repeat(np.repeat(x[0][0],v_res,axis=0),v_res,axis=1),v_res,axis=2)

    # VTK Image Importer
    dataImporter = vtk.vtkImageImport()

    # Make the initial data matrix
   
    # initial random latent vector
    z_1 = np.random.randn(1,cfg['num_latents']).astype(np.float32)
    
    if cfg['cc']: # If augmenting with class-conditional vector
        cc_1 = np.zeros((1,10),dtype=np.float32)
        cc_1[0,np.random.randint(10)] = 1
        data_matrix = make_data_matrix(np.asarray(tfuncs['pred'](z_1,cc_1),dtype=np.uint8),128)
    else:
        data_matrix = make_data_matrix(np.asarray(tfuncs['pred'](z_1),dtype=np.uint8),128)
        
    # VTK bookkeeping stuff to prepare the central model
    data_string = data_matrix.tostring()
    dataImporter.CopyImportVoidPointer(data_string, len(data_string))
    dataImporter.SetDataScalarTypeToUnsignedChar()
    dataImporter.SetNumberOfScalarComponents(1)
    dataImporter.SetDataExtent(0, int(dim*v_res)-1, 0, int(dim*v_res)-1, 0, int(dim*v_res)-1)
    dataImporter.SetWholeExtent(0, int(dim*v_res)-1, 0, int(dim*v_res)-1, 0, int(dim*v_res)-1)
    
    # Prepare the interpolant endpoints
    
    # endpoint data importer
    edi = [0,0,0,0]
    
    # Endpoint data matrices    
    dm = [0,0,0,0]
    
    # Endpoint Latent values
    eZ = [0,0,0,0]

    # Endpoint sigmas
    eS = [0,0,0,0]
    
    # Endpoint class-conditional values
    eCC = [0,0,0,0]
    
    # Endpoint intensity values for colormapping
    eIs = [64,128,192,255]
    
    # VTK Bookkeeping stuff for interpolant endpoints
    for i in xrange(4):
        eZ[i] = tfuncs['Zfn'](ygnd[None,display_ix[i]])[0]
        eS[i] = tfuncs['sigma_fn'](ygnd[None,display_ix[i]])[0]
        eCC[i] = cc[None,display_ix[i]] # This may need changing to preserve shape? to be a 1x10 matrix instead of a 10x1?
        dm[i] = make_data_matrix(ygnd[None,display_ix[i]],eIs[i]).tostring()
        edi[i] = vtk.vtkImageImport()
        edi[i].CopyImportVoidPointer(dm[i], len(dm[i]))
        edi[i].SetDataScalarTypeToUnsignedChar()
        edi[i].SetNumberOfScalarComponents(1)
        edi[i].SetDataExtent(0, int(dim*v_res)-1, 0, int(dim*v_res)-1, 0, int(dim*v_res)-1)
        edi[i].SetWholeExtent(0, int(dim*v_res)-1, 0, int(dim*v_res)-1, 0, int(dim*v_res)-1)
  
    
        
    # Prepare color and transparency values
    colorFunc = vtk.vtkColorTransferFunction()
    alphaChannelFunc = vtk.vtkPiecewiseFunction()
    alphaChannelFunc.AddPoint(0, 0.0)
    alphaChannelFunc.AddPoint(64,1)
    alphaChannelFunc.AddPoint(128,1.0)
    alphaChannelFunc.AddPoint(192,1.0)
    alphaChannelFunc.AddPoint(255,1.0)
    
    colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0)
    colorFunc.AddRGBPoint(64, 0.0, 0.4, 0.8)
    colorFunc.AddRGBPoint(128,0.8,0.0,0.0)
    colorFunc.AddRGBPoint(192,0.8,0.0,0.7)
    colorFunc.AddRGBPoint(255,0.0,0.8,0.0)

    # Prepare volume properties.
    volumeProperty = vtk.vtkVolumeProperty()
    volumeProperty.SetColor(colorFunc)
    volumeProperty.SetScalarOpacity(alphaChannelFunc)
    volumeProperty.ShadeOn() # Keep this on unless you want everything to look terrible
    volumeProperty.SetInterpolationTypeToNearest()
    
    # Optional settings
    # volumeProperty.SetSpecular(0.2)
    # volumeProperty.SetAmbient(0.4)
    # volumeProperty.SetDiffuse(0.6)
     
    # More VTK Bookkeeping stuff.
    compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
    
    # Specify the data and raycast methods for the rendered volumes.
    volumeMapper = vtk.vtkVolumeRayCastMapper()
    volumeMapper.SetVolumeRayCastFunction(compositeFunction)
    volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
    
    # Endpoint volumeMappers
    evm = [0,0,0,0]
    for i in xrange(4):
        evm[i] = vtk.vtkVolumeRayCastMapper()
        evm[i].SetVolumeRayCastFunction(compositeFunction)
        evm[i].SetInputConnection(edi[i].GetOutputPort())

     
    # Prepare the volume for the draggable model.
    volume = vtk.vtkVolume()
    volume.SetMapper(volumeMapper)
    volume.SetProperty(volumeProperty)
    volume.SetPosition([0, 0, 0])
    
    # Endpoint volumes
    ev = [0,0,0,0]
    vps = [[0,-150.0,-150.0],[0,150.0,-150.0],[0,-150.0,150.0],[0,150.0,150.0]]
    for i in xrange(4):
        ev[i] = vtk.vtkVolume()
        ev[i].SetMapper(evm[i])
        ev[i].SetProperty(volumeProperty)
        ev[i].SetPosition(vps[i])
        ev[i].DragableOff()
        ev[i].PickableOff()
    
    # Simple linear 2D Interpolation function for interpolation between latent values.
    # Feel free to extend this to use more advanced interpolation methods.
    def interp2d(x,y,z_):
        x1 = vps[0][1]+97.5
        x2 = vps[1][1]
        y1 = vps[0][2]+97.5
        y2 = vps[2][2]

        return ( ( (z_[0] * (x2-x) * (y2-y)) + 
                   (z_[1] * (x-x1) * (y2-y)) + 
                   (z_[2] * (x2-x) * (y-y1)) + 
                   (z_[3] * (x-x1) * (y-y1)) ) /
                   ( (x2-x1) * (y2-y1) ) )
    
    
    ### Interactor Style
    # This class defines the user interface, and how the system reacts to different user inputs.
    class MyInteractorStyle(vtk.vtkInteractorStyleSwitch):
     
        def __init__(self,parent=None):
            

            # Index indicating which models are currently selected for endpoints
            self.ix = 0
            
            # Togglable flag indicating if the center model is being dragged or not
            self.drag = 0;
            
            # Picker
            self.picker = vtk.vtkCellPicker()
            self.picker.SetTolerance(0.001)
            
            # Set up observers. These functions watch for specific user actions.
            self.SetCurrentStyleToTrackballActor()
            self.GetCurrentStyle().AddObserver("MiddleButtonReleaseEvent",self.middleButtonReleaseEvent)
            self.GetCurrentStyle().AddObserver("MouseMoveEvent",self.mouseMoveEvent)
            self.SetCurrentStyleToTrackballCamera()
            self.GetCurrentStyle().AddObserver("MiddleButtonPressEvent",self.middleButtonPressEvent)
            self.GetCurrentStyle().AddObserver("KeyPressEvent",self.keyPress)
            

        #
        def mouseMoveEvent(self,obj,event):
            # Re-render every time the user moves the mouse while clicking.
            # If you have a slow computer, consider changing this to be thresholded so as to only have a certain resolution
            # (i.e. to only change if the mouse moves a certain distance, rather than any move)
           
           if self.drag and self.picker.GetProp3D():
                
                # Move object. This is a rewrite of the raw move object code;
                # Normally you would do this with the built-in version of this function and extend 
                # it pythonically in the normal way, but the python bindings for VTK don't expose
                # this function in that way (it's all hard-coded in C++) so this is a simple
                # re-implementation that gives more control over how the object is moved.
                # Specifically, this constrains the draggable object to only move in-plane
                # and prevents it going out of bounds.
                
                center = self.picker.GetProp3D().GetCenter()
                display_center = [0,0,0]
                new_point = [0,0,0,0]
                old_point = [0,0,0,0]
                motion_vector = [0,0]
                event_pos = self.GetCurrentStyle().GetInteractor().GetEventPosition()
                last_event_pos = self.GetCurrentStyle().GetInteractor().GetLastEventPosition()
                self.ComputeWorldToDisplay(self.GetDefaultRenderer(),
                                            center[0],
                                            center[1],
                                            center[2],
                                            display_center)
                
                self.ComputeDisplayToWorld(self.GetDefaultRenderer(),
                                            event_pos[0],
                                            event_pos[1],
                                            display_center[2],
                                            new_point)
                
                self.ComputeDisplayToWorld(self.GetDefaultRenderer(),
                                            last_event_pos[0],
                                            last_event_pos[1],
                                            display_center[2],
                                            old_point)
                
                # Calculate the position change, making sure to confine the object to within the boundaries.
                # Consider finding a way to do this so that it depends on position of center instead of mouse
                new_point[1] = max(min(vps[1][1], new_point[1]), vps[0][1]+97.5)
                new_point[2] = max(min(vps[2][2], new_point[2]), vps[0][2]+97.5)
                old_point[1] = max(min(vps[1][1], self.picker.GetProp3D().GetCenter()[1]), vps[0][1]+97.5)
                old_point[2] = max(min(vps[2][2], self.picker.GetProp3D().GetCenter()[2]), vps[0][2]+97.5)
                
                # Increment the position
                self.picker.GetProp3D().AddPosition(0,new_point[1]-old_point[1],new_point[2]-old_point[2])
                
                # Update Data
                if cfg['cc']:
                    data_string = make_data_matrix(np.asarray(tfuncs['pred']([interp2d(volume.GetCenter()[1],
                                                                                       volume.GetCenter()[2],eZ)],
                                                                              interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eCC)),
                                                                                        dtype=np.uint8),
                                                                                        int(interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eIs))).tostring()
                else:
                    data_string = make_data_matrix(np.asarray(tfuncs['pred']([interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eZ)]),
                                                                                        dtype=np.uint8),
                                                                                        int(interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eIs))).tostring()
                # Update the renderer's pointer to the data so that the GUI has the updated data.
                dataImporter.CopyImportVoidPointer(data_string, len(data_string))
                # Update the window.
                self.GetCurrentStyle().GetInteractor().Render()
            
                return
  
        # If the middle button is used to select the center object, change to
        # dragging mode. Else, use it to pan the view.
        def middleButtonPressEvent(self,obj,event):
            
            clickPos = self.GetCurrentStyle().GetInteractor().GetEventPosition()
            self.picker.Pick(clickPos[0],clickPos[1],0,self.GetDefaultRenderer())
            
            if self.picker.GetProp3D():
                self.SetCurrentStyleToTrackballActor()
                self.drag=1
                
                # Optional: Add the ability to modify interpolant endpoints.
                # else:
                    # If we click an interpolant endpoint, change that endpoint somehow. 
                    # self.drag = 0
            
            
            self.GetCurrentStyle().OnMiddleButtonDown()     
            # self.GetCurrentStyle().HighlightProp3D(volume)
            return
        
        # When we release, change style from TrackballActor to TrackballCamera.
        def middleButtonReleaseEvent(self,obj,event):
            self.SetCurrentStyleToTrackballCamera()
            self.drag=0
            self.GetCurrentStyle().OnMiddleButtonUp()
            return
        
        # If the user presses an arrow key, swap out interpolant endpoints and re-render.
        # If the user hits space, sample randomly in the latent space and re-render.
        # If class-conditional vectors are enabled and the user hits 1-9, render a random
        # class-conditional object.
        def keyPress(self,obj,event):
            key=self.GetCurrentStyle().GetInteractor().GetKeySym()
            if key == 'Right':
                # Increment index of which models we're using, re-render all endpoints
                self.ix+=1
                for i in xrange(4):
                    eZ[i] = tfuncs['Zfn'](ygnd[None,display_ix[self.ix+i]])[0]
                    eS[i] = tfuncs['sigma_fn'](ygnd[None,display_ix[self.ix+i]])[0]
                    eCC[i] = cc[None,display_ix[self.ix+i]]
                    dm[i] = make_data_matrix(ygnd[None,display_ix[self.ix+i]],eIs[i]).tostring()
                    edi[i].CopyImportVoidPointer(dm[i], len(dm[i]))
                if cfg['cc']:
                    data_string = make_data_matrix(np.asarray(tfuncs['pred']([interp2d(volume.GetCenter()[1],
                                                                                       volume.GetCenter()[2],eZ)],
                                                                              interp2d(volume.GetCenter()[1],
                                                                                       volume.GetCenter()[2],eCC)),
                                                                                        dtype=np.uint8),
                                                                                        int(interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eIs))).tostring()
                else:                                                                        
                    data_string = make_data_matrix(np.asarray(tfuncs['pred']([interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eZ)]),
                                                                                        dtype=np.uint8),
                                                                                        int(interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eIs))).tostring()
                dataImporter.CopyImportVoidPointer(data_string, len(data_string))
                
            
            elif key == 'Left' and (self.ix > 0):
                self.ix-=1
                for i in xrange(4):
                    eZ[i] = tfuncs['Zfn'](ygnd[None,display_ix[self.ix+i]])[0]
                    eS[i] = tfuncs['sigma_fn'](ygnd[None,display_ix[self.ix+i]])[0]
                    eCC[i] = cc[None,display_ix[self.ix+i]]
                    dm[i] = make_data_matrix(ygnd[None,display_ix[self.ix+i]],eIs[i]).tostring()
                    edi[i].CopyImportVoidPointer(dm[i], len(dm[i]))
                if cfg['cc']:
                    data_string = make_data_matrix(np.asarray(tfuncs['pred']([interp2d(volume.GetCenter()[1],
                                                                                       volume.GetCenter()[2],eZ)],
                                                                              interp2d(volume.GetCenter()[1],
                                                                                       volume.GetCenter()[2],eCC)),
                                                                                        dtype=np.uint8),
                                                                                        int(interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eIs))).tostring()

                else:        
                    data_string = make_data_matrix(np.asarray(tfuncs['pred']([interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eZ)]),
                                                                                        dtype=np.uint8),
                                                                                        int(interp2d(volume.GetCenter()[1],
                                                                                        volume.GetCenter()[2],eIs))).tostring()
                dataImporter.CopyImportVoidPointer(data_string, len(data_string))
            elif key == 'space':
                # Random Z, with optional weighting.
                Z_rand = 0.5*np.random.randn(1,cfg['num_latents']).astype(np.float32)
                
                # Optionally, sample using the interpolated sigmas as well.
                # Z_rand = np.square(np.exp(interp2d(volume.GetCenter()[1],volume.GetCenter()[2],eS))*np.random.randn(1,cfg['num_latents']).astype(np.float32))
               
                if cfg['cc']: # if class-conditional, take the class vector into account
                    cc_rand = np.zeros((1,10),dtype=np.float32)
                    cc_rand[0,np.random.randint(10)] = 1
                    data_string = make_data_matrix(np.asarray(tfuncs['pred'](interp2d(volume.GetCenter()[1],
                                                                                       volume.GetCenter()[2],eZ)+Z_rand,cc_rand),
                                                                            dtype=np.uint8),
                                                                            int(interp2d(volume.GetCenter()[1],
                                                                            volume.GetCenter()[2],eIs))).tostring()
                else:
                    data_string = make_data_matrix(np.asarray(tfuncs['pred'](Z_rand),
                                                                            dtype=np.uint8),
                                                                            int(interp2d(volume.GetCenter()[1],
                                                                            volume.GetCenter()[2],eIs))).tostring()
                dataImporter.CopyImportVoidPointer(data_string, len(data_string))
            
                # Generate random Class-conditional Z
            elif 0<= int(float(key))<=9 and cfg['cc']:
                cc_rand = np.zeros((1,10),dtype=np.float32)
                cc_rand[0,int(float(key))] = 5
                Z_rand = np.square(np.exp(interp2d(volume.GetCenter()[1],volume.GetCenter()[2],eS)))*np.random.randn(1,cfg['num_latents']).astype(np.float32)+interp2d(volume.GetCenter()[1],volume.GetCenter()[2],eZ)
                data_string = make_data_matrix(np.asarray(tfuncs['pred'](Z_rand,cc_rand),
                                                                            dtype=np.uint8),
                                                                            int(interp2d(volume.GetCenter()[1],
                                                                            volume.GetCenter()[2],eIs))).tostring()
                dataImporter.CopyImportVoidPointer(data_string, len(data_string))                                                            
                # print(key)
                
            # Render and pass event on
            self.GetCurrentStyle().GetInteractor().Render()   
            self.GetCurrentStyle().OnKeyPress()    
            return
            
    # Initialize the render window
    renderer = vtk.vtkRenderer()
    renderWin = vtk.vtkRenderWindow()
    renderWin.AddRenderer(renderer)

    # Initialize the render interactor
    renderInteractor = vtk.vtkRenderWindowInteractor()
    style = MyInteractorStyle()
    style.SetDefaultRenderer(renderer)
    renderInteractor.SetInteractorStyle(style)#volume_set=volume,Lvolume_set = Lvolume, Rvolume_set = Rvolume))
    renderInteractor.SetRenderWindow(renderWin)

    # Make boundary plane
    rgrid = vtk.vtkRectilinearGrid()
    rgrid.SetDimensions(1,2,2)
    xCoords = vtk.vtkFloatArray()
    xCoords.InsertNextValue(30)
    yCoords = vtk.vtkFloatArray()
    yCoords.InsertNextValue(vps[0][1]+97.5)
    yCoords.InsertNextValue(vps[1][1])
    rgrid.SetXCoordinates(xCoords)
    rgrid.SetYCoordinates(yCoords)
    rgrid.SetZCoordinates(yCoords)
    plane = vtk.vtkRectilinearGridGeometryFilter()
    plane.SetInputData(rgrid) 
    rgridMapper = vtk.vtkPolyDataMapper()
    rgridMapper.SetInputConnection(plane.GetOutputPort())
    wireActor = vtk.vtkActor()
    wireActor.SetMapper(rgridMapper)
    wireActor.GetProperty().SetRepresentationToWireframe()
    wireActor.GetProperty().SetColor(0, 0, 0)
    wireActor.PickableOff()
    wireActor.DragableOff()
    
    # Add model, endpoints, and boundary plane to renderer
    renderer.AddActor(wireActor)
    for i in xrange(4):
        renderer.AddVolume(ev[i])
    renderer.AddVolume(volume) 

    # set background to white. Optionally change it to a fun color, like "Lifeblood of the Untenderized."    
    renderer.SetBackground(1.0,1.0,1.0)

    # Set initial window size. You can drag the window to change size, but keep in mind that
    # the larger the window, the slower this thing runs. On my laptop, I get little spikes
    # of lag when I run this on full screen, though a more graphics-cardy setup should do fine.
    renderWin.SetSize(400, 400)
     
    # Exit function
    def exitCheck(obj, event):
        if obj.GetEventPending() != 0:
            obj.SetAbortRender(1)
     
    # Add exit function
    renderWin.AddObserver("AbortCheckEvent", exitCheck)
    
    # initialize interactor
    renderInteractor.Initialize()

    # Start application!
    renderer.ResetCamera()
    renderer.GetActiveCamera().Azimuth(30)
    renderer.GetActiveCamera().Elevation(20)
    renderer.GetActiveCamera().Dolly(2.8)
    renderer.ResetCameraClippingRange()    
    renderWin.Render()
    renderInteractor.Start()
Exemple #16
0
    def render(self, **args):
        """ main function to render all required objects """

        gridData = args.get('gridData', True)
        drawSurface = args.get('drawSurface', True)
        drawAxes = args.get('drawAxes', True)
        drawColorBar = args.get('drawColorBar', True)
        drawLegend = args.get('drawLegend', True)
        wireSurface = args.get('wireSurface', False)
        drawBox = args.get('drawBox', True)
        scaleFactor = args.get('scaleFactor', (1, 1, 1))
        autoscale = args.get('autoScale', True)
        colorMap = args.get('colorMap', 'rainbow')
        reverseMap = args.get('reverseMap', False)
        drawGrid = args.get('drawGrid', False)
        resolution = args.get('gridResolution', 10)
        xtics = args.get('xtics', 0)
        ytics = args.get('ytics', 0)
        ztics = args.get('ztics', 0)
        planeGrid = args.get('planeGrid', True)
        xCutterOn = args.get('XCutterOn', True)
        yCutterOn = args.get('YCutterOn', True)
        zCutterOn = args.get('ZCutterOn', True)
        xCutterPos = args.get('XCutterPos', None)
        yCutterPos = args.get('YCutterPos', None)
        zCutterPos = args.get('ZCutterPos', None)

        self.parseRenderArgs(**args)

        if gridData:
            geometry = vtk.vtkStructuredGridGeometryFilter()
        else:
            geometry = vtk.vtkRectilinearGridGeometryFilter()

        geometry.SetInputData(self.gridfunc)
        geometry.SetExtent(self.gridfunc.GetExtent())

        if gridData:
            wzscale = self.computeScale(self.gridfunc)
            self.out = geometry.GetOutput()
        else:
            geometry.SetExtent(self.gridfunc.GetExtent())
            geometry.GetOutput().SetPoints(self.Points)
            geometry.GetOutput().GetPointData().SetScalars(self.Colors)
            geometry.GetOutput().Update()

            self.out = geometry.GetOutput()
            self.out.SetPoints(self.Points)
            self.out.GetPointData().SetScalars(self.Colors)
            self.out.Update()
            wzscale = self.computeScale(self.out)

        x = self.XScale if autoscale else self.XScale * scaleFactor[0]
        y = self.YScale if autoscale else self.YScale * scaleFactor[1]
        z = 0.5 * self.ZScale if autoscale else self.ZScale * scaleFactor[2]

        transform = vtk.vtkTransform()
        transform.Scale(x, y, z)
        trans = vtk.vtkTransformPolyDataFilter()
        trans.SetInputConnection(geometry.GetOutputPort())
        trans.SetTransform(transform)

        localScale = wzscale if wzscale < 1 else 1 / wzscale

        self.warp = vtk.vtkWarpScalar()
        self.warp.XYPlaneOn()
        self.warp.SetInputConnection(trans.GetOutputPort())
        self.warp.SetNormal(0, 0, 1)
        self.warp.UseNormalOn()
        self.warp.SetScaleFactor(localScale)

        tmp = self.gridfunc.GetScalarRange()

        # map gridfunction
        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputConnection(self.warp.GetOutputPort())

        # calculate ranges
        if self.customZRange:
            self.mapper.SetScalarRange(*self.customZRange)
        elif self.autoZRange:
            mx = max(abs(tmp[0]), abs(tmp[1]))
            self.mapper.SetScalarRange(-mx, mx)
        else:
            self.mapper.SetScalarRange(tmp[0], tmp[1])

        wireActor = None
        bounds = self.mapper.GetBounds()

        # wire mapper
        if planeGrid:
            if not gridData:
                self.plane = vtk.vtkRectilinearGridGeometryFilter()
                self.plane.SetInput(self.gridfunc)
                self.plane.SetExtent(self.gridfunc.GetExtent())
                x_, y_ = x, y
            else:
                self.plane = vtk.vtkPlaneSource()
                self.plane.SetXResolution(resolution)
                self.plane.SetYResolution(resolution)
                x_, y_ = bounds[1] - bounds[0], bounds[3] - bounds[2]

            pltr = vtk.vtkTransform()
            pltr.Translate((bounds[1] - bounds[0]) / 2. - (0 - bounds[0]),
                           (bounds[3] - bounds[2]) / 2. - (0 - bounds[2]), bounds[4])
            pltr.Scale(x_, y_, 1)
            pltran = vtk.vtkTransformPolyDataFilter()
            pltran.SetInputConnection(self.plane.GetOutputPort())
            pltran.SetTransform(pltr)

            cmap = self.buildColormap('black-white', True)

            rgridMapper = vtk.vtkPolyDataMapper()
            rgridMapper.SetInputConnection(pltran.GetOutputPort())
            rgridMapper.SetLookupTable(cmap)

            wireActor = vtk.vtkActor()
            wireActor.SetMapper(rgridMapper)
            wireActor.GetProperty().SetRepresentationToWireframe()
            wireActor.GetProperty().SetColor(self.fgColor)

        # xcutter actor
        xactor = None
        if xCutterOn:
            xactor = self.makeXCutter(bounds, scaleFactor, xCutterPos)

        # ycutter actor
        yactor = None
        if yCutterOn:
            yactor = self.makeYCutter(bounds, scaleFactor, yCutterPos)

        # zcutter actor
        zactor = None
        if zCutterOn:
            zactor = self.makeZCutter(bounds, scaleFactor, zCutterPos)

        # create plot surface actor
        surfplot = vtk.vtkActor()
        surfplot.SetMapper(self.mapper)
        if wireSurface:
            surfplot.GetProperty().SetRepresentationToWireframe()

        # color map
        clut = self.buildColormap(colorMap, reverseMap)
        self.mapper.SetLookupTable(clut)

        # create outline
        outlinefilter = vtk.vtkOutlineFilter()
        outlinefilter.SetInputConnection(self.warp.GetOutputPort())

        outlineMapper = vtk.vtkPolyDataMapper()
        outlineMapper.SetInputConnection(outlinefilter.GetOutputPort())
        outline = vtk.vtkActor()
        outline.SetMapper(outlineMapper)
        outline.GetProperty().SetColor(self.fgColor)

        # make axes
        zax, axes = self.makeAxes(outline, outlinefilter)

        # setup axes
        xaxis = axes.GetXAxisActor2D()
        yaxis = axes.GetYAxisActor2D()
        zaxis = axes.GetZAxisActor2D()

        xaxis.SetLabelFormat(self.config.XLabelsFormat())
        xaxis.SetAdjustLabels(1)
        xaxis.SetNumberOfMinorTicks(xtics)

        yaxis.SetLabelFormat(self.config.YLabelsFormat())
        yaxis.SetNumberOfMinorTicks(ytics)
        yaxis.SetAdjustLabels(1)

        zaxis.SetLabelFormat(self.config.ZLabelsFormat())
        zaxis.SetNumberOfMinorTicks(ztics)
        zaxis.SetAdjustLabels(1)

        # create colorbar
        colorbar = self.makeColorbar()

        # renderer
        if drawSurface:
            self.renderer.AddActor(surfplot)
            self.actors.append(surfplot)
        if drawGrid:
            self.renderer.AddViewProp(zax)
            self.actors.append(zax)
        if planeGrid:
            self.renderer.AddActor(wireActor)
            self.actors.append(wireActor)
        if drawBox:
            self.renderer.AddActor(outline)
            self.actors.append(outline)
        if drawAxes:
            self.renderer.AddViewProp(axes)
            self.actors.append(axes)
        if drawColorBar or drawLegend:
            self.renderer.AddActor(colorbar)
            self.actors.append(colorbar)

        self.colorbar = colorbar
        self._addPlaneCutters(xactor, yactor, zactor, xCutterOn, yCutterOn, zCutterOn)
Exemple #17
0
    def __init__(self):
        x = [
            -1.22396, -1.17188, -1.11979, -1.06771, -1.01562, -0.963542,
            -0.911458, -0.859375, -0.807292, -0.755208, -0.703125, -0.651042,
            -0.598958, -0.546875, -0.494792, -0.442708, -0.390625, -0.338542,
            -0.286458, -0.234375, -0.182292, -0.130209, -0.078125, -0.026042,
            0.0260415, 0.078125, 0.130208, 0.182291, 0.234375, 0.286458,
            0.338542, 0.390625, 0.442708, 0.494792, 0.546875, 0.598958,
            0.651042, 0.703125, 0.755208, 0.807292, 0.859375, 0.911458,
            0.963542, 1.01562, 1.06771, 1.11979, 1.17188]

        y = [
            -1.25, -1.17188, -1.09375, -1.01562, -0.9375, -0.859375,
            -0.78125, -0.703125, -0.625, -0.546875, -0.46875, -0.390625,
            -0.3125, -0.234375, -0.15625, -0.078125, 0, 0.078125,
            0.15625, 0.234375, 0.3125, 0.390625, 0.46875, 0.546875,
            0.625, 0.703125, 0.78125, 0.859375, 0.9375, 1.01562,
            1.09375, 1.17188, 1.25]

        z = [
            0, 0.1, 0.2, 0.3, 0.4, 0.5,
            0.6, 0.7, 0.75, 0.8, 0.9, 1,
            1.1, 1.2, 1.3, 1.4, 1.5, 1.6,
            1.7, 1.75, 1.8, 1.9, 2, 2.1,
            2.2, 2.3, 2.4, 2.5, 2.6, 2.7,
            2.75, 2.8, 2.9, 3, 3.1, 3.2,
            3.3, 3.4, 3.5, 3.6, 3.7, 3.75,
            3.8, 3.9]

        # Create a rectilinear grid by defining three arrays specifying the
        # coordinates in the x-y-z directions.
        xCoords = vtk.vtkFloatArray()
        for i in x:
            xCoords.InsertNextValue(i)

        yCoords = vtk.vtkFloatArray()
        for i in y:
            yCoords.InsertNextValue(i)

        zCoords = vtk.vtkFloatArray()
        for i in z:
            zCoords.InsertNextValue(i)

        # The coordinates are assigned to the rectilinear grid. Make sure that
        # the number of values in each of the XCoordinates, YCoordinates,
        # and ZCoordinates is equal to what is defined in SetDimensions().
        #
        rgrid = vtk.vtkRectilinearGrid()
        rgrid.SetDimensions(len(x), len(y), len(z))
        rgrid.SetXCoordinates(xCoords)
        rgrid.SetYCoordinates(yCoords)
        rgrid.SetZCoordinates(zCoords)

        # Extract a plane from the grid to see what we've got.
        plane = vtk.vtkRectilinearGridGeometryFilter()
        plane.SetInputData(rgrid)
        plane.SetExtent(0, 46, 16, 16, 0, 43)

        rgridMapper = vtk.vtkPolyDataMapper()
        rgridMapper.SetInputConnection(plane.GetOutputPort())

        self.wire_actor = vtk.vtkActor()
        self.wire_actor.SetMapper(rgridMapper)
        self.wire_actor.GetProperty().SetRepresentationToWireframe()
        self.wire_actor.GetProperty().SetColor(0, 0, 0)
def main():
    colors = vtk.vtkNamedColors()

    # Create polydata to slice the grid with. In this case, use a cone. This
    # could
    # be any polydata including a stl file.
    cone = vtk.vtkConeSource()
    cone.SetResolution(50)
    cone.SetDirection(0, 0, -1)
    cone.SetHeight(3.0)
    cone.CappingOn()
    cone.Update()

    # Implicit function that will be used to slice the mesh
    implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance()
    implicitPolyDataDistance.SetInput(cone.GetOutput())

    # create a grid
    dimension = 51
    xCoords = vtk.vtkFloatArray()
    for x, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
        xCoords.InsertNextValue(i)

    yCoords = vtk.vtkFloatArray()
    for y, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
        yCoords.InsertNextValue(i)

    zCoords = vtk.vtkFloatArray()
    for z, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
        zCoords.InsertNextValue(i)

    # # create a grid - if not using numpy
    # dimension = 51
    # xCoords = vtk.vtkFloatArray()
    # for i in range(0, dimension):
    #     xCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
    #
    # yCoords = vtk.vtkFloatArray()
    # for i in range(0, dimension):
    #     yCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
    #
    # zCoords = vtk.vtkFloatArray()
    # for i in range(0, dimension):
    #     zCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))

    # The coordinates are assigned to the rectilinear grid. Make sure that
    # the number of values in each of the XCoordinates, YCoordinates,
    # and ZCoordinates is equal to what is defined in SetDimensions().
    rgrid = vtk.vtkRectilinearGrid()
    rgrid.SetDimensions(xCoords.GetNumberOfTuples(),
                        yCoords.GetNumberOfTuples(),
                        zCoords.GetNumberOfTuples())
    rgrid.SetXCoordinates(xCoords)
    rgrid.SetYCoordinates(yCoords)
    rgrid.SetZCoordinates(zCoords)

    # Create an array to hold distance information
    signedDistances = vtk.vtkFloatArray()
    signedDistances.SetNumberOfComponents(1)
    signedDistances.SetName('SignedDistances')

    # Evaluate the signed distance function at all of the grid points
    for pointId in range(0, rgrid.GetNumberOfPoints()):
        p = rgrid.GetPoint(pointId)
        signedDistance = implicitPolyDataDistance.EvaluateFunction(p)
        signedDistances.InsertNextValue(signedDistance)

    # Add the SignedDistances to the grid
    rgrid.GetPointData().SetScalars(signedDistances)

    # Use vtkClipDataSet to slice the grid with the polydata
    clipper = vtk.vtkClipDataSet()
    clipper.SetInputData(rgrid)
    clipper.InsideOutOn()
    clipper.SetValue(0.0)
    clipper.GenerateClippedOutputOn()
    clipper.Update()

    # --- mappers, actors, render, etc. ---
    # mapper and actor to view the cone
    coneMapper = vtk.vtkPolyDataMapper()
    coneMapper.SetInputConnection(cone.GetOutputPort())
    coneActor = vtk.vtkActor()
    coneActor.SetMapper(coneMapper)

    # geometry filter to view the background grid
    geometryFilter = vtk.vtkRectilinearGridGeometryFilter()
    geometryFilter.SetInputData(rgrid)
    geometryFilter.SetExtent(0, dimension, 0, dimension, int(dimension / 2), int(dimension / 2))
    geometryFilter.Update()

    rgridMapper = vtk.vtkPolyDataMapper()
    rgridMapper.SetInputConnection(geometryFilter.GetOutputPort())
    rgridMapper.SetScalarRange(
        rgrid.GetPointData().GetArray('SignedDistances').GetRange())

    wireActor = vtk.vtkActor()
    wireActor.SetMapper(rgridMapper)
    wireActor.GetProperty().SetRepresentationToWireframe()

    # mapper and actor to view the clipped mesh
    clipperMapper = vtk.vtkDataSetMapper()
    clipperMapper.SetInputConnection(clipper.GetOutputPort())
    clipperMapper.ScalarVisibilityOff()

    clipperOutsideMapper = vtk.vtkDataSetMapper()
    clipperOutsideMapper.SetInputConnection(clipper.GetOutputPort(1))
    clipperOutsideMapper.ScalarVisibilityOff()

    clipperActor = vtk.vtkActor()
    clipperActor.SetMapper(clipperMapper)
    clipperActor.GetProperty().SetColor(colors.GetColor3d('Banana'))

    clipperOutsideActor = vtk.vtkActor()
    clipperOutsideActor.SetMapper(clipperOutsideMapper)
    clipperOutsideActor.GetProperty().SetColor(
        colors.GetColor3d('Banana'))

    # A renderer and render window
    # Create a renderer, render window, and interactor
    leftViewport = [0.0, 0.0, 0.5, 1.0]
    leftRenderer = vtk.vtkRenderer()
    leftRenderer.SetViewport(leftViewport)
    leftRenderer.SetBackground(colors.GetColor3d('SteelBlue'))

    rightViewport = [0.5, 0.0, 1.0, 1.0]
    rightRenderer = vtk.vtkRenderer()
    rightRenderer.SetViewport(rightViewport)
    rightRenderer.SetBackground(colors.GetColor3d('CadetBlue'))

    # add the actors
    leftRenderer.AddActor(wireActor)
    leftRenderer.AddActor(clipperActor)
    rightRenderer.AddActor(clipperOutsideActor)

    renwin = vtk.vtkRenderWindow()
    renwin.SetSize(640, 480)
    renwin.AddRenderer(leftRenderer)
    renwin.AddRenderer(rightRenderer)
    renwin.SetWindowName('ClipDataSetWithPolyData')

    # An interactor
    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renwin)

    # Share the camera

    leftRenderer.GetActiveCamera().SetPosition(0, -1, 0)
    leftRenderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
    leftRenderer.GetActiveCamera().SetViewUp(0, 0, 1)
    leftRenderer.GetActiveCamera().Azimuth(30)
    leftRenderer.GetActiveCamera().Elevation(30)
    leftRenderer.ResetCamera()
    rightRenderer.SetActiveCamera(leftRenderer.GetActiveCamera())

    renwin.Render()
    interactor.Start()

    # Generate a report
    ct = vtk.vtkCellTypes()

    numberOfCells = clipper.GetOutput().GetNumberOfCells()
    print('------------------------')
    print('The clipped dataset(inside) contains a\n', clipper.GetOutput().GetClassName(), 'that has', numberOfCells,
          'cells')
    cellMap = dict()
    for i in range(0, numberOfCells):
        cellMap[clipper.GetOutput().GetCellType(i)] = cellMap.get(clipper.GetOutput().GetCellType(i), 0) + 1

    for k, v in cellMap.items():
        print('\tCell type ', ct.GetClassNameFromTypeId(k), 'occurs', v, 'times.')
        
    numberOfCells = clipper.GetClippedOutput().GetNumberOfCells()
    print('------------------------')
    print('The clipped dataset(outside) contains a\n', clipper.GetClippedOutput().GetClassName(), 'that has',
          numberOfCells, 'cells')
    outsideCellMap = dict()
    for i in range(0, numberOfCells):
        outsideCellMap[clipper.GetClippedOutput().GetCellType(i)] = outsideCellMap.get(
            clipper.GetClippedOutput().GetCellType(i), 0) + 1

    for k, v in outsideCellMap.items():
        print('\tCell type ', ct.GetClassNameFromTypeId(k), 'occurs', v, 'times.')
Exemple #19
0
 def scan(wannabeacts):
     scannedacts = []
     if not utils.isSequence(wannabeacts):
         wannabeacts = [wannabeacts]
     for a in wannabeacts:  # scan content of list
         if isinstance(a, vtk.vtkActor):
             scannedacts.append(a)
             if hasattr(a, 'trail'
                        ) and a.trail and not a.trail in self.actors:
                 scannedacts.append(a.trail)
         elif isinstance(a, vtk.vtkAssembly):
             scannedacts.append(a)
             if a.trail and not a.trail in self.actors:
                 scannedacts.append(a.trail)
         elif isinstance(a, vtk.vtkActor2D):
             if isinstance(a, vtk.vtkCornerAnnotation):
                 for a2 in settings.collectable_actors:
                     if isinstance(a2, vtk.vtkCornerAnnotation):
                         if at in a2.renderedAt:  # remove old message
                             self.removeActor(a2)
                 scannedacts.append(a)
         elif isinstance(a, vtk.vtkImageActor):
             scannedacts.append(a)
         elif isinstance(a, vtk.vtkVolume):
             scannedacts.append(a)
         elif isinstance(a, vtk.vtkImageData):
             scannedacts.append(Volume(a))
         elif isinstance(a, vtk.vtkPolyData):
             scannedacts.append(Actor(a, c, alpha, wire, bc))
         elif isinstance(a, str):  # assume a filepath was given
             out = vtkio.load(a, c, alpha, wire, bc)
             if isinstance(out, str):
                 colors.printc("~times File not found:", out, c=1)
                 scannedacts.append(None)
             else:
                 scannedacts.append(out)
         elif "dolfin" in str(type(a)):  # assume a dolfin.Mesh object
             from vtkplotter.dolfin import MeshActor
             out = MeshActor(a, c=c, alpha=alpha, wire=True, bc=bc)
             scannedacts.append(out)
         elif a is None:
             pass
         elif isinstance(a, vtk.vtkUnstructuredGrid):
             gf = vtk.vtkGeometryFilter()
             gf.SetInputData(a)
             gf.Update()
             scannedacts.append(
                 Actor(gf.GetOutput(), c, alpha, wire, bc))
         elif isinstance(a, vtk.vtkStructuredGrid):
             gf = vtk.vtkGeometryFilter()
             gf.SetInputData(a)
             gf.Update()
             scannedacts.append(
                 Actor(gf.GetOutput(), c, alpha, wire, bc))
         elif isinstance(a, vtk.vtkRectilinearGrid):
             gf = vtk.vtkRectilinearGridGeometryFilter()
             gf.SetInputData(a)
             gf.Update()
             scannedacts.append(
                 Actor(gf.GetOutput(), c, alpha, wire, bc))
         elif isinstance(a, vtk.vtkMultiBlockDataSet):
             for i in range(a.GetNumberOfBlocks()):
                 b = a.GetBlock(i)
                 if isinstance(b, vtk.vtkPolyData):
                     scannedacts.append(Actor(b, c, alpha, wire, bc))
                 elif isinstance(b, vtk.vtkImageData):
                     scannedacts.append(Volume(b))
         else:
             colors.printc("~!? Cannot understand input in show():",
                           type(a),
                           c=1)
             scannedacts.append(None)
     return scannedacts
Exemple #20
0
def testVTK():
    print(vtk.VTK_VERSION, sys.version)

    line = vtk.vtkLineSource()
    line.SetPoint1(0, 0, 0)
    line.SetPoint2(5, 0, 0)
    # tubeFilter = vtk.vtkTubeFilter()
    # tubeFilter.SetInputConnection(line.GetOutputPort())
    # tubeFilter.SetRadius(0.1)
    # tubeFilter.SetNumberOfSides(8)
    # tubeFilter.CappingOn()

    cone_a = vtk.vtkConeSource()
    cone_a.SetHeight(10)
    cone_a.SetRadius(5)
    cone_a.SetResolution(30)

    coneMapper1 = vtk.vtkPolyDataMapper()
    coneMapper1.SetInputConnection(cone_a.GetOutputPort())
    coneMapper2 = vtk.vtkPolyDataMapper()
    # coneMapper2.SetInputConnection(tubeFilter.GetOutputPort())
    coneMapper2.SetInputConnection(line.GetOutputPort())

    coneActor1 = vtk.vtkActor()
    coneActor2 = vtk.vtkActor()
    coneActor2.SetPosition(0, 0, -2.5)
    # coneActor1.RotateY(90)
    # coneActor2.RotateY(45)
    # coneActor.RotateWXYZ(90, 0, 0, 1)
    # coneActor.SetScale(0.4)
    coneActor1.SetMapper(coneMapper1)
    coneActor2.SetMapper(coneMapper2)
    coneActor1.GetProperty().SetColor(1, 0, 0)
    coneActor1.GetProperty().SetOpacity(0.5)
    # coneActor2.GetProperty().SetOpacity(0.8)

    xc, yc, zc = 3, 6, 12
    xCoords = vtk.vtkFloatArray()
    yCoords = vtk.vtkFloatArray()
    zCoords = vtk.vtkFloatArray()
    for i in range(xc):
        xCoords.InsertNextValue(i * i)
    for i in range(yc):
        yCoords.InsertNextValue(i * i)
    for i in range(zc):
        zCoords.InsertNextValue(i * i)
    rgrid = vtk.vtkRectilinearGrid()
    rgrid.SetDimensions(xc, yc, zc)
    rgrid.SetXCoordinates(xCoords)
    rgrid.SetYCoordinates(yCoords)
    rgrid.SetZCoordinates(zCoords)
    plane = vtk.vtkRectilinearGridGeometryFilter()
    plane.SetInputData(rgrid)
    plane.SetExtent(0, xc - 1, 0, yc - 1, 0, zc - 1)
    mapper = vtk.vtkDataSetMapper()
    mapper.SetInputConnection(plane.GetOutputPort())
    # mapper.SetInputData(rgrid)
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)

    ren1 = vtk.vtkRenderer()
    ren1.AddActor(coneActor1)
    ren1.AddActor(coneActor2)
    # ren1.AddActor(actor)
    ren1.SetBackground(0, .4, .4)

    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren1)
    renWin.SetSize(400, 400)
    renWin.Render()

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

    iren.Initialize()
    iren.Start()