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)
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
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 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)
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()
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))
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)
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()
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)
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()
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
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)
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()
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())
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)
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)
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()
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
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()
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
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))
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
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
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()
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 ])
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()
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()
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
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))
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)
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)
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()
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
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)
def CheckVTKVersion(requiredMajorVersion): ''' Check the VTK version. ''' version = vtk.vtkVersion() if version.GetVTKMajorVersion() > requiredMajorVersion: raise else: return
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))
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()
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()
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)
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
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()
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)
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()
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)
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)
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
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)]
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)