示例#1
0
    def __init__(self, parent = None, title=None):
        QtGui.QMainWindow.__init__(self, parent)
        if title:
            self.setWindowTitle(title)
        else:
            self.setWindowTitle('Visualization')

        self.vl = QtGui.QVBoxLayout()
        self.hl = QtGui.QHBoxLayout()
        self.frame = QtGui.QFrame()
        self.vtkWidget, self.ren, self.iren, self.intstyle = self.init_vtk_widget(self.frame)
        self.save_main_vizualization_button = self.init_save_vizualization_button(
            self.frame,
            self.vtkWidget.GetRenderWindow()
        )
        self.vl.addWidget(self.vtkWidget)
        self.hl.insertLayout(-1, self.vl)

        self.ren = vtk.vtkRenderer()
        self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        self.vtkWidget.GetRenderWindow().LineSmoothingOn()
        self.vtkWidget.GetRenderWindow().PolygonSmoothingOn()
        self.vtkWidget.GetRenderWindow().PointSmoothingOn()
        self.vtkWidget.GetRenderWindow().SetMultiSamples(8)
        self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
        self.ren.GetActiveCamera().ParallelProjectionOn()
        self.intstyle = vtk.vtkInteractorStyleRubberBand2D()
        self.iren.SetInteractorStyle(self.intstyle)
        self.ren.SetBackground(1.0, 1.0, 1.0)

        self.frame.setLayout(self.hl)
        self.setCentralWidget(self.frame)
示例#2
0
    def OpenAddBoundaryDlg(self):
        self.style = vtk.vtkInteractorStyleRubberBand2D()
        self.position=[0.0,0.0,0.0,0.0]
        self.statusbar.showMessage('Select Boundary Elements')

        self.style.area_picker = vtk.vtkRenderedAreaPicker()
        self.style.AddObserver("LeftButtonReleaseEvent", self.leftButtonReleaseEvent)
        self.style.SetDefaultRenderer(self.renderer)
        self.renWinInteract.SetInteractorStyle(self.style) 
        self.renWinInteract.SetPicker(self.style.area_picker)
示例#3
0
 def set_interaction(self, interaction):
     if interaction == "rubber_band_2d":
         for renderer in self.plotter.renderers:
             renderer.enable_parallel_projection()
         if hasattr(self.plotter, 'enable_rubber_band_2d_style'):
             self.plotter.enable_rubber_band_2d_style()
         else:
             style = vtk.vtkInteractorStyleRubberBand2D()
             self.plotter.interactor.SetInteractorStyle(style)
     else:
         for renderer in self.plotter.renderers:
             renderer.disable_parallel_projection()
         getattr(self.plotter, f'enable_{interaction}_style')()
示例#4
0
 def show(self, render_window=None):
     if render_window is None:
         render_window = vtk.vtkRenderWindow()
         render_window.SetSize(700, 700)
     render_window.AddRenderer(self.renderer)
     render_interactor = vtk.vtkRenderWindowInteractor()
     if self.allow_rotation:
         render_interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
     else:
         render_interactor.SetInteractorStyle(vtk.vtkInteractorStyleRubberBand2D())
     render_interactor.SetRenderWindow(render_window)
     render_interactor.Initialize()
     render_interactor.Start()
示例#5
0
 def show(self, render_window=None):
     if render_window is None:
         render_window = vtk.vtkRenderWindow()
         render_window.SetSize(700, 700)
     render_window.AddRenderer(self.renderer)
     render_interactor = vtk.vtkRenderWindowInteractor()
     if self.allow_rotation:
         render_interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
     else:
         render_interactor.SetInteractorStyle(vtk.vtkInteractorStyleRubberBand2D())
     render_interactor.SetRenderWindow(render_window)
     render_interactor.Initialize()
     render_interactor.Start()
示例#6
0
 def _createwindow(self):
     ren1 = vtk.vtkRenderer()
     ren1.AddActor(self.actor)
     ren1.SetBackground(0.1, 0.2, 0.4)
     ren1.ResetCamera()
     renWin = vtk.vtkRenderWindow()
     renWin.AddRenderer(ren1)
     renWin.SetSize(700, 700)
     iren = vtk.vtkRenderWindowInteractor()
     if self.rotation:
         iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
     else:
         iren.SetInteractorStyle(vtk.vtkInteractorStyleRubberBand2D())
     iren.SetRenderWindow(renWin)
     iren.Initialize()
     iren.Start()
示例#7
0
    def init_vtk_widget(self, widget):
        vtk_widget = QVTKRenderWindowInteractor(widget)
        renderer = vtk.vtkRenderer()
        vtk_widget.GetRenderWindow().AddRenderer(renderer)

        renderer.SetBackground(1.0, 1.0, 1.0)

        interactor = vtk_widget.GetRenderWindow().GetInteractor()
        interactor_style = vtk.vtkInteractorStyleRubberBand2D()
        interactor.SetInteractorStyle(interactor_style)

        vtk_widget.GetRenderWindow().LineSmoothingOn()
        vtk_widget.GetRenderWindow().PolygonSmoothingOn()
        vtk_widget.GetRenderWindow().PointSmoothingOn()
        vtk_widget.GetRenderWindow().SetMultiSamples(8)

        return vtk_widget, renderer, interactor, interactor_style
示例#8
0
 def show(self):
     self.renderer = vtk.vtkRenderer()
     self.renderer.SetBackground(0.1, 0.2, 0.4)  # Blue
     self.renderer.ResetCamera()
     self.renderer.AddActor(self.actor)
     render_window = vtk.vtkRenderWindow()
     render_window.SetSize(700, 700)
     render_window.AddRenderer(self.renderer)
     render_interactor = vtk.vtkRenderWindowInteractor()
     if self.allow_rotation:
         render_interactor.SetInteractorStyle(
             vtk.vtkInteractorStyleTrackballCamera())
     else:
         render_interactor.SetInteractorStyle(
             vtk.vtkInteractorStyleRubberBand2D())
     render_interactor.SetRenderWindow(render_window)
     render_interactor.Initialize()
     render_interactor.Start()
示例#9
0
    def __init__(self, parent=None):

        QtGui.QMainWindow.__init__(self, parent)
        self.ui = Ui_MainWindow()

        data_file = "/Users/emonson/Data/Fodava/EMoGWDataSets/mnist12_1k_20100521.mat"
        self.ds = DataSource(data_file)

        self.pc_class = PCoordsChart(self.ds)
        self.view = self.pc_class.GetView()

        self.ui.setupUi(self, self.view.GetRenderWindow())
        style = vtk.vtkInteractorStyleRubberBand2D()
        self.view.SetInteractorStyle(style)
        # Need this additional command (plus above set style) for this class
        self.view.SetInteractionModeTo2D()

        self.view.ResetCamera()
        self.view.GetInteractor().Start()
示例#10
0
def show(*graphics):
    allow_rotation = True

    render_window = vtk.vtkRenderWindow()
    render_window.SetSize(700, 700)
    render_interactor = vtk.vtkRenderWindowInteractor()
    if allow_rotation:
        render_interactor.SetInteractorStyle(
            vtk.vtkInteractorStyleTrackballCamera())
    else:
        render_interactor.SetInteractorStyle(
            vtk.vtkInteractorStyleRubberBand2D())

    renderer = vtk.vtkRenderer()
    renderer.SetBackground(0.1, 0.2, 0.4)  # Blue
    renderer.ResetCamera()
    for g in graphics:
        g.redraw()
        renderer.AddActor(g.actor)

    render_interactor.SetRenderWindow(render_window)
    render_window.AddRenderer(renderer)
    render_interactor.Initialize()
    render_interactor.Start()
示例#11
0
	def __init__(self, parent = None):
	
		QtGui.QMainWindow.__init__(self, parent)
		self.ui = Ui_MainWindow()
		
		self.renWinList = []
		   
		# data_file = askopenfilename()
		data_file = '/Users/emonson/Data/Fodava/EMoGWDataSets/mnist1_5c_20100324.mat'
# 		self.openFilesDefaultPath = QtCore.QDir.homePath()
# 		data_file = QtGui.QFileDialog.getOpenFileName(self,
# 				"Load Saved Matlab File", 
# 				self.openFilesDefaultPath,
# 				"All Files (*);;Matlab Files (*.mat)")
		
		# DataSource loads .mat file and can generate data from it for other views
		self.ds = DataSource(str(data_file))
		
		# All view classes have access to an instance of that data source for internal queries
		# Note that the only view which will pull and display data right away is the icicle view
		#  the other views need to be able to initialize without any data and only pull and show
		#  upon the first AnnotationChanged event...
		
		# View #0 -- Icicle View
		# Set up a 2D scene, add an XY chart to it
		self.chartView = vtk.vtkContextView()
		self.chartView.GetRenderer().SetBackground(1.0, 1.0, 1.0)
		self.renWinList.append(self.chartView.GetRenderWindow())

		self.chart = vtkvtg.vtkMyChartXY()
		self.chartView.GetScene().AddItem(self.chart)

		# View #1 -- AxisImageView
		self.axisView = vtk.vtkContextView()
		self.axisView.GetRenderer().SetBackground(1.0, 1.0, 1.0)
		self.renWinList.append(self.axisView.GetRenderWindow())

		self.ai = vtkvtg.vtkAxisImageItem()
		self.axisView.GetScene().AddItem(self.ai)
		
		# Set up all the render windows in the GUI
		self.ui.setupUi(self, self.renWinList)
		
		# Now need to get all the interactors working properly
		# XY
		style0 = vtk.vtkInteractorStyleRubberBand2D()
		self.chartView.GetInteractor().SetInteractorStyle(style0)
		self.chartView.GetScene().SetInteractorStyle(style0)

		# Axis images
		style1 = vtk.vtkInteractorStyleRubberBand2D()
		self.axisView.GetInteractor().SetInteractorStyle(style1)
		self.axisView.GetScene().SetInteractorStyle(style1)

		# Set sizes for veritcal splitters
		self.ui.splitter.setSizes([200,400])		
		
		# Connect signals and slots
		QtCore.QObject.connect(self.ui.actionExit, QtCore.SIGNAL("triggered()"), self.fileExit)

		
		# CORE setting up chart and axis images
		test_id = 68
		self.table = self.ds.GetNodeOneScaleCoeffTable(test_id)
		
		line1 = vtkvtg.vtkMyPlotPoints()
		# line1.DebugOn()
		self.chart.AddPlot(line1)		# POINTS
		line1.SetInput(self.table, 0, 1)
		line1.SetMarkerStyle(2)
		line1.SetColor(0, 0, 0, 255)
		
		# Tooltip image stack will now be owned by the tooltip, so need to do that differently... 
		id_list = self.ds.PIN[test_id]
		image_stack = self.ds.GetProjectedImages(id_list)
		self.chart.SetTooltipImageStack(image_stack)
		self.chart.SetTooltipShowImage(True)
		# self.chart.SetTooltipImageScalingFactor(2.0)
		self.chart.SetTooltipImageTargetSize(40)
		
		axis_images = self.ds.GetNodeBasisImages(test_id)
		center_image = self.ds.GetNodeCenterImage(test_id)
		self.ai.SetAxisImagesHorizontal()
		self.ai.SetChartXY(self.chart)
		self.ai.SetChartXYView(self.chartView)
		self.ai.SetAxisImageStack(axis_images)
		self.ai.SetCenterImage(center_image)
		
		# Set up annotation link which will carry indices to parallel coordinates chart
		# for highlighting outside selections (e.g. back from image_flow)
		# This needs to carry indices, while image_flow link outputs pedigree ids
		# so conversion happens in HighlightSelectionCallback
# 		data_col_idxs = vtk.vtkAnnotationLink()
# 		data_col_idxs.GetCurrentSelection().GetNode(0).SetFieldType(1)     # Point
# 		data_col_idxs.GetCurrentSelection().GetNode(0).SetContentType(4)   # 2 = PedigreeIds, 4 = Indices
# 		self.chart.SetDataColumnsLink(data_col_idxs)
# 		self.ai.SetDataColumnsLink(data_col_idxs)

		# Create a annotation link to access selection in XY chart
		annotationLink = vtk.vtkAnnotationLink()
		annotationLink.GetCurrentSelection().GetNode(0).SetFieldType(1)     # Point
		annotationLink.GetCurrentSelection().GetNode(0).SetContentType(4)   # Indices
		# Connect the annotation link to the parallel coordinates representation
		self.chart.SetAnnotationLink(annotationLink)
		self.chart.GetAnnotationLink().AddObserver("AnnotationChangedEvent", self.IcicleSelectionCallback)

		# Set up annotation link which will carry indices to parallel coordinates chart
		# for highlighting outside selections (e.g. back from image_flow)
		# This needs to carry indices, while image_flow link outputs pedigree ids
		# so conversion happens in HighlightSelectionCallback
		highlight_link_idxs = vtk.vtkAnnotationLink()
		highlight_link_idxs.GetCurrentSelection().GetNode(0).SetFieldType(1)     # Point
		highlight_link_idxs.GetCurrentSelection().GetNode(0).SetContentType(4)   # 2 = PedigreeIds, 4 = Indices
		self.chart.SetHighlightLink(highlight_link_idxs)
		
		# Fill selection link with dummy IDs
		id_array = N.array([0],dtype='int64')
		id_list = VN.numpy_to_vtkIdTypeArray(id_array, deep=True)
		highlight_link_idxs.GetCurrentSelection().GetNode(0).SetSelectionList(id_list)
		highlight_link_idxs.InvokeEvent("AnnotationChangedEvent")

# 		self.updater = vtk.vtkViewUpdater()
# 		self.updater.AddAnnotationLink(data_col_idxs)
# 		self.updater.AddView(self.axisView)
# 		self.updater.AddView(self.chartView)
		
# 		col_array = N.array([0,1],dtype='int64')
# 		col_vtk = VN.numpy_to_vtkIdTypeArray(col_array, deep=True)
# 		data_col_idxs.GetCurrentSelection().GetNode(0).SetSelectionList(col_vtk)
# 		data_col_idxs.InvokeEvent("AnnotationChangedEvent")
		
		self.chart.RecalculateBounds()

		# Only need to Start() interactor for one view
		# self.pc_class.GetView().GetInteractor().Start()
		# Shouldn't have to do this render...
		for rw in self.renWinList:
			rw.Render()
示例#12
0
 def SetStyle(self, style=None):
     if style:
         self.style = style
     else:
         self.style = vtk.vtkInteractorStyleRubberBand2D()
示例#13
0
	def __init__(self, parent = None):
	
		# Number of slider divisions per integer value
		self.divs = 10

		# self.rot_method = 'alt_axis'
		self.rot_method = '111'
		# self.rot_method = 'simple'
		
		self.axis_rescale = False

		QtGui.QMainWindow.__init__(self, parent)
		self.ui = Ui_MainWindow()
		   
		# Set up a 2D scene, add an XY chart to it
		self.view = vtk.vtkContextView()
		self.view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
		
		self.ui.setupUi(self, self.view.GetRenderWindow())

		if self.rot_method == 'alt_axis':
			self.ui.comboBox.setCurrentIndex(0)
		elif self.rot_method == '111':
			self.ui.comboBox.setCurrentIndex(1)
		else:
			self.ui.comboBox.setCurrentIndex(2)
			
		style = vtk.vtkInteractorStyleRubberBand2D()
		self.view.GetInteractor().SetInteractorStyle(style)
		self.view.GetScene().SetInteractorStyle(style)
		# Need this additional command (plus above set style) for this class
		# self.view.SetInteractionModeTo2D()
		
		self.chart = vtk.vtkChartXY()
		self.chart.SetShowLegend(False)

		# Create a annotation link to access selection in parallel coordinates view
		annotationLink = vtk.vtkAnnotationLink()
		# If you don't set the FieldType explicitly it ends up as UNKNOWN (as of 21 Feb 2010)
		# See vtkSelectionNode doc for field and content type enum values
		annotationLink.GetCurrentSelection().GetNode(0).SetFieldType(1)     # Point
		annotationLink.GetCurrentSelection().GetNode(0).SetContentType(4)   # Indices
		# Connect the annotation link to the parallel coordinates representation
		self.chart.SetAnnotationLink(annotationLink)
		
		self.view.GetScene().AddItem(self.chart)		
		
		# Set up callback to update 3d render window when selections are changed in 
		#	parallel coordinates view
		annotationLink.AddObserver("AnnotationChangedEvent", self.selectionCallback)
						
		QtCore.QObject.connect(self.ui.actionExit, QtCore.SIGNAL("triggered()"), self.fileExit)
		QtCore.QObject.connect(self.ui.actionOpen, QtCore.SIGNAL("triggered()"), self.LoadData)
		QtCore.QObject.connect(self.ui.horizontalSlider, QtCore.SIGNAL("valueChanged(int)"), self.columnUpdate)
		QtCore.QObject.connect(self.ui.comboBox, QtCore.SIGNAL("currentIndexChanged(int)"), self.rotMethodChanged)
		
		self.LoadData()
		
		self.view.ResetCamera()
		self.ui.vtkWidget.GetRenderWindow().Render()
		self.view.GetInteractor().Start()
示例#14
0
    def plot(self, struct):

        # creates self. data1, legend, filename, fieldname, dim, has_field, tracker, revision
        if not self.call_config(struct):
            return

        # creates self.src
        #if not self.call_src():
        #    return

        self.rens[0].SetBackground((1.0, 1.0, 1.0))
        self.xyplot = vtk.vtkXYPlotActor()

        if self.tracker.is_void:
            return False
        elif self.tracker.type == "node_files":
            series_num = 0
            labels = []

            trackers = self.tracker.trackers
            self.dataname = []
            for tracker in trackers:
                self.dataname.append(tracker.get_vtkfile())

            for name in self.dataname:
                res = self.Gr2_File_to_Polydata(name)
                polydata = res.get('polydata')
                labels.extend(res.get('labels')[min(len(labels), 3):])
                series_num = series_num + res.get('series_num')

                for pd in polydata:
                    if vtk.vtkVersion.GetVTKMajorVersion() < 6:
                        self.xyplot.AddInput(pd)
                    else:
                        self.xyplot.AddDataSetInput(pd)
#            return False
        else:
            self.dataname = self.tracker.get_vtkfile()
            #returns 'labels', 'series_num' and 'polydata' keys
            res = self.Gr2_File_to_Polydata(self.dataname)

            polydata = res.get('polydata')
            labels = res.get('labels')
            series_num = res.get('series_num')

            for pd in polydata:
                if vtk.vtkVersion.GetVTKMajorVersion() < 6:
                    self.xyplot.AddInput(pd)
                else:
                    self.xyplot.AddDataSetInput(pd)

        self.xyplot.GetPositionCoordinate().SetValue(self.pospi0)
        self.xyplot.GetPosition2Coordinate().SetValue(self.pospt0)  # rel
        # relative to the ones avobe
        self.xyplot.SetLegendPosition(self.posli0)
        self.xyplot.SetLegendPosition2(self.poslt0)  # rel

        #        self.xyplot.SetXValuesToArcLength()
        self.xyplot.SetXValuesToValue()

        temp = labels[0]
        if temp is None:
            temp = '2D graph'
        self.xyplot.SetTitle(temp)
        temp = labels[1]
        if temp is None:
            temp = 'X axis'
        self.xyplot.SetXTitle(temp)
        temp = labels[2]
        if temp is None:
            temp = 'Y axis'
        self.xyplot.SetYTitle(temp)

        for t in range(series_num):
            temp = labels[3 + t]
            if temp is None:
                temp = 'Series ' + unicode(t)
            self.xyplot.SetPlotLabel(t, temp)
            self.xyplot.SetPlotColor(t, palette[t % len(palette)])

        self.xyplot.LegendOn()

        self.xyplot.PlotPointsOn()

        self.xyplot.GetProperty().SetColor(0.0, 0.0, 0.0)
        self.xyplot.GetProperty().SetPointSize(3)
        # Set text prop color (same color for backward compat with test)
        # Assign same object to all text props
        tprop = self.xyplot.GetTitleTextProperty()
        tprop.SetColor(self.xyplot.GetProperty().GetColor())
        self.xyplot.SetAxisTitleTextProperty(tprop)
        self.xyplot.SetAxisLabelTextProperty(tprop)

        self.copy_params(struct)

        self.set_iren()
        self.inter = vtk.vtkInteractorStyleRubberBand2D()
        #self.inter = vtk.vtkInteractorStyleRubberBandZoom()
        self.inter.SetInteractor(self.iren)
        self.widget.SetInteractorStyle(self.inter)

        self.rens[0].AddActor(self.xyplot)

        self.last = None
        self.inter.AddObserver("SelectionChangedEvent", self.selection)
        # meanwhile not enough with the above:
        self.inter.AddObserver("StartInteractionEvent", self.selectioni)
        self.inter.AddObserver("EndInteractionEvent", self.selectionf)

        self.done = True
示例#15
0
import math
import vtkvtg
from data_source import DataSource

data_file = '/Users/emonson/Data/Fodava/EMoGWDataSets/mnist1_5c_20100324.mat'

# DataSource loads .mat file and can generate data from it for other views
ds = DataSource(data_file)


renwin = vtk.vtkRenderWindow()
renwin.SetMultiSamples(0)
renwin.SetSize(400, 600)

iren = vtk.vtkRenderWindowInteractor()
istyle = vtk.vtkInteractorStyleRubberBand2D()
iren.SetInteractorStyle(istyle)
iren.SetRenderWindow(renwin)

# setup the 2 view ports
viewports = [(0.0,0.0,1.0,0.5), (0.0,0.5,1.0,1.0)]

# CHART
chartRen = vtk.vtkRenderer()
chartRen.SetBackground(1.0,1.0,1.0)
chartRen.SetViewport(viewports[1])
renwin.AddRenderer(chartRen)

# Testing my custom chart class which has image hover tooltips
chart = vtkvtg.vtkMyChartXY()
chartScene = vtk.vtkContextScene()
示例#16
0
    def loadGraph():
        
        # ----------
        # Load and construct whole graph and multi-resolution data from Matlab structure
        dataDir = '/Users/emonson/Programming/Matlab/EMonson/Fodava/DocumentAnalysis/Analysis/'
        filename = dataDir + 'X20_042709b.mat'
        # filename = '/Users/emonson/Programming/Python/VTK/X20_040609b.mat'
        X = scipy.io.loadmat(filename)
        # Get graph structure G out of matlab variables
        G = X['G']
        
        # ----------
        # Set multi-resolution level bounds in GUI sliders
        levelMax = G.Tree.shape[0]-1
        ui_window.hSlider_level.setMinimum(1)
        ui_window.hSlider_level.setMaximum(levelMax)
        ui_window.spinBox_level.setMinimum(1)
        ui_window.spinBox_level.setMaximum(levelMax)
        
        # Start setting up basis function for display as subgraph
        ExtBasis = GTree[level,0]['ExtBasis'][0][0][0]
        basisMax = ExtBasis.shape[1]-1    # zero-based indices
        
        # Set particular level basis function bounds in GUI sliders
        ui_window.hSlider_basisIndex.setMinimum(0)
        ui_window.hSlider_basisIndex.setMaximum(basisMax)
        ui_window.spinBox_basisIndex.setMinimum(0)
        ui_window.spinBox_basisIndex.setMaximum(basisMax)
        
        # Build table which will become graph
        table = vtk.vtkTable()
        col0 = vtk.vtkIntArray()
        col0.SetName('index1')
        col1 = vtk.vtkIntArray()
        col1.SetName('index2')
        val = vtk.vtkDoubleArray()
        val.SetName('weight')
        
        Tmat = G.T
        # Tmat = G.W
        
        for ii in range(Tmat.nzmax):
            col0.InsertNextValue(Tmat.rowcol(ii)[0])
            col1.InsertNextValue(Tmat.rowcol(ii)[1])
            val.InsertNextValue(abs(Tmat.getdata(ii)))
        
        table.AddColumn(col0)
        table.AddColumn(col1)
        table.AddColumn(val)
        
        # Vertex links need to be done with index2 first or indexing won't be right...
        # TODO: Make this foolproof so that graph always ends up with correct ordering of indices...
        tgraph = vtk.vtkTableToGraph()
        tgraph.SetInput(table)
        tgraph.AddLinkVertex('index2', 'stuff', False)
        tgraph.AddLinkVertex('index1', 'stuff', False)
        tgraph.AddLinkEdge('index2', 'index1')
        
        rawGraph = tgraph.GetOutput()
        rawGraph.Update()
        # print graph
        
        # Load and assign whole graph pre-layout coordinates
        ptsFile = os.path.splitext(filename)[0] + '_pts.vtp'
        if os.path.exists(ptsFile):
            polyreader = vtk.vtkXMLPolyDataReader()
            polyreader.SetFileName(ptsFile)
            polyreader.Update()
            pts = polyreader.GetOutput().GetPoints()
            rawGraph.SetPoints(pts)
            # print pts
            
        strategy = vtk.vtkPassThroughLayoutStrategy()
        layout = vtk.vtkGraphLayout()
        layout.SetInput(rawGraph)
        layout.SetLayoutStrategy(strategy)
        
        edgeLayout = vtk.vtkEdgeLayout()
        edgeStrategy = vtk.vtkArcParallelEdgeStrategy()
        edgeStrategy.SetNumberOfSubdivisions(50)
        edgeLayout.SetInputConnection(layout.GetOutputPort())
        edgeLayout.SetLayoutStrategy(edgeStrategy)
        
        graph = edgeLayout.GetOutput()
        graph.Update()
        
        # --------
        # Add ExtBasis to graph data & Select particular basis function
        
        # print 'ExtBasis shape: ' + str(ExtBasis[:,basisNum].data.shape) + ' (level,basis) (' + str(level) + ',' + str(basisNum) + ')'
        
        # Indexing of ExtBasis is backwards from graph, so need to reverse with [::-1]
        # and array not "contiguous" if don't do .copy()
        Esub = ExtBasis[:,basisNum].data[::-1].copy()
        EsubSq = Esub**2
        # Esub = N.random.random(ExtBasis[:,basisNum].data.shape[0])
        # SubIdxs = (Esub > 0.001).nonzero()
        # SubIdxs = (Esub**2 > 0.8).nonzero()
        
        # Set ExtBasis vertex data from numpy array
        basisFunc = VN.numpy_to_vtk(Esub)
        basisFunc.SetName('ExtBasis')
        basisFuncSq = VN.numpy_to_vtk(EsubSq)
        basisFuncSq.SetName('ExtBasisSq')
        
        vertexData = graph.GetVertexData()
        vertexData.AddArray(basisFunc)
        vertexData.AddArray(basisFuncSq)
        
        selection = vtk.vtkSelectionSource()
        selection.SetContentType(7) # vtkSelection::THRESHOLDS
        # selection.SetContentType(2) # vtkSelection::PEDIGREE_IDS
        selection.SetFieldType(3) # vtkSelection::VERTEX
        selection.SetArrayName("ExtBasisSq")
        selection.AddThreshold(basisCutoff, 10)
        # TODO: There was something wrong with the indexing in the PEDIGREE_IDS selection...
        # for ii in SubIdxs[0]:
        #     selection.AddID(0,ii)
        minmax = "(%3.2e, %3.2e)" % (EsubSq.min(), EsubSq.max())
        ui_window.label_basisCutoff_minmax.setText(minmax)
        selection.Update()
        
        # ----------
        # Back to pipeline
        degree = vtk.vtkVertexDegree()
        degree.SetInput(graph)
        
        subgraph = vtk.vtkExtractSelectedGraph()
        subgraph.SetRemoveIsolatedVertices(False)
        subgraph.SetInputConnection(degree.GetOutputPort())
        subgraph.SetSelectionConnection(selection.GetOutputPort())
        
        # +++++++++++++
        graphToPoly = vtk.vtkGraphToPolyData()
        graphToPoly.SetInputConnection(subgraph.GetOutputPort())
        edgeMapper = vtk.vtkPolyDataMapper()
        edgeMapper.SetInputConnection(graphToPoly.GetOutputPort())
        edgeMapper.SetScalarModeToUseCellData()
        edgeMapper.SetScalarVisibility(False)
        edgeMapper.SetImmediateModeRendering(True)
        edgeActor = vtk.vtkActor()
        edgeActor.SetMapper(edgeMapper)
        edgeActor.SetPosition(0, 0, -0.003);
        
        lut = vtk.vtkLookupTable()
        lutNum = 256
        lut.SetNumberOfTableValues(lutNum)
        ctf = vtk.vtkColorTransferFunction()
        ctf.SetColorSpaceToDiverging()
        ctf.AddRGBPoint(0.0, 0, 0, 1.0)
        ctf.AddRGBPoint(1.0, 1.0, 0, 0)
        for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]):
            cc = ctf.GetColor(ss)
            lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0)
        
        vertGlyph = vtk.vtkVertexGlyphFilter()
        vertGlyph.SetInputConnection(subgraph.GetOutputPort())
        vertMapper = vtk.vtkPolyDataMapper()
        vertMapper.SetInputConnection(vertGlyph.GetOutputPort())
        vertMapper.SetImmediateModeRendering(True)
        vertMapper.SetScalarModeToUsePointFieldData()
        vertMapper.SetLookupTable(lut)
        vertMapper.SelectColorArray('ExtBasis')
        vertMapper.Update()
        vertRange = vertMapper.GetInput().GetPointData().GetArray(vertMapper.GetArrayName()).GetRange()
        vertMapper.SetScalarRange(-1.0*vertRange[1], vertRange[1])
        vertActor = vtk.vtkActor()
        vertActor.SetMapper(vertMapper)
        
        outlineMapper = vtk.vtkPolyDataMapper()
        outlineMapper.SetScalarVisibility(False)
        outlineMapper.SetImmediateModeRendering(True)
        outlineMapper.SetInputConnection(vertGlyph.GetOutputPort())
        outlineActor = vtk.vtkActor()
        outlineActor.PickableOff()
        outlineActor.SetPosition(0, 0, -0.001)
        outlineActor.GetProperty().SetRepresentationToWireframe()
        outlineActor.SetMapper(outlineMapper)
        
        # Create an Actor Collection for applying visibility to group
        basisActorCollection = vtk.vtkActorCollection()
        basisActorCollection.AddItem(vertActor)
        # basisActorCollection.AddItem(edgeActor)
        basisActorCollection.AddItem(outlineActor)
        
        
        # Apply a theme to the views
        theme = vtk.vtkViewTheme.CreateMellowTheme()
        theme.SetLineWidth(3)
        theme.SetPointSize(5)
        theme.SetSelectedCellColor(1,1,1)
        theme.SetSelectedPointColor(1,1,1)
        theme.SetOutlineColor(0.8, 0.8, 0.8)
        # theme.SetPointColor(0.9, 0.7, 0.3)
        theme.SetCellColor(0.9, 0.7, 0.3)
        # theme.SetPointOpacity(0.5)
        # theme.SetPointHueRange(0.0, 0.15)
        # theme.SetPointSaturationRange(0.6, 0.8)
        # theme.SetPointValueRange(0.4,0.8)
        # theme.SetPointAlphaRange(0.2,0.8)
        # theme.SetPointAlphaRange(1.0,1.0)

        
        # Apply theme
        # vertActor.GetProperty().SetColor(theme.GetPointColor())
        # vertActor.GetProperty().SetOpacity(theme.GetPointOpacity())
        vertActor.GetProperty().SetPointSize(theme.GetPointSize())
        outlineActor.GetProperty().SetPointSize(vertActor.GetProperty().GetPointSize()+2)
        outlineActor.GetProperty().SetColor(theme.GetOutlineColor())
        outlineActor.GetProperty().SetOpacity(theme.GetPointOpacity())
        edgeActor.GetProperty().SetColor(theme.GetCellColor())
        edgeActor.GetProperty().SetOpacity(theme.GetCellOpacity())
        edgeActor.GetProperty().SetLineWidth(theme.GetLineWidth())
        
        
        # ----------
        # Background graph skeleton
        graphMapper = vtk.vtkGraphMapper()
        graphMapper.SetInputConnection(0, degree.GetOutputPort(0))
        
        # Apply a theme to the background graph
        gtheme = vtk.vtkViewTheme()
        gtheme.SetLineWidth(1)
        gtheme.SetPointSize(0)
        gtheme.SetCellColor(0.8, 0.8, 0.8)
        gtheme.SetCellOpacity(0.2)
        gtheme.SetOutlineColor(0.8, 0.8, 0.8)
        gtheme.SetPointColor(0.8, 0.8, 0.8)
        gtheme.SetPointOpacity(0.0)
        graphMapper.ApplyViewTheme(gtheme)

        graphActor = vtk.vtkActor()
        graphActor.SetMapper(graphMapper)
        graphActor.SetPosition(0,0,-0.005)
        
        # ----------
        # Background vertices
        graphPoly = vtk.vtkGraphToPolyData()
        graphPoly.SetInputConnection(0, tgraph.GetOutputPort(0))
        
        vertGlyph = vtk.vtkGlyph3D()
        vertGlyph.SetInputConnection(0, graphPoly.GetOutputPort())
        glyphSource = vtk.vtkGlyphSource2D()
        glyphSource.SetGlyphTypeToVertex()
        # glyphSource.SetGlyphTypeToCircle()
        # glyphSource.SetScale(0.025)
        vertGlyph.SetInputConnection(1, glyphSource.GetOutputPort())
        
        vertexMapper = vtk.vtkPolyDataMapper()
        vertexMapper.SetInputConnection(vertGlyph.GetOutputPort())
        vertexActor = vtk.vtkActor()
        vertexActor.SetMapper(vertexMapper)
        vertexActor.GetProperty().SetPointSize(4)
        vertexActor.GetProperty().SetOpacity(0.5)
        vertexActor.GetProperty().SetColor(0.6, 0.6, 0.6)
        vertexActor.SetPosition(0, 0, -0.004)
        
        # ----------
        # Vertex index labels
        labelMapper = vtk.vtkDynamic2DLabelMapper()
        labelMapper.SetInputConnection(0, graphPoly.GetOutputPort(0))
        labelMapper.SetLabelModeToLabelFieldData()
        labelMapper.SetFieldDataName("label")
        labelMapper.SetLabelFormat("%s")
        labelMapper.GetLabelTextProperty().SetColor(0.0, 0.0, 0.0)
        
        labelActor = vtk.vtkActor2D()
        labelActor.SetMapper(labelMapper)
        
        # ----------
        # MultiScale Graph
        msGraph = buildSubGraph(level) 
        
        msMapper = vtk.vtkGraphMapper()
        msMapper.SetInput(msGraph)
        msMapper.SetColorEdges(True)
        msMapper.SetEdgeColorArrayName('weight')
        
        # Apply a theme to the background graph
        mtheme = vtk.vtkViewTheme()
        mtheme.SetLineWidth(3)
        mtheme.SetPointSize(11)
        # mtheme.SetCellColor(0.5, 0.5, 0.7)
        # mtheme.SetCellOpacity(0.5)
        mtheme.SetOutlineColor(0.8, 0.8, 0.8)
        mtheme.SetPointColor(0.3, 0.3, 0.6)
        mtheme.SetPointOpacity(1.0)
        mtheme.SetCellHueRange(0.67, 0.67)
        mtheme.SetCellSaturationRange(0.6, 0.1)
        mtheme.SetCellValueRange(0.5,1.0)
        mtheme.SetCellAlphaRange(0.2,0.8)
        msMapper.ApplyViewTheme(mtheme)

        msActor = vtk.vtkActor()
        msActor.SetMapper(msMapper)
        msActor.SetPosition(0,0,-0.002)
        
        # ----------
        # Set up window and add actors        
        view.SetLayoutStrategyToPassThrough()
        # view.ApplyViewTheme(theme)                
        # view.SetupRenderWindow(win)
        view.GetRenderer().SetBackground(theme.GetBackgroundColor())
        view.GetRenderer().SetBackground2(theme.GetBackgroundColor2())
        view.GetRenderer().SetGradientBackground(True)
        view.GetRenderer().AddActor(vertActor)
        view.GetRenderer().AddActor(outlineActor)
        view.GetRenderer().AddActor(edgeActor)
        view.GetRenderer().AddActor(graphActor)
        view.GetRenderer().AddActor(vertexActor)
        view.GetRenderer().AddActor(labelActor)
        view.GetRenderer().AddActor(msActor)
        
        # ----------
        # General interactor
        isty = vtk.vtkInteractorStyleRubberBand2D()
        # RubberBand2D assumes/needs parallel projection ON
        view.GetRenderer().GetActiveCamera().ParallelProjectionOn()
        iren = view.GetRenderWindow().GetInteractor()
        iren.SetInteractorStyle(isty)        
        # Interactor style must be set before scalar bar can be shown
        # view.SetVertexScalarBarVisibility(True)

        sbActor = vtk.vtkScalarBarActor()
        sbActor.SetLookupTable(vertMapper.GetLookupTable())
        sbActor.SetTitle(vertMapper.GetArrayName())
        sbActor.SetNumberOfLabels(3)
        vertexScalarBar = vtk.vtkScalarBarWidget()
        vertexScalarBar.SetScalarBarActor(sbActor)
        vertexScalarBar.SetInteractor(iren)
        vertexScalarBar.SetDefaultRenderer(view.GetRenderer())
        vertexScalarBar.SetCurrentRenderer(view.GetRenderer())
        vertexScalarBar.SetEnabled(True)
        scalarBarRep = vertexScalarBar.GetRepresentation()
        scalarBarRep.SetOrientation(1)  # 0 = Horizontal, 1 = Vertical
        scalarBarRep.GetPositionCoordinate().SetValue(0.05,0.05)
        scalarBarRep.GetPosition2Coordinate().SetValue(0.15,0.25)
        
        # Adding it this way gets it to show up, but it's not interactive
        view.GetRenderer().AddActor(sbActor)
        view.ResetCamera()
        view.Render()
        
        # ----------
        # Add Actors to QListWidget to allow check and uncheck for visibility
        listItem0 = QtGui.QListWidgetItem()
        listItem0.setText('Index Labels')
        listItem0.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        labelActor.SetVisibility(0)
        listItem0.setCheckState(QtCore.Qt.Unchecked)
        # Put actor it in as data in the list widget item
        listItem0.setData(QtCore.Qt.UserRole, QtCore.QVariant(labelActor))
        ui_window.listWidget.insertItem(0,listItem0)
        
        # Test retrieval of actor from list widget item
        # tmpItem = ui_window.listWidget.item(0)
        # tmpQtActor = tmpItem.data(QtCore.Qt.UserRole)
        # tmpActor = tmpQtActor.toPyObject()
        # tmpActor.SetVisibility(0)
        
        # Shorter way to add item to list widget
        listItem1 = QtGui.QListWidgetItem('Vertices (background)', ui_window.listWidget)
        listItem1.setData(QtCore.Qt.UserRole, QtCore.QVariant(vertexActor))
        listItem1.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem1.setCheckState(QtCore.Qt.Checked)

        listItem2 = QtGui.QListWidgetItem('Graph (background)', ui_window.listWidget)
        listItem2.setData(QtCore.Qt.UserRole, QtCore.QVariant(graphActor))
        listItem2.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem2.setCheckState(QtCore.Qt.Checked)

        listItem3 = QtGui.QListWidgetItem()
        listItem3.setText('Basis Function Vertices')
        listItem3.setData(QtCore.Qt.UserRole, QtCore.QVariant(basisActorCollection))
        listItem3.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem3.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(1,listItem3)
        
        listItem6 = QtGui.QListWidgetItem()
        listItem6.setText('Basis Function Edges')
        listItem6.setData(QtCore.Qt.UserRole, QtCore.QVariant(edgeActor))
        listItem6.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem6.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(2,listItem6)
        
        listItem4 = QtGui.QListWidgetItem()
        listItem4.setText('MultiScale Graph')
        listItem4.setData(QtCore.Qt.UserRole, QtCore.QVariant(msActor))
        listItem4.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem4.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(3,listItem4)
                
        listItem5 = QtGui.QListWidgetItem()
        listItem5.setText('Basis Function Scale Bar')
        listItem5.setData(QtCore.Qt.UserRole, QtCore.QVariant(sbActor))
        listItem5.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem5.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(3,listItem5)
        
        iren.Initialize()
        iren.Start()
示例#17
0
def main():
    img_reader = ImageReaderFactory().GenerateImageReader("png")
    img_reader.SetFileName("./kitti/image_00/000000.png")
    img_actor = ImageActor(img_reader.GetOutputPort())

    sphereSource = vtk.vtkSphereSource()
    sphereSource.SetRadius(4.0)
    sphereSource.Update()

    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(sphereSource.GetOutputPort())

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)

    renderer = vtk.vtkRenderer()
    renderWindow = vtk.vtkRenderWindow()

    renderWindow.AddRenderer(renderer)

    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renderWindow)

    borderWidget = vtk.vtkBorderWidget()
    borderWidget.SetInteractor(interactor)

    representation = vtk.vtkBorderRepresentation()
    representation.SetPosition(0, 0)
    representation.SetPosition2(0.1, 0.1)
    borderWidget.SetRepresentation(representation)

    # borderWidget.CreateDefaultRepresentation()
    borderWidget.SelectableOff()
    borderWidget.On()
    print(representation)

    style = vtk.vtkInteractorStyleRubberBand2D()

    def gen(style, event):
        size = renderWindow.GetSize()
        start = list(style.GetStartPosition())
        end = list(style.GetEndPosition())
        new_start = [start[0], end[1]]
        new_end = [end[0], start[1]]
        print("start,end: ", start, end)
        print("new_start,new_end: ", new_start, new_end)
        tmp = [new_start[0] / size[0], new_start[1] / size[1]]

        print("scaled bottom_left: ", tmp)
        print("scaled top_right: ", new_end[0] / size[0], new_end[1] / size[1])
        representation = vtk.vtkBorderRepresentation()
        borderWidget = vtk.vtkBorderWidget()

        representation.SetPosition(tmp[0], tmp[1])
        representation.SetPosition2(new_end[0] / size[0] - tmp[0],
                                    new_end[1] / size[1] - tmp[1])

        representation.SetMoving(0)
        print("Moving status: ", representation.GetMoving())
        borderWidget.SetRepresentation(representation)
        borderWidget.SetInteractor(interactor)
        borderWidget.ResizableOn()
        # borderWidget.CreateDefaultRepresentation()
        # borderWidget.SelectableO()
        borderWidget.On()
        renderWindow.Render()
        widgets.append(borderWidget)

    # def stylecallback(style, event):
    #     size = renderWindow.GetSize()
    #     start = list(style.GetStartPosition())
    #     end = list(style.GetEndPosition())
    #     new_start = [start[0], end[1]]
    #     new_end = [end[0], start[1]]
    #     print("start,end: ", start, end)
    #     print("new_start,new_end: ", new_start, new_end)
    #     tmp = [new_start[0] / size[0], new_start[1] / size[1]]

    #     print("scaled bottom_left: ", tmp)
    #     print("scaled top_right: ", new_end[0] / size[0], new_end[1] / size[1])
    #     r = vtk.vtkBorderRepresentation()
    #     # representation.MovingOff()
    #     borderWidget = vtk.vtkBorderWidget()
    #     # representation.ResizableOff()
    #     # representation = vtk.vtkBorderRepresentation()
    #     # representation
    #     borderWidget.SelectableOff()
    #     # global Flag
    #     # if Flag:
    #     #     borderWidget.SelectableOn()
    #     #     Flag = False
    #     # else:
    #     #     borderWidget.SelectableOff()
    #     #     Flag = True

    #     # representation.SetPosition(tmp[0], tmp[1])
    #     # representation.SetPosition2(
    #     #     new_end[0] / size[0] - tmp[0], new_end[1] / size[1] - tmp[1])

    #     # representation.SetMoving(1)
    #     # print("Moving status: ", representation.GetMoving())
    #     # borderWidget.CreateDefaultRepresentation()
    #     # r = borderWidget.GetBorderRepresentation()
    #     r.MovingOff()
    #     r.SetPosition(tmp[0], tmp[1])
    #     r.SetPosition2(
    #         new_end[0] / size[0] - tmp[0], new_end[1] / size[1] - tmp[1])
    #     r.SetMoving(1)
    #     r.BuildRepresentation()
    #     borderWidget.SetRepresentation(r)
    #     borderWidget.SetInteractor(interactor)
    #     # borderWidget.ResizableOff()
    #     # borderWidget.CreateDefaultRepresentation()
    #     # borderWidget.SelectableOn()
    #     borderWidget.On()
    #     print(r)
    #     renderWindow.Render()
    #     widgets.append(borderWidget)

    # style.AddObserver("SelectionChangedEvent", stylecallback)
    interactor.SetInteractorStyle(style)
    renderer.AddActor(actor)
    renderer.AddActor(img_actor.actor)

    interactor.Initialize()
    renderWindow.Render()
    # borderWidget.On()

    interactor.Start()