def __init__(self, sliceWidget): super(RectangleEffectTool, self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = RectangleEffectLogic(self.sliceWidget.sliceLogic()) # interaction state variables self.actionState = None self.startXYPosition = None self.currentXYPosition = None # initialization self.createGlyph() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() if vtk.VTK_MAJOR_VERSION <= 5: self.mapper.SetInput(self.polyData) else: self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1, 1, 0) property_.SetLineWidth(1) self.renderer.AddActor2D(self.actor) self.actors.append(self.actor)
def __init__(self, sliceWidget): super(LevelTracingEffectTool,self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = LevelTracingEffectLogic(self.sliceWidget.sliceLogic()) # instance variables self.actionState = '' # initialization self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = vtk.vtkPolyData() self.tracingFilter = vtkITK.vtkITKLevelTracingImageFilter() self.ijkToXY = vtk.vtkGeneralTransform() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() property_ = self.actor.GetProperty() property_.SetColor( 107/255., 190/255., 99/255. ) property_.SetLineWidth( 1 ) if vtk.VTK_MAJOR_VERSION <= 5: self.mapper.SetInput(self.polyData) else: self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1,1,0) property_.SetLineWidth(1) self.renderer.AddActor2D( self.actor ) self.actors.append( self.actor )
def __init__(self, sliceWidget): # keep a flag since events such as sliceNode modified # may come during superclass construction, which will # invoke our processEvents method self.initialized = False super(DrawEffectTool, self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = DrawEffectLogic(self.sliceWidget.sliceLogic()) # interaction state variables self.activeSlice = None self.lastInsertSLiceNodeMTime = None self.actionState = None # initialization self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = self.createPolyData() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1, 1, 0) property_.SetLineWidth(1) self.renderer.AddActor2D(self.actor) self.actors.append(self.actor) self.initialized = True
def __init__(self, sliceWidget): # keep a flag since events such as sliceNode modified # may come during superclass construction, which will # invoke our processEvents method self.initialized = False PointerEffectTool.__init__(self, sliceWidget) # interaction state variables self.activeSlice = None self.lastInsertSLiceNodeMTime = None self.actionState = None # initialization self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = self.createPolyData() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1, 1, 0) property_.SetLineWidth(1) self.renderer.AddActor2D(self.actor) self.actors.append(self.actor) self.transform = vtk.vtkThinPlateSplineTransform() self.transform.SetBasisToR() self.transform.Inverse() self.auxNodes = [] self.initialized = True
def enable(self, parent): self.parent = parent self.pts = vtk.vtkPoints() self.pts.SetNumberOfPoints(4) self.lines = vtk.vtkCellArray() self.lines.InsertNextCell(5) for i in range(4): self.lines.InsertCellPoint(i) self.lines.InsertCellPoint(0) self.pd = vtk.vtkPolyData() self.pd.SetPoints(self.pts) self.pd.SetLines(self.lines) self.bboxMapper = vtk.vtkPolyDataMapper2D() self.bboxMapper.SetInput(self.pd) self.bboxActor = vtk.vtkActor2D() self.bboxActor.SetMapper(self.bboxMapper) self.bboxActor.GetProperty().SetColor(1, 0, 0) self.parent.renderer.AddViewProp(self.bboxActor) self.pts.SetPoint(0, self.X1, self.Y1, 0) self.pts.SetPoint(1, self.X2, self.Y1, 0) self.pts.SetPoint(2, self.X2, self.Y2, 0) self.pts.SetPoint(3, self.X1, self.Y2, 0) self.bboxEnabled = False
def __init__(self, sliceWidget): super(LevelTracingEffectTool, self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = LevelTracingEffectLogic(self.sliceWidget.sliceLogic()) # instance variables self.actionState = '' # initialization self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = vtk.vtkPolyData() self.tracingFilter = vtkITK.vtkITKLevelTracingImageFilter() self.ijkToXY = vtk.vtkGeneralTransform() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() property_ = self.actor.GetProperty() property_.SetColor(107 / 255., 190 / 255., 99 / 255.) property_.SetLineWidth(1) if vtk.VTK_MAJOR_VERSION <= 5: self.mapper.SetInput(self.polyData) else: self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1, 1, 0) property_.SetLineWidth(1) self.renderer.AddActor2D(self.actor) self.actors.append(self.actor)
def _draw_line(self): line1 = vtk.vtkLineSource() line1.SetPoint1(self.points[0]) line1.SetPoint2(self.points[1]) line2 = vtk.vtkLineSource() line2.SetPoint1(self.points[1]) line2.SetPoint2(self.points[2]) arc = self.DrawArc() line = vtk.vtkAppendPolyData() line.AddInput(line1.GetOutput()) line.AddInput(line2.GetOutput()) line.AddInput(arc.GetOutput()) c = vtk.vtkCoordinate() c.SetCoordinateSystemToWorld() m = vtk.vtkPolyDataMapper2D() m.SetInputConnection(line.GetOutputPort()) m.SetTransformCoordinate(c) a = vtk.vtkActor2D() a.SetMapper(m) a.GetProperty().SetColor(self.colour) self.line_actor = a
def __init__(self, sliceWidget): super(RectangleEffectTool,self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = RectangleEffectLogic(self.sliceWidget.sliceLogic()) # interaction state variables self.actionState = None self.startXYPosition = None self.currentXYPosition = None # initialization self.createGlyph() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() if vtk.VTK_MAJOR_VERSION <= 5: self.mapper.SetInput(self.polyData) else: self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1,1,0) property_.SetLineWidth(1) self.renderer.AddActor2D( self.actor ) self.actors.append( self.actor )
def __init__(self, list): self.list = list self.points = vtk.vtkPoints() self.cells = vtk.vtkCellArray() self.cells.Initialize() self.line = vtk.vtkLine() self.update() self.polyData = vtk.vtkPolyData() self.polyData.Initialize() self.polyData.SetPoints(self.points) self.polyData.SetLines(self.cells) self.polyData.Modified() self.coordinate = vtk.vtkCoordinate() self.coordinate.SetCoordinateSystemToDisplay() self.lassoMapper = vtk.vtkPolyDataMapper2D() self.lassoMapper.SetInput(self.polyData) self.lassoMapper.SetTransformCoordinate(self.coordinate) self.lassoMapper.ScalarVisibilityOn() self.lassoMapper.SetScalarModeToUsePointData() self.lassoMapper.Update() self.actor = vtk.vtkActor2D() self.actor.SetMapper(self.lassoMapper) self.actor.GetProperty().SetLineWidth(2.0) self.actor.GetProperty().SetColor(1, 0, 0)
def __init__(self, sliceWidget): super(QuickTCGAEffectTool, self).__init__(sliceWidget) # create a logic instance to do the non-gui work #self.logic = QuickTCGAEffectLogic(self.sliceWidget.sliceLogic()) self.sliceWidget = sliceWidget self.sliceLogic = sliceWidget.sliceLogic() self.sliceView = self.sliceWidget.sliceView() self.interactor = self.sliceView.interactorStyle().GetInteractor() self.renderWindow = self.sliceWidget.sliceView().renderWindow() self.actionState = None self.startXYPosition = None self.currentXYPosition = None self.createGlyph() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1, 1, 0) property_.SetLineWidth(1) self.renderer.AddActor2D(self.actor) self.actors.append(self.actor)
def __init__(self, sliceWidget): # keep a flag since events such as sliceNode modified # may come during superclass construction, which will # invoke our processEvents method self.initialized = False super(DrawEffectTool,self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = DrawEffectLogic(self.sliceWidget.sliceLogic()) # interaction state variables self.activeSlice = None self.lastInsertSLiceNodeMTime = None self.actionState = None # initialization self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = self.createPolyData() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1,1,0) property_.SetLineWidth(1) self.renderer.AddActor2D( self.actor ) self.actors.append( self.actor ) self.initialized = True
def __init__(self, sliceWidget): super(PaintEffectTool,self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = PaintEffectLogic(self.sliceWidget.sliceLogic()) # configuration variables self.delayedPaint = True self.parameterNode = EditUtil.getParameterNode() self.sphere = not (0 == int(self.parameterNode.GetParameter("PaintEffect,sphere"))) self.smudge = not (0 == int(self.parameterNode.GetParameter("PaintEffect,smudge"))) self.pixelMode = not (0 == int(self.parameterNode.GetParameter("PaintEffect,pixelMode"))) self.radius = float(self.parameterNode.GetParameter("PaintEffect,radius")) # interaction state variables self.position = [0, 0, 0] self.paintCoordinates = [] self.feedbackActors = [] self.lastRadius = 0 # scratch variables self.rasToXY = vtk.vtkMatrix4x4() # initialization self.brush = vtk.vtkPolyData() self.createGlyph(self.brush) self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.brush) self.actor.SetMapper(self.mapper) self.actor.VisibilityOff() self.renderer.AddActor2D(self.actor) self.actors.append(self.actor) self.processEvent()
def __create_line_actor(self, line): line_mapper = vtk.vtkPolyDataMapper2D() line_mapper.SetInputConnection(line.GetOutputPort()) line_actor = vtk.vtkActor2D() line_actor.SetMapper(line_mapper) return line_actor
def __init__(self, sliceWidget): super(QuickTCGAEffectTool,self).__init__(sliceWidget) # create a logic instance to do the non-gui work #self.logic = QuickTCGAEffectLogic(self.sliceWidget.sliceLogic()) self.sliceWidget = sliceWidget self.sliceLogic = sliceWidget.sliceLogic() self.sliceView = self.sliceWidget.sliceView() self.interactor = self.sliceView.interactorStyle().GetInteractor() self.renderWindow = self.sliceWidget.sliceView().renderWindow() self.actionState = None self.startXYPosition = None self.currentXYPosition = None self.createGlyph() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1,1,0) property_.SetLineWidth(1) self.renderer.AddActor2D( self.actor ) self.actors.append( self.actor )
def addFrame(c=None, alpha=0.5, bg=None, lw=0.5): if c is None: # automatic black or white c = (0.9, 0.9, 0.9) if numpy.sum(settings.plotter_instance.renderer.GetBackground()) > 1.5: c = (0.1, 0.1, 0.1) c = colors.getColor(c) ppoints = vtk.vtkPoints() # Generate the polyline psqr = [[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]] for i, pt in enumerate(psqr): ppoints.InsertPoint(i, pt[0], pt[1], 0) lines = vtk.vtkCellArray() lines.InsertNextCell(len(psqr)) for i in range(len(psqr)): lines.InsertCellPoint(i) pd = vtk.vtkPolyData() pd.SetPoints(ppoints) pd.SetLines(lines) mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputData(pd) cs = vtk.vtkCoordinate() cs.SetCoordinateSystemToNormalizedViewport() mapper.SetTransformCoordinate(cs) fractor = vtk.vtkActor2D() fractor.GetPositionCoordinate().SetValue(0, 0) fractor.GetPosition2Coordinate().SetValue(1, 1) fractor.SetMapper(mapper) fractor.GetProperty().SetColor(c) fractor.GetProperty().SetOpacity(alpha) fractor.GetProperty().SetLineWidth(lw) settings.plotter_instance.renderer.AddActor(fractor)
def add_legend_actors(self): # TODO: Potentially change scale to use hardcoded values (e.g., 5, 10, 50, 100, 500, 1000....) and pick 4 evenly spaced values from this list (all parts of this list smaller than the max_cases) for i in range(4): cases = math.pow(2, (math.log2(self.max_cases) / (i+1))) radius = (math.log2(cases)/math.log2(self.max_cases)) * self.max_radius legend_polygon_source = vtk.vtkRegularPolygonSource() legend_polygon_source.SetNumberOfSides(50) legend_polygon_source.SetRadius(radius) legend_polygon_source.SetCenter(0, 0, 0) circle_mapper = vtk.vtkPolyDataMapper2D() circle_mapper.SetInputConnection(legend_polygon_source.GetOutputPort()) circle_actor = vtk.vtkActor2D() circle_actor.SetMapper(circle_mapper) circle_actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport() circle_actor.GetPositionCoordinate().SetValue(.05, .1 + .075 * i) text_actor = vtk.vtkTextActor() text_actor.SetInput(str(int(cases)) + " cases") text_actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport() text_actor.GetPositionCoordinate().SetValue(.075, .1 + .075 * i) text_actor.GetTextProperty().SetFontSize(25) self.ren.AddActor(circle_actor) self.legend_circle_actors.append(circle_actor) self.ren.AddActor(text_actor) self.legend_text_actors.append(text_actor)
def add_border(self, color=[1, 1, 1], width=2.0): points = np.array([[1., 1., 0.], [0., 1., 0.], [0., 0., 0.], [1., 0., 0.]]) lines = np.array([[2, 0, 1], [2, 1, 2], [2, 2, 3], [2, 3, 0]]).ravel() poly = vtki.PolyData() poly.points = points poly.lines = lines coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToNormalizedViewport() mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputData(poly); mapper.SetTransformCoordinate(coordinate); actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.GetProperty().SetColor(parse_color(color)) actor.GetProperty().SetLineWidth(width) self.add_actor(actor)
def add_border(self, color=[1, 1, 1], width=2.0): """Add borders around the frame.""" points = np.array([[1., 1., 0.], [0., 1., 0.], [0., 0., 0.], [1., 0., 0.]]) lines = np.array([[2, 0, 1], [2, 1, 2], [2, 2, 3], [2, 3, 0]]).ravel() poly = pyvista.PolyData() poly.points = points poly.lines = lines coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToNormalizedViewport() mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputData(poly) mapper.SetTransformCoordinate(coordinate) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.GetProperty().SetColor(parse_color(color)) actor.GetProperty().SetLineWidth(width) self.AddViewProp(actor) self.Modified() return actor
def __create_line_actor(self, line): line_mapper = vtk.vtkPolyDataMapper2D() line_mapper.SetInput(line.GetOutput()) line_actor = vtk.vtkActor2D() line_actor.SetMapper(line_mapper) return line_actor
def CreateViewportBox(colorfg,linewidth=3) : pts = vtk.vtkPoints() pts.SetNumberOfPoints(4) pts.SetPoint(0, 0.0, 0.0, 0.0) pts.SetPoint(1, 0.0, 1.0, 0.0) pts.SetPoint(2, 1.0, 1.0, 0.0) pts.SetPoint(3, 1.0, 0.0, 0.0) lines = vtk.vtkCellArray() lines.InsertNextCell(5) lines.InsertCellPoint(0) lines.InsertCellPoint(1) lines.InsertCellPoint(2) lines.InsertCellPoint(3) lines.InsertCellPoint(0) box = vtk.vtkPolyData() box.SetPoints(pts) box.SetLines(lines) coords = vtk.vtkCoordinate() coords.SetCoordinateSystemToNormalizedViewport() boxmapper = vtk.vtkPolyDataMapper2D() boxmapper.SetInputData(box) boxmapper.SetTransformCoordinate(coords) boxactor = vtk.vtkActor2D() boxactor.SetMapper(boxmapper) boxactor.GetProperty().SetLineWidth(linewidth) boxactor.GetProperty().SetColor(colorfg) return boxactor
def main(): img_reader = ImageReaderFactory().GenerateImageReader( "./data/0000000000.png") img_actor = ImageActor(img_reader.GetOutputPort()) contour_widget = vtk.vtkContourWidget() contourRepresentation = vtk.vtkOrientedGlyphContourRepresentation() contourRepresentation.GetLinesProperty().SetColor(1, 1, 0) contour_widget.SetRepresentation(contourRepresentation) contour_widget.GetContourRepresentation().SetLineInterpolator( vtk.vtkLinearContourLineInterpolator()) numPts = 10 points = vtk.vtkPoints() for i in range(numPts): angle = 2.0 * vtk.vtkMath.Pi() * i / numPts points.InsertNextPoint( [0.1 * math.cos(angle), 0.1 * math.sin(angle), -1.0]) vertexIndices = vtk.vtkIdList() for i in range(numPts): vertexIndices.InsertNextId(i) # vertexIndices.InsertNextId(0) lines = vtk.vtkCellArray() lines.InsertNextCell(vertexIndices) polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.SetLines(lines) mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputData(polydata) actor = vtk.vtkActor2D() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderer.SetBackground(0.1, 0.2, 0.4) renderer.AddActor(img_actor.actor) renderer.AddActor(actor) renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) style = vtk.vtkInteractorStyleJoystickCamera() interactor.SetInteractorStyle(style) contour_widget.SetInteractor(interactor) contour_widget.On() contour_widget.Initialize(polydata) renderer.ResetCamera() interactor.Start()
def CreateViewportBox(colorfg, linewidth=3): pts = vtk.vtkPoints() pts.SetNumberOfPoints(4) pts.SetPoint(0, 0.0, 0.0, 0.0) pts.SetPoint(1, 0.0, 1.0, 0.0) pts.SetPoint(2, 1.0, 1.0, 0.0) pts.SetPoint(3, 1.0, 0.0, 0.0) lines = vtk.vtkCellArray() lines.InsertNextCell(5) lines.InsertCellPoint(0) lines.InsertCellPoint(1) lines.InsertCellPoint(2) lines.InsertCellPoint(3) lines.InsertCellPoint(0) box = vtk.vtkPolyData() box.SetPoints(pts) box.SetLines(lines) coords = vtk.vtkCoordinate() coords.SetCoordinateSystemToNormalizedViewport() boxmapper = vtk.vtkPolyDataMapper2D() boxmapper.SetInputData(box) boxmapper.SetTransformCoordinate(coords) boxactor = vtk.vtkActor2D() boxactor.SetMapper(boxmapper) boxactor.GetProperty().SetLineWidth(linewidth) boxactor.GetProperty().SetColor(colorfg) return boxactor
def _draw_line(self): line1 = vtk.vtkLineSource() line1.SetPoint1(self.points[0]) line1.SetPoint2(self.points[1]) line2 = vtk.vtkLineSource() line2.SetPoint1(self.points[1]) line2.SetPoint2(self.points[2]) arc = self.DrawArc() line = vtk.vtkAppendPolyData() line.AddInputConnection(line1.GetOutputPort()) line.AddInputConnection(line2.GetOutputPort()) line.AddInputConnection(arc.GetOutputPort()) c = vtk.vtkCoordinate() c.SetCoordinateSystemToWorld() m = vtk.vtkPolyDataMapper2D() m.SetInputConnection(line.GetOutputPort()) m.SetTransformCoordinate(c) a = vtk.vtkActor2D() a.SetMapper(m) a.GetProperty().SetColor(self.colour) self.line_actor = a
def __init__(self): self.poly_list = [] self.actor_list = [] # Create shapes and actors boxUp = vtk.vtkRegularPolygonSource() boxUp.GeneratePolygonOn() boxUp.GeneratePolylineOff() boxUp.SetNumberOfSides(3) boxUp.SetCenter(0,14,0) boxUp.SetRadius(11) self.poly_list.append(boxUp) boxL = vtk.vtkRegularPolygonSource() boxL.GeneratePolygonOn() boxL.GeneratePolylineOff() boxL.SetNumberOfSides(4) boxL.SetCenter(-15,-2,0) boxL.SetRadius(9) self.poly_list.append(boxL) boxR = vtk.vtkRegularPolygonSource() boxR.GeneratePolygonOn() boxR.GeneratePolylineOff() boxR.SetNumberOfSides(4) boxR.SetCenter(15,-2,0) boxR.SetRadius(9) self.poly_list.append(boxR) boxLDown = vtk.vtkRegularPolygonSource() boxLDown.GeneratePolygonOn() boxLDown.GeneratePolylineOff() boxLDown.SetNumberOfSides(6) boxLDown.SetCenter(-12,-22,0) boxLDown.SetRadius(9) self.poly_list.append(boxLDown) boxRDown = vtk.vtkRegularPolygonSource() boxRDown.GeneratePolygonOn() boxRDown.GeneratePolylineOff() boxRDown.SetNumberOfSides(6) boxRDown.SetCenter(12,-22,0) boxRDown.SetRadius(9) self.poly_list.append(boxRDown) for ii, poly in enumerate(self.poly_list): map = vtk.vtkPolyDataMapper2D() map.SetInputConnection(poly.GetOutputPort(0)) act = vtk.vtkActor2D() act.SetMapper(map) act.SetPickable(True) # act.GetProperty().SetColor(0.5, 0.45, 0.35) act.GetProperty().SetColor(0.4, 0.4, 0.4) act.GetProperty().SetLineWidth(0.0) act.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() act.GetPositionCoordinate().SetValue(0.075 ,0.15) act.GetPosition2Coordinate().SetCoordinateSystemToNormalizedDisplay() act.GetPosition2Coordinate().SetValue(0.5, 0.5) self.actor_list.append(act)
def render_image(png_reader): square = 8 color_map = vtk.vtkLookupTable() color_map.SetNumberOfColors(16) color_map.SetHueRange(0, 0.667) magnitude = vtk.vtkImageMagnitude() magnitude.SetInput(png_reader.GetOutput()) geometry = vtk.vtkImageDataGeometryFilter() geometry.SetInput(magnitude.GetOutput()) warp = vtk.vtkWarpScalar() warp.SetInput(geometry.GetOutput()) warp.SetScaleFactor(0.25) merge = vtk.vtkMergeFilter() merge.SetGeometry(warp.GetOutput()) merge.SetScalars(png_reader.GetOutput()) elevation_mtHood = vtk.vtkElevationFilter() elevation_mtHood.SetInput(merge.GetOutput()) elevation_mtHood.SetLowPoint(0, 0, 0) elevation_mtHood.SetHighPoint(0, 0, 50) mapper_3D_mtHood = vtk.vtkDataSetMapper() mapper_3D_mtHood.SetInput(elevation_mtHood.GetOutput()) mapper_3D_mtHood.SetLookupTable(color_map) mapper_2D_mtHood = vtk.vtkPolyDataMapper2D() mapper_2D_mtHood.SetInput(elevation_mtHood.GetOutput()) mapper_2D_mtHood.SetLookupTable(color_map) actor_2D_mtHood = vtk.vtkActor2D() actor_2D_mtHood.SetMapper(mapper_2D_mtHood) actor_2D_mtHood.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() actor_2D_mtHood.GetPositionCoordinate().SetValue(0.25,0.25) actor_3D_mtHood = vtk.vtkActor() actor_3D_mtHood.SetMapper(mapper_3D_mtHood) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor_3D_mtHood) renderer.SetBackground(.5, .5, .5) renderWindow.SetSize(600, 600) renderWindow.Render() renderWindowInteractor.Start()
def ViewportBorder(renderer, color, last): # points start at upper right and proceed anti-clockwise points = vtk.vtkPoints() points.SetNumberOfPoints(4) points.InsertPoint(0, 1, 1, 0) points.InsertPoint(1, 0, 1, 0) points.InsertPoint(2, 0, 0, 0) points.InsertPoint(3, 1, 0, 0) # create cells, and lines cells = vtk.vtkCellArray() cells.Initialize() lines = vtk.vtkPolyLine() # only draw last line if this is the last viewport # this prevents double vertical lines at right border # if different colors are used for each border, then do # not specify last if (last): lines.GetPointIds().SetNumberOfIds(5) else: lines.GetPointIds().SetNumberOfIds(4) for i in range(0, 4): lines.GetPointIds().SetId(i, i) if (last): lines.GetPointIds().SetId(4, 0) cells.InsertNextCell(lines) # now make tge polydata and display it poly = vtk.vtkPolyData() poly.Initialize() poly.SetPoints(points) poly.SetLines(cells) # use normalized viewport coordinates since # they are independent of window size coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToNormalizedViewport() mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputData(poly) mapper.SetTransformCoordinate(coordinate) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.GetProperty().SetColor(color) actor.GetProperty().SetLineWidth(2.0) renderer.AddViewProp(actor)
def GetRepresentation(self, x, y, z): pc = self.camera.GetPosition() # camera position pf = self.camera.GetFocalPoint() # focal position pp = (x, y, z) # point where the user clicked # Vector from camera position to user clicked point vcp = [j-i for i,j in zip(pc, pp)] # Vector from camera position to camera focal point vcf = [j-i for i,j in zip(pc, pf)] # the vector where the perpendicular vector will be given n = [0,0,0] # The cross, or vectorial product, give a vector perpendicular to vcp # and vcf, in this case this vector will be in horizontal, this vector # will be stored in the variable "n" vtk.vtkMath.Cross(vcp, vcf, n) # then normalize n to only indicate the direction of this vector vtk.vtkMath.Normalize(n) # then p1 = [i*self.size + j for i,j in zip(n, pp)] p2 = [i*-self.size + j for i,j in zip(n, pp)] sh = vtk.vtkLineSource() sh.SetPoint1(p1) sh.SetPoint2(p2) n = [0,0,0] vcn = [j-i for i,j in zip(p1, pc)] vtk.vtkMath.Cross(vcp, vcn, n) vtk.vtkMath.Normalize(n) p3 = [i*self.size + j for i,j in zip(n, pp)] p4 = [i*-self.size +j for i,j in zip(n, pp)] sv = vtk.vtkLineSource() sv.SetPoint1(p3) sv.SetPoint2(p4) cruz = vtk.vtkAppendPolyData() cruz.AddInput(sv.GetOutput()) cruz.AddInput(sh.GetOutput()) c = vtk.vtkCoordinate() c.SetCoordinateSystemToWorld() m = vtk.vtkPolyDataMapper2D() m.SetInputConnection(cruz.GetOutputPort()) m.SetTransformCoordinate(c) a = vtk.vtkActor2D() a.SetMapper(m) a.GetProperty().SetColor(self.colour) return a
def GetRepresentation(self, x, y, z): pc = self.camera.GetPosition() # camera position pf = self.camera.GetFocalPoint() # focal position pp = (x, y, z) # point where the user clicked # Vector from camera position to user clicked point vcp = [j - i for i, j in zip(pc, pp)] # Vector from camera position to camera focal point vcf = [j - i for i, j in zip(pc, pf)] # the vector where the perpendicular vector will be given n = [0, 0, 0] # The cross, or vectorial product, give a vector perpendicular to vcp # and vcf, in this case this vector will be in horizontal, this vector # will be stored in the variable "n" vtk.vtkMath.Cross(vcp, vcf, n) # then normalize n to only indicate the direction of this vector vtk.vtkMath.Normalize(n) # then p1 = [i * self.size + j for i, j in zip(n, pp)] p2 = [i * -self.size + j for i, j in zip(n, pp)] sh = vtk.vtkLineSource() sh.SetPoint1(p1) sh.SetPoint2(p2) n = [0, 0, 0] vcn = [j - i for i, j in zip(p1, pc)] vtk.vtkMath.Cross(vcp, vcn, n) vtk.vtkMath.Normalize(n) p3 = [i * self.size + j for i, j in zip(n, pp)] p4 = [i * -self.size + j for i, j in zip(n, pp)] sv = vtk.vtkLineSource() sv.SetPoint1(p3) sv.SetPoint2(p4) cruz = vtk.vtkAppendPolyData() cruz.AddInputData(sv.GetOutput()) cruz.AddInputData(sh.GetOutput()) c = vtk.vtkCoordinate() c.SetCoordinateSystemToWorld() m = vtk.vtkPolyDataMapper2D() m.SetInputConnection(cruz.GetOutputPort()) m.SetTransformCoordinate(c) a = vtk.vtkActor2D() a.SetMapper(m) a.GetProperty().SetColor(self.colour) return a
def _setup(self): """Setup this UI Component. Return an image as a 2D actor with a specific position. Returns ------- :class:`vtkTexturedActor2D` """ self.texture_polydata = vtk.vtkPolyData() self.texture_points = vtk.vtkPoints() self.texture_points.SetNumberOfPoints(4) polys = vtk.vtkCellArray() polys.InsertNextCell(4) polys.InsertCellPoint(0) polys.InsertCellPoint(1) polys.InsertCellPoint(2) polys.InsertCellPoint(3) self.texture_polydata.SetPolys(polys) tc = vtk.vtkFloatArray() tc.SetNumberOfComponents(2) tc.SetNumberOfTuples(4) tc.InsertComponent(0, 0, 0.0) tc.InsertComponent(0, 1, 0.0) tc.InsertComponent(1, 0, 1.0) tc.InsertComponent(1, 1, 0.0) tc.InsertComponent(2, 0, 1.0) tc.InsertComponent(2, 1, 1.0) tc.InsertComponent(3, 0, 0.0) tc.InsertComponent(3, 1, 1.0) self.texture_polydata.GetPointData().SetTCoords(tc) texture_mapper = vtk.vtkPolyDataMapper2D() texture_mapper = set_input(texture_mapper, self.texture_polydata) image = vtk.vtkTexturedActor2D() image.SetMapper(texture_mapper) self.texture = vtk.vtkTexture() image.SetTexture(self.texture) image_property = vtk.vtkProperty2D() image_property.SetOpacity(1.0) image.SetProperty(image_property) self.actor = image # Add default events listener to the VTK actor. self.handle_events(self.actor)
def _setup(self): """Set up this UI component. Creating the button actor used internally. """ # This is highly inspired by # https://github.com/Kitware/VTK/blob/c3ec2495b183e3327820e927af7f8f90d34c3474/Interaction/Widgets/vtkBalloonRepresentation.cxx#L47 self.texture_polydata = vtk.vtkPolyData() self.texture_points = vtk.vtkPoints() self.texture_points.SetNumberOfPoints(4) polys = vtk.vtkCellArray() polys.InsertNextCell(4) polys.InsertCellPoint(0) polys.InsertCellPoint(1) polys.InsertCellPoint(2) polys.InsertCellPoint(3) self.texture_polydata.SetPolys(polys) tc = vtk.vtkFloatArray() tc.SetNumberOfComponents(2) tc.SetNumberOfTuples(4) tc.InsertComponent(0, 0, 0.0) tc.InsertComponent(0, 1, 0.0) tc.InsertComponent(1, 0, 1.0) tc.InsertComponent(1, 1, 0.0) tc.InsertComponent(2, 0, 1.0) tc.InsertComponent(2, 1, 1.0) tc.InsertComponent(3, 0, 0.0) tc.InsertComponent(3, 1, 1.0) self.texture_polydata.GetPointData().SetTCoords(tc) texture_mapper = vtk.vtkPolyDataMapper2D() texture_mapper = set_input(texture_mapper, self.texture_polydata) button = vtk.vtkTexturedActor2D() button.SetMapper(texture_mapper) self.texture = vtk.vtkTexture() button.SetTexture(self.texture) button_property = vtk.vtkProperty2D() button_property.SetOpacity(1.0) button.SetProperty(button_property) self.actor = button # Add default events listener to the VTK actor. self.handle_events(self.actor)
def CreateAxisTickActor(xstart,ystart,xend,yend,colorfg) : line=vtk.vtkLineSource() line.SetPoint1(xstart,ystart,0.0) line.SetPoint2(xend,yend,0.0) coords = vtk.vtkCoordinate() coords.SetCoordinateSystemToNormalizedViewport() linemapper = vtk.vtkPolyDataMapper2D() linemapper.SetInputConnection(line.GetOutputPort()) linemapper.SetTransformCoordinate(coords) tick = vtk.vtkActor2D() tick.SetMapper(linemapper) tick.GetProperty().SetLineWidth(1) tick.GetProperty().SetColor(colorfg) tick.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport() return tick
def CreateAxisTickActor(xstart, ystart, xend, yend, colorfg): line = vtk.vtkLineSource() line.SetPoint1(xstart, ystart, 0.0) line.SetPoint2(xend, yend, 0.0) coords = vtk.vtkCoordinate() coords.SetCoordinateSystemToNormalizedViewport() linemapper = vtk.vtkPolyDataMapper2D() linemapper.SetInputConnection(line.GetOutputPort()) linemapper.SetTransformCoordinate(coords) tick = vtk.vtkActor2D() tick.SetMapper(linemapper) tick.GetProperty().SetLineWidth(1) tick.GetProperty().SetColor(colorfg) tick.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport() return tick
def main(): colors = vtk.vtkNamedColors() points = vtk.vtkPoints() points.InsertNextPoint(10, 10, 0) points.InsertNextPoint(100, 100, 0) points.InsertNextPoint(200, 200, 0) polydata = vtk.vtkPolyData() polydata.SetPoints(points) glyphFilter = vtk.vtkVertexGlyphFilter() glyphFilter.SetInputData(polydata) glyphFilter.Update() mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputConnection(glyphFilter.GetOutputPort()) mapper.Update() actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d('Gold')) actor.GetProperty().SetPointSize(8) # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actor to the scene renderer.AddActor(actor) renderWindow.SetSize(300, 300) renderer.SetBackground(colors.GetColor3d('DarkSlateGray')) renderWindow.SetWindowName('Actor2D') # Render and interact renderWindow.Render() # w2if = vtk.vtkWindowToImageFilter() # w2if.SetInput(renderWindow) # w2if.Update() # # writer = vtk.vtkPNGWriter() # writer.SetFileName('TestActor2D.png') # writer.SetInputConnection(w2if.GetOutputPort()) # writer.Write() renderWindowInteractor.Start()
def render_image(pointset): ''' square = 10 color_map = vtk.vtkLookupTable() color_map.SetNumberOfColors(square * square) color_map.SetTableRange(0, square * square - 1) for ii in range(0, square): for jj in range(0, square): color_map.SetTableValue(ii, jj / square, jj / square, ii /square) ''' color_map = vtk.vtkLookupTable() color_map.SetNumberOfColors(16) color_map.SetHueRange(0, 0.667) delaunay = vtk.vtkDelaunay2D() delaunay.SetTolerance(0.001) delaunay.SetAlpha(18) delaunay.SetInput(pointset); delaunay.Update(); elevation_thorax = vtk.vtkElevationFilter() elevation_thorax.SetInput(delaunay.GetOutput()) elevation_thorax.SetLowPoint(0, 0, -25) elevation_thorax.SetHighPoint(0, 0, 25) meshMapper = vtk.vtkPolyDataMapper2D() meshMapper.SetInput(elevation_thorax.GetOutput()) meshMapper.SetLookupTable(color_map) #meshMapper.SetScalarRange(0,255) meshActor = vtk.vtkActor2D() meshActor.SetMapper(meshMapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(meshActor) #renderer.AddActor(boundaryActor) renderer.SetBackground(.5, .5, .5) renderWindow.SetSize(600, 600) renderWindow.Render() renderWindowInteractor.Start()
def SetOrientation(self, roll, pitch, yaw): t = vtk.vtkTransform() t.RotateZ(roll) tf = vtk.vtkTransformPolyDataFilter() tf.SetInput(self.data) tf.SetTransform(t) tf.Update() coordView = vtk.vtkCoordinate() coordView.SetReferenceCoordinate(self.pos) coordView.SetCoordinateSystemToViewport() mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputConnection(tf.GetOutputPort()) mapper.SetTransformCoordinate(coordView) self.SetMapper(mapper)
def __init__(self, point_1, point_2, color=(0,0,0), width=1, renderer=None): self.line = vtk.vtkLineSource() mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputConnection(self.line.GetOutputPort()) self.actor = vtk.vtkActor2D() self.actor.SetMapper(mapper) self._renderer = None # Default to hidden self.hide() # Actor and everything need to be set up before magic properties work self.point_1 = point_1 self.point_2 = point_2 self.color = color self.width = width self.renderer = renderer
def render_image(pointset): ''' square = 10 color_map = vtk.vtkLookupTable() color_map.SetNumberOfColors(square * square) color_map.SetTableRange(0, square * square - 1) for ii in range(0, square): for jj in range(0, square): color_map.SetTableValue(ii, jj / square, jj / square, ii /square) ''' color_map = vtk.vtkLookupTable() color_map.SetNumberOfColors(16) color_map.SetHueRange(0, 0.667) delaunay = vtk.vtkDelaunay2D() delaunay.SetTolerance(0.001) delaunay.SetAlpha(18) delaunay.SetInput(pointset) delaunay.Update() elevation_thorax = vtk.vtkElevationFilter() elevation_thorax.SetInput(delaunay.GetOutput()) elevation_thorax.SetLowPoint(0, 0, -25) elevation_thorax.SetHighPoint(0, 0, 25) meshMapper = vtk.vtkPolyDataMapper2D() meshMapper.SetInput(elevation_thorax.GetOutput()) meshMapper.SetLookupTable(color_map) #meshMapper.SetScalarRange(0,255) meshActor = vtk.vtkActor2D() meshActor.SetMapper(meshMapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(meshActor) #renderer.AddActor(boundaryActor) renderer.SetBackground(.5, .5, .5) renderWindow.SetSize(600, 600) renderWindow.Render() renderWindowInteractor.Start()
def _draw_text(self): text = u' %.2f ' % \ self.CalculateAngle() x,y,z= self.points[1] textsource = vtk.vtkTextSource() textsource.SetText(text) textsource.SetBackgroundColor((250/255.0, 247/255.0, 218/255.0)) textsource.SetForegroundColor(self.colour) m = vtk.vtkPolyDataMapper2D() m.SetInputConnection(textsource.GetOutputPort()) a = vtk.vtkActor2D() a.SetMapper(m) a.DragableOn() a.GetPositionCoordinate().SetCoordinateSystemToWorld() a.GetPositionCoordinate().SetValue(x,y,z) self.text_actor = a
def resize(self, size): """Set the button size. Parameters ---------- size : (float, float) Button size (width, height) in pixels. """ self._points.SetPoint(0, 0, 0, 0.0) self._points.SetPoint(1, size[0], 0, 0.0) self._points.SetPoint(2, size[0], size[1], 0.0) self._points.SetPoint(3, 0, size[1], 0.0) self._polygonPolyData.SetPoints(self._points) mapper = vtk.vtkPolyDataMapper2D() mapper = set_input(mapper, self._polygonPolyData) self.actor.SetMapper(mapper)
def _draw_text(self): text = u' %.3f ' % \ self.CalculateAngle() x, y, z = self.points[1] textsource = vtk.vtkTextSource() textsource.SetText(text) textsource.SetBackgroundColor((250 / 255.0, 247 / 255.0, 218 / 255.0)) textsource.SetForegroundColor(self.colour) m = vtk.vtkPolyDataMapper2D() m.SetInputConnection(textsource.GetOutputPort()) a = vtk.vtkActor2D() a.SetMapper(m) a.DragableOn() a.GetPositionCoordinate().SetCoordinateSystemToWorld() a.GetPositionCoordinate().SetValue(x, y, z) self.text_actor = a
def __init__(self, scriptedEffect, sliceWidget): self.scriptedEffect = scriptedEffect self.sliceWidget = sliceWidget self.activeSlice = None self.lastInsertSliceNodeMTime = None self.actionState = None self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = self.createPolyData() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) actorProperty = self.actor.GetProperty() actorProperty.SetColor(1,1,0) actorProperty.SetLineWidth(1)
def __init__(self, scriptedEffect, sliceWidget): self.scriptedEffect = scriptedEffect self.sliceWidget = sliceWidget self.activeSlice = None self.lastInsertSliceNodeMTime = None self.actionState = None self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = self.createPolyData() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) actorProperty = self.actor.GetProperty() actorProperty.SetColor(1, 1, 0) actorProperty.SetLineWidth(1)
def drawLine(self, points): try: self.viewer.GetRenderer().RemoveActor(self.actor) self.viewer.GetRenderer().Render() except: pass point1 = points[0] point2 = points[1] points = vtk.vtkPoints() points.SetNumberOfPoints(2) points.Allocate(2) points.InsertPoint(0, point1[0], point1[1], 0.001) points.InsertPoint(1, point2[0], point2[1], 0.001) dist = numpy.sqrt(numpy.square((point1[0]-point2[0])*0.028) + numpy.square((point1[1]-point2[1])*0.030)) self.cells = vtk.vtkCellArray() self.cells.Initialize() line = vtk.vtkLine() line.GetPointIds().SetId(0,0) line.GetPointIds().SetId(1,1) self.cells.InsertNextCell(line) self.poly = vtk.vtkPolyData() self.poly.Initialize() self.poly.SetPoints(points) self.poly.SetLines(self.cells) self.poly.Modified() mapper = vtk.vtkPolyDataMapper2D() #print(dir(mapper)) mapper.SetInput(self.poly) mapper.ScalarVisibilityOn() mapper.SetScalarModeToUsePointData() mapper.Update() self.actor = vtk.vtkActor2D() self.actor.SetMapper(mapper) self.viewer.GetRenderer().AddActor2D(self.actor) self.dist = dist
def __init__(self, text, text_size=None): self.vtkTransform = None self.pos = vtk.vtkCoordinate() self.SetInput(text) self.GetTextProperty().BoldOn() self.GetTextProperty().SetColor(0.0, 0.0, 0.0) self.GetTextProperty().SetFontFamilyToArial() if text_size is not None: self.GetTextProperty().SetFontSize(text_size) self.pos.SetCoordinateSystemToWorld() coordView = vtk.vtkCoordinate() coordView.SetReferenceCoordinate(self.pos) coordView.SetCoordinateSystemToViewport() mapper = vtk.vtkPolyDataMapper2D() mapper.SetTransformCoordinate(coordView) self.SetMapper(mapper)
def _draw_text(self): p1, p2 = self.points text = ' %.2f mm ' % \ math.sqrt(vtk.vtkMath.Distance2BetweenPoints(p1, p2)) x,y,z=[(i+j)/2 for i,j in zip(p1, p2)] textsource = vtk.vtkTextSource() textsource.SetText(text) textsource.SetBackgroundColor((250/255.0, 247/255.0, 218/255.0)) textsource.SetForegroundColor(self.colour) m = vtk.vtkPolyDataMapper2D() m.SetInputConnection(textsource.GetOutputPort()) a = vtk.vtkActor2D() a.SetMapper(m) a.DragableOn() a.GetPositionCoordinate().SetCoordinateSystemToWorld() a.GetPositionCoordinate().SetValue(x,y,z) a.GetProperty().SetColor((0, 1, 0)) self.text_actor = a
def __init__(self, effect, sliceWidget): self.effect = effect self.sliceWidget = sliceWidget self.actionState = '' self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = vtk.vtkPolyData() self.tracingFilter = vtkITK.vtkITKLevelTracingImageFilter() self.ijkToXY = vtk.vtkGeneralTransform() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() actorProperty = self.actor.GetProperty() actorProperty.SetColor( 107/255., 190/255., 99/255. ) actorProperty.SetLineWidth( 1 ) self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) actorProperty = self.actor.GetProperty() actorProperty.SetColor(1,1,0) actorProperty.SetLineWidth(1)
def __init__ (self, xmin, ymin, xmax, ymax): self.pts = vtk.vtkPoints() self.pts.InsertPoint(0, xmin, ymin, 0) self.pts.InsertPoint(1, xmax, ymin, 0) self.pts.InsertPoint(2, xmax, ymax, 0) self.pts.InsertPoint(3, xmin, ymax, 0) self.rect = vtk.vtkCellArray() self.rect.InsertNextCell(4) self.rect.InsertCellPoint(0) self.rect.InsertCellPoint(1) self.rect.InsertCellPoint(2) self.rect.InsertCellPoint(3) self.selectRect = vtk.vtkPolyData() self.selectRect.SetPoints(self.pts) self.selectRect.SetPolys(self.rect) self.mapper = vtk.vtkPolyDataMapper2D() self.mapper.SetInput(self.selectRect) self.actor = vtk.vtkActor2D() self.actor.SetMapper(self.mapper) rprop = self.actor.GetProperty() rprop.SetColor(1, 1, 1) rprop.SetOpacity (0.4)
def _CreateButton(self): borderwidth = self._Config['borderwidth'] width, height = self._DisplaySize x, y = self._DisplayOrigin x0, y0 = self._Renderer.GetOrigin() self._Points = vtk.vtkPoints() self._SetPoints() cells = vtk.vtkCellArray() cells.InsertNextCell(4) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(7) if borderwidth > 0: cells.InsertNextCell(4) cells.InsertCellPoint(0) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(2) cells.InsertNextCell(4) cells.InsertCellPoint(2) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(4) cells.InsertNextCell(4) cells.InsertCellPoint(4) cells.InsertCellPoint(5) cells.InsertCellPoint(7) cells.InsertCellPoint(6) cells.InsertNextCell(4) cells.InsertCellPoint(6) cells.InsertCellPoint(7) cells.InsertCellPoint(1) cells.InsertCellPoint(0) scalars = vtk.vtkUnsignedCharArray() scalars.InsertTuple1(0, 0) scalars.InsertTuple1(1, 2) scalars.InsertTuple1(2, 2) scalars.InsertTuple1(3, 3) scalars.InsertTuple1(4, 3) data = vtk.vtkPolyData() data.SetPoints(self._Points) data.SetPolys(cells) data.GetCellData().SetScalars(scalars) mapper = vtk.vtkPolyDataMapper2D() mapper.SetInput(data) mapper.SetLookupTable(self._LookupTable) mapper.SetColorModeToMapScalars() mapper.SetScalarRange(0, 3) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetPosition(x - x0, y - y0) self._Scalars = scalars self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor) mapper = vtk.vtkTextMapper() mapper.SetInput(self._Config['text']) try: property = mapper.GetTextProperty() except AttributeError: property = mapper property.SetFontSize(self._Config['fontsize']) if self._Config['font'] in ('courier', 'Courier'): property.SetFontFamilyToCourier() elif self._Config['font'] in ('arial', 'Arial'): property.SetFontFamilyToArial() elif self._Config['font'] in ('times', 'Times'): property.SetFontFamilyToTimes() property.SetJustificationToCentered() property.SetVerticalJustificationToCentered() property.BoldOn() self._TextMapper = mapper actor = vtk.vtkActor2D() actor.GetProperty().SetColor(*self._Config['foreground']) actor.SetMapper(mapper) if "FreeType" in mapper.GetClassName(): actor.SetPosition(x + old_div(width, 2) - x0, y + old_div(height, 2) - y0) else: # not a FreeType font, needs position correction actor.SetPosition(x + old_div(width, 2) - x0 + 1, y + old_div(height, 2) - y0 + 1) self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor)
def __init__(self): ActorFactory.ActorFactory.__init__(self) # used to be 14 but VTK44 doesn't render arial 14 properly fontSize = 12 self._TextMapper = vtk.vtkTextMapper() self._TextMapper.SetInput(" ") self._TextProperty = self._TextMapper.GetTextProperty() self._TextProperty.SetFontSize(fontSize) self._TextProperty.SetFontFamilyToArial() self._TextProperty.BoldOff() self._TextProperty.ItalicOff() self._TextProperty.ShadowOff() self._TextProperty.SetColor(0.933, 0.505, 0) #self._TextProperty.SetColor(1, 1, 1) self._Input = None self._TextActor = vtk.vtkActor2D() self._TextActor.SetMapper(self._TextMapper) self._Position = "NW" self._Text = "" self._RectanglePoints = vtk.vtkPoints() self._RectanglePoints.SetNumberOfPoints(4) self._RectanglePoints.InsertPoint(0, 0, 0, 0) self._RectanglePoints.InsertPoint(1, 0, 0, 0) self._RectanglePoints.InsertPoint(2, 0, 0, 0) self._RectanglePoints.InsertPoint(3, 0, 0, 0) self._Rectangle = vtk.vtkPolygon() self._Rectangle.GetPointIds().SetNumberOfIds(4) self._Rectangle.GetPointIds().SetId(0, 0) self._Rectangle.GetPointIds().SetId(1, 1) self._Rectangle.GetPointIds().SetId(2, 2) self._Rectangle.GetPointIds().SetId(3, 3) self._RectangleGrid = vtk.vtkPolyData() self._RectangleGrid.Allocate(1, 1) self._RectangleGrid.InsertNextCell( self._Rectangle.GetCellType(), self._Rectangle.GetPointIds()) self._RectangleGrid.SetPoints(self._RectanglePoints) self._RectangleOpacity = 0.65 self._RectangleProperty = vtk.vtkProperty2D() self._RectangleProperty.SetColor(0, 0, 0) self._RectangleProperty.SetOpacity(self._RectangleOpacity) self._ActorRectangle = vtk.vtkActor2D() self._ActorRectangle.PickableOff() self._ActorRectangle.SetProperty(self._RectangleProperty) self._MapperRectangle = vtk.vtkPolyDataMapper2D() # VTK-6 if vtk.vtkVersion().GetVTKMajorVersion() > 5: self._MapperRectangle.SetInputData(self._RectangleGrid) else: self._MapperRectangle.SetInput(self._RectangleGrid) self._ActorRectangle.SetMapper(self._MapperRectangle)
"MouseMoveEvent 178 197 0 0 0 0 i" \ "MouseMoveEvent 195 209 0 0 0 0 i" \ "MouseMoveEvent 207 228 0 0 0 0 i" \ "MouseMoveEvent 220 247 0 0 0 0 i" \ "MouseMoveEvent 235 264 0 0 0 0 i" \ "MouseMoveEvent 246 283 0 0 0 0 i" \ "MouseMoveEvent 256 292 0 0 0 0 i" \ "LeaveEvent 256 292 0 0 0 0 i" \ "ExitEvent 256 292 0 0 0 0 i" # Create two widgets diskSource = vtk.vtkDiskSource() diskSource.SetInnerRadius(0.0) diskSource.SetOuterRadius(2) diskMapper = vtk.vtkPolyDataMapper2D() diskMapper.SetInput(diskSource.GetOutput()) diskActor = vtk.vtkActor2D() diskActor.SetMapper(diskMapper) diskActor.SetPosition(165, 180) diskSource2 = vtk.vtkDiskSource() diskSource2.SetInnerRadius(0.0) diskSource2.SetOuterRadius(2) diskMapper2 = vtk.vtkPolyDataMapper2D() diskMapper2.SetInput(diskSource.GetOutput()) diskActor2 = vtk.vtkActor2D() diskActor2.SetMapper(diskMapper2)
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # create four cursors configured differently cursor = vtk.vtkCursor2D() cursor.SetModelBounds(15, 45, 15, 45, 0, 0) cursor.SetFocalPoint(30, 30, 0) cursor.AllOff() cursor.AxesOn() cursor.OutlineOn() cursorMapper = vtk.vtkPolyDataMapper2D() cursorMapper.SetInputConnection(cursor.GetOutputPort()) cursorActor = vtk.vtkActor2D() cursorActor.SetMapper(cursorMapper) cursorActor.GetProperty().SetColor(1, 0, 0) cursor2 = vtk.vtkCursor2D() cursor2.SetModelBounds(75, 105, 15, 45, 0, 0) cursor2.SetFocalPoint(90, 30, 0) cursor2.AllOff() cursor2.AxesOn() cursor2.OutlineOn() cursor2.PointOn() cursor2Mapper = vtk.vtkPolyDataMapper2D() cursor2Mapper.SetInputConnection(cursor2.GetOutputPort()) cursor2Actor = vtk.vtkActor2D()
def _CreateLabel(self): borderwidth = self._Config['borderwidth'] width, height = self._DisplaySize x, y = self._DisplayOrigin x0, y0 = self._Renderer.GetOrigin() image = self._Config['bitmap'] # set up the border self._Points = vtk.vtkPoints() self._SetPoints() cells = vtk.vtkCellArray() cells.InsertNextCell(4) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(7) if borderwidth > 0: cells.InsertNextCell(4) cells.InsertCellPoint(0) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(2) cells.InsertNextCell(4) cells.InsertCellPoint(2) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(4) cells.InsertNextCell(4) cells.InsertCellPoint(4) cells.InsertCellPoint(5) cells.InsertCellPoint(7) cells.InsertCellPoint(6) cells.InsertNextCell(4) cells.InsertCellPoint(6) cells.InsertCellPoint(7) cells.InsertCellPoint(1) cells.InsertCellPoint(0) try: # for VTK 3.x scalars = vtk.vtkScalars() scalars.SetDataTypeToUnsignedChar() scalars.InsertScalar(0, 0) scalars.InsertScalar(1, 2) scalars.InsertScalar(2, 2) scalars.InsertScalar(3, 3) scalars.InsertScalar(4, 3) except (NameError, AttributeError): scalars = vtk.vtkUnsignedCharArray() scalars.InsertTuple1(0, 0) scalars.InsertTuple1(1, 2) scalars.InsertTuple1(2, 2) scalars.InsertTuple1(3, 3) scalars.InsertTuple1(4, 3) data = vtk.vtkPolyData() data.SetPoints(self._Points) data.SetPolys(cells) data.GetCellData().SetScalars(scalars) mapper = vtk.vtkPolyDataMapper2D() mapper.SetInput(data) mapper.SetLookupTable(self._LookupTable) mapper.SetColorModeToMapScalars() mapper.SetScalarRange(0, 3) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetPosition(x - x0, y - y0) self._Scalars = scalars self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor) # if there is a bitmap if image: image.UpdateInformation() extent = image.GetExtent() # VTK 6 spacing = image.GetSpacing() origin = image.GetOrigin() newextent = (0, width - 1 - borderwidth * 2, 0, height - 1 - borderwidth * 2, extent[4], extent[5]) newspacing = (spacing[0] * float(extent[1] - extent[0]) / float(newextent[1] - newextent[0]), spacing[1] * float(extent[3] - extent[2]) / float(newextent[3] - newextent[2]), spacing[2]) neworigin = (origin[0] + extent[0] * spacing[0] - newextent[0] * newspacing[0], origin[1] + extent[2] * spacing[1] - newextent[2] * newspacing[1], origin[2]) reslice = vtk.vtkImageReslice() reslice.SetInput(image) reslice.SetInterpolationModeToCubic() reslice.SetOutputExtent(newextent) reslice.SetOutputSpacing(newspacing) reslice.SetOutputOrigin(neworigin) self._BitmapReslice = reslice mapper = vtk.vtkImageMapper() mapper.SetInput(reslice.GetOutput()) mapper.SetColorWindow(255.0) mapper.SetColorLevel(127.5) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetPosition(x - x0, y - y0) self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor) mapper = vtk.vtkTextMapper() mapper.SetInput(self._Config['text']) try: property = mapper.GetTextProperty() except AttributeError: property = mapper property.SetFontSize(self._Config['fontsize']) if self._Config['font'] in ('courier', 'Courier'): property.SetFontFamilyToCourier() elif self._Config['font'] in ('arial', 'Arial'): property.SetFontFamilyToArial() elif self._Config['font'] in ('times', 'Times'): property.SetFontFamilyToTimes() property.SetJustificationToCentered() property.SetVerticalJustificationToCentered() property.BoldOn() self._TextMapper = mapper actor = vtk.vtkActor2D() actor.GetProperty().SetColor(*self._Config['foreground']) actor.SetMapper(mapper) if "FreeType" in mapper.GetClassName(): actor.SetPosition(x + old_div(width, 2) - x0, y + old_div(height, 2) - y0) else: # not a FreeType font, needs position correction actor.SetPosition(x + old_div(width, 2) - x0 + 1, y + old_div(height, 2) - y0 + 1) self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor)
Lines.InsertNextCell(2) Lines.InsertCellPoint(10) Lines.InsertCellPoint(11) Lines.InsertNextCell(2) Lines.InsertCellPoint(12) Lines.InsertCellPoint(13) # Create a grid that uses these points and lines. Grid = vtk.vtkPolyData() Grid.SetPoints(Pts) Grid.SetLines(Lines) # Set up the coordinate system. normCoords = vtk.vtkCoordinate() normCoords.SetCoordinateSystemToNormalizedViewport() # Set up the mapper and actor (2D) for the grid. mapper = vtk.vtkPolyDataMapper2D() mapper.SetInput(Grid) mapper.SetTransformCoordinate(normCoords) gridActor = vtk.vtkActor2D() gridActor.SetMapper(mapper) gridActor.GetProperty().SetColor(0.1, 0.1, 0.1) # Create the Renderer, RenderWindow, and RenderWindowInteractor 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; zoom in # closer to the image; render
def _CreateFrame(self): borderwidth = self._Config['borderwidth'] width, height = self._DisplaySize x, y = self._DisplayOrigin x0, y0 = self._Renderer.GetOrigin() self._Points = vtk.vtkPoints() self._SetPoints() cells = vtk.vtkCellArray() if borderwidth > 0: cells.InsertNextCell(4) cells.InsertCellPoint(0) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(2) cells.InsertNextCell(4) cells.InsertCellPoint(2) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(4) cells.InsertNextCell(4) cells.InsertCellPoint(4) cells.InsertCellPoint(5) cells.InsertCellPoint(7) cells.InsertCellPoint(6) cells.InsertNextCell(4) cells.InsertCellPoint(6) cells.InsertCellPoint(7) cells.InsertCellPoint(1) cells.InsertCellPoint(0) try: # for VTK 3.x scalars = vtk.vtkScalars() scalars.SetDataTypeToUnsignedChar() if self._Config['relief'] == 'raised': scalars.InsertScalar(0, 2) scalars.InsertScalar(1, 2) scalars.InsertScalar(2, 3) scalars.InsertScalar(3, 3) else: scalars.InsertScalar(0, 3) scalars.InsertScalar(1, 3) scalars.InsertScalar(2, 2) scalars.InsertScalar(3, 2) except: scalars = vtk.vtkUnsignedCharArray() if self._Config['relief'] == 'raised': scalars.InsertTuple1(0, 2) scalars.InsertTuple1(1, 2) scalars.InsertTuple1(2, 3) scalars.InsertTuple1(3, 3) else: scalars.InsertTuple1(0, 3) scalars.InsertTuple1(1, 3) scalars.InsertTuple1(2, 2) scalars.InsertTuple1(3, 2) data = vtk.vtkPolyData() data.SetPoints(self._Points) data.SetPolys(cells) data.GetCellData().SetScalars(scalars) mapper = vtk.vtkPolyDataMapper2D() mapper.SetInput(data) mapper.SetLookupTable(self._LookupTable) mapper.SetColorModeToMapScalars() mapper.SetScalarRange(0, 3) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetPosition(x - x0, y - y0) self._Scalars = scalars self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor)
def setup_renderers(renwin, fg_ren, bg_ren): """Utility method to configure foreground and background renderer and insert them into different layers of the renderenwinindow. Use this if you want an incredibly cool gradient background! """ # bit of code thanks to # http://www.bioengineering-research.com/vtk/BackgroundGradient.tcl # had to change approach though to using background renderer, # else transparent objects don't appear, and adding flat # shaded objects breaks the background gradient. # ================================================================= qpts = vtk.vtkPoints() qpts.SetNumberOfPoints(4) qpts.InsertPoint(0, 0, 0, 0) qpts.InsertPoint(1, 1, 0, 0) qpts.InsertPoint(2, 1, 1, 0) qpts.InsertPoint(3, 0, 1, 0) quad = vtk.vtkQuad() quad.GetPointIds().SetId(0,0) quad.GetPointIds().SetId(1,1) quad.GetPointIds().SetId(2,2) quad.GetPointIds().SetId(3,3) uc = vtk.vtkUnsignedCharArray() uc.SetNumberOfComponents(4) uc.SetNumberOfTuples(4) uc.SetTuple4(0, 128, 128, 128, 255) # bottom left RGBA uc.SetTuple4(1, 128, 128, 128, 255) # bottom right RGBA uc.SetTuple4(2, 255, 255, 255, 255) # top right RGBA uc.SetTuple4(3, 255, 255, 255, 255) # tob left RGBA dta = vtk.vtkPolyData() dta.Allocate(1,1) dta.InsertNextCell(quad.GetCellType(), quad.GetPointIds()) dta.SetPoints(qpts) dta.GetPointData().SetScalars(uc) coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedDisplay() mapper2d = vtk.vtkPolyDataMapper2D() mapper2d.SetInput(dta) mapper2d.SetTransformCoordinate(coord) actor2d = vtk.vtkActor2D() actor2d.SetMapper(mapper2d) actor2d.GetProperty().SetDisplayLocationToBackground() bg_ren.AddActor(actor2d) bg_ren.SetLayer(0) # seems to be background bg_ren.SetInteractive(0) fg_ren.SetLayer(1) # and foreground renwin.SetNumberOfLayers(2) renwin.AddRenderer(fg_ren) renwin.AddRenderer(bg_ren)
def leftButtonPressEvent(self,obj,event): xy = self.renWin.GetInteractor().GetEventPosition() sz = self.renWin.GetSize() x = float(xy[0])/sz[0] y = float(xy[1])/sz[1] st = "" for dnm in self.canvas.display_names: d=vcs.elements["display"][dnm] if d.array[0] is None: continue t=vcs.elements["template"][d.template] gm = vcs.elements[d.g_type][d.g_name] if t.data.x1 <= x <= t.data.x2 and t.data.y1 <= y <= t.data.y2: ## Ok we clicked within template if numpy.allclose(gm.datawc_x1,1.e20): x1 = d.array[0].getAxis(-1)[0] else: x1 = gm.datawc_x1 if numpy.allclose(gm.datawc_x2,1.e20): x2 = d.array[0].getAxis(-1)[-1] else: x2 = gm.datawc_x2 if numpy.allclose(gm.datawc_y1,1.e20): y1 = d.array[0].getAxis(-2)[0] else: y1 = gm.datawc_y1 if numpy.allclose(gm.datawc_y2,1.e20): y2 = d.array[0].getAxis(-2)[-1] else: y2 = gm.datawc_y2 X = (x-t.data.x1)/(t.data.x2-t.data.x1)*(x2-x1)+x1 Y = (y-t.data.y1)/(t.data.y2-t.data.y1)*(y2-y1)+y1 # Ok we now have the X/Y values we need to figure out the indices try: I = d.array[0].getAxis(-1).mapInterval((X,X,'cob'))[0] try: J = d.array[0].getAxis(-2).mapInterval((Y,Y,'cob'))[0] # Values at that point V = d.array[0][...,J,I] except: V = d.array[0][...,I] if isinstance(V,numpy.ndarray): V=V.flat[0] try: st+="Var: %s\nX[%i] = %g\nY[%i] = %g\nValue: %g" % (d.array[0].id,I,X,J,Y,V) except: st+="Var: %s\nX = %g\nY[%i] = %g\nValue: %g" % (d.array[0].id,X,I,Y,V) except: st+="Var: %s\nX=%g\nY=%g\nValue = N/A" % (d.array[0].id,X,Y) if st == "": return ren = vtk.vtkRenderer() ren.SetBackground(.96,.96,.86) ren.SetViewport(x,y,min(x+.2,1.),min(y+.2,1)) ren.SetLayer(self.renWin.GetNumberOfLayers()-1) a=vtk.vtkTextActor() a.SetInput(st) p=a.GetProperty() p.SetColor(0,0,0) bb = [0,0,0,0] a.GetBoundingBox(ren,bb) ps=vtk.vtkPlaneSource() ps.SetCenter(bb[0],bb[2],0.) ps.SetPoint1(bb[1],bb[2],0.) ps.SetPoint2(bb[0],bb[3],0.) ps.Update() m2d=vtk.vtkPolyDataMapper2D() m2d.SetInputConnection(ps.GetOutputPort()) a2d=vtk.vtkActor2D() a2d.SetMapper(m2d) a2d.GetProperty().SetColor(.93,.91,.67) ren.AddActor(a2d) ren.AddActor(a) ren.ResetCamera() self.clickRenderer = ren self.renWin.AddRenderer(ren) self.renWin.Render()