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 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 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()
