def add_outline(self): outline = vtk.vtkOutlineFilter() outline.SetInputData(self.data.grid[self.current_timestep]) outline_mapper = vtk.vtkDataSetMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) self.outline_actor.SetMapper(outline_mapper) self.ren.AddActor(self.outline_actor)
def __init__(self, parent, visualizer, **kws): """ Method: __init__(parent) Initialization """ self.x, self.y, self.z = -1, -1, -1 VisualizationModule.__init__(self, parent, visualizer, **kws) #self.name = "Arbitrary Slices" self.on = 0 self.renew = 1 self.mapper = vtk.vtkPolyDataMapper() self.outline = vtk.vtkOutlineFilter() self.outlineMapper = vtk.vtkPolyDataMapper() self.outlineActor = vtk.vtkActor() self.outlineActor.SetMapper(self.outlineMapper) self.picker = vtk.vtkCellPicker() self.picker.SetTolerance(0.5) self.planes = [] self.renderer = self.parent.getRenderer() self.renderer.AddActor(self.outlineActor) self.ctf = None self.origin = None self.spacing = None self.extent = None
def SetInput(self, input) : img = image(input) self.__input__ = img if img : # Update to try to avoid to exit if a c++ exception is throwed # sadely, it will not prevent the program to exit later... # a real fix would be to wrap c++ exception in vtk img.UpdateOutputInformation() img.Update() import itk self.__flipper__ = itk.FlipImageFilter[img].New(Input=img) axes = self.__flipper__.GetFlipAxes() axes.SetElement(1, True) self.__flipper__.SetFlipAxes(axes) self.__itkvtkConverter__ = itk.ImageToVTKImageFilter[img].New(self.__flipper__) self.__volumeMapper__.SetInput(self.__itkvtkConverter__.GetOutput()) # needed to avoid warnings # self.__itkvtkConverter__.GetOutput() must be callable import vtk if not self.__outline__ : self.__outline__ = vtk.vtkOutlineFilter() self.__outline__.SetInput(self.__itkvtkConverter__.GetOutput()) self.__outlineMapper__ = vtk.vtkPolyDataMapper() self.__outlineMapper__.SetInput(self.__outline__.GetOutput()) self.__outlineActor__ = vtk.vtkActor() self.__outlineActor__.SetMapper(self.__outlineMapper__) self.__ren__.AddActor(self.__outlineActor__) else : self.__outline__.SetInput(self.__itkvtkConverter__.GetOutput()) self.Render()
def readStl(self, name): self.reader = vtk.vtkSTLReader() self.reader.SetFileName(str(name)) logger.log.info('STL file <b><font color=%s>' % (LOGCOLOR) + str(name) + '</b> loaded') self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.reader.GetOutputPort()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self.actor.GetProperty().SetColor(0, 1, 0.2) # (R,G,B) self.actor.GetProperty().SetLineWidth(2.0) # create outline mapper self.outl = vtk.vtkOutlineFilter() self.outl.SetInputConnection(self.reader.GetOutputPort()) self.outlineMapper = vtk.vtkPolyDataMapper() self.outlineMapper.SetInputConnection(self.outl.GetOutputPort()) # create outline actor self.outlineActor = vtk.vtkActor() self.outlineActor.SetMapper(self.outlineMapper) self.renderer.AddActor(self.actor) self.renderer.ResetCamera() self.setDisplay('shaded') self.setShading('gouraud') # set tab to VTK window after loading an STL file ntabs = self.parent.centralwidget.tabs.count() self.parent.centralwidget.tabs.setCurrentIndex(ntabs - 1)
def __init__(self, reader): self.reader = reader sg = self.src_glyph = vtk.vtkSphereSource() sg.SetRadius(0.5) sg.SetCenter(0.5, 0.0, 0.0) g = self.glyph = vtk.vtkTensorGlyph() g.SetInputConnection(self.reader.GetOutputPort()) g.SetSourceConnection(self.src_glyph.GetOutputPort()) g.SetScaleFactor(0.25) # The normals are needed to generate the right colors and if # not used some of the glyphs are black. self.normals = vtk.vtkPolyDataNormals() self.normals.SetInputConnection(g.GetOutputPort()) self.map = vtk.vtkPolyDataMapper() self.map.SetInputConnection(self.normals.GetOutputPort()) self.act = vtk.vtkActor() self.act.SetMapper(self.map) # An outline. self.of = vtk.vtkOutlineFilter() self.of.SetInputConnection(self.reader.GetOutputPort()) self.out_map = vtk.vtkPolyDataMapper() self.out_map.SetInputConnection(self.of.GetOutputPort()) self.out_act = vtk.vtkActor() self.out_act.SetMapper(self.out_map)
def CreateOutline(source, actor): outline = vtk.vtkOutlineFilter() outline.SetInputConnection(source.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(outline.GetOutputPort()) actor.SetMapper(mapper) return
def task1(InputData): #print(InputData.GetOutput()) # create a BoundingBox using # vtkOutlineFilter # vtkPolyDataMapper # vtkActor #BBox_poly = vtk.vtkPolyData() #BBox_poly.SetPoints(bbox_points) #outlineDimTmp=InputData.GetDimensions() # img = vtk.vtkXMLImageDataWriter() # img.SetFileName(InputData) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(InputData.GetOutputPort()) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outActor = vtk.vtkActor() outActor.SetMapper(outline_mapper) outActor.GetProperty().SetColor(0, 128, 0) outActor.GetProperty().SetLineWidth(3) #print("task1") return outActor
def __init__(self, reader): self.reader = reader sg = self.src_glyph = vtk.vtkSphereSource() sg.SetRadius(0.5) sg.SetCenter(0.5, 0.0, 0.0) g = self.glyph = vtk.vtkTensorGlyph() g.SetInputConnection(self.reader.GetOutputPort()) g.SetSource(self.src_glyph.GetOutput()) g.SetScaleFactor(0.25) # The normals are needed to generate the right colors and if # not used some of the glyphs are black. self.normals = vtk.vtkPolyDataNormals() self.normals.SetInputConnection(g.GetOutputPort()) self.map = vtk.vtkPolyDataMapper() self.map.SetInputConnection(self.normals.GetOutputPort()) self.act = vtk.vtkActor() self.act.SetMapper(self.map) # An outline. self.of = vtk.vtkOutlineFilter() self.of.SetInputConnection(self.reader.GetOutputPort()) self.out_map = vtk.vtkPolyDataMapper() self.out_map.SetInputConnection(self.of.GetOutputPort()) self.out_act = vtk.vtkActor() self.out_act.SetMapper(self.out_map)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkOutlineFilter(), 'Processing.', ('vtkDataSet',), ('vtkPolyData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def main(): colors = vtk.vtkNamedColors() aren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(aren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # # Create surfaces F(x,y,z) = constant # # Sample quadric function quadric = vtk.vtkQuadric() quadric.SetCoefficients(.5, 1, .2, 0, .1, 0, 0, .2, 0, 0) sample = vtk.vtkSampleFunction() sample.SetSampleDimensions(50, 50, 50) sample.SetImplicitFunction(quadric) contour = vtk.vtkContourFilter() contour.SetInputConnection(sample.GetOutputPort()) contour.GenerateValues(5, 0, 1.2) contourMapper = vtk.vtkPolyDataMapper() contourMapper.SetInputConnection(contour.GetOutputPort()) contourMapper.SetScalarRange(0, 1.2) contourActor = vtk.vtkActor() contourActor.SetMapper(contourMapper) # Create outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(colors.GetColor3d("Brown")) outlineActor.GetProperty().SetLineWidth(3.0) # # Rendering stuff # aren.SetBackground(colors.GetColor3d("SlateGray")) aren.AddActor(contourActor) aren.AddActor(outlineActor) aren.ResetCamera() aren.GetActiveCamera().Azimuth(30) aren.GetActiveCamera().Elevation(30) renWin.SetSize(640, 512) renWin.Render() # interact with data iren.Start()
def setup_renderer(renderer, actors, bboxpolydata=None): ren = renderer for actor in actors: # assign actor to the renderer ren.AddActor(actor) ############################################ # Create a vtkOutlineFilter to draw the bounding box of the data set. # Also create the associated mapper and actor. if bboxpolydata is not None: outline = vtk.vtkOutlineFilter() outline.SetInput(bboxpolydata.GetOutput()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(mapOutline) outlineActor.GetProperty().SetColor(100, 100, 100) ren.AddViewProp(outlineActor) ren.AddActor(outlineActor) # Create a vtkLight, and set the light parameters. #light = vtk.vtkLight() #light.SetFocalPoint(0.21406, 1.5, 0) #light.SetPosition(8.3761, 4.94858, 4.12505) #ren.AddLight(light) return ren
def DrawVoxelArray(self, arrayBuffer): #reshape resolution = self.VolumeMgr.resolution sample = arrayBuffer.reshape(1, 1, resolution, resolution, resolution) dataMatrix = self.MakeDataMatrix( np.asarray(sample, dtype=np.uint8), 255) data_string = dataMatrix.tostring() dataImporter = vtk.vtkImageImport() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataScalarTypeToUnsignedChar() dataImporter.SetNumberOfScalarComponents(1) dataImporter.SetDataExtent(0, int(dim * v_res)-1, 0, int(dim * v_res)-1, 0, int(dim * v_res)-1) dataImporter.SetWholeExtent(0, int(dim * v_res)-1, 0, int(dim * v_res)-1, 0, int(dim * v_res)-1) self.VolumeMgr.AddVolumeData(dataImporter.GetOutputPort()) #Display BoundignBox boundingBox = vtk.vtkOutlineFilter() boundingBox.SetInputData(dataImporter.GetOutput()) bbmapper = vtk.vtkPolyDataMapper() bbmapper.SetInputConnection(boundingBox.GetOutputPort()) bbActor = vtk.vtkActor() bbActor.SetMapper(bbmapper) bbActor.GetProperty().SetColor(1, 0, 0) self.renderer.AddActor(bbActor) self.Redraw()
def PlotFunction(quadric, value): colors = vtk.vtkNamedColors() # sample the quadric function sample = vtk.vtkSampleFunction() sample.SetSampleDimensions(50, 50, 50) sample.SetImplicitFunction(quadric) # double xmin = 0, xmax=1, ymin=0, ymax=1, zmin=0, zmax=1 xmin = -10 xmax = 11 ymin = -10 ymax = 10 zmin = -10 zmax = 10 sample.SetModelBounds(xmin, xmax, ymin, ymax, zmin, zmax) # create the 0 isosurface contours = vtk.vtkContourFilter() contours.SetInputConnection(sample.GetOutputPort()) contours.GenerateValues(1, value, value) # map the contours to graphical primitives contourMapper = vtk.vtkPolyDataMapper() contourMapper.SetInputConnection(contours.GetOutputPort()) contourMapper.SetScalarRange(0.0, 1.2) # create an actor for the contours contourActor = vtk.vtkActor() contourActor.SetMapper(contourMapper) # -- create a box around the function to indicate the sampling volume -- # create outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) # map it to graphics primitives outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) # create an actor for it outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(colors.GetColor3d('Black')) # setup the window ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # add the actors to the scene ren1.AddActor(contourActor) ren1.AddActor(outlineActor) ren1.SetBackground(colors.GetColor3d('AliceBlue')) # render and interact renWin.Render() iren.Start()
def build_real_bbox(self, molecule): Xmin,Xmax,Ymin, Ymax, Zmin, Zmax = molecule.GetBounds() bbox_points = vtk.vtkPoints() bbox_points.InsertNextPoint(Xmin, Ymin, Zmin) bbox_points.InsertNextPoint(Xmax , Ymax, Zmax) BBox_poly = vtk.vtkPolyData() BBox_poly.SetPoints(bbox_points) outline = vtk.vtkOutlineFilter() if vtk.vtkVersion.GetVTKMajorVersion()<6: outline.SetInput(BBox_poly) else: outline.SetInputData(BBox_poly) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outline_actor = vtk.vtkActor() outline_actor.SetMapper(outline_mapper) outline_actor.GetProperty().SetColor(1,0,0) outline_actor.GetProperty().SetLineWidth(3) self._renderer.AddActor(outline_actor) self._iren.Render()
def vtk_render_window(ren, iso, img=None, color=[0.5, 0.5, 0.5]): normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(iso.GetOutputPort()) normals.FlipNormalsOn() isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(normals.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(color) # Add the actors to the renderer, set the background and size if img != None: outline = vtk.vtkOutlineFilter() outline.SetInputConnection(img.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.VisibilityOff() ren.AddActor(outlineActor) ren.AddActor(isoActor) return ren
def build_bbox(self, basis_vector): cell = numpy.array(basis_vector).astype(numpy.float32) Xmax,Ymax,Zmax = numpy.array([cell[0,0], cell[1,1], cell[2,2]], dtype = numpy.float32) bbox_points = vtk.vtkPoints() self.cell_bounds_coords = numpy.array([-Xmax/2. , Xmax/2., -Ymax/2., Ymax/2., -Zmax/2., Zmax/2.]) bbox_points.InsertNextPoint(-Xmax/2. , -Ymax/2., -Zmax/2.) bbox_points.InsertNextPoint(Xmax/2. , Ymax/2., Zmax/2.) BBox_poly = vtk.vtkPolyData() BBox_poly.SetPoints(bbox_points) outline = vtk.vtkOutlineFilter() if vtk.vtkVersion.GetVTKMajorVersion()<6: outline.SetInput(BBox_poly) else: outline.SetInputData(BBox_poly) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outline_actor = vtk.vtkActor() outline_actor.SetMapper(outline_mapper) outline_actor.GetProperty().SetColor(1,1,1) outline_actor.GetProperty().SetLineWidth(3) return outline_actor
def __init__(self,viewer, selection_color): self.viewer = viewer self.selection_color = selection_color outline = vtk.vtkOutlineFilter() if vtk.vtkVersion.GetVTKMajorVersion()<6: outline.SetInput(self.viewer._polydata) else: outline.SetInputData(self.viewer._polydata) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) self.box=vtk.vtkActor() self.box.SetMapper( outlineMapper ) self.box.GetProperty().SetColor(1,1,1) self.box.PickableOff() self.SetProp3D(self.box) self.planes=vtk.vtkPlanes() self.SetInteractor(viewer.iren) if vtk.vtkVersion.GetVTKMajorVersion()<6: self.SetInput(self.viewer._polydata) else: self.SetInputData(self.viewer._polydata) self.SetPlaceFactor(1) self.PlaceWidget() self.InsideOutOn() self.SetRotationEnabled(0) self.GetPlanes(self.planes) self.AddObserver("EndInteractionEvent",self.on_select_atoms)
def load(self): self.reader = vtk.vtkSTLReader() self.reader.SetFileName(str(self.filename)) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.reader.GetOutputPort()) #create model actor self.actor = vtk.vtkActor() self.actor.GetProperty().SetColor(1, 1, 1) self.actor.GetProperty().SetOpacity(1) self.actor.SetMapper(self.mapper) #create outline mapper self.outline = vtk.vtkOutlineFilter() self.outline.SetInputConnection(self.reader.GetOutputPort()) self.outlineMapper = vtk.vtkPolyDataMapper() self.outlineMapper.SetInputConnection(self.outline.GetOutputPort()) #create outline actor self.outlineActor = vtk.vtkActor() self.outlineActor.SetMapper(self.outlineMapper) #add actors to parent render window self.parent.ren.AddActor(self.actor) self.parent.ren.AddActor(self.outlineActor)
def setup_renderer(renderer, actors, bboxpolydata=None): ren = renderer for actor in actors: # assign actor to the renderer ren.AddActor(actor) ############################################ # Create a vtkOutlineFilter to draw the bounding box of the data set. # Also create the associated mapper and actor. if bboxpolydata is not None: outline = vtk.vtkOutlineFilter() outline.SetInput(bboxpolydata.GetOutput()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(mapOutline) outlineActor.GetProperty().SetColor(100, 100, 100) ren.AddViewProp(outlineActor) ren.AddActor(outlineActor) # Create a vtkLight, and set the light parameters. light = vtk.vtkLight() light.SetFocalPoint(0.21406, 1.5, 0) light.SetPosition(8.3761, 4.94858, 4.12505) ren.AddLight(light) return ren
def __init__(self, parent, visualizer, **kws): """ Initialization """ self.x, self.y, self.z = -1, -1, -1 VisualizationModule.__init__(self, parent, visualizer, **kws) self.on = 0 self.renew = 1 self.mapper = vtk.vtkPolyDataMapper() self.eventDesc = "Rendering orthogonal slices" self.outline = vtk.vtkOutlineFilter() self.outlineMapper = vtk.vtkPolyDataMapper() self.outlineActor = vtk.vtkActor() self.outlineActor.SetMapper(self.outlineMapper) self.picker = vtk.vtkCellPicker() self.picker.SetTolerance(0.005) self.planeWidgetX = vtk.vtkImagePlaneWidget() self.planeWidgetX.DisplayTextOn() self.planeWidgetX.SetPicker(self.picker) self.planeWidgetX.SetKeyPressActivationValue("x") #self.planeWidgetX.UserControlledLookupTableOn() self.prop1 = self.planeWidgetX.GetPlaneProperty() #self.prop1.SetColor(1, 0, 0) self.planeWidgetX.SetResliceInterpolateToCubic() self.planeWidgetY = vtk.vtkImagePlaneWidget() self.planeWidgetY.DisplayTextOn() self.planeWidgetY.SetPicker(self.picker) self.planeWidgetY.SetKeyPressActivationValue("y") self.prop2 = self.planeWidgetY.GetPlaneProperty() self.planeWidgetY.SetResliceInterpolateToCubic() #self.planeWidgetY.UserControlledLookupTableOn() #self.prop2.SetColor(1, 1, 0) # for the z-slice, turn off texture interpolation: # interpolation is now nearest neighbour, to demonstrate # cross-hair cursor snapping to pixel centers self.planeWidgetZ = vtk.vtkImagePlaneWidget() self.planeWidgetZ.DisplayTextOn() self.planeWidgetZ.SetPicker(self.picker) self.planeWidgetZ.SetKeyPressActivationValue("z") self.prop3 = self.planeWidgetZ.GetPlaneProperty() #self.prop3.SetColor(1, 0, 1) #self.planeWidgetZ.UserControlledLookupTableOn() self.planeWidgetZ.SetResliceInterpolateToCubic() self.renderer = self.parent.getRenderer() self.renderer.AddActor(self.outlineActor) self.useOutline = 1 iactor = self.wxrenwin.GetRenderWindow().GetInteractor() self.planeWidgetX.SetInteractor(iactor) self.planeWidgetY.SetInteractor(iactor) self.planeWidgetZ.SetInteractor(iactor) lib.messenger.connect(None, "zslice_changed", self.setZ) self.filterDesc = "View orthogonal slices"
def CreateRen1(slcr, cam, viewport, background): #Create BOne contourBone = vtk.vtkContourFilter() contourBone.SetInputConnection(slcr.GetOutputPort()) contourBone.SetValue(0, 75.0) mapperBone = vtk.vtkPolyDataMapper() mapperBone.SetInputConnection(contourBone.GetOutputPort()) mapperBone.SetScalarVisibility(0) # Create Outliner outliner = vtk.vtkOutlineFilter() outliner.SetInputConnection(slcr.GetOutputPort()) outliner.Update() mapperOutliner = vtk.vtkPolyDataMapper() mapperOutliner.SetInputConnection(outliner.GetOutputPort()) contourSkin = vtk.vtkContourFilter() contourSkin.SetInputConnection(slcr.GetOutputPort()) contourSkin.SetValue(0, 50.0) # Create CutSkin plane = vtk.vtkPlane() plane.SetOrigin(0, 0, 0) plane.SetNormal(0, 0, 1) cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(contourSkin.GetOutputPort()) for i in range(100): cutter.SetValue(i, 10 * i) cutter.Update() mapperSkin = vtk.vtkPolyDataMapper() mapperSkin.SetInputConnection(cutter.GetOutputPort()) mapperSkin.SetScalarVisibility(0) # Create Actor actorBone = vtk.vtkActor() actorBone.SetMapper(mapperBone) actorSkin = vtk.vtkActor() actorSkin.SetMapper(mapperSkin) actorSkin.GetProperty().SetColor(0.74, 0.55, 0.55) actorOutliner = vtk.vtkActor() actorOutliner.SetMapper(mapperOutliner) ren = vtk.vtkRenderer() ren.AddActor(actorBone) ren.AddActor(actorSkin) ren.AddActor(actorOutliner) ren.SetViewport(viewport) ren.SetActiveCamera(cam) ren.ResetCamera() ren.SetBackground(background) return ren
def contour_G(filename): # Creating contour for G fileld data = vtk.vtkXMLImageDataReader() data.SetFileName( filename) #"/Users/y1275963/Documents/homework/multifield.0060.vti") data_g = vtk.vtkAssignAttribute() data_g.SetInputConnection(data.GetOutputPort()) data_g.Assign('G', 'SCALARS', 'POINT_DATA') outline = vtk.vtkOutlineFilter() outline.SetInputConnection(data_g.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(0, 0, 1) # Create a filter to extract an isosurface from # the dataset. Connect the input of this # filter to the output of the reader. Set the # value for the (one) isosurface that we want # to extract, and tell the filter to compute # normal vectors for each triangle on the # output isosurface. iso = vtk.vtkContourFilter() iso.SetInputConnection(data_g.GetOutputPort()) iso.ComputeNormalsOn() iso.SetNumberOfContours(1) iso.SetValue(0, 2500) #Chnge here to change the isovalue # Create a mapper to traverse the polydata and # generate graphics commands for drawing the # polygons onto the output device. mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(iso.GetOutputPort()) mapper.ScalarVisibilityOff() # Output primitives (i.e. the triangles making # up the isosurface) are managed as an actor; # we specify that all outputs are coloured # red. actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(1, 0, 0) actor.GetProperty().SetOpacity(0.5) # Create a renderer which will output the # graphics commands onto a drawing surface within # a window. By default the renderer will fill # all of the window. We set the background # colour of the window to white. return (outlineActor, actor)
def __init__(self,reader): self.outline=vtk.vtkOutlineFilter() self.outline.SetInput(reader.get_data_set()) self.outlinemapper=vtk.vtkPolyDataMapper() self.outlinemapper.SetInput(self.outline.GetOutput()) self.actor=vtk.vtkActor() self.actor.SetMapper(self.outlinemapper) self.actor.GetProperty().SetColor(0,0,0)
def outline(source): outline_filter = vtk.vtkOutlineFilter() outline_filter.SetInput(source.GetOutput()) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(outline_filter.GetOutput()) actor = vtk.vtkActor() actor.SetMapper(mapper) return actor
def __init__(self, reader): self.outline = vtk.vtkOutlineFilter() self.outline.SetInput(reader.get_data_set()) self.outlinemapper = vtk.vtkPolyDataMapper() self.outlinemapper.SetInput(self.outline.GetOutput()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.outlinemapper) self.actor.GetProperty().SetColor(0, 0, 0)
def create_box(source): outline = vtk.vtkOutlineFilter() outline.SetInputConnection(source.GetOutputPort()) mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(outline.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) return actor
def visQuadFunc(): """ vtk sample scene with iso contours """ # VTK supports implicit functions of the form f(x,y,z)=constant. These # functions can represent things spheres, cones, etc. Here we use a # general form for a quadric to create an elliptical data field. quadric = vtk.vtkQuadric() quadric.SetCoefficients(.5, 1, .2, 0, .1, 0, 0, .2, 0, 0) # vtkSampleFunction samples an implicit function over the x-y-z range # specified (here it defaults to -1,1 in the x,y,z directions). sample = vtk.vtkSampleFunction() sample.SetSampleDimensions(30, 30, 30) sample.SetImplicitFunction(quadric) # Create five surfaces F(x,y,z) = constant between range specified. The # GenerateValues() method creates n isocontour values between the range # specified. contours = vtk.vtkContourFilter() contours.SetInputConnection(sample.GetOutputPort()) contours.GenerateValues(8, 0.0, 1.2) contMapper = vtk.vtkPolyDataMapper() contMapper.SetInputConnection(contours.GetOutputPort()) contMapper.SetScalarRange(0.0, 1.2) contActor = vtk.vtkActor() contActor.SetMapper(contMapper) # We'll put a simple outline around the data. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(1, 0.5, 0) # extract data from the volume extract = vtk.vtkExtractVOI() extract.SetInputConnection(sample.GetOutputPort()) extract.SetVOI(0, 29, 0, 29, 15, 15) extract.SetSampleRate(1, 2, 3) contours2 = vtk.vtkContourFilter() contours2.SetInputConnection(extract.GetOutputPort()) contours2.GenerateValues(8, 0.0, 1.2) contMapper2 = vtk.vtkPolyDataMapper() contMapper2.SetInputConnection(contours2.GetOutputPort()) contMapper2.SetScalarRange(0.0, 1.2) contActor2 = vtk.vtkActor() contActor2.SetMapper(contMapper2) return contActor, contActor2, outlineActor, contours, contours2
def __init__(self, parent): QVTKRenderWindowInteractor.__init__(self, parent) self.renderer = vtk.vtkRenderer() self.GetRenderWindow().AddRenderer(self.renderer) interactor = vtk.vtkInteractorStyleSwitch() self._Iren.SetInteractorStyle(interactor) self.surface = None # Remainng calls set up axes. tprop = vtk.vtkTextProperty() tprop.SetColor(1,1,1) # Create a faint outline to go with the axes. self.outline = vtk.vtkOutlineFilter() # Initially set up with a box as input. This will be changed # to a plot once the user clicks something. self.box = vtk.vtkBox() self.box.SetBounds(0,10,0,10,0,10) sample = vtk.vtkSampleFunction() sample.SetImplicitFunction(self.box) sample.SetSampleDimensions(2,2,2) sample.SetModelBounds(0,10,0,10,0,5) sample.ComputeNormalsOff() self.outline.SetInputConnection(sample.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(self.outline.GetOutputPort()) self.outlineActor = vtk.vtkActor() self.outlineActor.SetMapper(mapOutline) self.outlineActor.GetProperty().SetColor(1,1,1) self.outlineActor.GetProperty().SetOpacity(.25) self.renderer.AddActor(self.outlineActor) self.axes = vtk.vtkCubeAxesActor2D() self.axes.SetCamera(self.renderer.GetActiveCamera()) self.axes.SetFlyModeToOuterEdges() self.axes.SetLabelFormat("%6.4g") self.axes.SetFontFactor(0.8) self.axes.SetAxisTitleTextProperty(tprop) self.axes.SetAxisLabelTextProperty(tprop) self.axes.SetXLabel("MPI Rank") self.axes.SetYLabel("Progress") self.axes.SetZLabel("Effort") self.axes.SetInput(sample.GetOutput()) self.renderer.AddViewProp(self.axes) # Keep original camera around in case it gets changed self.originalCamera = self.renderer.GetActiveCamera() self.renderer.GetActiveCamera().Pitch(90) # Want effort to be vertical self.renderer.GetActiveCamera().OrthogonalizeViewUp() self.renderer.ResetCamera() self.renderer.GetActiveCamera().Elevation(15) # Be slightly above the data
def setVtkWidget(vtkWidget): colors = vtk.vtkNamedColors() # Create the RenderWindow, Renderer and Interactor. # ren1 = vtk.vtkRenderer() vtkWidget.GetRenderWindow().AddRenderer(ren1) iren = vtkWidget.GetRenderWindow().GetInteractor() reader = vtk.vtkMetaImageReader() reader.SetFileName('FullHead.mha') reader.Update() locator = vtk.vtkMergePoints() locator.SetDivisions(396, 396, 24) locator.SetNumberOfPointsPerBucket(1) locator.AutomaticOff() iso = vtk.vtkMarchingCubes() iso.SetInputConnection(reader.GetOutputPort()) iso.ComputeGradientsOn() iso.ComputeScalarsOff() iso.SetValue(0, 1) iso.SetLocator(locator) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(colors.GetColor3d("Wheat")) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Add the actors to the renderer, set the background and size. # ren1.AddActor(outlineActor) ren1.AddActor(isoActor) ren1.SetBackground(colors.GetColor3d("Black")) ren1.GetActiveCamera().SetFocalPoint(0, 0, 0) ren1.GetActiveCamera().SetPosition(0, -1, 0) ren1.GetActiveCamera().SetViewUp(0, 0, -1) ren1.ResetCamera() ren1.GetActiveCamera().Dolly(1.5) ren1.ResetCameraClippingRange() iren.Initialize()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkOutlineFilter(), 'Processing.', ('vtkDataSet', ), ('vtkPolyData', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def new_outline_actor(node: vtk.vtkDataSet): outline = vtk.vtkOutlineFilter() outline.SetInputConnection(node.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(mapOutline) outlineActor.GetProperty().SetColor(0, 0, 0) return outlineActor
def main(): fileName = get_program_parameters() colors = vtk.vtkNamedColors() # Create the RenderWindow, Renderer and Interactor. # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the pipeline. # reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fileName) iso = vtk.vtkContourFilter() iso.SetInputConnection(reader.GetOutputPort()) iso.SetValue(0, 128) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(colors.GetColor3d("Banana")) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Add the actors to the renderer, set the background and size. # ren1.AddActor(outlineActor) ren1.AddActor(isoActor) ren1.SetBackground(colors.GetColor3d("SlateGray")) renWin.SetSize(640, 640) renWin.SetWindowName('IronIsoSurface') # Render the image. # ren1.ResetCamera() ren1.GetActiveCamera().Azimuth(30) ren1.GetActiveCamera().Elevation(30) renWin.Render() iren.Start()
def MakeBoundingBoxActor(polydata): bbFilter = vtk.vtkOutlineFilter() bbFilter.SetInputData(polydata) bbFilter.Update() actor = utils.MakeActor(bbFilter.GetOutput()) return actor
def createOutlineActor(image): outlineData = vtk.vtkOutlineFilter() outlineData.SetInput(image) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outlineData.GetOutputPort()) outline = vtk.vtkActor() outline.SetMapper(mapOutline) outline.GetProperty().SetColor(0, 0, 0) return outline
def getBoundingBox(vtkData): boundingBoxFilter = vtk.vtkOutlineFilter() if vtk.VTK_MAJOR_VERSION <= 5: boundingBoxFilter.SetInput(vtkData) else: boundingBoxFilter.SetInputData(vtkData) boundingBoxFilter.Update() boundingBox = boundingBoxFilter.GetOutput() return boundingBox
def isoFile(filename): reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename) reader.Update() iso = vtk.vtkMarchingCubes() iso.SetInput(reader.GetOutput()) iso.SetValue(0,0.4) # Set up mapper poly_map = vtk.vtkPolyDataMapper() poly_map.SetInput(iso.GetOutput()) # Set up actor for iso surface rendering isoActor = vtk.vtkActor() isoActor.SetMapper(poly_map) # Define outline of the isosurface outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(mapOutline) outlineActor.GetProperty().SetColor(0, 0, 0) # Set up the Back ground of iso surface ren.SetBackground(1,1,1) # Adding actors for rendering. If you want to see the outline of the isosurface then please activate outlineactor here. ren.AddActor(outlineActor) ren.AddActor(isoActor) # Selecting renderer good position and focal point. If you want you can change the camera positin for viewing your expected image. ren.GetActiveCamera().SetPosition(0, 2,20) ren.GetActiveCamera().SetFocalPoint(-15,12,90) ren.GetActiveCamera().SetViewUp(180,10 ,-90 ) ren.ResetCamera() ren.GetActiveCamera().Dolly(2.25) ren.ResetCameraClippingRange() largestreamline=vtk.vtkRenderLargeImage() largestreamline.SetInput(ren) largestreamline.SetMagnification(2) # Writing .PNG Images of the streamlines with geometry writer = vtk.vtkPNGWriter() writer.SetInputConnection(largestreamline.GetOutputPort()) writer.SetFileName("Streamline.png") writer.Modified() writer.Write()
def __init__(self, parent=None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.ren.SetBackground(0.1, 0.2, 0.4) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Create source sphere = vtk.vtkSphere() # Sample the function sample = vtk.vtkSampleFunction() sample.SetSampleDimensions(50, 50, 50) sample.SetImplicitFunction(sphere) sample.SetModelBounds(-2, 2, -2, 2, -2, 2) # Create the 0 isosurface contours = vtk.vtkContourFilter() contours.SetInputConnection(sample.GetOutputPort()) contours.GenerateValues(1, 1, 1) # Map the contours to graphical primitives contourMapper = vtk.vtkPolyDataMapper() contourMapper.SetInputConnection(contours.GetOutputPort()) contourMapper.SetScalarRange(0, 1.2) # Create an actor for the contours contourActor = vtk.vtkActor() contourActor.SetMapper(contourMapper) # -- Create a box around the function to indicated the sampling volume # Create outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) # Map it to graphics primitives outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) # Create an actor for it outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(0, 0, 0) self.ren.AddActor(contourActor) self.ren.AddActor(outlineActor) self.ren.ResetCamera() self._initialized = False
def main(): InputFilename = get_program_parameters() colors = vtk.vtkNamedColors() # vtkSLCReader to read. reader = vtk.vtkSLCReader() reader.SetFileName(InputFilename) reader.Update() # Create a mapper. mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(reader.GetOutputPort()) # Implementing Marching Cubes Algorithm to create the surface using vtkContourFilter object. contourFilter = vtk.vtkContourFilter() contourFilter.SetInputConnection(reader.GetOutputPort()) contourFilter.SetValue(0, 72.0) outliner = vtk.vtkOutlineFilter() outliner.SetInputConnection(reader.GetOutputPort()) outliner.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(contourFilter.GetOutputPort()) mapper.SetScalarVisibility(0) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a rendering window and renderer. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(500, 500) # Create a renderwindowinteractor. renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Assign actor to the renderer. renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d("lemon_chiffon")) # Pick a good view renderer.GetActiveCamera().SetPosition(-382.606608, -3.308563, 223.475751) renderer.GetActiveCamera().SetFocalPoint(77.311562, 72.821162, 100.000000) renderer.GetActiveCamera().SetViewUp(0.235483, 0.137775, 0.962063) renderer.GetActiveCamera().SetDistance(482.25171) renderer.GetActiveCamera().SetClippingRange(27.933848, 677.669341) renderWindow.Render() # Enable user interface interactor. renderWindowInteractor.Initialize() renderWindow.Render() renderWindowInteractor.Start()
def main(): # source—filter——mapper——actor——render——renderwindow——interactor aRenderer = vtk.vtkRenderer() # 渲染器 renWin = vtk.vtkRenderWindow() # 渲染窗口 renWin.AddRenderer(aRenderer) v16 = vtk.vtkNIFTIImageReader() v16.SetFileName(file) v16.TimeAsVectorOn() v16.Update() skinExtractor = vtk.vtkContourFilter() skinExtractor.SetInputConnection(v16.GetOutputPort()) skinExtractor.SetValue(0, 500) skinNormals = vtk.vtkPolyDataNormals() skinNormals.SetInputConnection(skinExtractor.GetOutputPort()) skinNormals.SetFeatureAngle(60.0) skinMapper = vtk.vtkPolyDataMapper() # 映射器 skinMapper.SetInputConnection(skinNormals.GetOutputPort()) skinMapper.ScalarVisibilityOff() skin = vtk.vtkActor() skin.SetMapper(skinMapper) outlineData = vtk.vtkOutlineFilter() outlineData.SetInputConnection(v16.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outlineData.GetOutputPort()) outline = vtk.vtkActor() outline.SetMapper(mapOutline) outline.GetProperty().SetColor(0, 0, 0) aCamera = vtk.vtkCamera() aCamera.SetViewUp(0, 0, -1) aCamera.SetPosition(0, 1, 0) aCamera.SetFocalPoint(0, 0, 0) aCamera.ComputeViewPlaneNormal() aRenderer.AddActor(outline) aRenderer.AddActor(skin) aRenderer.SetActiveCamera(aCamera) aRenderer.ResetCamera() aCamera.Dolly(1.5) aRenderer.SetBackground(1, 1, 1) renWin.SetSize(640, 480) aRenderer.ResetCameraClippingRange() iren = vtk.vtkRenderWindowInteractor() # 窗口交互 iren.SetRenderWindow(renWin) iren.Initialize() iren.Start()
def create_outline(self): outline = vtk.vtkOutlineFilter() outline.SetInputData(self.rdr.GetOutput()) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) self.outline_actor = vtk.vtkActor() self.outline_actor.SetMapper(outline_mapper) self.outline_actor.GetProperty().SetColor(1,1,1) self.outline = outline self.renderer.AddActor(self.outline_actor)
def prepareOutlineActor(self,_dim): outlineData = vtk.vtkImageData() outlineData.SetDimensions(_dim[0], _dim[1], 1) outline = vtk.vtkOutlineFilter() outline.SetInput(outlineData) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) self.outlineActor.SetMapper(outlineMapper) self.outlineActor.GetProperty().SetColor(1, 1, 1)
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 __init__ (self, mod_m): debug ("In Outline::__init__ ()") Common.state.busy () Base.Objects.Module.__init__ (self, mod_m) data_src = self.mod_m.get_data_source () self.type = data_src.get_grid_type () self.outline = vtk.vtkOutlineFilter () self.outline.SetInput (mod_m.GetOutput ()) self.mapper = self.map = vtk.vtkPolyDataMapper () self.map.SetInput (self.outline.GetOutput ()) self.actor = self.act = vtk.vtkActor () self.act.SetMapper (self.map) self.act.GetProperty ().SetColor (*Common.config.fg_color) self.renwin.add_actors (self.act) # used for the pipeline browser self.pipe_objs = self.act self.renwin.Render () Common.state.idle ()
def prepareOutlineActor(self,_imageData): # print MODULENAME, '------------ prepareOutlineActor()' outlineDimTmp=_imageData.GetDimensions() # print "\n\n\n this is outlineDimTmp=",outlineDimTmp," self.outlineDim=",self.outlineDim if self.outlineDim[0] != outlineDimTmp[0] or self.outlineDim[1] != outlineDimTmp[1] or self.outlineDim[2] != outlineDimTmp[2]: self.outlineDim=outlineDimTmp outline = vtk.vtkOutlineFilter() outline.SetInput(_imageData) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) self.outlineActor.SetMapper(outlineMapper) color = Configuration.getSetting("WindowColor") # eventually do this smarter (only get/update when it changes) self.outlineActor.GetProperty().SetColor(float(color.red())/255,float(color.green())/255,float(color.blue())/255) # self.outlineActor.GetProperty().SetColor(1, 1, 1) self.outlineDim = _imageData.GetDimensions()
def SetInput(self, input) : import itk img = itk.output(input) self.__input__ = img if img : # Update to try to avoid to exit if a c++ exception is throwed # sadely, it will not prevent the program to exit later... # a real fix would be to wrap c++ exception in vtk img.UpdateOutputInformation() img.Update() # flip the image to get the same representation than the vtk one self.__flipper__ = itk.FlipImageFilter[img].New(Input=img) axes = self.__flipper__.GetFlipAxes() axes.SetElement(1, True) self.__flipper__.SetFlipAxes(axes) # change the spacing while still keeping the ratio to workaround vtk bug # when spacing is very small spacing_ = itk.spacing(img) normSpacing = [] for i in range(0, spacing_.Size()): normSpacing.append( spacing_.GetElement(i) / spacing_.GetElement(0) ) self.__changeInfo__ = itk.ChangeInformationImageFilter[img].New(self.__flipper__, OutputSpacing=normSpacing, ChangeSpacing=True) # now really convert the data self.__itkvtkConverter__ = itk.ImageToVTKImageFilter[img].New(self.__changeInfo__) self.__volumeMapper__.SetInput(self.__itkvtkConverter__.GetOutput()) # needed to avoid warnings # self.__itkvtkConverter__.GetOutput() must be callable import vtk if not self.__outline__ : self.__outline__ = vtk.vtkOutlineFilter() self.__outline__.SetInput(self.__itkvtkConverter__.GetOutput()) self.__outlineMapper__ = vtk.vtkPolyDataMapper() self.__outlineMapper__.SetInput(self.__outline__.GetOutput()) self.__outlineActor__ = vtk.vtkActor() self.__outlineActor__.SetMapper(self.__outlineMapper__) self.__ren__.AddActor(self.__outlineActor__) else : self.__outline__.SetInput(self.__itkvtkConverter__.GetOutput()) self.Render()
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.ren.SetBackground(0.1, 0.2, 0.4) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Create source source = vtk.vtkConeSource() source.SetHeight(3.0) source.SetRadius(1.0) source.SetResolution(20) # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) # outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(source.GetOutputPort()) mapper2 = vtk.vtkPolyDataMapper() mapper2.SetInputConnection(outline.GetOutputPort()) actor2 = vtk.vtkActor() actor2.SetMapper(mapper2) self.ren.AddActor(actor2) self.ren.ResetCamera() self._initialized = False
def create_renderer(): """ vtk renderer with a sample scene """ quadric = vtk.vtkQuadric() quadric.SetCoefficients(.5, 1, .2, 0, .1, 0, 0, .2, 0, 0) sample = vtk.vtkSampleFunction() sample.SetSampleDimensions(50, 50, 50) sample.SetImplicitFunction(quadric) contours = vtk.vtkContourFilter() contours.SetInputConnection(sample.GetOutputPort()) contours.GenerateValues(5, 0.0, 1.2) contour_mapper = vtk.vtkPolyDataMapper() contour_mapper.SetInputConnection(contours.GetOutputPort()) contour_mapper.SetScalarRange(0.0, 1.2) contour_actor = vtk.vtkActor() contour_actor.SetMapper(contour_mapper) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outline_actor = vtk.vtkActor() outline_actor.SetMapper(outline_mapper) outline_actor.GetProperty().SetColor(0, 0, 0) renderer = vtk.vtkRenderer() renderer.AddActor(contour_actor) renderer.AddActor(outline_actor) renderer.SetBackground(.75, .75, .75) return renderer
def SetInput( self, Input ): import vtk if "GetOutput" in dir(Input): self.inputFilter = Input self.inputFilter.AddObserver('EndEvent', self.Update) self.input = Input.GetOutput() else: self.inputFilter = None self.input = Input self.volumeMapper.SetInput( self.input ) if not self.outline : self.outline = vtk.vtkOutlineFilter() self.outline.SetInput( self.input ) self.outlineMapper = vtk.vtkPolyDataMapper() self.outlineMapper.SetInput( self.outline.GetOutput() ) self.outlineActor = vtk.vtkActor() self.outlineActor.SetMapper( self.outlineMapper ) self.renderer.AddActor( self.outlineActor ) else : self.outline.SetInput( self.input ) self.colorAndOpacityEditor.SetInput( self.input )
def vtk_render_window(iso, img=None, color=[0.5,0.5,0.5]): normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(iso.GetOutputPort()) normals.FlipNormalsOn() isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInput(normals.GetOutput()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(color) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size if img!=None: outline = vtk.vtkOutlineFilter() outline.SetInput(img.GetOutput()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInput(outline.GetOutput()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.VisibilityOff() ren.AddActor(outlineActor) ren.AddActor(isoActor) ren.SetBackground(1.0,1.0,1.0) renWin.SetSize(450,450) ## ren.GetActiveCamera().Elevation(235) ## ren.GetActiveCamera().SetViewUp(0,.5,-1) ## ren.GetActiveCamera().Azimuth(90) iren.Initialize() return iren
def init_outline_actors(self, actor_specs, drawing_params=None): """ Initializes outline actors for hex actors :param actor_specs: {ActorSpecs} :param drawing_params: {DrawingParameters} :return: None """ actors_dict = actor_specs.actors_dict field_dim = self.currentDrawingParameters.bsd.fieldDim scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) outline_data = vtk.vtkImageData() outline_data.SetDimensions(field_dim.x + 1, field_dim.y + 1, field_dim.z + 1) outline = vtk.vtkOutlineFilter() if VTK_MAJOR_VERSION >= 6: outline.SetInputData(outline_data) else: outline.SetInput(outline_data) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outline_actor = actors_dict['outline_actor'] outline_actor.SetMapper(outline_mapper) # lattice_type_str = self.get_lattice_type_str() # if lattice_type_str.lower() == 'hexagonal': if self.is_lattice_hex(drawing_params=drawing_params): outline_actor.SetScale(self.xScaleHex, self.yScaleHex, self.zScaleHex) outline_color = to_vtk_rgb(mdata.get('BoundingBoxColor',data_type='color')) outline_actor.GetProperty().SetColor(*outline_color)
ellipNormals.SetInputConnection(ellipsoids.GetOutputPort()) # Map contour lut = vtk.vtkLogLookupTable() lut.SetHueRange(.6667,0.0) ellipMapper = vtk.vtkPolyDataMapper() ellipMapper.SetInputConnection(ellipNormals.GetOutputPort()) ellipMapper.SetLookupTable(lut) plane.Update() #force update for scalar range ellipMapper.SetScalarRange(plane.GetOutput().GetScalarRange()) ellipActor = vtk.vtkActor() ellipActor.SetMapper(ellipMapper) # # Create outline around data # outline = vtk.vtkOutlineFilter() outline.SetInputConnection(ptLoad.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(0,0,0) # # Create cone indicating application of load # coneSrc = vtk.vtkConeSource() coneSrc.SetRadius(.5) coneSrc.SetHeight(2) coneMap = vtk.vtkPolyDataMapper() coneMap.SetInputConnection(coneSrc.GetOutputPort()) coneActor = vtk.vtkActor()
skinExtractor.SetValue(0,500) skinNormals = vtk.vtkPolyDataNormals() skinNormals.SetInputConnection(skinExtractor.GetOutputPort()) skinNormals.SetFeatureAngle(60.0) skinMapper = vtk.vtkPolyDataMapper() skinMapper.SetInputConnection(skinNormals.GetOutputPort()) skinMapper.ScalarVisibilityOff() skin = vtk.vtkActor() skin.SetPosition(400, 200, 400) skin.SetOrientation(270, 0, 180) skin.SetMapper(skinMapper) skin.GetProperty().SetDiffuseColor(1, .6, .25) skin.GetProperty().SetOpacity(0.25) #Create outline to show extent of the data. outlineData = vtk.vtkOutlineFilter() outlineData.SetInputConnection(v16.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outlineData.GetOutputPort()) outline = vtk.vtkActor() outline.SetPosition(400, 200, 400) outline.SetOrientation(270, 0, 180) outline.SetMapper(mapOutline) outline.GetProperty().SetColor(0, 0, 0) #Add actors to the renderer aRenderer.AddActor(outline) aRenderer.AddActor(contour) aRenderer.AddActor(skin) # Camera (viewpoint) settings
def testImagePlaneWidget(self): "A more rigorous test using the image plane widget." # This test is largely copied from # Widgets/Python/TestImagePlaneWidget.py # Load some data. v16 = vtk.vtkVolume16Reader() v16.SetDataDimensions(64, 64) v16.SetDataByteOrderToLittleEndian() v16.SetFilePrefix(os.path.join(VTK_DATA_ROOT, "Data", "headsq", "quarter")) v16.SetImageRange(1, 93) v16.SetDataSpacing(3.2, 3.2, 1.5) v16.Update() xMin, xMax, yMin, yMax, zMin, zMax = v16.GetExecutive().GetWholeExtent(v16.GetOutputInformation(0)) img_data = v16.GetOutput() spacing = img_data.GetSpacing() sx, sy, sz = spacing origin = img_data.GetOrigin() ox, oy, oz = origin # An outline is shown for context. outline = vtk.vtkOutlineFilter() outline.SetInputData(img_data) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # The shared picker enables us to use 3 planes at one time # and gets the picking order right picker = vtk.vtkCellPicker() picker.SetTolerance(0.005) # The 3 image plane widgets are used to probe the dataset. planeWidgetX = vtk.vtkImagePlaneWidget() planeWidgetX.DisplayTextOn() planeWidgetX.SetInputData(img_data) planeWidgetX.SetPlaneOrientationToXAxes() planeWidgetX.SetSliceIndex(32) planeWidgetX.SetPicker(picker) planeWidgetX.SetKeyPressActivationValue("x") prop1 = planeWidgetX.GetPlaneProperty() prop1.SetColor(1, 0, 0) planeWidgetY = vtk.vtkImagePlaneWidget() planeWidgetY.DisplayTextOn() planeWidgetY.SetInputData(img_data) planeWidgetY.SetPlaneOrientationToYAxes() planeWidgetY.SetSliceIndex(32) planeWidgetY.SetPicker(picker) planeWidgetY.SetKeyPressActivationValue("y") prop2 = planeWidgetY.GetPlaneProperty() prop2.SetColor(1, 1, 0) planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable()) # for the z-slice, turn off texture interpolation: # interpolation is now nearest neighbour, to demonstrate # cross-hair cursor snapping to pixel centers planeWidgetZ = vtk.vtkImagePlaneWidget() planeWidgetZ.DisplayTextOn() planeWidgetZ.SetInputData(img_data) planeWidgetZ.SetPlaneOrientationToZAxes() planeWidgetZ.SetSliceIndex(46) planeWidgetZ.SetPicker(picker) planeWidgetZ.SetKeyPressActivationValue("z") prop3 = planeWidgetZ.GetPlaneProperty() prop3.SetColor(0, 0, 1) planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable()) # Now create another actor with an opacity < 1 and with some # scalars. p = vtk.vtkPolyData() pts = vtk.vtkPoints() pts.InsertNextPoint((0, 0, 0)) sc = vtk.vtkFloatArray() sc.InsertNextValue(1.0) p.SetPoints(pts) p.GetPointData().SetScalars(sc) m = vtk.vtkPolyDataMapper() m.SetInputData(p) # Share the lookup table of the widgets. m.SetLookupTable(planeWidgetX.GetLookupTable()) m.UseLookupTableScalarRangeOn() dummyActor = vtk.vtkActor() dummyActor.SetMapper(m) dummyActor.GetProperty().SetOpacity(0.0) # Create the RenderWindow and Renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetMultiSamples(0) renWin.AddRenderer(ren) # Add the dummy actor. ren.AddActor(dummyActor) # Add the outline actor to the renderer, set the background # color and size ren.AddActor(outlineActor) renWin.SetSize(600, 600) ren.SetBackground(0.1, 0.1, 0.2) current_widget = planeWidgetZ mode_widget = planeWidgetZ # Set the interactor for the widgets iact = vtk.vtkRenderWindowInteractor() iact.SetRenderWindow(renWin) planeWidgetX.SetInteractor(iact) planeWidgetX.On() planeWidgetY.SetInteractor(iact) planeWidgetY.On() planeWidgetZ.SetInteractor(iact) planeWidgetZ.On() # Create an initial interesting view ren.ResetCamera() cam1 = ren.GetActiveCamera() cam1.Elevation(110) cam1.SetViewUp(0, 0, -1) cam1.Azimuth(45) ren.ResetCameraClippingRange() iact.Initialize() renWin.Render()
def main(vector_file, magnitude_file): num_critical_points = 6 CriticalPoints = vtk.vtkPoints() CriticalPoints.InsertNextPoint(35, 14, 20) CriticalPoints.InsertNextPoint(55, 15, 20) CriticalPoints.InsertNextPoint(65, 45, 19) CriticalPoints.InsertNextPoint(45, 44.8, 20) CriticalPoints.InsertNextPoint(20, 29.7, 19.8) CriticalPoints.InsertNextPoint(10, 32.2, 16.1) ColorRange = vtk.vtkLookupTable() ColorRange.SetTableRange(0, 1) ColorRange.SetHueRange(0, 1) ColorRange.SetSaturationRange(1, 1) ColorRange.SetAlphaRange(0.3, 0.5) ColorRange.Build() reader = vtk.vtkStructuredPointsReader() reader.SetFileName(vector_file) reader.Update() mags = reader.GetOutput() range1 = mags.GetScalarRange() v0 = range1[0] v1 = range1[1] reader_magnitude = vtk.vtkStructuredPointsReader() reader_magnitude.SetFileName(magnitude_file) reader_magnitude.Update() # All entities initialized equal to number of critical points sphere1, stream1, scalarSurface1, tube1, dataMapper1, dataActor1, criticalMarker1, criticalMapper1, criticalActor1, probe1, mask1, glyph1, glyphMapper1, glyphActor1, plane1 = ( [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], ) for i in range(0, num_critical_points): sphere1.append(vtk.vtkSphereSource()) stream1.append(vtk.vtkStreamLine()) scalarSurface1.append(vtk.vtkRuledSurfaceFilter()) tube1.append(vtk.vtkTubeFilter()) dataMapper1.append(vtk.vtkPolyDataMapper()) dataActor1.append(vtk.vtkActor()) criticalMarker1.append(vtk.vtkSphereSource()) criticalMapper1.append(vtk.vtkPolyDataMapper()) criticalActor1.append(vtk.vtkActor()) probe1.append(vtk.vtkProbeFilter()) mask1.append(vtk.vtkMaskPoints()) glyph1.append(vtk.vtkGlyph3D()) glyphMapper1.append(vtk.vtkPolyDataMapper()) glyphActor1.append(vtk.vtkActor()) plane1.append(vtk.vtkPlaneSource()) integ = vtk.vtkRungeKutta4() cone = vtk.vtkConeSource() cone.SetResolution(8) cone.SetHeight(1.0) cone.SetRadius(0.2) transform = vtk.vtkTransform() transform.Translate(0, 0, 0) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetInput(cone.GetOutput()) transformFilter.SetTransform(transform) outline = vtk.vtkOutlineFilter() outline.SetInput(reader.GetOutput()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInput(outline.GetOutput()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(1, 1, 1) bar = vtk.vtkScalarBarActor() bar.SetLookupTable(ColorRange) renderer = vtk.vtkRenderer() for i in range(0, num_critical_points): sphere1[i].SetRadius(2) sphere1[i].SetCenter( CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2] ) sphere1[i].SetThetaResolution(1) stream1[i].SetInput(reader.GetOutput()) stream1[i].SetSource(sphere1[i].GetOutput()) stream1[i].SetIntegrator(integ) stream1[i].SetMaximumPropagationTime(500) stream1[i].SetIntegrationStepLength(0.1) stream1[i].SetIntegrationDirectionToIntegrateBothDirections() stream1[i].SetStepLength(0.1) scalarSurface1[i].SetInput(stream1[i].GetOutput()) scalarSurface1[i].SetOffset(0) scalarSurface1[i].SetOnRatio(2) scalarSurface1[i].PassLinesOn() scalarSurface1[i].SetRuledModeToPointWalk() scalarSurface1[i].SetDistanceFactor(50) tube1[i].SetInput(scalarSurface1[i].GetOutput()) tube1[i].SetRadius(0.1) tube1[i].SetNumberOfSides(6) dataMapper1[i].SetInput(tube1[i].GetOutput()) dataMapper1[i].SetScalarRange(v0, v1) dataMapper1[i].SetLookupTable(ColorRange) dataActor1[i].SetMapper(dataMapper1[i]) # renderer.AddActor(dataActor1[i]) criticalMarker1[i].SetRadius(1.0) criticalMarker1[i].SetCenter( CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2] ) criticalMarker1[i].SetThetaResolution(10) criticalMapper1[i].SetInput(criticalMarker1[i].GetOutput()) criticalActor1[i].SetMapper(criticalMapper1[i]) criticalActor1[i].GetProperty().SetColor(1, 1, 0) criticalActor1[i].GetProperty().SetOpacity(0.5) # renderer.AddActor(criticalActor1[i]) probe1[i].SetInput(stream1[i].GetOutput()) probe1[i].SetSource(reader.GetOutput()) mask1[i].SetInput(probe1[i].GetOutput()) mask1[i].SetOnRatio(60) mask1[i].RandomModeOn() glyph1[i].SetInput(mask1[i].GetOutput()) glyph1[i].SetSource(transformFilter.GetOutput()) glyph1[i].SetScaleModeToScaleByVector() glyph1[i].SetScaleFactor(2) glyph1[i].SetVectorModeToUseVector() glyph1[i].SetColorModeToColorByVector() glyphMapper1[i].SetInput(glyph1[i].GetOutput()) glyphMapper1[i].SetLookupTable(ColorRange) glyphActor1[i].SetMapper(glyphMapper1[i]) # renderer.AddActor(glyphActor1[i]) # removeActors1(renderer, dataActor, criticalActor, glyphActor, dataActor1, criticalActor1, glyphActor1) mags = reader.GetOutput() bounds = mags.GetBounds() x0 = bounds[0] x1 = bounds[1] y0 = bounds[2] y1 = bounds[3] z0 = bounds[4] z1 = bounds[5] range1 = mags.GetScalarRange() v0 = range1[0] v1 = range1[1] plane1[0].SetOrigin(x0, y0, z0) plane1[0].SetPoint1(x0, y1, z0) plane1[0].SetPoint2(x0, y0, z1) plane1[1].SetOrigin(x0, y0, z0) plane1[1].SetPoint1(x0, y1, z0) plane1[1].SetPoint2(x1, y0, z0) plane1[2].SetOrigin(x0, y0, z0) plane1[2].SetPoint1(x0, y0, z1) plane1[2].SetPoint2(x1, y0, z0) plane1[3].SetOrigin(x1, y1, z1) plane1[3].SetPoint1(x1, y1, z0) plane1[3].SetPoint2(x1, y0, z1) plane1[4].SetOrigin(x1, y1, z1) plane1[4].SetPoint1(x0, y1, z1) plane1[4].SetPoint2(x1, y1, z0) plane1[5].SetOrigin(x1, y1, z1) plane1[5].SetPoint1(x0, y1, z1) plane1[5].SetPoint2(x1, y1, z0) for i in range(0, num_critical_points): plane1[i].SetResolution(5, 5) stream1[i].SetSource(plane1[i].GetOutput()) renderer.AddActor(dataActor1[i]) renderer.AddActor(glyphActor1[i]) glyph1[i].SetScaleFactor(4) renderer.AddActor(bar) renderer.AddActor(outlineActor) for i in range(0, num_critical_points): renderer.AddActor(criticalActor1[i]) renderer_window = vtk.vtkRenderWindow() renderer_window.AddRenderer(renderer) renderer_window.SetSize(512, 512) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderer_window) style = vtk.vtkInteractorStyleTrackballCamera() interactor.SetInteractorStyle(style) renderer.AddActor(bar) renderer.AddActor(outlineActor) renderer_window.Render() interactor.Start()
def testimageMCAll(self): # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create pipeline # slc = vtk.vtkStructuredPointsReader() slc.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk") colors = ["flesh", "banana", "grey", "pink", "carrot", "gainsboro", "tomato", "gold", "thistle", "chocolate"] types = ["UnsignedChar", "Char", "Short", "UnsignedShort", "Int", "UnsignedInt", "Long", "UnsignedLong", "Float", "Double"] i = 1 c = 0 clip = list() cast = list() iso = list() mapper = list() actor = list() colorWrapper = self.Colors() for idx, vtkType in enumerate(types): clip.append(vtk.vtkImageClip()) clip[idx].SetInputConnection(slc.GetOutputPort()) clip[idx].SetOutputWholeExtent(-1000, 1000, -1000, 1000, i, i + 5) i += 5 cast.append(vtk.vtkImageCast()) eval('cast[idx].SetOutputScalarTypeTo' + vtkType + '()') cast[idx].SetInputConnection(clip[idx].GetOutputPort()) cast[idx].ClampOverflowOn() iso.append(vtk.vtkMarchingContourFilter()) iso[idx].SetInputConnection(cast[idx].GetOutputPort()) iso[idx].GenerateValues(1, 30, 30) mapper.append(vtk.vtkPolyDataMapper()) mapper[idx].SetInputConnection(iso[idx].GetOutputPort()) mapper[idx].ScalarVisibilityOff() actor.append(vtk.vtkActor()) actor[idx].SetMapper(mapper[idx]) # actor[idx].Actor.GetProperty().SetDiffuseColor(lindex.colors.c.lindex.colors.c+1.lindex.colors.c+1) actor[idx].GetProperty().SetDiffuseColor(colorWrapper.GetRGBColor(colors[c])) actor[idx].GetProperty().SetSpecularPower(30) actor[idx].GetProperty().SetDiffuse(.7) actor[idx].GetProperty().SetSpecular(.5) c += 1 ren.AddActor(actor[idx]) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(slc.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.VisibilityOff() # Add the actors to the renderer, set the background and size # ren.AddActor(outlineActor) ren.SetBackground(0.9, .9, .9) ren.ResetCamera() ren.GetActiveCamera().SetViewAngle(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Azimuth(20) ren.GetActiveCamera().Zoom(1.5) ren.ResetCameraClippingRange() renWin.SetSize(400, 400) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "imageMCAll.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def testBug(self): # Uncomment the next line if you want to run this via # `gdb python`. #raw_input('Hit Ctrl-C') # Load some data. v16 = vtk.vtkVolume16Reader() v16.SetDataDimensions(64, 64) v16.SetDataByteOrderToLittleEndian() v16.SetFilePrefix(os.path.join(Testing.VTK_DATA_ROOT, "Data", "headsq", "quarter")) v16.SetImageRange(1, 93) v16.SetDataSpacing(3.2, 3.2, 1.5) v16.Update() xMin, xMax, yMin, yMax, zMin, zMax = v16.GetOutput().GetWholeExtent() img_data = v16.GetOutput() # ************************************************** # Look here for wierdness. # Lets create this data using the data from the reader. my_img_data = vtk.vtkImageData() my_img_data.SetDimensions(img_data.GetDimensions()) my_img_data.SetWholeExtent(img_data.GetWholeExtent()) my_img_data.SetExtent(img_data.GetExtent()) my_img_data.SetUpdateExtent(img_data.GetUpdateExtent()) my_img_data.SetSpacing(img_data.GetSpacing()) my_img_data.SetOrigin(img_data.GetOrigin()) my_img_data.SetScalarType(img_data.GetScalarType()) my_img_data.GetPointData().SetScalars(img_data.GetPointData().GetScalars()) my_img_data.Update() # hang on to original image data. orig_img_data = img_data # hijack img_data with our own. If you comment this out everything is # fine. img_data = my_img_data # ************************************************** spacing = img_data.GetSpacing() sx, sy, sz = spacing origin = img_data.GetOrigin() ox, oy, oz = origin # An outline is shown for context. outline = vtk.vtkOutlineFilter() outline.SetInput(img_data) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # The shared picker enables us to use 3 planes at one time # and gets the picking order right picker = vtk.vtkCellPicker() picker.SetTolerance(0.005) # The 3 image plane widgets are used to probe the dataset. planeWidgetX = vtk.vtkImagePlaneWidget() planeWidgetX.DisplayTextOn() planeWidgetX.SetInput(img_data) planeWidgetX.SetPlaneOrientationToXAxes() planeWidgetX.SetSliceIndex(32) planeWidgetX.SetPicker(picker) planeWidgetX.SetKeyPressActivationValue("x") prop1 = planeWidgetX.GetPlaneProperty() prop1.SetColor(1, 0, 0) planeWidgetY = vtk.vtkImagePlaneWidget() planeWidgetY.DisplayTextOn() planeWidgetY.SetInput(img_data) planeWidgetY.SetPlaneOrientationToYAxes() planeWidgetY.SetSliceIndex(32) planeWidgetY.SetPicker(picker) planeWidgetY.SetKeyPressActivationValue("y") prop2 = planeWidgetY.GetPlaneProperty() prop2.SetColor(1, 1, 0) planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable()) # for the z-slice, turn off texture interpolation: # interpolation is now nearest neighbour, to demonstrate # cross-hair cursor snapping to pixel centers planeWidgetZ = vtk.vtkImagePlaneWidget() planeWidgetZ.DisplayTextOn() planeWidgetZ.SetInput(img_data) planeWidgetZ.SetPlaneOrientationToZAxes() planeWidgetZ.SetSliceIndex(46) planeWidgetZ.SetPicker(picker) planeWidgetZ.SetKeyPressActivationValue("z") prop3 = planeWidgetZ.GetPlaneProperty() prop3.SetColor(0, 0, 1) planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable()) # Create the RenderWindow and Renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # Add the outline actor to the renderer, set the background # color and size ren.AddActor(outlineActor) renWin.SetSize(600, 600) ren.SetBackground(0.1, 0.1, 0.2) current_widget = planeWidgetZ mode_widget = planeWidgetZ # Set the interactor for the widgets iact = vtk.vtkRenderWindowInteractor() iact.SetRenderWindow(renWin) planeWidgetX.SetInteractor(iact) planeWidgetX.On() planeWidgetY.SetInteractor(iact) planeWidgetY.On() planeWidgetZ.SetInteractor(iact) planeWidgetZ.On() # Create an initial interesting view ren.ResetCamera(); cam1 = ren.GetActiveCamera() cam1.Elevation(110) cam1.SetViewUp(0, 0, -1) cam1.Azimuth(45) ren.ResetCameraClippingRange() iact.Initialize() renWin.Render() # Compare the images and test. img_file = "TestImagePlaneWidget.png" Testing.compareImage(renWin, Testing.getAbsImagePath(img_file)) # Interact if necessary. if Testing.isInteractive(): iact.Start()