Example #1
0
def createAllModules(g):
    """ createAllModules(g: ClassTree) -> None
    Traverse the VTK class tree and add all modules into the module registry
    
    """
    if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
        assert len(g.tree[0]) == 1
        base = g.tree[0][0]
        assert base.name == 'vtkObjectBase'
    
    vtkObjectBase = new_module(vtkBaseModule, 'vtkObjectBase')
    vtkObjectBase.vtkClass = vtk.vtkObjectBase
    registry = get_module_registry()
    registry.add_module(vtkObjectBase)
    if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
        for child in base.children:
            if child.name in disallowed_classes:
                continue
            createModule(vtkObjectBase, child)
    else:
        for base in g.tree[0]:
            for child in base.children:
                if child.name in disallowed_classes:
                    continue
                createModule(vtkObjectBase, child)
Example #2
0
def createAllModules(g):
    """ createAllModules(g: ClassTree) -> None
    Traverse the VTK class tree and add all modules into the module registry
    
    """
    if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
        assert len(g.tree[0]) == 1
        base = g.tree[0][0]
        assert base.name == 'vtkObjectBase'

    vtkObjectBase = new_module(vtkBaseModule, 'vtkObjectBase')
    vtkObjectBase.vtkClass = vtk.vtkObjectBase
    registry = get_module_registry()
    registry.add_module(vtkObjectBase)
    if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
        for child in base.children:
            if child.name in disallowed_classes:
                continue
            createModule(vtkObjectBase, child)
    else:
        for base in g.tree[0]:
            for child in base.children:
                if child.name in disallowed_classes:
                    continue
                createModule(vtkObjectBase, child)
Example #3
0
def PlotEdges(mesh, angle):
    featureEdges = vtk.vtkFeatureEdges()
    if vtk.vtkVersion().GetVTKMajorVersion() >5:
        featureEdges.SetInputData(mesh)
    else:
        featureEdges.SetInput(mesh)
    featureEdges.FeatureEdgesOn()
    featureEdges.BoundaryEdgesOff()
    featureEdges.NonManifoldEdgesOff()
    featureEdges.ManifoldEdgesOff()
    featureEdges.SetFeatureAngle(angle)
    
    
    edgeMapper = vtk.vtkPolyDataMapper();
    edgeMapper.SetInputConnection(featureEdges.GetOutputPort());
    
    edgeActor = vtk.vtkActor();
    edgeActor.GetProperty().SetLineWidth(5);
    edgeActor.SetMapper(edgeMapper)
    
    
    mapper = vtk.vtkDataSetMapper()
    if vtk.vtkVersion().GetVTKMajorVersion() >5:
        mapper.SetInputData(mesh)
    else:
        mapper.SetInput(mesh)

    
    # Actor
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().LightingOff()    
        
    ###############################
    # Display
    ###############################
    
    # Render
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
    
    # Allow user to interact
    istyle = vtk.vtkInteractorStyleTrackballCamera()
    iren.SetInteractorStyle(istyle)
    
    ren.AddActor(actor)
    ren.AddActor(edgeActor)
    
        
    iren.Initialize()
    renWin.Render()
    iren.Start()
def _compare_vtkAbstractArray(vtk_expect, vtk_compare, type):
    '''
    Verify if the basic attributes of the vtkAbstractArray are equal
    :param vtk_expect:
    :param vtk_compare:
    :param type: The vtk type object
    :return:
    '''
    list_errors = []

    if vtk_expect.GetNumberOfTuples() != vtk_compare.GetNumberOfTuples():
        list_errors.append(
            'The number of tuples of the {} are different. Expected: {}, '
            'received: {}'.format(type, vtk_expect.GetNumberOfTuples(),
                                  vtk_compare.GetNumberOfTuples()))

    if vtk.vtkVersion().GetVTKMajorVersion() > 7 or vtk.vtkVersion().GetVTKVersion() == '7.1.1' and \
       vtk_expect.GetNumberOfValues() != vtk_compare.GetNumberOfValues():
        list_errors.append(
            'The number of values of the {} are different. Expected: {}, '
            'received: {}'.format(type, vtk_expect.GetNumberOfValues(),
                                  vtk_compare.GetNumberOfValues()))

    if vtk_expect.GetSize() != vtk_compare.GetSize():
        list_errors.append('The size of the {} are different. Expected: {}, '
                           'received: {}'.format(type, vtk_expect.GetSize(),
                                                 vtk_compare.GetSize()))

    if vtk_expect.GetMaxId() != vtk_compare.GetMaxId():
        list_errors.append(
            'The maximum id of the {} are different. Expected: {}, '
            'received: {}'.format(type, vtk_expect.GetMaxId(),
                                  vtk_compare.GetMaxId()))

    if vtk_expect.GetArrayType() != vtk_compare.GetArrayType():
        list_errors.append(
            'The array type of the {} are different. Expected: {}, '
            'received: {}'.format(type, vtk_expect.GetArrayType(),
                                  vtk_compare.GetArrayType()))

    if vtk_expect.GetName() != vtk_compare.GetName():
        list_errors.append(
            'The array name of the {} are different. Expected: {}, '
            'received: {}'.format(type, vtk_expect.GetName(),
                                  vtk_compare.GetName()))

    if vtk_expect.GetMaxDiscreteValues() != vtk_compare.GetMaxDiscreteValues():
        list_errors.append(
            'The maximum discrete values of the {} are different. Expected: {}, '
            'received: {}'.format(type, vtk_expect.GetMaxDiscreteValues(),
                                  vtk_compare.GetMaxDiscreteValues()))

    return list_errors
Example #5
0
def PlotEdges(mesh, angle):
    featureEdges = vtk.vtkFeatureEdges()
    if vtk.vtkVersion().GetVTKMajorVersion() > 5:
        featureEdges.SetInputData(mesh)
    else:
        featureEdges.SetInput(mesh)
    featureEdges.FeatureEdgesOn()
    featureEdges.BoundaryEdgesOff()
    featureEdges.NonManifoldEdgesOff()
    featureEdges.ManifoldEdgesOff()
    featureEdges.SetFeatureAngle(angle)

    edgeMapper = vtk.vtkPolyDataMapper()
    edgeMapper.SetInputConnection(featureEdges.GetOutputPort())

    edgeActor = vtk.vtkActor()
    edgeActor.GetProperty().SetLineWidth(5)
    edgeActor.SetMapper(edgeMapper)

    mapper = vtk.vtkDataSetMapper()
    if vtk.vtkVersion().GetVTKMajorVersion() > 5:
        mapper.SetInputData(mesh)
    else:
        mapper.SetInput(mesh)

    # Actor
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().LightingOff()

    ###############################
    # Display
    ###############################

    # Render
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    # Allow user to interact
    istyle = vtk.vtkInteractorStyleTrackballCamera()
    iren.SetInteractorStyle(istyle)

    ren.AddActor(actor)
    ren.AddActor(edgeActor)

    iren.Initialize()
    renWin.Render()
    iren.Start()
Example #6
0
    def addGrid(self, grid):
        nx, ny, nz = grid.shape[1:]

        self.display.append(True)

        self.grids.append(vtk.vtkStructuredGrid())

        self.grids[-1].SetExtent(0, nz-1, 0, ny-1, 0, nx-1)
        p = vtk.vtkPoints()

        shp = grid.shape
        grid.shape = (3, nx*ny*nz)
        p.SetData(vtknp.numpy_to_vtk(np.ascontiguousarray(grid.T), deep=True, array_type=vtknp.get_vtk_array_type(grid.dtype)))
        grid.shape = shp
        self.grids[-1].SetPoints(p)

        #Couleur
        color = np.random.rand(3)
        #Create a vtkOutlineFilter to draw the bounding box of the data set.
        ol = vtk.vtkOutlineFilter()
        if (vtk.vtkVersion().GetVTKMajorVersion()>=6):
          ol.SetInputData(self.grids[-1])
        else:
          ol.SetInput(self.grids[-1])      
        olm = vtk.vtkPolyDataMapper()
        olm.SetInputConnection(ol.GetOutputPort())
        ola = vtk.vtkActor()
        ola.SetMapper(olm)
        ola.GetProperty().SetColor(color)

        s=vtk.vtkShrinkFilter()
        if (vtk.vtkVersion().GetVTKMajorVersion()>=6):
          s.SetInputData(self.grids[-1])
        else:
          s.SetInput(self.grids[-1])      
        s.SetShrinkFactor(0.8)
        #
        mapper = vtk.vtkDataSetMapper()
        #map.SetInputData(data)
        mapper.SetInputConnection(s.GetOutputPort())
        act = vtk.vtkLODActor()
        act.SetMapper(mapper)
        #act.GetProperty().SetRepresentationToWireframe()
        #act.GetProperty().SetRepresentationToPoints()	
        act.GetProperty().SetColor(color)
        act.GetProperty().SetEdgeColor(color)
        act.GetProperty().EdgeVisibilityOff()	
        self.actors.append(act)
        self.setBounds()
        self.ren.SetActiveCamera(self.cam)
Example #7
0
def VertFacetoPoly(new_pt, new_fc):
    """ Creates a vtk polydata object given points and triangular faces """

    # Convert points to vtkfloat object
    points = np.vstack(new_pt)
    vtkArray = VN.numpy_to_vtk(np.ascontiguousarray(points),
                               deep=True)  #, deep=True)
    points = vtk.vtkPoints()
    points.SetData(vtkArray)

    # Convert faces to vtk cells object
    ints = np.ones(len(new_fc), 'int') * 3
    cells = np.hstack((ints.reshape(-1, 1), np.vstack(new_fc)))
    cells = np.ascontiguousarray(np.hstack(cells).astype('int64'))
    vtkcells = vtk.vtkCellArray()
    vtkcells.SetCells(cells.shape[0],
                      VN.numpy_to_vtkIdTypeArray(cells, deep=True))

    # Create polydata object
    pdata = vtk.vtkPolyData()
    pdata.SetPoints(points)
    pdata.SetPolys(vtkcells)

    # Remove duplicate verticies
    clean = vtk.vtkCleanPolyData()
    clean.ConvertPolysToLinesOff()
    clean.ConvertLinesToPointsOff()
    clean.ConvertStripsToPolysOff()
    if vtk.vtkVersion().GetVTKMajorVersion() > 5:
        clean.SetInputData(pdata)
    else:
        clean.SetInput(pdata)
    clean.Update()

    return clean.GetOutput()
Example #8
0
def compareGeneratedAndCurrentVTKVersion():
    """Check if the vtk version with which the files were generated is equal to the current vtk version and log a warning if not"""
    import re
    import os
    from .generated_nodes import gen_VTKFilters

    vtk_re = re.compile("^\# VTK version\: (\S*).*$")

    gen_vtk_path = os.path.abspath(gen_VTKFilters.__file__)
    gen_vtk_f = open(gen_vtk_path, "r")
    lines = gen_vtk_f.readlines()
    vtk_version = vtk.vtkVersion().GetVTKVersion()
    gen_vtk_version = None

    # Strips the newline character
    for line in lines:
        matches = vtk_re.match(line)

        if matches is not None:
            gen_vtk_version = matches.group(1)
            break

    if gen_vtk_version is None:
        l.warning("Warning: Generated VTK file did not provide a VTK version")

    elif gen_vtk_version != vtk_version:
        l.warning(
            "Warning: Generated VTK file has version %s, but Blender's VTK version is %s"
            % (gen_vtk_version, vtk_version))
Example #9
0
def parse(filename="vtk_raw.xml"):
    inheritance_graph = ClassTree(vtk)
    inheritance_graph.create()

    v = vtk.vtkVersion()
    version = [v.GetVTKMajorVersion(),
               v.GetVTKMinorVersion(),
               v.GetVTKBuildVersion()]
    if version < [5, 7, 0]:
        assert len(inheritance_graph.tree[0]) == 1
        base = inheritance_graph.tree[0][0]
        assert base.name == 'vtkObjectBase'

    specs_list = []
    if version < [5, 7, 0]:
        for child in base.children:
            if child.name in disallowed_classes:
                continue
            specs_list.extend(create_module("vtkObjectBase", child))
    else:
        for base in inheritance_graph.tree[0]:
            for child in base.children:
                if child.name in disallowed_classes:
                    continue
                specs_list.extend(create_module("vtkObjectBase", child))

    specs = SpecList(specs_list)
    specs.write_to_xml(filename)
Example #10
0
def write_polydata(polydata, filename):
    """Write polydata as vtkPolyData format, according to extension."""

    if VERBOSE:
        print "Writing ", filename, "..."

    basename, extension = os.path.splitext(filename)

    if   (extension == '.vtk'):
        writer = vtk.vtkPolyDataWriter()
        writer.SetFileTypeToBinary()
    elif (extension == '.vtp'):
        writer = vtk.vtkXMLPolyDataWriter()
        writer.SetDataModeToBinary()
    else:
        print 'Cannot recognize model file format'
        return None

    writer.SetFileName(filename)
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        writer.SetInputData(polydata)
    else:
        writer.SetInput(polydata)
    writer.Update()

    del writer

    if VERBOSE:
        print "Done writing ", filename
        print "Number of lines found:", outpd.GetNumberOfLines()
Example #11
0
    def build_vtk_renderer(self):

        # offscreen rendering
        if (vtk.vtkVersion().GetVTKMajorVersion() == 5.0):
            graphics_factory = vtk.vtkGraphicsFactory()
            graphics_factory.SetOffScreenOnlyMode( 1);
            graphics_factory.SetUseMesaClasses( 1 );
            imaging_factory = vtk.vtkImagingFactory()
            imaging_factory.SetUseMesaClasses( 1 );
  
        self.renderer = vtk.vtkRenderer()
        self.renderer.SetBackground(1, 1, 1)
        self.render_window = vtk.vtkRenderWindow()
        # offscreen rendering
        self.render_window.SetOffScreenRendering(1)

        self.render_window.AddRenderer(self.renderer)
        # create a renderwindowinteractor
        #if self.interact:
        #self.iren = vtk.vtkRenderWindowInteractor()
        #self.iren.SetRenderWindow(self.render_window)

        # scalar bar        
        self.scalarbar = vtk.vtkScalarBarActor()
        # To avoid uninitialized warning in VTK 6
        self.scalarbar.SetTitle("") 
        # black text since background is white for printing
        self.scalarbar.GetLabelTextProperty().SetColor(0, 0, 0)
        self.scalarbar.GetTitleTextProperty().SetColor(0, 0, 0)
Example #12
0
def VertFacetoPoly(new_pt, new_fc):
    """ Creates a vtk polydata object given points and triangular faces """
    
    # Convert points to vtkfloat object
    points = np.vstack(new_pt)
    vtkArray = VN.numpy_to_vtk(np.ascontiguousarray(points), deep=True)#, deep=True) 
    points = vtk.vtkPoints()
    points.SetData(vtkArray) 
    
    # Convert faces to vtk cells object
    ints = np.ones(len(new_fc), 'int')*3
    cells = np.hstack((ints.reshape(-1, 1), np.vstack(new_fc)))
    cells = np.ascontiguousarray(np.hstack(cells).astype('int64'))
    vtkcells = vtk.vtkCellArray()
    vtkcells.SetCells(cells.shape[0], VN.numpy_to_vtkIdTypeArray(cells, deep=True))

    # Create polydata object
    pdata = vtk.vtkPolyData()
    pdata.SetPoints(points)
    pdata.SetPolys(vtkcells)
    
    # Remove duplicate verticies
    clean = vtk.vtkCleanPolyData()
    clean.ConvertPolysToLinesOff()
    clean.ConvertLinesToPointsOff()
    clean.ConvertStripsToPolysOff()
    if vtk.vtkVersion().GetVTKMajorVersion() > 5:
        clean.SetInputData(pdata)
    else:
        clean.SetInput(pdata) 
    clean.Update()

    return clean.GetOutput()
Example #13
0
def transform_polydata_from_disk(in_filename, transform_filename, out_filename):
    # Read it in.
    print "<io.py> Transforming ", in_filename, "->", out_filename, "..."

    # Read the transform from disk because we cannot pickle it
    (root, ext) = os.path.splitext(transform_filename)
    print root, ext
    if ext == '.xfm':
        reader = vtk.vtkMNITransformReader()
        reader.SetFileName(transform_filename)
        reader.Update()
        transform = reader.GetTransform()
    elif ext == '.img':
        reader = vtk.vtkImageReader()
        reader.SetFileName(transform_filename)
        reader.Update()
        coeffs = reader.GetOutput()
        transform = vtk.vtkBSplineTransform()
        transform.SetCoefficients(coeffs)
        print coeffs
        print transform
    else:
        f = open(transform_filename, 'r')
        transform = vtk.vtkTransform()
        matrix = vtk.vtkMatrix4x4()
        for i in range(0,4):
            for j in range(0,4):
                matrix_val = float(f.readline())
                matrix.SetElement(i,j, matrix_val)
        transform.SetMatrix(matrix)
        del matrix

    start_time = time.time()
    pd = read_polydata(in_filename)
    elapsed_time = time.time() - start_time
    print "READ:", elapsed_time
    # Transform it.
    start_time = time.time()
    transformer = vtk.vtkTransformPolyDataFilter()
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        transformer.SetInputData(pd)
    else:
        transformer.SetInput(pd)
    transformer.SetTransform(transform)
    transformer.Update()
    elapsed_time = time.time() - start_time
    print "TXFORM:", elapsed_time

    # Write it out.
    start_time = time.time()
    pd2 = transformer.GetOutput()
    write_polydata(pd2, out_filename)
    elapsed_time = time.time() - start_time
    print "WRITE:", elapsed_time

    # Clean up.
    del transformer
    del pd2
    del pd
    del transform
Example #14
0
    def __init__(self):
        ActorFactory.ActorFactory.__init__(self)

        # Create a green line
        self._Points = vtk.vtkPoints()
        self._Lines = vtk.vtkCellArray()
        self._Poly = vtk.vtkPolyData()

        self._Poly.SetPoints(self._Points)
        self._Poly.SetLines(self._Lines)

        self._PathProperty = vtk.vtkProperty()
        self._PathProperty.SetColor(0, 1, 0)
        self._PathProperty.SetOpacity(0.0)

        # turn the line into a cylinder
        self._tube = vtk.vtkTubeFilter()

        # VTK-6
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            self._tube.SetInputData(self._Poly)
        else:
            self._tube.SetInput(self._Poly)

        self._tube.SetNumberOfSides(3)
        self._tube.SetRadius(2.5)
Example #15
0
  def updateWidgetFromLogic(self):
    lightkit = self.logic.lightKit

    self.ui.keyIntensitySliderWidget.value = lightkit.GetKeyLightIntensity()
    self.ui.keyWarmthSliderWidget.value = lightkit.GetKeyLightWarmth()
    self.ui.keyElevationSliderWidget.value = lightkit.GetKeyLightElevation()
    self.ui.keyAzimuthSliderWidget.value = lightkit.GetKeyLightAzimuth()

    self.ui.headIntensitySliderWidget.value = 1.0/lightkit.GetKeyToHeadRatio()
    self.ui.headWarmthSliderWidget.value = lightkit.GetHeadLightWarmth()

    self.ui.fillIntensitySliderWidget.value = 1.0/lightkit.GetKeyToFillRatio()
    self.ui.fillWarmthSliderWidget.value = lightkit.GetFillLightWarmth()
    self.ui.fillElevationSliderWidget.value = lightkit.GetFillLightElevation()
    self.ui.fillAzimuthSliderWidget.value = lightkit.GetFillLightAzimuth()

    self.ui.backIntensitySliderWidget.value = 1.0/lightkit.GetKeyToBackRatio()
    self.ui.backWarmthSliderWidget.value = lightkit.GetBackLightWarmth()
    self.ui.backElevationSliderWidget.value = lightkit.GetBackLightElevation()
    self.ui.backAzimuthSliderWidget.value = lightkit.GetBackLightAzimuth()

    if vtk.vtkVersion().GetVTKMajorVersion()>=9:
      self.ui.ssaoCheckBox.checked = self.logic.ssaoEnabled
      self.ui.ssaoSizeScaleSliderWidget.value = self.logic.ssaoSizeScaleLog
    else:
      self.ui.SSAOCollapsibleButton.hide()
Example #16
0
    def SetRenderWindow(self,w):
        """ SetRenderWindow(w: vtkRenderWindow)        
        Set a new render window to QVTKWidget and initialize the
        interactor as well
        
        """
        if w == self.mRenWin:
            return
        
        if self.mRenWin:
            if system.systemType!='Linux':
                self.mRenWin.SetInteractor(None)
            if self.mRenWin.GetMapped():
                self.mRenWin.Finalize()
            
        self.mRenWin = w

        if self.mRenWin:
            self.mRenWin.Register(None)
            if self.mRenWin.GetMapped():
                self.mRenWin.Finalize()
            if system.systemType=='Linux':
                display = None
                try:
                    display = int(QtGui.QX11Info.display())
                except TypeError:
                    # This was changed for PyQt4.2
                    if isinstance(QtGui.QX11Info.display(), QtGui.Display):
                        display = sip.unwrapinstance(QtGui.QX11Info.display())
                if display is not None:
                    v = vtk.vtkVersion()
                    version = [v.GetVTKMajorVersion(),
                               v.GetVTKMinorVersion(),
                               v.GetVTKBuildVersion()]
                    display = hex(display)[2:]
                    if version < [5, 7, 0]:
                        vp = ('_%s_void_p\0x00' % display)
                    elif version < [6, 2, 0]:
                        vp = ('_%s_void_p' % display)
                    else:
                        vp = ('_%s_p_void' % display)
                    self.mRenWin.SetDisplayId(vp)
                self.resizeWindow(1,1)
            self.mRenWin.SetWindowInfo(str(int(self.winId())))
            if self.isVisible():
                self.mRenWin.Start()

            if not self.mRenWin.GetInteractor():
                #iren = vtk.vtkRenderWindowInteractor()
                iren = QVTKRenderWindowInteractor()
#                if system.systemType=='Darwin':
#                    iren.InstallMessageProcOff()
                iren.SetRenderWindow(self.mRenWin)
                iren.Initialize()
#                if system.systemType=='Linux':
#                    system.XDestroyWindow(self.mRenWin.GetGenericDisplayId(),
#                                          self.mRenWin.GetGenericWindowId())
                self.mRenWin.SetWindowInfo(str(int(self.winId())))
                self.resizeWindow(self.width(), self.height())
                self.mRenWin.SetPosition(self.x(), self.y())
Example #17
0
def parse(filename="vtk_raw.xml"):
    inheritance_graph = ClassTree(vtk)
    inheritance_graph.create()

    v = vtk.vtkVersion()
    version = [
        v.GetVTKMajorVersion(),
        v.GetVTKMinorVersion(),
        v.GetVTKBuildVersion()
    ]
    if version < [5, 7, 0]:
        assert len(inheritance_graph.tree[0]) == 1
        base = inheritance_graph.tree[0][0]
        assert base.name == 'vtkObjectBase'

    specs_list = []
    if version < [5, 7, 0]:
        for child in base.children:
            if child.name in disallowed_classes:
                continue
            specs_list.extend(create_module("vtkObjectBase", child))
    else:
        for base in inheritance_graph.tree[0]:
            for child in base.children:
                if child.name in disallowed_classes:
                    continue
                specs_list.extend(create_module("vtkObjectBase", child))

    specs = SpecList(specs_list)
    specs.write_to_xml(filename)
Example #18
0
    def SetHistogramStencil(self, stencil_data):

        # VTK-6
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            self.__histogram_stats.SetStencilData(stencil_data)
        else:
            self.__histogram_stats.SetStencil(stencil_data)
Example #19
0
    def make_vtu(path, add_elset_id_field=False, elset_prefix='_ELSET'):
        '''Convert a mesh to vtk format.
        
        This method reads the mesh and then write the corresponding .vtu file.
        The file will have the same name as the input mesh, with the extension changed to vtu.
        Only .geof and .mesh file are currently supported.

        :param str path: path to the mesh file.
        :param bool add_elset_id_field: flag to add a field representing the elset id.
        :param str elset_prefix: prefix to use if computing the leset id field.
        '''
        if path.endswith('.geof'):
            m = FE_Mesh.load_from_geof(path)
        elif path.endswith('.mesh'):
            m = FE_Mesh.load_from_mesh(path)
        else:
            print('unsupported mesh format (must be .geof or .mesh): %s' %
                  path)
            return
        vtk_mesh = m.build_vtk()
        if add_elset_id_field:
            from vtk.util import numpy_support
            id_field = m.compute_elset_id_field(elset_prefix)
            print('adding field %s' % 'elset_id')
            vtk_data_array = numpy_support.numpy_to_vtk(id_field, deep=1)
            vtk_data_array.SetName('elset_id')
            vtk_mesh.GetCellData().AddArray(vtk_data_array)
        writer = vtk.vtkXMLUnstructuredGridWriter()
        writer.SetFileName(path[:-5] + '.vtu')
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            writer.SetInputData(vtk_mesh)
        else:
            writer.SetInput(vtk_mesh)
        writer.Write()
Example #20
0
    def SetRenderWindow(self,w):
        """ SetRenderWindow(w: vtkRenderWindow)        
        Set a new render window to QVTKWidget and initialize the
        interactor as well
        
        """
        if w == self.mRenWin:
            return
        
        if self.mRenWin:
            if system.systemType!='Linux':
                self.mRenWin.SetInteractor(None)
            if self.mRenWin.GetMapped():
                self.mRenWin.Finalize()
            
        self.mRenWin = w

        if self.mRenWin:
            self.mRenWin.Register(None)
            if self.mRenWin.GetMapped():
                self.mRenWin.Finalize()
            if system.systemType=='Linux':
                display = None
                try:
                    display = int(QtGui.QX11Info.display())
                except TypeError:
                    # This was changed for PyQt4.2
                    if isinstance(QtGui.QX11Info.display(), QtGui.Display):
                        display = sip.unwrapinstance(QtGui.QX11Info.display())
                if display is not None:
                    v = vtk.vtkVersion()
                    version = [v.GetVTKMajorVersion(),
                               v.GetVTKMinorVersion(),
                               v.GetVTKBuildVersion()]
                    display = hex(display)[2:]
                    if version < [5, 7, 0]:
                        vp = ('_%s_void_p\0x00' % display)
                    elif version < [6, 2, 0]:
                        vp = ('_%s_void_p' % display)
                    else:
                        vp = ('_%s_p_void' % display)
                    self.mRenWin.SetDisplayId(vp)
                self.resizeWindow(1,1)
            self.mRenWin.SetWindowInfo(str(int(self.winId())))
            if self.isVisible():
                self.mRenWin.Start()

            if not self.mRenWin.GetInteractor():
                #iren = vtk.vtkRenderWindowInteractor()
                iren = QVTKRenderWindowInteractor()
#                if system.systemType=='Darwin':
#                    iren.InstallMessageProcOff()
                iren.SetRenderWindow(self.mRenWin)
                iren.Initialize()
#                if system.systemType=='Linux':
#                    system.XDestroyWindow(self.mRenWin.GetGenericDisplayId(),
#                                          self.mRenWin.GetGenericWindowId())
                self.mRenWin.SetWindowInfo(str(int(self.winId())))
                self.resizeWindow(self.width(), self.height())
                self.mRenWin.SetPosition(self.x(), self.y())
Example #21
0
    def GetROIImage(self, clipDataOn=0):
        """Return ROI Image port from ROIStencil"""
        component.getUtility(ICurrentImage).Update()
        minV, maxV = component.getUtility(ICurrentImage).GetScalarRange()
        reslice = vtk.vtkImageReslice()
        reslice.SetInputConnection(
            component.getUtility(ICurrentImage).GetOutputPort())
        reslice.SetInterpolationModeToCubic()

        # 2014-12-22 this is important
        self.__stencil_data.Update()

        # VTK-6
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            reslice.SetStencilData(self.__stencil_data)
        else:
            reslice.SetStencil(self.__stencil_data)

        reslice.SetOutputExtent(self.__stencil_data.GetWholeExtent())
        reslice.SetOutputOrigin(self._Origin)
        reslice.SetOutputSpacing(self._Spacing)
        reslice.SetBackgroundLevel(minV)
        reslice.Update()

        return reslice
Example #22
0
def render_to_image(output_filename, vtk_format, renderer, w, h):
    window = vtk.vtkRenderWindow()
    window.OffScreenRenderingOn()
    window.SetSize(w, h)

    # FIXME think this may be fixed in VTK6 so we don't have this
    # dependency...
    widget = None
    if systemType=='Darwin':
        from PyQt4 import QtCore, QtGui
        widget = QtGui.QWidget(None, QtCore.Qt.FramelessWindowHint)
        widget.resize(w, h)
        widget.show()
        window.SetWindowInfo(str(int(widget.winId())))

    window.AddRenderer(renderer)
    window.Render()
    win2image = vtk.vtkWindowToImageFilter()
    win2image.SetInput(window)
    win2image.Update()
    writer = vtk_format()
    if LooseVersion(vtk.vtkVersion().GetVTKVersion()) >= \
       LooseVersion('6.0.0'):
        writer.SetInputData(win2image.GetOutput())
    else:
        writer.SetInput(win2image.GetOutput())
    writer.SetFileName(output_filename)
    writer.Write()
    window.Finalize()
    if widget!=None:
        widget.close()
Example #23
0
def transform_polydata_from_disk_using_transform_object(
        in_filename, transform, out_filename):
    # Read it in.
    print "<io.py> Transforming ", in_filename, "->", out_filename, "..."
    start_time = time.time()
    pd = read_polydata(in_filename)
    elapsed_time = time.time() - start_time
    print "READ:", elapsed_time
    # Transform it.
    start_time = time.time()
    transformer = vtk.vtkTransformPolyDataFilter()
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        transformer.SetInputData(pd)
    else:
        transformer.SetInput(pd)
    transformer.SetTransform(transform)
    transformer.Update()
    elapsed_time = time.time() - start_time
    print "TXFORM:", elapsed_time

    # Write it out.
    start_time = time.time()
    pd2 = transformer.GetOutput()
    write_polydata(pd2, out_filename)
    elapsed_time = time.time() - start_time
    print "WRITE:", elapsed_time

    # Clean up.
    del transformer
    del pd2
    del pd
Example #24
0
    def test_method_signature(self):
        """Check if VTK method signatures are parsed correctly."""
        p = self.p

        # Simple tests.
        o = vtk.vtkProperty()
        self.assertEqual([(["string"], None)], p.get_method_signature(o.GetClassName))
        if hasattr(vtk, "vtkArrayCoordinates"):
            self.assertEqual(
                [
                    ([("float", "float", "float")], None),
                    ([None], (["float", "float", "float"],)),
                    ([None], ("float", "float", "float")),
                ],
                p.get_method_signature(o.GetColor),
            )
        else:
            self.assertEqual(
                [([("float", "float", "float")], None), ([None], (("float", "float", "float"),))],
                p.get_method_signature(o.GetColor),
            )
        if hasattr(vtk, "vtkArrayCoordinates"):
            self.assertEqual(
                [([None], ("float", "float", "float")), ([None], (["float", "float", "float"],))],
                p.get_method_signature(o.SetColor),
            )

        else:
            self.assertEqual(
                [([None], ("float", "float", "float")), ([None], (("float", "float", "float"),))],
                p.get_method_signature(o.SetColor),
            )

        # Get VTK version to handle changed APIs.
        vtk_ver = vtk.vtkVersion().GetVTKVersion()

        # Test vtkObjects args.
        o = vtk.vtkContourFilter()
        sig = p.get_method_signature(o.SetInput)
        if len(sig) == 1:
            self.assertEqual([([None], ["vtkDataSet"])], sig)
        elif vtk_ver[:3] in ["4.2", "4.4"]:
            self.assertEqual(
                [
                    ([None], ["vtkDataObject"]),
                    ([None], ("int", "vtkDataObject")),
                    ([None], ["vtkDataSet"]),
                    ([None], ("int", "vtkDataSet")),
                ],
                sig,
            )
        elif vtk_ver[:2] == "5." or vtk_ver[:3] == "4.5":
            self.assertEqual([([None], ["vtkDataObject"]), ([None], ("int", "vtkDataObject"))], sig)

        self.assertEqual([(["vtkPolyData"], None), (["vtkPolyData"], ["int"])], p.get_method_signature(o.GetOutput))

        # Test if function arguments work.
        self.assertEqual([(["int"], ("int", "function"))], p.get_method_signature(o.AddObserver))
        # This one's for completeness.
        self.assertEqual([([None], ["int"])], p.get_method_signature(o.RemoveObserver))
Example #25
0
    def __getattr__(self, name):
        v = vtk.vtkVersion()
        version = [v.GetVTKMajorVersion(),
                   v.GetVTKMinorVersion(),
                   v.GetVTKBuildVersion()]
        if version < [6, 0, 0]:
            # Translate vtk6 method names to vtk5 method names
            to_vtk5_names = {'AddInputData':  'AddInput',
                          'AddDataSetInput':  'AddInput',
                             'SetInputData':  'SetInput',
                            'AddSourceData': 'AddSource',
                            'SetSourceData': 'SetSource'}
            for new, old in to_vtk5_names.iteritems():
                if name.startswith(new):
                    # Keep suffix
                    name = old + name[len(new):]
                    break
        # redirect calls to vtkInstance
        def call_wrapper(*args):
            args = list(args)
            for i in xrange(len(args)):
                if hasattr(args[i], 'vtkInstance'):
                    # Unwrap VTK objects
                    args[i] = args[i].vtkInstance
            args = tuple(args)

            #print "CALLING", name, [a.__class__.__name__ for a in args]
            result = getattr(self.vtkInstance, name)(*args)
            #print "GOT", result.__class__.__name__

            if isinstance(result, vtk.vtkObjectBase):
                # Wrap VTK objects
                result = VTKInstanceWrapper(result)
            return result
        return call_wrapper
Example #26
0
def transform_polydata_from_disk_using_transform_object(in_filename, transform, out_filename):
    # Read it in.
    print "<io.py> Transforming ", in_filename, "->", out_filename, "..."
    start_time = time.time()
    pd = read_polydata(in_filename)
    elapsed_time = time.time() - start_time
    print "READ:", elapsed_time
    # Transform it.
    start_time = time.time()
    transformer = vtk.vtkTransformPolyDataFilter()
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        transformer.SetInputData(pd)
    else:
        transformer.SetInput(pd)
    transformer.SetTransform(transform)
    transformer.Update()
    elapsed_time = time.time() - start_time
    print "TXFORM:", elapsed_time

    # Write it out.
    start_time = time.time()
    pd2 = transformer.GetOutput()
    write_polydata(pd2, out_filename)
    elapsed_time = time.time() - start_time
    print "WRITE:", elapsed_time

    # Clean up.
    del transformer
    del pd2
    del pd
Example #27
0
    def to_vtk(self, file_name):

        for i, time in enumerate(self.times):
            file_base, file_ext = os.path.splitext(file_name)
            if file_ext == ".vtk":
                writer = vtk.vtkStructuredGridWriter()
            elif file_ext == ".vts":
                writer = vtk.vtkXMLStructuredGridWriter()
            elif file_ext == "":
                file_name = file_base + ".vts"
                writer = vtk.vtkXMLStructuredGridWriter()
            else:
                msg = "This function can only use the vtk or vts file extension not %s" % file_ext
                raise ValueError(msg)

            grid = self.CoordDF.vtkStructuredGrid()
            if len(self.times) > 1:
                num_zeros = int(np.log10(len(self.times))) + 1
                ext = str(num_zeros).zfill(num_zeros)
                file_name = os.path.join(file_name, ".%s" % ext)

            for comp in self.comp:
                grid.cell_arrays[np.str_(comp)] = self[time, comp].flatten()
            # pyvista.save_meshio(file_name,grid,file_format="vtk")

            writer.SetFileName(file_name)

            if vtk.vtkVersion().GetVTKMajorVersion() <= 5:
                grid.Update()
                writer.SetInput(grid)
            else:
                writer.SetInputData(grid)

            writer.Write()
Example #28
0
def initialize():
    # First check if spec for this VTK version exists
    v = vtk.vtkVersion()
    vtk_version = [
        v.GetVTKMajorVersion(),
        v.GetVTKMinorVersion(),
        v.GetVTKBuildVersion()
    ]

    # vtk-VTKVERSION-spec-PKGVERSION.xml
    spec_name = os.path.join(
        current_dot_vistrails(), 'vtk-%s-spec-%s.xml' %
        ('_'.join([str(v)
                   for v in vtk_version]), package_version.replace('.', '_')))
    # TODO: how to patch with diff/merge
    if not os.path.exists(spec_name):
        from .vtk_wrapper.parse import parse
        parse(spec_name)
    vtk_classes.initialize(spec_name)
    _modules.insert(0, BaseClassModule)
    _modules.extend([
        gen_class_module(spec,
                         vtk_classes,
                         klasses,
                         signature=hasher.vtk_hasher)
        for spec in vtk_classes.specs.module_specs
    ])
Example #29
0
def transform_polydata_from_disk(in_filename, transform_filename, out_filename):
    # Read it in.
    print "<io.py> Transforming ", in_filename, "->", out_filename, "..."

    # Read the transform from disk because we cannot pickle it
    (root, ext) = os.path.splitext(transform_filename)
    print root, ext
    if ext == '.xfm':
        reader = vtk.vtkMNITransformReader()
        reader.SetFileName(transform_filename)
        reader.Update()
        transform = reader.GetTransform()
    elif ext == '.img':
        reader = vtk.vtkImageReader()
        reader.SetFileName(transform_filename)
        reader.Update()
        coeffs = reader.GetOutput()
        transform = vtk.vtkBSplineTransform()
        transform.SetCoefficients(coeffs)
        print coeffs
        print transform
    else:
        f = open(transform_filename, 'r')
        transform = vtk.vtkTransform()
        matrix = vtk.vtkMatrix4x4()
        for i in range(0,4):
            for j in range(0,4):
                matrix_val = float(f.readline())
                matrix.SetElement(i,j, matrix_val)
        transform.SetMatrix(matrix)
        del matrix

    start_time = time.time()
    pd = read_polydata(in_filename)
    elapsed_time = time.time() - start_time
    print "READ:", elapsed_time
    # Transform it.
    start_time = time.time()
    transformer = vtk.vtkTransformPolyDataFilter()
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        transformer.SetInputData(pd)
    else:
        transformer.SetInput(pd)
    transformer.SetTransform(transform)
    transformer.Update()
    elapsed_time = time.time() - start_time
    print "TXFORM:", elapsed_time

    # Write it out.
    start_time = time.time()
    pd2 = transformer.GetOutput()
    write_polydata(pd2, out_filename)
    elapsed_time = time.time() - start_time
    print "WRITE:", elapsed_time

    # Clean up.
    del transformer
    del pd2
    del pd
    del transform
Example #30
0
def render_to_image(output_filename, vtk_format, renderer, w, h):
    window = vtk.vtkRenderWindow()
    window.OffScreenRenderingOn()
    window.SetSize(w, h)

    # FIXME think this may be fixed in VTK6 so we don't have this
    # dependency...
    widget = None
    if systemType == 'Darwin':
        from PyQt4 import QtCore, QtGui
        widget = QtGui.QWidget(None, QtCore.Qt.FramelessWindowHint)
        widget.resize(w, h)
        widget.show()
        window.SetWindowInfo(str(int(widget.winId())))

    window.AddRenderer(renderer)
    window.Render()
    win2image = vtk.vtkWindowToImageFilter()
    win2image.SetInput(window)
    win2image.Update()
    writer = vtk_format()
    if LooseVersion(vtk.vtkVersion().GetVTKVersion()) >= \
       LooseVersion('6.0.0'):
        writer.SetInputData(win2image.GetOutput())
    else:
        writer.SetInput(win2image.GetOutput())
    writer.SetFileName(output_filename)
    writer.Write()
    window.Finalize()
    if widget != None:
        widget.close()
Example #31
0
def rotateUGrid(ugrid,
                rx=0.0,
                ry=0.0,
                rz=0.0,
                sx=1.0,
                sy=1.0,
                sz=1.0,
                verbose=True):

    transmat = vtk.vtkTransform()
    transmat.RotateX(rx)
    transmat.RotateY(ry)
    transmat.RotateZ(rz)
    transmat.Scale(sx, sy, sz)

    transmat.Update()

    tf = vtk.vtkTransformFilter()
    if (vtk.vtkVersion().GetVTKMajorVersion() < 6):
        tf.SetInput(ugrid)
    else:
        tf.SetInputData(ugrid)
    tf.SetTransform(transmat)
    tf.Update()

    return tf.GetOutput()
Example #32
0
def write_polydata(polydata, filename):
    """Write polydata as vtkPolyData format, according to extension."""

    if VERBOSE:
        print "Writing ", filename, "..."

    basename, extension = os.path.splitext(filename)

    if (extension == '.vtk'):
        writer = vtk.vtkPolyDataWriter()
        writer.SetFileTypeToBinary()
    elif (extension == '.vtp'):
        writer = vtk.vtkXMLPolyDataWriter()
        writer.SetDataModeToBinary()
    else:
        print 'Cannot recognize model file format'
        return None

    writer.SetFileName(filename)
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        writer.SetInputData(polydata)
    else:
        writer.SetInput(polydata)
    writer.Update()

    del writer

    if VERBOSE:
        print "Done writing ", filename
Example #33
0
    def build_vtk_renderer(self):

        # offscreen rendering
        if (vtk.vtkVersion().GetVTKMajorVersion() == 5.0):
            graphics_factory = vtk.vtkGraphicsFactory()
            graphics_factory.SetOffScreenOnlyMode( 1);
            graphics_factory.SetUseMesaClasses( 1 );
            imaging_factory = vtk.vtkImagingFactory()
            imaging_factory.SetUseMesaClasses( 1 );
  
        self.renderer = vtk.vtkRenderer()
        self.renderer.SetBackground(1, 1, 1)
        self.render_window = vtk.vtkRenderWindow()
        # offscreen rendering
        self.render_window.SetOffScreenRendering(1)

        self.render_window.AddRenderer(self.renderer)
        # create a renderwindowinteractor
        #if self.interact:
        #self.iren = vtk.vtkRenderWindowInteractor()
        #self.iren.SetRenderWindow(self.render_window)

        # scalar bar        
        self.scalarbar = vtk.vtkScalarBarActor()
        # To avoid uninitialized warning in VTK 6
        self.scalarbar.SetTitle("") 
        # black text since background is white for printing
        self.scalarbar.GetLabelTextProperty().SetColor(0, 0, 0)
        self.scalarbar.GetTitleTextProperty().SetColor(0, 0, 0)
Example #34
0
    def __getattr__(self, name):
        v = vtk.vtkVersion()
        version = [v.GetVTKMajorVersion(),
                   v.GetVTKMinorVersion(),
                   v.GetVTKBuildVersion()]
        if version < [6, 0, 0]:
            # Translate vtk6 method names to vtk5 method names
            to_vtk5_names = {'AddInputData':  'AddInput',
                          'AddDataSetInput':  'AddInput',
                             'SetInputData':  'SetInput',
                            'AddSourceData': 'AddSource',
                            'SetSourceData': 'SetSource'}
            for new, old in to_vtk5_names.iteritems():
                if name.startswith(new):
                    # Keep suffix
                    name = old + name[len(new):]
                    break
        # redirect calls to vtkInstance
        def call_wrapper(*args):
            args = list(args)
            for i in xrange(len(args)):
                if hasattr(args[i], 'vtkInstance'):
                    # Unwrap VTK objects
                    args[i] = args[i].vtkInstance
            args = tuple(args)

            #print "CALLING", name, [a.__class__.__name__ for a in args]
            result = getattr(self.vtkInstance, name)(*args)
            #print "GOT", result.__class__.__name__

            if isinstance(result, vtk.vtkObjectBase):
                # Wrap VTK objects
                result = VTKInstanceWrapper(result)
            return result
        return call_wrapper
Example #35
0
    def GetROIImage(self, clipDataOn=0):
        """Return ROI Image port from ROIStencil"""
        component.getUtility(ICurrentImage).Update()
        minV, maxV = component.getUtility(ICurrentImage).GetScalarRange()
        reslice = vtk.vtkImageReslice()
        reslice.SetInputConnection(
            component.getUtility(ICurrentImage).GetOutputPort())
        reslice.SetInterpolationModeToCubic()

        # 2014-12-22 this is important
        self.__stencil_data.Update()

        # VTK-6
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            reslice.SetStencilData(self.__stencil_data)
        else:
            reslice.SetStencil(self.__stencil_data)

        reslice.SetOutputExtent(self.__stencil_data.GetWholeExtent())
        reslice.SetOutputOrigin(self._Origin)
        reslice.SetOutputSpacing(self._Spacing)
        reslice.SetBackgroundLevel(minV)
        reslice.Update()

        return reslice
Example #36
0
    def test_method_signature(self):
        """Check if VTK method signatures are parsed correctly."""
        p = self.p

        # Simple tests.
        o = vtk.vtkProperty()
        self.assertEqual([(['string'], None)],
                         p.get_method_signature(o.GetClassName))
        if hasattr(vtk, 'vtkArrayCoordinates'):
            self.assertEqual([([('float', 'float', 'float')], None),
                              ([None], (['float', 'float', 'float'], )),
                              ([None], ('float', 'float', 'float'))],
                             p.get_method_signature(o.GetColor))
        else:
            self.assertEqual([([('float', 'float', 'float')], None),
                              ([None], (('float', 'float', 'float'), ))],
                             p.get_method_signature(o.GetColor))
        if hasattr(vtk, 'vtkArrayCoordinates'):
            self.assertEqual([([None], ('float', 'float', 'float')),
                              ([None], (['float', 'float', 'float'], ))],
                             p.get_method_signature(o.SetColor))

        else:
            self.assertEqual([([None], ('float', 'float', 'float')),
                              ([None], (('float', 'float', 'float'), ))],
                             p.get_method_signature(o.SetColor))

        # Get VTK version to handle changed APIs.
        vtk_ver = vtk.vtkVersion().GetVTKVersion()

        # Test vtkObjects args.
        o = vtk.vtkContourFilter()
        sig = p.get_method_signature(o.SetInput)
        if len(sig) == 1:
            self.assertEqual([([None], ['vtkDataSet'])], sig)
        elif vtk_ver[:3] in ['4.2', '4.4']:
            self.assertEqual([([None], ['vtkDataObject']),
                              ([None], ('int', 'vtkDataObject')),
                              ([None], ['vtkDataSet']),
                              ([None], ('int', 'vtkDataSet'))], sig)
        elif vtk_ver[:2] == '5.' or vtk_ver[:3] == '4.5':
            self.assertEqual([
                ([None], ['vtkDataObject']),
                ([None], ('int', 'vtkDataObject')),
            ], sig)

        self.assertEqual([(['vtkPolyData'], None), (['vtkPolyData'], ['int'])],
                         p.get_method_signature(o.GetOutput))

        # Test if function arguments work.
        self.assertEqual([(['int'], ('int', 'function'))],
                         p.get_method_signature(o.AddObserver))
        # This one's for completeness.
        if ((len(p.get_method_signature(o.RemoveObserver))) == 2):
            self.assertEqual([([None], ['vtkCommand']), ([None], ['int'])],
                             p.get_method_signature(o.RemoveObserver))
        else:
            self.assertEqual([([None], ['int'])],
                             p.get_method_signature(o.RemoveObserver))
Example #37
0
def PlotGrids_wFEM(grids):
    """ Plots CFD structured grids with a single FEM """

    N = len(grids)
    HSV_tuples = [(x*1.0/N, 0.5, 0.5) for x in range(N)]
    RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples)
    
    actors = []
    for i in range(len(grids)):
        
        # Create mapper
        mapper = vtk.vtkDataSetMapper()
        if vtk.vtkVersion().GetVTKMajorVersion() >5:
            mapper.SetInput(grids[i])
        else:
            mapper.SetInputData(grids[i])
        
        # Create actor
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
        actor.GetProperty().EdgeVisibilityOn()
        if i != 0:
            actor.GetProperty().SetRepresentationToWireframe()
            actor.GetProperty().SetColor(RGB_tuples[i])
        actor.GetProperty().LightingOff()
        actors.append(actor)
        
    # Add FEM Actor to renderer window
    ren = vtk.vtkRenderer()
#    ren.SetBackground(0.3, 0.3, 0.3)
    ren.SetBackground(0.8, 0.8, 0.8)
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
    
    # Allow user to interact
    istyle = vtk.vtkInteractorStyleTrackballCamera()
    iren.SetInteractorStyle(istyle)
    

    
    # Add actor
    for actor in actors:
        ren.AddActor(actor)
    
    axes = vtk.vtkAxesActor()
    widget = vtk.vtkOrientationMarkerWidget()
#    widget.SetOutlineColor( 0.9300, 0.5700, 0.1300 )
    widget.SetOrientationMarker( axes )
    widget.SetInteractor( iren )
    widget.SetViewport( 0.0, 0.0, 0.4, 0.4 )
    widget.SetEnabled( 1 )
    widget.InteractiveOn()
    
    # Render
    iren.Initialize()
    renWin.Render()
    iren.Start()
    def __init__(self, master=None, *args, **kw):
        used_default_root = 0
        if not master:
            if not tkinter._default_root:
                tkinter._default_root = tkinter.Tk()
            master = tkinter._default_root
            used_default_root = 1
        if vtk.vtkVersion().GetVTKMajorVersion() >= 4:
            vtkLoadPythonTkWidgets(master.tk)
        else:
            try:  # check for VTK_TK_WIDGET_PATH environment variable
                tkWidgetPath = os.environ['VTK_TK_WIDGET_PATH']
            except KeyError:
                tkWidgetPath = '.'

            try:  # try specified path or current directory
                master.tk.call('load', os.path.join(tkWidgetPath,
                                                    'vtkTkRenderWidget'))
            except:  # try tcl/tk load path
                master.tk.call('load', 'vtkTkRenderWidget')

        self._RenderWindow = vtk.vtkRenderWindow()

        if 'stereo' in kw:
            if kw['stereo']:
                self._RenderWindow.StereoCapableWindowOn()
                self._RenderWindow.SetStereoTypeToCrystalEyes()
            del kw['stereo']

        # first initialize the Tkinter widget
        kw['rw'] = self._RenderWindow.GetAddressAsString("vtkRenderWindow")

        tkinter.Widget.__init__(self, master, 'vtkTkRenderWidget', {}, kw)

        # then initialize the PaneFrame
        PaneFrame.__init__(self)

        # a silly special-purpose thingy
        self.__InExpose = 0

        # is the system cursor hidden?
        self.__SystemCursorHidden = 0

        if used_default_root:
            self.pack(expand='true', fill='both')

        # do the Tk bindings
        self.bind("<ButtonPress>", self.OnButtonPress)
        self.bind("<ButtonRelease>", self.OnButtonRelease)
        self.bind("<Motion>", self.ConvertTkEvent)
        self.bind("<KeyPress>", self.ConvertTkEvent)
        self.bind("<KeyRelease>", self.ConvertTkEvent)

        # self.bind("<Enter>",self.DoEnter)
# JG: the follow line is commented out to prevent automatic redraws whenever mouse
# leaves the tkPaneframe
# self.bind("<Leave>",self.DoLeave)
        self.bind("<Expose>", self.DoExpose)
        self.bind("<Configure>", self.DoConfigure)
Example #39
0
    def __init__(self, master=None, *args, **kw):
        used_default_root = 0
        if not master:
            if not Tkinter._default_root:
                Tkinter._default_root = Tkinter.Tk()
            master = Tkinter._default_root
            used_default_root = 1
        if vtk.vtkVersion().GetVTKMajorVersion() >= 4:
            vtkLoadPythonTkWidgets(master.tk)
        else:
            try:  # check for VTK_TK_WIDGET_PATH environment variable
                tkWidgetPath = os.environ['VTK_TK_WIDGET_PATH']
            except KeyError:
                tkWidgetPath = '.'

            try:  # try specified path or current directory
                master.tk.call('load',
                               os.path.join(tkWidgetPath, 'vtkTkRenderWidget'))
            except:  # try tcl/tk load path
                master.tk.call('load', 'vtkTkRenderWidget')

        self._RenderWindow = vtk.vtkRenderWindow()

        if 'stereo' in kw:
            if kw['stereo']:
                self._RenderWindow.StereoCapableWindowOn()
                self._RenderWindow.SetStereoTypeToCrystalEyes()
            del kw['stereo']

        # first initialize the Tkinter widget
        kw['rw'] = self._RenderWindow.GetAddressAsString("vtkRenderWindow")

        Tkinter.Widget.__init__(self, master, 'vtkTkRenderWidget', {}, kw)

        # then initialize the PaneFrame
        PaneFrame.__init__(self)

        # a silly special-purpose thingy
        self.__InExpose = 0

        # is the system cursor hidden?
        self.__SystemCursorHidden = 0

        if used_default_root:
            self.pack(expand='true', fill='both')

        # do the Tk bindings
        self.bind("<ButtonPress>", self.OnButtonPress)
        self.bind("<ButtonRelease>", self.OnButtonRelease)
        self.bind("<Motion>", self.ConvertTkEvent)
        self.bind("<KeyPress>", self.ConvertTkEvent)
        self.bind("<KeyRelease>", self.ConvertTkEvent)

        # self.bind("<Enter>",self.DoEnter)
        # JG: the follow line is commented out to prevent automatic redraws whenever mouse
        # leaves the tkPaneframe
        # self.bind("<Leave>",self.DoLeave)
        self.bind("<Expose>", self.DoExpose)
        self.bind("<Configure>", self.DoConfigure)
Example #40
0
 def SetInputData(self, input):
     self._Input = input
     # VTK-6
     if vtk.vtkVersion().GetVTKMajorVersion() > 5:
         self._OutlineFilter.SetInputData(input)
     else:
         self._OutlineFilter.SetInput(input)
     self.Modified()
Example #41
0
def convert_cluster_to_volume_with_sz(inpd, volume, sampling_size=0.5):

    volume_shape = volume.get_data().shape
    new_voxel_data = numpy.zeros(volume_shape)

    resampler = vtk.vtkPolyDataPointSampler()
    resampler.GenerateEdgePointsOn()
    resampler.GenerateVertexPointsOff()
    resampler.GenerateInteriorPointsOff()
    resampler.GenerateVerticesOff()
    resampler.SetDistance(sampling_size)

    inpoints = inpd.GetPoints()

    inpd.GetLines().InitTraversal()
    for lidx in range(0, inpd.GetNumberOfLines()):

        ptids = vtk.vtkIdList()
        inpd.GetLines().GetNextCell(ptids)

        tmpPd = vtk.vtkPolyData()
        tmpPoints = vtk.vtkPoints()
        tmpCellPtIds = vtk.vtkIdList()
        tmpLines = vtk.vtkCellArray()

        for pidx in range(0, ptids.GetNumberOfIds()):
            point = inpoints.GetPoint(ptids.GetId(pidx))
            idx_ = tmpPoints.InsertNextPoint(point)
            tmpCellPtIds.InsertNextId(idx_)

        tmpLines.InsertNextCell(tmpCellPtIds)

        tmpPd.SetLines(tmpLines)
        tmpPd.SetPoints(tmpPoints)

        if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
            resampler.SetInputData(tmpPd)
        else:
            resampler.SetInput(tmpPd)

        resampler.Update()

        sampledCellPts = resampler.GetOutput().GetPoints()
        sampledNpts = resampler.GetOutput().GetNumberOfPoints()

        line_tmp_voxel_data = numpy.zeros(volume_shape)
        for pidx in range(0, sampledNpts):
            point = sampledCellPts.GetPoint(pidx)

            point_ijk = apply_affine(numpy.linalg.inv(volume.affine), point)
            point_ijk = numpy.rint(point_ijk).astype(numpy.int32)

            line_tmp_voxel_data[(point_ijk[0], point_ijk[1],
                                 point_ijk[2])] += 1

        new_voxel_data = new_voxel_data + line_tmp_voxel_data

    return new_voxel_data
Example #42
0
    def generate_code(self):
        """Generate all the wrapper code in `self.out_dir`.
        """
        out_dir = self.out_dir
        helper_gen = self.helper_gen
        wrap_gen = self.wrap_gen
        # Create an __init__.py file
        with open(os.path.join(out_dir, '__init__.py'), 'w'):
            pass

        # Crete a vtk_version.py file that contains VTK build
        # information.
        v = vtk.vtkVersion()
        vtk_version = v.GetVTKVersion()[:3]
        vtk_src_version = v.GetVTKSourceVersion()
        code = "vtk_build_version = \'%s\'\n" % (vtk_version)
        code += "vtk_build_src_version = \'%s\'\n" % (vtk_src_version)

        with open(os.path.join(out_dir, 'vtk_version.py'), 'w') as f:
            f.write(code)

        # Write the helper code header.
        with open(os.path.join(out_dir, 'tvtk_helper.py'), 'w') as helper_file:
            helper_gen.write_prelims(helper_file)

            # Write the wrapper files.
            tree = wrap_gen.get_tree().tree

            classes = []
            for node in wrap_gen.get_tree():
                name = node.name
                # This is another class we should not wrap and exists
                # in version 8.1.0.
                ignore = ['vtkOpenGLGL2PSHelperImpl']
                if name in ignore:
                    continue
                if not name.startswith('vtk') or name.startswith('vtkQt'):
                    continue
                if not hasattr(vtk, name) or not hasattr(
                        getattr(vtk, name), 'IsA'):  # noqa
                    # We need to wrap VTK classes that are derived
                    # from vtkObjectBase, the others are
                    # straightforward VTK classes that can be used as
                    # such.  All of these have an 'IsA' method so we
                    # check for that.  Only the vtkObjectBase
                    # subclasses support observers etc. and hence only
                    # those make sense to wrap into TVTK.
                    continue
                classes.append(name)

            for nodes in tree:
                for node in nodes:
                    if node.name in classes:
                        tvtk_name = get_tvtk_name(node.name)
                        logger.debug('Wrapping %s as %s' %
                                     (node.name, tvtk_name))
                        self._write_wrapper_class(node, tvtk_name)
                        helper_gen.add_class(tvtk_name, helper_file)
Example #43
0
def CheckVTKVersion(requiredMajorVersion):
    '''
        Check the VTK version.
    '''
    version = vtk.vtkVersion()
    if version.GetVTKMajorVersion() > requiredMajorVersion:
        raise
    else:
        return
Example #44
0
def CheckVTKVersion(requiredMajorVersion):
    '''
        Check the VTK version.
    '''
    version = vtk.vtkVersion()
    if version.GetVTKMajorVersion() > requiredMajorVersion:
        raise
    else:
        return
Example #45
0
    def test_method_signature(self):
        """Check if VTK method signatures are parsed correctly."""
        p = self.p

        # Simple tests.
        o = vtk.vtkProperty()
        self.assertEqual([(['string'], None)],
                         p.get_method_signature(o.GetClassName))
        if hasattr(vtk, 'vtkArrayCoordinates'):
            self.assertEqual([([('float', 'float', 'float')], None),
                              ([None], (['float', 'float', 'float'],)),
                              ([None], ('float', 'float', 'float'))],
                             p.get_method_signature(o.GetColor))
        else:
            self.assertEqual([([('float', 'float', 'float')], None),
                              ([None], (('float', 'float', 'float'),))],
                             p.get_method_signature(o.GetColor))
        if hasattr(vtk, 'vtkArrayCoordinates'):
            self.assertEqual([([None], ('float', 'float', 'float')),
                ([None], (['float', 'float', 'float'],))],
                             p.get_method_signature(o.SetColor))

        else:
            self.assertEqual([([None], ('float', 'float', 'float')),
                              ([None], (('float', 'float', 'float'),))],
                             p.get_method_signature(o.SetColor))

        # Get VTK version to handle changed APIs.
        vtk_ver = vtk.vtkVersion().GetVTKVersion()

        # Test vtkObjects args.
        o = vtk.vtkContourFilter()
        sig = p.get_method_signature(o.SetInput)
        if len(sig) == 1:
            self.assertEqual([([None], ['vtkDataSet'])],
                             sig)
        elif vtk_ver[:3] in ['4.2', '4.4']:
            self.assertEqual([([None], ['vtkDataObject']),
                              ([None], ('int', 'vtkDataObject')),
                              ([None], ['vtkDataSet']),
                              ([None], ('int', 'vtkDataSet'))
                              ], sig)
        elif vtk_ver[:2] == '5.' or vtk_ver[:3] == '4.5':
            self.assertEqual([([None], ['vtkDataObject']),
                              ([None], ('int', 'vtkDataObject')),
                              ], sig)

        self.assertEqual([(['vtkPolyData'], None),
                          (['vtkPolyData'], ['int'])],
                         p.get_method_signature(o.GetOutput))

        # Test if function arguments work.
        self.assertEqual([(['int'], ('int', 'function'))],
                         p.get_method_signature(o.AddObserver))
        # This one's for completeness.
        self.assertEqual([([None], ['int'])],
                         p.get_method_signature(o.RemoveObserver))
Example #46
0
def PlotGrids(grids):
    """ Plots CFD structured grids """

    N = len(grids)
    HSV_tuples = [(x * 1.0 / N, 0.5, 0.5) for x in range(N)]
    RGB_tuples = [colorsys.hsv_to_rgb(*x) for x in HSV_tuples]

    actors = []
    for i in range(len(grids)):

        # Create mapper
        mapper = vtk.vtkDataSetMapper()
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            mapper.SetInput(grids[i])
        else:
            mapper.SetInputData(grids[i])

        # Create actor
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
        actor.GetProperty().SetRepresentationToWireframe()
        actor.GetProperty().EdgeVisibilityOn()
        actor.GetProperty().SetColor(RGB_tuples[i])
        actor.GetProperty().LightingOff()
        actors.append(actor)

    # Add FEM Actor to renderer window
    ren = vtk.vtkRenderer()
    ren.SetBackground(0.8, 0.8, 0.8)
    #    ren.SetBackground(1, 1, 1)

    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    # Allow user to interact
    istyle = vtk.vtkInteractorStyleTrackballCamera()
    iren.SetInteractorStyle(istyle)

    # Add actor
    for actor in actors:
        ren.AddActor(actor)

    # Add axes
    axes = vtk.vtkAxesActor()
    widget = vtk.vtkOrientationMarkerWidget()
    widget.SetOrientationMarker(axes)
    widget.SetInteractor(iren)
    widget.SetViewport(0.0, 0.0, 0.4, 0.4)
    widget.SetEnabled(1)
    widget.InteractiveOn()

    # Render
    iren.Initialize()
    renWin.Render()
    iren.Start()
Example #47
0
def vtk_writer(polydata, objfile):
    assert polydata
    from packaging import version
    assert (version.parse(vtk.vtkVersion().GetVTKVersion()) >=
            version.parse("8.2.0")), "OBJWriter is not available before 8.2.0"
    obj_writer = vtk.vtkOBJWriter()
    obj_writer.SetFileName(objfile)
    obj_writer.SetInputData(polydata)
    obj_writer.Update()
Example #48
0
def onelinetip():
    import vtk, sys
    from vtkplotter import colors, __version__
    vvers = ' vtkplotter ' + __version__ + ' '
    colors.printc(vvers, invert=1, dim=1, end='')
    vvers = '| vtk ' + vtk.vtkVersion().GetVTKVersion()
    vvers += ' | python ' + str(sys.version_info[0]) + '.' + str(
        sys.version_info[1])
    vvers += " | press h for help."
    colors.printc(vvers, invert=0, dim=1)
Example #49
0
 def save_image(self, filename="test.jpg"):
     img = vtk.vtkWindowToImageFilter()
     img.SetInput(self.render_window)
     if (vtk.vtkVersion().GetVTKMajorVersion() >= 8.0):
         img.SetScale(self.magnification, self.magnification)
     else:
         img.SetMagnification(self.magnification)
     img.Update()
     #writer = vtk.vtkPNGWriter()
     writer = vtk.vtkJPEGWriter()
     if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
         writer.SetInputConnection(img.GetOutputPort())
     else:
         writer.SetInput(img.GetOutput())
     
     writer.SetFileName(filename)
     writer.Write()
     del writer
     del img
Example #50
0
 def save_image(self, filename="test.jpg"):
     img = vtk.vtkWindowToImageFilter()
     img.SetInput(self.render_window)
     if (vtk.vtkVersion().GetVTKMajorVersion() >= 8.0):
         img.SetScale(self.magnification, self.magnification)
     else:
         img.SetMagnification(self.magnification)
     img.Update()
     #writer = vtk.vtkPNGWriter()
     writer = vtk.vtkJPEGWriter()
     if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
         writer.SetInputConnection(img.GetOutputPort())
     else:
         writer.SetInput(img.GetOutput())
     
     writer.SetFileName(filename)
     writer.Write()
     del writer
     del img
Example #51
0
def PlotQualFace(mesh, qual, rng, scbar=False):
    """ Plot score """
    
    # Add score to mesh
    vtkfloat = VN.numpy_to_vtk(np.ascontiguousarray(qual), deep=True)
    vtkfloat.SetName('Score')
    mesh.GetCellData().AddArray(vtkfloat)
    mesh.GetCellData().SetActiveScalars('Score')
    
    mapper = vtk.vtkDataSetMapper()
    if vtk.vtkVersion().GetVTKMajorVersion() >5:
        mapper.SetInputData(mesh)
    else:
        mapper.SetInput(mesh)
    mapper.SetScalarRange(rng[0], rng[1])
    mapper.SetScalarModeToUseCellData()

    # Create Actor
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    
    actor.GetProperty().SetRepresentationToSurface()
        
    actor.GetProperty().EdgeVisibilityOn()
    actor.GetProperty().SetColor(1, 1, 1)
    actor.GetProperty().LightingOff()
    

    
    # Add FEM Actor to renderer window
    ren = vtk.vtkRenderer()
    ren.SetBackground(0.3, 0.3, 0.3)
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
    
    # Allow user to interact
    istyle = vtk.vtkInteractorStyleTrackballCamera()
    iren.SetInteractorStyle(istyle)
    
    # Add actor
    ren.AddActor(actor)
    
    if scbar:
        scalarBar = vtk.vtkScalarBarActor()
        scalarBar.SetLookupTable(mapper.GetLookupTable())
#        scalarBar.SetTitle('Quality')
        scalarBar.SetNumberOfLabels(5)    
        ren.AddActor(scalarBar)
    
    # Render
    iren.Initialize()
    renWin.Render()
    iren.Start()
Example #52
0
    def SetROIStencilData(self, stencil_data):
        """One of the three methods to set the ROI:
        SetROIExtent, SetROIStencilData, SetROIPolyData.
        """
        self._stencil = stencil_data

        # VTK-6
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            self._imageStats.SetStencilData(stencil_data)
        else:
            self._imageStats.SetStencil(stencil_data)
Example #53
0
def PlotCurvature(mesh, curvtype):
    """ Plots curvature of a mesh """
    
    # Curvatures Filter
    curvefilter = vtk.vtkCurvatures()
    
    curvefilter.SetInput(mesh)
    
    if curvtype == 'Mean':
        curvefilter.SetCurvatureTypeToMean()
    elif curvtype == 'Gaussian': 
        curvefilter.SetCurvatureTypeToGaussian()
    elif curvtype == 'Maximum':
        curvefilter.SetCurvatureTypeToMaximum()
    else:
        curvefilter.SetCurvatureTypeToMinimum()

    # Get curves
    curvefilter.Update()
    
    # Mapper
    mapper = vtk.vtkDataSetMapper()
    if vtk.vtkVersion().GetVTKMajorVersion() >5:
        mapper.SetInputData(curvefilter.GetOutput())
    else:
        mapper.SetInput(curvefilter.GetOutput())
    
    # Actor
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().LightingOff()    
        
    ###############################
    # Display
    ###############################
    
    # Render
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
    
    # Allow user to interact
    istyle = vtk.vtkInteractorStyleTrackballCamera()
    iren.SetInteractorStyle(istyle)
    
    ren.AddActor(actor)
        
    iren.Initialize()
    renWin.Render()
    iren.Start()
Example #54
0
    def generate_code(self):
        """Generate all the wrapper code in `self.out_dir`.
        """
        out_dir = self.out_dir
        helper_gen = self.helper_gen
        wrap_gen = self.wrap_gen
        # Create an __init__.py file
        with open(os.path.join(out_dir, '__init__.py'), 'w'):
            pass

        # Crete a vtk_version.py file that contains VTK build
        # information.
        v = vtk.vtkVersion()
        vtk_version = v.GetVTKVersion()[:3]
        vtk_src_version = v.GetVTKSourceVersion()
        code ="vtk_build_version = \'%s\'\n"%(vtk_version)
        code += "vtk_build_src_version = \'%s\'\n"%(vtk_src_version)

        with open(os.path.join(out_dir, 'vtk_version.py'), 'w') as f:
            f.write(code)

        # Write the helper code header.
        with open(os.path.join(out_dir, 'tvtk_helper.py'), 'w') as helper_file:
            helper_gen.write_prelims(helper_file)

            # Write the wrapper files.
            tree = wrap_gen.get_tree().tree

            classes = []
            for node in wrap_gen.get_tree():
                name = node.name
                if not name.startswith('vtk') or name.startswith('vtkQt'):
                    continue
                if not hasattr(vtk, name) or not hasattr(getattr(vtk, name), 'IsA'):  # noqa
                    # We need to wrap VTK classes that are derived
                    # from vtkObjectBase, the others are
                    # straightforward VTK classes that can be used as
                    # such.  All of these have an 'IsA' method so we
                    # check for that.  Only the vtkObjectBase
                    # subclasses support observers etc. and hence only
                    # those make sense to wrap into TVTK.
                    continue
                classes.append(name)

            for nodes in tree:
                for node in nodes:
                    if node.name in classes:
                        tvtk_name = get_tvtk_name(node.name)
                        logger.debug(
                            'Wrapping %s as %s' % (node.name, tvtk_name))
                        self._write_wrapper_class(node, tvtk_name)
                        helper_gen.add_class(tvtk_name, helper_file)
Example #55
0
def SubdivideMesh(mesh, nsub):
    """ Subdivides a VTK mesh """
    if nsub > 3:
        subdivide = vtk.vtkLinearSubdivisionFilter()
    else:
        subdivide = vtk.vtkLoopSubdivisionFilter() # slower, but appears to be smoother
    subdivide.SetNumberOfSubdivisions(nsub)
    if vtk.vtkVersion().GetVTKMajorVersion() > 5:
        subdivide.SetInputData(mesh)
    else:
        subdivide.SetInput(mesh)
    subdivide.Update()
    return subdivide.GetOutput()
    def SetPlanes(self, planes):

        self._Planes = planes

        for i in range(3):
            for j in range(i + 1, 3):
                cutter = vtk.vtkCutter()
                # VTK-6
                if vtk.vtkVersion().GetVTKMajorVersion() > 5:
                    cutter.SetInputData(planes[i].GetPolyData())
                else:
                    cutter.SetInput(planes[i].GetPolyData())
                cutter.SetCutFunction(planes[j].GetPlaneEquation())
                self._Cutters.append(cutter)
Example #57
0
def system_info():
  """
  Print system information and assorted library versions.
  """
  
  import platform
  import socket
  import time

  import FIAT
  import instant
  import ufc

  dolfin.info("Date / time    : %s" % time.ctime())
  dolfin.info("Machine        : %s" % socket.gethostname())
  dolfin.info("Platform       : %s" % platform.platform())
  dolfin.info("Processor      : %s" % platform.processor())
  dolfin.info("Python version : %s" % platform.python_version())
  dolfin.info("NumPy version  : %s" % numpy.__version__)
  dolfin.info("SciPy version  : %s" % scipy.__version__)
  dolfin.info("VTK version    : %s" % vtk.vtkVersion().GetVTKVersion())
  dolfin.info("DOLFIN version : %s" % dolfin.__version__)
  dolfin.info("FIAT version   : %s" % FIAT.__version__)
  try:
    import ferari
    dolfin.info("FErari version : %s" % ferari.VERSION)
  except ImportError:
    pass
  dolfin.info("FFC version    : %s" % ffc.__version__)
  dolfin.info("Instant version: %s" % instant.__version__)
  try:
    import SyFi
    dolfin.info("SyFi version   : %i.%i" % (SyFi.version_major, SyFi.version_minor))
  except ImportError:
    pass
  dolfin.info("UFC version    : %s" % ufc.__version__)
  dolfin.info("UFL version    : %s" % ufl.__version__)
  try:
    import viper
    dolfin.info("Viper version  : %s" % viper.__version__)
  except ImportError:
    pass
  petsc_ver = petsc_version()
  if petsc_ver is None:
    dolfin.info("PETSc version  : Unknown")
  else:
    dolfin.info("PETSc version  : %i.%i.%ip%i" % petsc_ver.tuple())

  return
Example #58
0
    def write(self, dirname, savedist=False):
        """Write output laterality results for one subject."""
        print "a"
        if not os.path.isdir(dirname):
            os.mkdir(dirname)
        print "b"
        # output polydata
        writer = vtk.vtkPolyDataWriter()
        if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
            writer.SetInputData(self.polydata)
        else:
            writer.SetInput(self.polydata)
        
        writer.SetFileName(os.path.join(dirname, 'tractography_with_LI.vtk'))
        writer.Write()
        print "c"
        # output LI and other data values to text file
        # first pickle everything for later python processing
        fid = open(os.path.join(dirname, 'pickle_laterality_index.txt'), 'w')
        pickle.dump(self.laterality_index, fid)
        fid.close()

        fid = open(os.path.join(dirname, 'pickle_left_hem_similarity.txt'), 'w')
        pickle.dump(self.left_hem_similarity, fid)
        fid.close()
        fid = open(os.path.join(dirname, 'pickle_right_hem_similarity.txt'), 'w')
        pickle.dump(self.right_hem_similarity, fid)
        fid.close()
        fid = open(os.path.join(dirname, 'pickle_hemisphere.txt'), 'w')
        pickle.dump(self.hemisphere, fid)
        fid.close()

        if savedist:
            fid = open(os.path.join(dirname, 'pickle_right_hem_distance.txt'), 'w')
            pickle.dump(self.right_hem_distance, fid)
            fid.close()
            fid = open(os.path.join(dirname, 'pickle_left_hem_distance.txt'), 'w')
            pickle.dump(self.left_hem_distance, fid)
            fid.close()
            print "d"
        # now output human-readable LI values
        fid = open(os.path.join(dirname, 'laterality_index_values.txt'), 'w')
        for idx in range(0, len(self.laterality_index)):
            fid.write(str(self.laterality_index[idx]))
            fid.write('\n')
        fid.close()
        print "e"
        # generate histogram (needs matplotlib)
        li_stats = self.laterality_index[numpy.nonzero(self.laterality_index)]
Example #59
0
    def SetInputData(self, data_object):

        if self._algorithm is None:
            self._algorithm = vtk.vtkTrivialProducer()
            self._algorithm.SetOutput(data_object)

        self._image_data_object = data_object

        if self.__histogram_stats is None:
            self.__histogram_stats = vtk.vtkImageHistogramStatistics()

        # VTK-6
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            self.__histogram_stats.SetInputConnection(self._algorithm)
        else:
            self.__histogram_stats.SetInput(self._image_data_object)