def leftDownEvt(self, obj, event): if self.leftDown == False: #Get current camera position renWin = self.GetInteractor().GetRenderWindow() renderer = renWin.GetRenderers().GetFirstRenderer() #Get click location and compute world coordinates click = self.GetInteractor().GetEventPosition() coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToDisplay() coord.SetValue(click[0], click[1], -1) clickPos = coord.GetComputedWorldValue(renderer) #Update position self.click = [clickPos[0], clickPos[1], clickPos[2]] #Get camera focal point cam = renderer.GetActiveCamera() camFoc = cam.GetFocalPoint() camFocCoord = vtk.vtkCoordinate() camFocCoord.SetCoordinateSystemToDisplay() camFocCoord.SetValue(camFoc[0], camFoc[1], camFoc[2]) foc = camFocCoord.GetComputedWorldValue(renderer) #Get camera position camPos = cam.GetPosition() camPosCoord = vtk.vtkCoordinate() camPosCoord.SetCoordinateSystemToDisplay() camPosCoord.SetValue(camPos[0], camPos[1], camPos[2]) pos = camPosCoord.GetComputedWorldValue(renderer) #Update variables self.click = [clickPos[0], clickPos[1], clickPos[2]] self.pos = [pos[0], pos[1], pos[2]] self.foc = [foc[0], foc[1], 0] self.leftDown = True return
def get_camera_coordinate(renderer, mode='world'): choices = ['world', 'display'] if mode not in choices: raise ValueError("Invalid mode, select one from %s" % choices) #Get camera cam = renderer.GetActiveCamera() #Get focal point foc_ = cam.GetFocalPoint() foc_coord = vtk.vtkCoordinate() foc_coord.SetCoordinateSystemToDisplay() foc_coord.SetValue(foc_[0], foc_[1], foc_[2]) #Get position pos_ = cam.GetPosition() pos_coord = vtk.vtkCoordinate() pos_coord.SetCoordinateSystemToDisplay() pos_coord.SetValue(pos_[0], pos_[1], pos_[2]) if mode == 'world': foc = foc_coord.GetComputedWorldValue(renderer) pos = pos_coord.GetComputedWorldValue(renderer) elif mode == 'display': foc = foc_coord.GetComputedDisplayValue(renderer) pos = pos_coord.GetComputedDisplayValue(renderer) return pos, foc
def Move2d(self, obj, event): self.cursor.__move__() if self.leftDown == True: #Get render window components renWin = self.GetInteractor().GetRenderWindow() renderer = renWin.GetRenderers().GetFirstRenderer() #Remove old contour actor renderer.RemoveActor(self.actor) #Compute click coordinates move = self.GetInteractor().GetEventPosition() coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToDisplay() coord.SetValue(move[0], move[1], 0) movePos = coord.GetComputedWorldValue(renderer) #Record point self.points[1, :] = np.array([movePos[0], movePos[1]]) self.actor = make_actor(self.points) self.actor.GetProperty().SetLineWidth(self.lw) self.actor.GetProperty().SetColor(self.lc) #Update actor position actPos = self.actor.GetPosition() self.actor.SetPosition(actPos[0], actPos[1], -1) renderer.AddActor(self.actor) renWin.Render() jsw = (self.points[0, :] - self.points[1, :])**2 jsw = (jsw.sum()**0.5) * 0.148 self.jsw = jsw if self.rightDown == True: #Get event position renWin = self.GetInteractor().GetRenderWindow() renderer = renWin.GetRenderers().GetFirstRenderer() move = self.GetInteractor().GetEventPosition() #Compute position in world coordinates coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToDisplay() coord.SetValue(move[0], move[1], -1) pos = coord.GetComputedWorldValue(renderer) #Compute new location, opposite of the movement direction self.pos = [ self.pos[0] - (pos[0] - self.click[0]), self.pos[1] - (pos[1] - self.click[1]), self.pos[2] ] #Update camera cam = renderer.GetActiveCamera() cam.SetPosition(self.pos[0], self.pos[1], self.pos[2]) cam.SetFocalPoint(self.pos[0], self.pos[1], self.foc[2]) renWin.Render() return
def __build_cross_lines(self): renderer = self.slice_data.overlay_renderer cross = vtk.vtkCursor3D() cross.AllOff() cross.AxesOn() self.cross = cross c = vtk.vtkCoordinate() c.SetCoordinateSystemToWorld() cross_mapper = vtk.vtkPolyDataMapper() cross_mapper.SetInput(cross.GetOutput()) #cross_mapper.SetTransformCoordinate(c) p = vtk.vtkProperty() p.SetColor(1, 0, 0) cross_actor = vtk.vtkActor() cross_actor.SetMapper(cross_mapper) cross_actor.SetProperty(p) cross_actor.VisibilityOff() # Only the slices are pickable cross_actor.PickableOff() self.cross_actor = cross_actor renderer.AddActor(cross_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 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 chooseTarget(self, obj, event): clickPos = self.GetInteractor().GetEventPosition() coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToDisplay() coordinate.SetValue(clickPos[0], clickPos[1], 0) world = coordinate.GetComputedWorldValue(self.GetInteractor( ).GetRenderWindow().GetRenderers().GetFirstRenderer()) self.target[0].set(world[0]) self.target[1].set(world[1]) sphere = vtk.vtkRegularPolygonSource() sphere.SetCenter(world[0], world[1], 0.0) sphere.SetRadius(2.0) sphere.SetNumberOfSides(50) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) mapper.SetScalarVisibility(0) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(1.0, 0.0, 0.0) self.ren.AddActor(actor) self.RemoveObserver(self.leftag) self.ren.RemoveActor(self.txt_target) self.rw.Render()
def GetDirections(self): """ Return image directions of current view in world coordinates. Changes if image is rotated. """ renderer = self.viewer.GetRenderer() # Get screen frame coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToNormalizedDisplay() coordinate.SetValue(0.0, 0.0) # Lower left lowerLeft = coordinate.GetComputedWorldValue(renderer) coordinate.SetValue(1.0, 0.0) # Lower right lowerRight = coordinate.GetComputedWorldValue(renderer) coordinate.SetValue(0.0, 1.0) # Upper left upperLeft = coordinate.GetComputedWorldValue(renderer) first1 = vtk.vtkVector3d() vtk.vtkMath.Subtract(lowerRight, lowerLeft, first1) tmp = vtk.vtkMath.Distance2BetweenPoints(lowerRight, lowerLeft) vtk.vtkMath.MultiplyScalar(first1, 1.0 / math.sqrt(tmp)) second1 = vtk.vtkVector3d() vtk.vtkMath.Subtract(upperLeft, lowerLeft, second1) tmp = vtk.vtkMath.Distance2BetweenPoints(upperLeft, lowerLeft) vtk.vtkMath.MultiplyScalar(second1, 1.0 / math.sqrt(tmp)) normal1 = vtk.vtkVector3d() vtk.vtkMath.Cross(first1, second1, normal1) return first1, second1, normal1
def resizeCallback(self, widget, event): """ Callback for repositioning button. Only observe this if a button is added """ curSize = widget.GetSize() if (curSize != self.lastSize): self.lastSize = curSize upperRight = vtk.vtkCoordinate() upperRight.SetCoordinateSystemToNormalizedDisplay() upperRight.SetValue(1.0, 1.0) renderer = self.viewer.GetRenderer() buttonRepresentation = self.buttonWidget.GetRepresentation() bds = [0] * 6 sz = self.buttonSize bds[0] = upperRight.GetComputedDisplayValue(renderer)[0] - sz bds[1] = bds[0] + sz bds[2] = upperRight.GetComputedDisplayValue(renderer)[1] - sz bds[3] = bds[2] + sz bds[4] = bds[5] = 0.0 # Scale to 1, default is .5 buttonRepresentation.SetPlaceFactor(1) buttonRepresentation.PlaceWidget(bds)
def __init__( self, name, interactor, **args ): self.vtk_coord = vtk.vtkCoordinate() self.vtk_coord.SetCoordinateSystemToNormalizedDisplay() self.StateChangedSignal = SIGNAL('StateChanged') self.process_mode = ProcessMode.Default self.currentSliders = {} self.slider_postions = [ [ [ 0.25, 0.75 ] ], [ [0.01,0.48], [0.52, 0.99 ] ], [ [0.01,0.3], [0.35,0.7], [0.75, 0.99 ] ], [ [0.01,0.24], [0.26,0.49], [0.51,0.74], [0.76, 0.99 ] ] ] self.slidersVisible = [ True, False, False, False ] self.interactor = interactor self.InteractionState = None self.LastInteractionState = None self.activeSliceIndex = 0 self.name = name self.groups = {} self.origin = args.get( 'origin', OriginPosition.Upper_Left ) self.orientation = args.get( 'orientation', Orientation.Vertical ) self.position = args.get( 'position', ( 0.0, 1.0 ) ) self.buffer = args.get( 'buffer', ( 3, 3 ) ) self.windowSizeRange = [ 200, 1200 ] self.minScale = 0.3 self.buttons = [] self.visible = False self.configurableFunctions = collections.OrderedDict() ButtonBarWidget.button_bars[ name ] = self self.updateWindowSize()
def __init__(self, name, interactor, **args): self.vtk_coord = vtk.vtkCoordinate() self.vtk_coord.SetCoordinateSystemToNormalizedDisplay() self.StateChangedSignal = SIGNAL('StateChanged') self.process_mode = ProcessMode.Default self.currentSliders = {} self.slider_postions = [[[0.25, 0.75]], [[0.01, 0.48], [0.52, 0.99]], [[0.01, 0.3], [0.35, 0.7], [0.75, 0.99]], [[0.01, 0.24], [0.26, 0.49], [0.51, 0.74], [0.76, 0.99]]] self.slidersVisible = [True, False, False, False] self.interactor = interactor self.InteractionState = None self.LastInteractionState = None self.activeSliceIndex = 0 self.name = name self.groups = {} self.origin = args.get('origin', OriginPosition.Upper_Left) self.orientation = args.get('orientation', Orientation.Vertical) self.position = args.get('position', (0.0, 1.0)) self.buffer = args.get('buffer', (3, 3)) self.fullButtonWindowSize = 1300 self.buttons = [] self.visible = False self.configurableFunctions = collections.OrderedDict() ButtonBarWidget.button_bars[name] = self self.updateWindowSize()
def draw_to_canvas(self, gc, canvas): """ Draws to an wx.GraphicsContext. Parameters: gc: is a wx.GraphicsContext canvas: the canvas it's being drawn. """ coord = vtk.vtkCoordinate() points = [] for p in self.points: coord.SetValue(p) cx, cy = coord.GetComputedDoubleDisplayValue(canvas.evt_renderer) print cx, cy # canvas.draw_circle((cx, cy), 2.5) points.append((cx, cy)) if len(points) > 1: for (p0, p1) in zip(points[:-1:], points[1::]): r, g, b = self.colour canvas.draw_line(p0, p1, colour=(r*255, g*255, b*255, 255)) if len(points) == 3: txt = u"%.3f° / %.3f°" % (self.GetValue(), 360.0 - self.GetValue()) r, g, b = self.colour canvas.draw_arc(points[1], points[0], points[2], line_colour=(r*255, g*255, b*255, 255)) canvas.draw_text_box(txt, (points[1][0], points[1][1]), txt_colour=MEASURE_TEXT_COLOUR, bg_colour=MEASURE_TEXTBOX_COLOUR)
def Coord3DtoDisplay(self, x, y, z, canvas): coord = vtk.vtkCoordinate() coord.SetValue(x, y, z) cx, cy = coord.GetComputedDisplayValue(canvas.evt_renderer) return (cx, cy)
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 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 __init__(self, font_size=14, color=(0.0, 0.0, 0.0), relative_position=(0, 1), absolute_offset=(10, -10), text="", **kwargs): kwargs["text"] = text kwargs['color'] = color kwargs["absolute_offset"] = absolute_offset kwargs["relative_position"] = relative_position kwargs["font_size"] = font_size self.actor = vtk.vtkTextActor() self.text_property = self.actor.GetTextProperty() self.text_property.SetFontFamilyToCourier() self.text_property.SetVerticalJustificationToTop() self.relpos_coord = vtk.vtkCoordinate() self.relpos_coord.SetCoordinateSystemToNormalizedViewport() self.actor.GetPositionCoordinate().SetCoordinateSystemToViewport() self.actor.GetPositionCoordinate().SetReferenceCoordinate( self.relpos_coord) self._process_kwargs(**kwargs)
def draw_to_canvas(self, gc, canvas): """ Draws to an wx.GraphicsContext. Parameters: gc: is a wx.GraphicsContext canvas: the canvas it's being drawn. """ coord = vtk.vtkCoordinate() points = [] for p in self.points: coord.SetValue(p) cx, cy = coord.GetComputedDisplayValue(canvas.evt_renderer) # canvas.draw_circle((cx, cy), 2.5) points.append((cx, cy)) if len(points) > 1: for (p0, p1) in zip(points[:-1:], points[1::]): r, g, b = self.colour canvas.draw_line(p0, p1, colour=(r * 255, g * 255, b * 255, 255)) txt = u"%.3f mm" % self.GetValue() canvas.draw_text_box(txt, ((points[0][0] + points[1][0]) / 2.0, (points[0][1] + points[1][1]) / 2.0), txt_colour=MEASURE_TEXT_COLOUR, bg_colour=MEASURE_TEXTBOX_COLOUR)
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 _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 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 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 set2d_camera(renderer): cam = vtk.vtkCamera() cam.SetViewUp(0,-1,0) pos = cam.GetPosition() coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToDisplay() coord.SetValue(pos[0], pos[1], pos[2]) newpos = coord.GetComputedWorldValue(renderer) cam.SetPosition(newpos[0], newpos[1], -newpos[2]) foc = cam.GetFocalPoint() focCoord = vtk.vtkCoordinate() focCoord.SetCoordinateSystemToDisplay() focCoord.SetValue(foc[0], foc[1], foc[2]) newFoc = focCoord.GetComputedWorldValue(renderer) cam.SetFocalPoint(newFoc[0], newFoc[1], -1) cam.SetClippingRange(1e-5, 1) renderer.ResetCamera()
def computeBounds( renderer, normalized_display_position, size ): upperRight = vtk.vtkCoordinate() upperRight.SetCoordinateSystemToNormalizedDisplay() upperRight.SetValue( normalized_display_position[0], normalized_display_position[1] ) bds = [0.0]*6 bds[0] = upperRight.GetComputedDisplayValue(renderer)[0] - size[0] bds[1] = bds[0] + size[0] bds[2] = upperRight.GetComputedDisplayValue(renderer)[1] - size[1] bds[3] = bds[2] + size[1] return bds
def draw_to_canvas(self, gc, canvas): coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedDisplay() coord.SetValue(*self.position) x, y = coord.GetComputedDisplayValue(canvas.evt_renderer) font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT) # font.SetWeight(wx.FONTWEIGHT_BOLD) font.SetSymbolicSize(self.symbolic_syze) canvas.draw_text(self.text, (x, y), font=font)
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 _3d_to_2d(plotter, xyz): # https://vtk.org/Wiki/VTK/Examples/Cxx/Utilities/Coordinate import vtk coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToWorld() xy = list() for coord in xyz: coordinate.SetValue(*coord) xy.append(coordinate.GetComputedLocalDisplayValue(plotter.renderer)) xy = np.array(xy, float).reshape(-1, 2) # in case it's empty return xy
def computeBounds(self, normalized_display_position, size): renderer = self.getRenderer() upperRight = vtk.vtkCoordinate() upperRight.SetCoordinateSystemToNormalizedDisplay() upperRight.SetValue(normalized_display_position[0], normalized_display_position[1]) bds = [0.0] * 6 bds[0] = upperRight.GetComputedDisplayValue(renderer)[0] - size[0] bds[1] = bds[0] + size[0] bds[2] = upperRight.GetComputedDisplayValue(renderer)[1] - size[1] bds[3] = bds[2] + size[1] return bds
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 __move__(self): #Get components interactor = self.interactorstyle.GetInteractor() renWin = interactor.GetRenderWindow() renderer = renWin.GetRenderers().GetFirstRenderer() #Remove old actor renderer.RemoveActor(self.actor) #Get mouse position pos = interactor.GetEventPosition() coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToDisplay() coord.SetValue(pos[0], pos[1], 0) center = coord.GetComputedWorldValue(renderer) #Create line objects points = vtk.vtkPoints() lines = vtk.vtkCellArray() polydata = vtk.vtkPolyData() #Line positions x1, x2 = center[0] - self.R, center[0] + self.R y1, y2 = center[1] - self.R, center[1] + self.R id1 = points.InsertNextPoint([x1, y1, 0]) id2 = points.InsertNextPoint([x2, y2, 0]) lines.InsertNextCell(2) lines.InsertCellPoint(id1) lines.InsertCellPoint(id2) x1, x2 = center[0] - self.R, center[0] + self.R y1, y2 = center[1] + self.R, center[1] - self.R id1 = points.InsertNextPoint([x1, y1, 0]) id2 = points.InsertNextPoint([x2, y2, 0]) lines.InsertNextCell(2) lines.InsertCellPoint(id1) lines.InsertCellPoint(id2) polydata.SetPoints(points) polydata.SetLines(lines) mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(polydata) #Add to render window self.actor.SetMapper(mapper) self.actor.GetProperty().SetLineWidth(self.lw) self.actor.GetProperty().SetColor(self.color) renderer.AddActor(self.actor) renWin.Render()
def button_display_coordinates(renderer, normalized_display_position, size): upperRight = vtk.vtkCoordinate() upperRight.SetCoordinateSystemToNormalizedDisplay() upperRight.SetValue(normalized_display_position[0], normalized_display_position[1]) bds = [0.0] * 6 bds[0] = upperRight.GetComputedDisplayValue(renderer)[0] - size[0] bds[1] = bds[0] + size[0] bds[2] = upperRight.GetComputedDisplayValue(renderer)[1] - size[1] bds[3] = bds[2] + size[1] return bds
def OnPaint(self, evt, obj): size = self.canvas_renderer.GetSize() w, h = size if self._size != size: self._size = size self._resize_canvas(w, h) cam_modif_time = self.evt_renderer.GetActiveCamera().GetMTime() if (not self.modified) and cam_modif_time == self.last_cam_modif_time: return self.last_cam_modif_time = cam_modif_time self._array[:] = 0 coord = vtk.vtkCoordinate() self.image.SetDataBuffer(self.rgb) self.image.SetAlphaBuffer(self.alpha) self.image.Clear() gc = wx.GraphicsContext.Create(self.image) if sys.platform != 'darwin': gc.SetAntialiasMode(0) self.gc = gc font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT) # font.SetWeight(wx.BOLD) font = gc.CreateFont(font, (0, 0, 255)) gc.SetFont(font) pen = wx.Pen(wx.Colour(255, 0, 0, 128), 2, wx.SOLID) brush = wx.Brush(wx.Colour(0, 255, 0, 128)) gc.SetPen(pen) gc.SetBrush(brush) gc.Scale(1, -1) self._ordered_draw_list = sorted(self._follow_draw_list(), key=lambda x: x[0]) for l, d in self._ordered_draw_list: #sorted(self.draw_list, key=lambda x: x.layer if hasattr(x, 'layer') else 0): d.draw_to_canvas(gc, self) gc.Destroy() self.gc = None if self._drawn: self.bitmap = self.image.ConvertToBitmap() self.bitmap.CopyToBuffer(self._array, wx.BitmapBufferFormat_RGBA) self._cv_image.Modified() self.modified = False self._drawn = False
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 draw_to_canvas(self, gc, canvas): coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedDisplay() coord.SetValue(*self.position) x, y = coord.GetComputedDisplayValue(canvas.evt_renderer) font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT) font.SetSymbolicSize(self.symbolic_syze) font.Scale(canvas.viewer.GetContentScaleFactor()) if self.bottom_pos or self.right_pos: w, h = canvas.calc_text_size(self.text, font) if self.right_pos: x -= w if self.bottom_pos: y += h canvas.draw_text(self.text, (x, y), font=font)
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 convert_world_to_display(self, viewpoint, x, y, z): """Converts world coordinates x, y, z to display coordinates. Used in 2D affine alignment model to get shape feature coordinates in image. """ self.vtkrenderer.SetActiveCamera(self.vtkcamera) self._setup_camera(viewpoint) vtkcoordinate = vtk.vtkCoordinate() vtkcoordinate.SetCoordinateSystemToWorld() vtkcoordinate.SetValue(x, y, z) # x and y are flipped in render method. y, x = vtkcoordinate.GetComputedDisplayValue(self.vtkrenderer) return x, y
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 set_options(vtkchart, vtkrenderer, opt): """ A method for updating the legend options. """ legend = vtkchart.GetLegend() if opt.isOptionValid('visible'): vtkchart.SetShowLegend(opt['visible']) else: vtkchart.SetShowLegend(True) if opt.isOptionValid('background'): legend.GetBrush().SetColorF(opt['background']) else: legend.GetBrush().SetColorF(vtkrenderer.GetBackground()) legend.GetLabelProperties().SetColor(opt['label_color']) legend.GetBrush().SetOpacityF(opt['opacity']) if opt.isOptionValid('label_font_size'): legend.SetLabelSize(opt['label_font_size']) if opt.isOptionValid('point'): pt = opt['point'] legend.SetVerticalAlignment(vtk.vtkChartLegend.CUSTOM) legend.SetHorizontalAlignment(vtk.vtkChartLegend.CUSTOM) coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedViewport() coord.SetValue(pt[0], pt[1], 0) loc = coord.GetComputedDisplayValue(vtkrenderer) legend.SetPoint(*loc) else: legend.SetVerticalAlignment(eval('vtk.vtkChartLegend.' + opt['vertical_alignment'].upper())) legend.SetHorizontalAlignment(eval('vtk.vtkChartLegend.' + opt['horizontal_alignment'].upper())) if opt.isOptionValid('border'): legend.GetPen().SetOpacity(opt['border_opacity']) legend.GetPen().SetColorF(opt['border_color']) if opt.isOptionValid('border_width'): legend.GetPen().SetWidth(opt['border_width']) else: legend.GetPen().SetOpacity(0)
def __init__( self, name, interactor, **args ): self.name = name self.interactor = interactor self.buttons = [] self.updateWindowSize() self.visible = False self.position = args.get( 'position', ( 0.0, 1.0 ) ) self.vtk_coord = vtk.vtkCoordinate() self.vtk_coord.SetCoordinateSystemToNormalizedDisplay() self.StateChangedSignal = SIGNAL('StateChanged') self.process_mode = ProcessMode.Default self.origin = args.get( 'origin', OriginPosition.Upper_Left ) self.orientation = args.get( 'orientation', Orientation.Vertical ) # print " ButtonBar[%s]: %s" % ( name, str(self.position) ) self.buffer = args.get( 'buffer', ( 3, 3 ) ) self.fullButtonWindowSize = 1300 self.magnification = args.get( 'mag', 1.0 )
def startEvent(self): logging.debug("In TextWidget::startEvent()") if not self._started: self._started = True self.setText(self.text) coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedDisplay() coord.SetValue(self.position[0], self.position[1]) pos = coord.GetComputedDisplayValue(self.scene.renderer) x = self.position[0]/pos[0] y = self.position[1]/pos[1] pos = self.scene.interactor.GetEventPosition() self.position[0] = pos[0]*x self.position[1] = pos[1]*y self.rep.GetPositionCoordinate().SetValue(self.position[0], self.position[1]) self.setText(self.text) self.On()
def OnRenderEvent(self, renderer, evt): w = self._TextMapper.GetWidth(renderer) h = self._TextMapper.GetHeight(renderer) p = self._TextActor.GetPosition() if self._Text.strip() == "": 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) return coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedViewport() coord.SetValue(p[0], p[1]) p = coord.GetComputedViewportValue(renderer) x = p[0] y = p[1] if self._Position[1] == "E": x += 5 else: x -= 5 if self._Position[0] == "N": y += 5 else: y -= 5 # pad w += 10 h += 10 if self._Position == "SE": self._RectanglePoints.InsertPoint(0, x - w, y, 0) self._RectanglePoints.InsertPoint(1, x - w, y + h, 0) self._RectanglePoints.InsertPoint(2, x, y + h, 0) self._RectanglePoints.InsertPoint(3, x, y, 0) elif self._Position == "NW": self._RectanglePoints.InsertPoint(0, x, y, 0) self._RectanglePoints.InsertPoint(1, x, y - h, 0) self._RectanglePoints.InsertPoint(2, x + w, y - h, 0) self._RectanglePoints.InsertPoint(3, x + w, y, 0)
def __init__(self, font_size=14, color=(0.0, 0.0, 0.0), relative_position=(0, 1), absolute_offset=(10, -10), text="", **kwargs): kwargs["text"] = text kwargs['color'] = color kwargs["absolute_offset"] = absolute_offset kwargs["relative_position"] = relative_position kwargs["font_size"] = font_size self.actor = vtk.vtkTextActor() self.text_property = self.actor.GetTextProperty() self.text_property.SetFontFamilyToCourier() self.text_property.SetVerticalJustificationToTop() self.relpos_coord = vtk.vtkCoordinate() self.relpos_coord.SetCoordinateSystemToNormalizedViewport() self.actor.GetPositionCoordinate().SetCoordinateSystemToViewport() self.actor.GetPositionCoordinate().SetReferenceCoordinate(self.relpos_coord) self._process_kwargs(**kwargs)
def HandleVisibilityLonAxisTextAndTicks(renwin,ren0,ren1,text,tickb,ticku,xpos) : xsize,ysize=renwin.GetSize() ren1xstart,ren1ystart,ren1xend,ren1yend=ren1.GetViewport() coords = vtk.vtkCoordinate() coords.SetCoordinateSystemToWorld() coords.SetValue(xpos,0.0,0.0) x1,y1 = coords.GetComputedDoubleViewportValue(ren1) renxpos=x1/xsize+ren1xstart if renxpos > ren1xstart and renxpos < ren1xend : ren0.AddActor(text) text.SetPosition(renxpos,ren1ystart-axisxoffset) ren0.AddActor(tickb) tickb.SetPosition(renxpos,ren1ystart-axisxticksize) ren0.AddActor(ticku) ticku.SetPosition(renxpos,ren1yend) visibility=1 else : ren0.RemoveActor(text) ren0.RemoveActor(tickb) ren0.RemoveActor(ticku) visibility=0 return visibility
def HandleVisibilityLatAxisTextAndTicks(renwin,ren0,ren1,text,tickl,tickr,ypos) : xsize,ysize=renwin.GetSize() ren1xstart,ren1ystart,ren1xend,ren1yend=ren1.GetViewport() coords = vtk.vtkCoordinate() coords.SetCoordinateSystemToWorld() coords.SetValue(0.0,ypos,0.0) x1,y1 = coords.GetComputedDoubleViewportValue(ren1) renypos=y1/ysize+ren1ystart if renypos > ren1ystart and renypos < ren1yend : ren0.AddActor(text) text.SetPosition(ren1xstart-axisyoffset,renypos) ren0.AddActor(tickl) tickl.SetPosition(ren1xstart-axisyticksize,renypos) ren0.AddActor(tickr) tickr.SetPosition(ren1xend,renypos) visibility=1 else : ren0.RemoveActor(text) ren0.RemoveActor(tickl) ren0.RemoveActor(tickr) visibility=0 return visibility
def GetImagedataCoordinates(self, picker_position): x, y, z = picker_position c = vtk.vtkCoordinate() c.SetCoordinateSystemToWorld() c.SetValue(bounds[::2]) xi, yi = c.GetComputedViewportValue(self.render) c.SetValue(bounds[1::2]) xf, yf = c.GetComputedViewportValue(self.render) c.SetValue(x, y, z) wx, wy = c.GetComputedViewportValue(self.render) wx = wx - xi wy = wy - yi xf = xf - xi yf = yf - yi wx = (wx * self.imagedata_dimensions[0]) / xf wy = (wy * self.imagedata_dimensions[1]) / yf return wx, wy
Lines.InsertCellPoint(7) Lines.InsertNextCell(2) Lines.InsertCellPoint(8) Lines.InsertCellPoint(9) 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()
renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(600, 600) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) camera = vtk.vtkCamera() camera.SetPosition(0, 0, -30) camera.SetFocalPoint(0, 0, 10) ren.SetActiveCamera(camera) coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToWorld() coordinate.SetValue(5, 0, 0) print coordinate.GetComputedDisplayValue(ren) source = vtk.vtkSphereSource() source.SetCenter(0, 0, 0) source.SetRadius(5.0) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(source.GetOutput()) actor = vtk.vtkActor()
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 drawROI(self, interactor, startXY, endXY): coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToDisplay() coord.SetValue(startXY[0], startXY[1], 0.0) worldStartXY = coord.GetComputedWorldValue(interactor.GetRenderWindow().GetRenderers().GetFirstRenderer()) coord.SetValue(endXY[0], endXY[1], 0.0) worldEndXY = coord.GetComputedWorldValue(interactor.GetRenderWindow().GetRenderers().GetFirstRenderer()) pts = vtk.vtkPoints() pts.InsertNextPoint(worldStartXY) vectors = vtk.vtkDoubleArray() vectors.SetNumberOfComponents(3) vectors.SetNumberOfTuples(1) vectors.SetTuple3(0, worldEndXY[0]-worldStartXY[0], worldEndXY[1]-worldStartXY[1], worldEndXY[2]-worldStartXY[2]) r = 0 for d in range(3): r += (worldEndXY[d] - worldStartXY[d]) ** 2.0 r = math.sqrt(r) radii = vtk.vtkFloatArray() radii.InsertNextValue(r) radii.SetName("radius") pd = vtk.vtkPolyData() pd.SetPoints(pts) #pd.GetPointData().SetVectors(vectors) #pd.GetPointData().AddArray(radii) #pd.GetPointData().SetActiveScalars("radius") pd.GetPointData().SetScalars(radii) #lineSource = vtk.vtkArrowSource() """ lineSource = vtk.vtkGlyphSource2D() lineSource.SetGlyphTypeToCircle() #lineSource.SetGlyphTypeToArrow() lineSource.FilledOff() lineSource.Update() """ lineSource = vtk.vtkSphereSource() lineSource.SetRadius(1.0) lineSource.SetPhiResolution(12) lineSource.SetThetaResolution(12) self.roiGlyph.SetInput(pd) self.roiGlyph.SetSource(lineSource.GetOutput()) self.roiGlyph.ScalingOn() self.roiGlyph.OrientOn() self.roiGlyph.SetScaleFactor(1.0) #self.roiGlyph.SetVectorModeToUseVector() #self.roiGlyph.SetScaleModeToScaleByVector() self.roiGlyph.SetScaleModeToScaleByScalar() self.roiGlyph.Update() self.roiMapper.SetInput(self.roiGlyph.GetOutput()) self.roiActor.SetMapper(self.roiMapper) renOverlay = self.getOverlayRenderer( interactor.GetRenderWindow() ) renOverlay.AddActor(self.roiActor)
def update(self, **kwargs): """ Updates the 3D camera to place the image in the defined location. """ super(ImageAnnotation, self).update(**kwargs) renderer = self.getVTKRenderer() # Coordinate transormation object tr = vtk.vtkCoordinate() tr.SetCoordinateSystemToNormalizedViewport() # Size of window window = renderer.GetRenderWindow().GetSize() # Size of image size = self._sources[-1].getVTKSource().GetOutput().GetDimensions() # Image scale if self.isOptionValid('scale'): scale = self.getOption('scale') else: scale = float(window[0])/float(size[0]) * self.getOption('width') # Compute the camera distance angle = self._vtkcamera.GetViewAngle() d = window[1]*0.5 / math.tan(math.radians(angle*0.5)) # Determine the image position if self.isOptionValid('position'): p = self.getOption('position') tr.SetValue(p[0], p[1], 0) position = list(tr.GetComputedDisplayValue(renderer)) # Adjust for off-center alignments if self.getOption('horizontal_alignment') == 'left': position[0] = position[0] + (size[0]*0.5*scale) elif self.getOption('horizontal_alignment') == 'right': position[0] = position[0] - (size[0]*0.5*scale) if self.getOption('vertical_alignment') == 'top': position[1] = position[1] - (size[1]*0.5*scale) elif self.getOption('vertical_alignment') == 'bottom': position[1] = position[1] + (size[1]*0.5*scale) # Reference position (middle of window) tr.SetValue(0.5, 0.5, 0) ref = tr.GetComputedDisplayValue(renderer) # Camera offsets x = (ref[0] - position[0]) * 1/scale y = (ref[1] - position[1]) * 1/scale # Set the camera self._vtkcamera.SetViewUp(0, 1, 0) self._vtkcamera.SetPosition(size[0]/2. + x, size[1]/2. + y, d * 1/scale) self._vtkcamera.SetFocalPoint(size[0]/2. + x, size[1]/2. + y, 0) # Update the renderer renderer.SetActiveCamera(self._vtkcamera) renderer.ResetCameraClippingRange()
def _3d_to_2d(self, renderer, pos): coord = vtk.vtkCoordinate() coord.SetValue(pos) px, py = coord.GetComputedDoubleDisplayValue(renderer) return px, py
def update(self, **kwargs): """ Apply setting to create a colorbar. Inputs: see ChiggerResult """ # Set the options provided self.setOptions(**kwargs) if self.needsInitialize(): self.initialize() # Convenience names for the various sources plane, axis0, axis1 = self._sources # Origin loc = self.getOption('location').lower() if not self.isOptionValid('colorbar_origin'): if (loc == 'right') or (loc == 'left'): self.setOption('colorbar_origin', [0.8, 0.25, 0.0]) else: self.setOption('colorbar_origin', [0.25, 0.2, 0.0]) # Get dimensions of colorbar, taking into account the orientation n = self.getOption('cmap_num_colors') length0 = 0 length1 = 0 loc = self.getOption('location') if (loc == 'right') or (loc == 'left'): length0 = self.getOption('width') length1 = self.getOption('length') plane.setOptions(resolution=[1, n+1]) else: length0 = self.getOption('length') length1 = self.getOption('width') plane.setOptions(resolution=[n+1, 1]) # Coordinate system transformation object pos = self.getOption('colorbar_origin') coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedViewport() # The viewport must be set, before the points are computed. if self.isOptionValid('viewport'): self._vtkrenderer.SetViewport(self.getOption('viewport')) # Point 0 coord.SetViewport(self._vtkrenderer) coord.SetValue(pos[0]+length0, pos[1], 0) p0 = coord.GetComputedViewportValue(self._vtkrenderer) # Point 1 coord.SetValue(pos[0], pos[1]+length1, 0) p1 = coord.GetComputedViewportValue(self._vtkrenderer) coord.SetValue(*pos) pos = coord.GetComputedViewportValue(self._vtkrenderer) # Update the bar position plane.setOptions(origin=[pos[0], pos[1], 0], point1=[p0[0], p0[1], 0], point2=[p1[0], p1[1], 0]) # Set the colormap for the bar rng = self.getOption('cmap_range') step = (rng[1] - rng[0]) / float(n) data = vtk.vtkFloatArray() data.SetNumberOfTuples(n+1) for i in xrange(n+1): data.SetValue(i, rng[0] + i*step) plane.setOptions(data=data) # Setup the primary Axis axis0.options().update(self.getOption('primary')) location = self.__setAxisPosition(axis0, p0, p1, self.getOption('location')) # Setup the secondary Axis axis1.options().update(self.getOption('secondary')) self.__setAxisPosition(axis1, p0, p1, location) # Call base class method super(ColorBar, self).update()