예제 #1
0
    def __init__(self, x, y, xrange_=10.):
        super(VTKPlot, self).__init__()
        self.setGeometry(50, 50, 700, 350)

        self.setWindowOpacity(1.)

        self.view = vtk.vtkContextView()
        chartMatrix = vtk.vtkChartMatrix()
        chartMatrix.SetSize(vtk.vtkVector2i(1, 1))
        chartMatrix.SetGutter(vtk.vtkVector2f(50, 50))

        self.vtkWidget = QVTKRenderWindowInteractor(self)
        self.view.SetRenderWindow(self.vtkWidget.GetRenderWindow())
        self.view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        self.view.GetScene().AddItem(chartMatrix)

        self.chart = chartMatrix.GetChart(vtk.vtkVector2i(0, 0))
        self.arrY = vtk.vtkFloatArray()
        self.arrX = vtk.vtkFloatArray()

        self.table = vtk.vtkTable()
        self.add_plot(x, y, xrange_=xrange_)

        self.chart.GetAxis(vtk.vtkAxis.BOTTOM).SetTitle("Time")
        self.chart.GetAxis(vtk.vtkAxis.LEFT).SetTitle("Signal")

        self.view.GetRenderWindow().SetMultiSamples(0)
        self.view.GetRenderWindow().Render()

        layout = QGridLayout()
        layout.addWidget(self.vtkWidget, 0, 0)

        self.setLayout(layout)
    def set_multiple_xy_data(self, x_array, y_arrays_list, title):
        if not title:
            title = 'N/A'
        self.chart.SetTitle(title)
        self.chart.ClearPlots()
        self.chart.GetAxis(0).SetTitle('')
        self.chart.GetAxis(1).SetTitle(x_array.GetName())

        self.table = vtk.vtkTable()

        self.table.AddColumn(x_array)
        for var_index, y_array in enumerate(y_arrays_list):
            self.table.AddColumn(y_array)
            line = self.chart.AddPlot(vtk.vtkChart.LINE)
            line.SetInputData(self.table, 0, var_index + 1)

            _index = var_index % len(self.line_colors)
            color_rgb = self.line_colors[_index]

            line.SetColor(*color_rgb)
            line.GetPen().SetLineType(self.line_types[_index])
            line.SetWidth(self.line_width[_index])

        self.set_active()
        self.render()
예제 #3
0
    def testMultiTreeOutputs(self):
        outputs = vtk.vtkStringArray()
        outputs.SetNumberOfComponents(1)
        outputs.SetNumberOfTuples(2)
        outputs.SetValue(0, "tree1")
        outputs.SetValue(1, "tree2")
        rcal = vtk.vtkRCalculatorFilter()


        rcal.SetRscript("library(ape)\n\
                         tree1 = read.tree(text=\"" + tree_data + "\")\n\
                         tree2 = read.tree(text=\"" + tree_data + "\")\n")

        rcal.GetTrees(outputs)

        input = vtk.vtkTable()
        rcal.SetInputData(input)

        rcal.Update()

        compo = rcal.GetOutput()
        tree1 = compo.GetPieceAsDataObject(0)
        self.assertTrue(tree1.IsA('vtkTree'))
        tree2 = compo.GetPieceAsDataObject(1)
        self.assertTrue(tree2.IsA('vtkTree'))
    def set_xy_data(self, x_array, y_array, title):
        if not title:
            title = 'N/A'
        self.chart.SetTitle(title)
        self.chart.ClearPlots()

        self.table = vtk.vtkTable()

        self.table.AddColumn(x_array)
        self.table.AddColumn(y_array)

        line = self.chart.AddPlot(vtk.vtkChart.LINE)

        self.chart.GetAxis(1).SetTitle(x_array.GetName())
        self.chart.GetAxis(0).SetTitle(y_array.GetName())

        line.SetInputData(self.table, 0, 1)

        line.SetColor(*self.line_colors[0])
        line.SetWidth(self.line_width[0])
        line.GetPen().SetLineType(self.line_types[0])

        self.set_active()

        self.render()
    def testTableInputOutput(self):
        rcal = vtk.vtkRCalculatorFilter()
        rcal.SetRscript("output = input\n")
        rcal.PutTable('input')
        rcal.GetTable('output')

        value = 1
        array = vtk.vtkDoubleArray()
        array.SetNumberOfComponents(1)
        array.SetNumberOfTuples(4)
        array.SetName('test')
        for i in range(0, 4):
            array.SetValue(i, value)
            value += 1

        input = vtk.vtkTable()
        input.AddColumn(array)
        rcal.SetInputData(input)

        rcal.Update()

        t1 = rcal.GetOutput().GetColumnByName('test')
        value = 1

        for i in range(0, t1.GetNumberOfTuples()):
            self.assertEqual(value, t1.GetValue(i))
            value += 1
def addPlot(chart, reader, name):
    data1 = reader.GetOutput()

    coords = vtk.vtkFloatArray()
    coords.SetName("Coords")

    for i in range(data1.GetNumberOfPoints()):
        x, y, z = data1.GetPoint(i)
        coords.InsertNextValue(y)

    table = vtk.vtkTable()
    table.AddColumn(coords)
    table.AddColumn(data1.GetPointData().GetArray("S_g"))
    table.AddColumn(data1.GetPointData().GetArray("S_n"))
    table.AddColumn(data1.GetPointData().GetArray("S_w"))

    line1 = chart.AddPlot(vtk.vtkChart.LINE)
    line1.SetInput(table, 0, 1)
    line1.SetMarkerStyle(vtk.vtkPlotPoints.CROSS)

    line2 = chart.AddPlot(vtk.vtkChart.LINE)
    line2.SetInput(table, 0, 2)
    line2.SetMarkerStyle(vtk.vtkPlotPoints.PLUS)

    line3 = chart.AddPlot(vtk.vtkChart.LINE)
    line3.SetInput(table, 0, 3)
    line3.SetMarkerStyle(vtk.vtkPlotPoints.CIRCLE)
예제 #7
0
    def generateParallelCoordinatesPlot( self ):
        input = self.inputModule().getOutput() 
        ptData = input.GetPointData()
        narrays = ptData.GetNumberOfArrays()
        arrays = []
        # Create a table with some points in it...
        table = vtk.vtkTable()
        for iArray in range( narrays ):
            table.AddColumn(  ptData.GetArray( iArray ) )                  
        
        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
#        view.SetRenderer( self.renderer )    
#        view.SetRenderWindow( self.renderer.GetRenderWindow() )
        view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        view.GetRenderWindow().SetSize(600,300)
        
        plot = vtk.vtkPlotParallelCoordinates()
        plot.SetInput(table)
                
        view.GetScene().AddItem(plot)
                                
        view.ResetCamera()
        view.Render()       
        # Start interaction event loop
        view.GetInteractor().Start()
예제 #8
0
    def testTableInputOutput(self):
        rcal = vtk.vtkRCalculatorFilter()
        rcal.SetRscript("output = input\n");
        rcal.PutTable('input')
        rcal.GetTable('output')

        value = 1
        array = vtk.vtkDoubleArray()
        array.SetNumberOfComponents(1)
        array.SetNumberOfTuples(4)
        array.SetName('test')
        for i in range(0, 4):
            array.SetValue(i, value)
            value += 1

        input = vtk.vtkTable()
        input.AddColumn(array)
        rcal.SetInputData(input)

        rcal.Update()

        t1 = rcal.GetOutput().GetColumnByName('test')
        value = 1

        for i in range(0, t1.GetNumberOfTuples()):
            self.assertEqual(value, t1.GetValue(i))
            value += 1
예제 #9
0
def make_spreadsheet(column_names, table):
    # column_names is a list of strings
    # table is a 2D numpy.ndarray
    # returns a vtkTable object that stores the table content

    # Create a vtkTable to store the output.
    rows = table.shape[0]

    if (table.shape[1] != len(column_names)):
        print('Warning: table number of columns differs from number of '
              'column names')
        return

    from vtk import vtkTable, vtkFloatArray
    vtk_table = vtkTable()
    for (column, name) in enumerate(column_names):
        array = vtkFloatArray()
        array.SetName(name)
        array.SetNumberOfComponents(1)
        array.SetNumberOfTuples(rows)
        vtk_table.AddColumn(array)

        for row in range(0, rows):
            array.InsertValue(row, table[row, column])

    return vtk_table
예제 #10
0
파일: sgems.py 프로젝트: shineusn/PVGeo
 def RequestData(self, request, inInfo, outInfo):
     """Used by pipeline to get output data object for given time step.
     Constructs the ``vtkImageData``
     """
     # Get output:
     output = vtk.vtkImageData.GetData(outInfo)
     # Get requested time index
     i = _helpers.getRequestedTime(self, outInfo)
     if self.NeedToRead():
         self._ReadUpFront()
     # Generate the data object
     n1, n2, n3 = self.__extent
     dx, dy, dz = self.__spacing
     ox, oy, oz = self.__origin
     output.SetDimensions(n1 + 1, n2 + 1, n3 + 1)
     output.SetSpacing(dx, dy, dz)
     output.SetOrigin(ox, oy, oz)
     # Use table generater and convert because its easy:
     table = vtk.vtkTable()
     interface.dataFrameToTable(self._GetRawData(idx=i), table)
     # now get arrays from table and add to point data of pdo
     for i in range(table.GetNumberOfColumns()):
         output.GetCellData().AddArray(table.GetColumn(i))
     del (table)
     return 1
예제 #11
0
 def RequestData(self, request, inInfo, outInfo):
     """Used by pipeline to get data for current timestep and populate the
     output data object. This assumes that ``self._get_raw_data()`` will return
     a dataset ready for PVGeo's ``interface.points_to_poly_data()``.
     """
     # Get output:
     output = self.GetOutputData(outInfo, 0)
     # Get requested time index
     i = _helpers.get_requested_time(self, outInfo)
     if self.need_to_read():
         self._read_up_front()
     # Get the data which has already been loaded
     data = self._get_raw_data(idx=i)
     # Generate the data object
     nx, ny, nz = self.get_extent(dim=True)
     dx, dy, dz = self.__spacing
     ox, oy, oz = self.__origin
     output.SetDimensions(nx+1, ny+1, nz+1)
     output.SetSpacing(dx, dy, dz)
     output.SetOrigin(ox, oy, oz)
     # Use table generater and convert because its easy:
     table = vtk.vtkTable()
     interface.data_frame_to_table(data, table)
     # now get arrays from table and add to cell data of output
     for i in range(table.GetNumberOfColumns()):
         output.GetCellData().AddArray(table.GetColumn(i))
     del(table)
     return 1 # NOTE: ALWAYS return 1 on pipeline methods
예제 #12
0
def main():
    colors = vtk.vtkNamedColors()

    chart = vtk.vtkChartXYZ()
    chart.SetGeometry(vtk.vtkRectf(10.0, 10.0, 630, 470))

    plot = vtk.vtkPlotSurface()

    view = vtk.vtkContextView()
    view.GetRenderer().SetBackground(colors.GetColor3d("Silver"))
    view.GetRenderWindow().SetSize(640, 480)
    view.GetScene().AddItem(chart)

    # Create a surface
    table = vtk.vtkTable()
    numPoints = 70
    inc = 9.424778 / (numPoints - 1)
    for i in range(numPoints):
        arr = vtk.vtkFloatArray()
        table.AddColumn(arr)

    table.SetNumberOfRows(numPoints)
    for i in range(numPoints):
        x = i * inc
        for j in range(numPoints):
            y = j * inc
            table.SetValue(i, j, sin(sqrt(x * x + y * y)))

    # Set up the surface plot we wish to visualize and add it to the chart
    plot.SetXRange(0, 10.0)
    plot.SetYRange(0, 10.0)
    plot.SetInputData(table)
    plot.GetPen().SetColorF(colors.GetColor3d("Tomato"))
    chart.AddPlot(plot)

    view.GetRenderWindow().SetMultiSamples(0)
    view.GetInteractor().Initialize()
    view.GetRenderWindow().Render()

    # Rotate
    mouseEvent = vtk.vtkContextMouseEvent()
    mouseEvent.SetInteractor(view.GetInteractor())

    pos = vtk.vtkVector2i()

    lastPos = vtk.vtkVector2i()
    mouseEvent.SetButton(vtk.vtkContextMouseEvent.LEFT_BUTTON)
    lastPos.Set(100, 50)
    mouseEvent.SetLastScreenPos(lastPos)
    pos.Set(150, 100)
    mouseEvent.SetScreenPos(pos)

    sP = [float(x) for x in pos]
    lSP = [float(x) for x in lastPos]
    screenPos = [float(x) for x in mouseEvent.GetScreenPos()]
    lastScreenPos = [float(x) for x in mouseEvent.GetLastScreenPos()]

    chart.MouseMoveEvent(mouseEvent)

    view.GetInteractor().Start()
def addPlot(chart, reader, name):
        data1 = reader.GetOutput()
        
        coords = vtk.vtkFloatArray()
        coords.SetName("Coords")

        for i in range(data1.GetNumberOfPoints()):
                x,y,z = data1.GetPoint(i)
		coords.InsertNextValue(y)

	table = vtk.vtkTable()
	table.AddColumn(coords)
	table.AddColumn(data1.GetPointData().GetArray("S_g"))
        table.AddColumn(data1.GetPointData().GetArray("S_n"))
        table.AddColumn(data1.GetPointData().GetArray("S_w"))

        line1 = chart.AddPlot(vtk.vtkChart.LINE)
        line1.SetInput(table, 0, 1)
	line1.SetMarkerStyle(vtk.vtkPlotPoints.CROSS)

        line2 = chart.AddPlot(vtk.vtkChart.LINE)
        line2.SetInput(table, 0, 2)
	line2.SetMarkerStyle(vtk.vtkPlotPoints.PLUS)

        line3 = chart.AddPlot(vtk.vtkChart.LINE)
        line3.SetInput(table, 0, 3)
        line3.SetMarkerStyle(vtk.vtkPlotPoints.CIRCLE)
예제 #14
0
def make_spreadsheet(column_names, table):
    # column_names is a list of strings
    # table is a 2D numpy.ndarray
    # returns a vtkTable object that stores the table content
    require_internal_mode()

    # Create a vtkTable to store the output.
    rows = table.shape[0]

    if (table.shape[1] != len(column_names)):
        print('Warning: table number of columns differs from number of '
              'column names')
        return

    from vtk import vtkTable, vtkFloatArray
    vtk_table = vtkTable()
    for (column, name) in enumerate(column_names):
        array = vtkFloatArray()
        array.SetName(name)
        array.SetNumberOfComponents(1)
        array.SetNumberOfTuples(rows)
        vtk_table.AddColumn(array)

        for row in range(0, rows):
            array.InsertValue(row, table[row, column])

    return vtk_table
예제 #15
0
    def testLinePlot(self):
        "Test if line plots can be built with python"

        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
        view.GetRenderer().SetBackground(1.0,1.0,1.0)
        view.GetRenderWindow().SetSize(400,300)
        chart = vtk.vtkChartXY()
        view.GetScene().AddItem(chart)

        # Create a table with some points in it
        table = vtk.vtkTable()

        arrX = vtk.vtkFloatArray()
        arrX.SetName("X Axis")

        arrC = vtk.vtkFloatArray()
        arrC.SetName("Cosine")

        arrS = vtk.vtkFloatArray()
        arrS.SetName("Sine")

        arrS2 = vtk.vtkFloatArray()
        arrS2.SetName("Sine2")

        numPoints = 69
        inc = 7.5 / (numPoints - 1)

        for i in range(0,numPoints):
            arrX.InsertNextValue(i*inc)
            arrC.InsertNextValue(math.cos(i * inc) + 0.0)
            arrS.InsertNextValue(math.sin(i * inc) + 0.0)
            arrS2.InsertNextValue(math.sin(i * inc) + 0.5)

        table.AddColumn(arrX)
        table.AddColumn(arrC)
        table.AddColumn(arrS)
        table.AddColumn(arrS2)

        # Now add the line plots with appropriate colors
        line = chart.AddPlot(0)
        line.SetInput(table,0,1)
        line.SetColor(0,255,0,255)
        line.SetWidth(1.0)

        line = chart.AddPlot(0)
        line.SetInput(table,0,2)
        line.SetColor(255,0,0,255);
        line.SetWidth(5.0)

        line = chart.AddPlot(0)
        line.SetInput(table,0,3)
        line.SetColor(0,0,255,255);
        line.SetWidth(4.0)

        view.GetRenderWindow().SetMultiSamples(0)

        img_file = "TestLinePlot.png"
        vtk.test.Testing.compareImage(view.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25)
        vtk.test.Testing.interact()
예제 #16
0
def main():
    # Use the specified filename
    output_filename = get_program_parameters()

    # Construct an empty table
    table = vtk.vtkTable()

    for i in range(0, 3):
        col = vtk.vtkVariantArray()
        col_name = "column-" + str(i)
        col.SetName(col_name)

        col.InsertNextValue(vtk.vtkVariant(0.0))
        col.InsertNextValue(vtk.vtkVariant(0.0))
        col.InsertNextValue(vtk.vtkVariant(0.0))
        table.AddColumn(col)

    # Fill the table with values
    counter = 0
    for r in range(0, table.GetNumberOfRows()):
        for c in range(table.GetNumberOfColumns()):
            table.SetValue(r, c, vtk.vtkVariant(counter))
            counter += 1

    writer = vtk.vtkDelimitedTextWriter()
    writer.SetFileName(output_filename)
    writer.SetInputData(table)
    writer.Write()
예제 #17
0
 def RequestData(self, request, inInfo, outInfo):
     """Used by pipeline to get output data object for given time step.
     Constructs the ``vtkImageData``
     """
     # Get output:
     output = vtk.vtkImageData.GetData(outInfo)
     # Get requested time index
     i = _helpers.get_requested_time(self, outInfo)
     if self.need_to_read():
         self._read_up_front()
     # Generate the data object
     n1, n2, n3 = self.__extent
     dx, dy, dz = self.__spacing
     ox, oy, oz = self.__origin
     output.SetDimensions(n1 + 1, n2 + 1, n3 + 1)
     output.SetSpacing(dx, dy, dz)
     output.SetOrigin(ox, oy, oz)
     # Use table generator and convert because its easy:
     table = vtk.vtkTable()
     df = self._get_raw_data(idx=i)
     # Replace all masked values with NaN
     df.replace(self.__mask, np.nan, inplace=True)
     interface.data_frame_to_table(df, table)
     # now get arrays from table and add to point data of pdo
     for i in range(table.GetNumberOfColumns()):
         output.GetCellData().AddArray(table.GetColumn(i))
     del (table)
     return 1
예제 #18
0
    def addPlot(self,_plotName,_style="Lines"):   # called directly from Steppable; add a (possibly more than one) plot to a plot window

        self.plotWindowInterfaceMutex.lock()
#        self.plotWindowMutex.lock()

#        return
#        print MODULENAME,'   addPlot():  _plotName= ',_plotName
#        import pdb; pdb.set_trace()
        
#        self.plotData[_plotName] = [array([],dtype=double),array([],dtype=double),False]  # 'array': from PyQt4.Qwt5.anynumpy import *
        
        self.chart = vtk.vtkChartXY()
#        self.chart.GetAxis(vtk.vtkAxis.LEFT).SetLogScale(True)
#        self.chart.GetAxis(vtk.vtkAxis.BOTTOM).SetLogScale(True)
#        self.numCharts += 1
        self.plotData[_plotName] = [self.chart]

        self.view = vtk.vtkContextView()
        self.ren = self.view.GetRenderer()
#        self.renWin = self.qvtkWidget.GetRenderWindow()
        self.renWin = self.pW.GetRenderWindow()
        self.renWin.AddRenderer(self.ren)

        # Create a table with some points in it
        self.table = vtk.vtkTable()

        self.arrX = vtk.vtkFloatArray()
        self.arrX.SetName("xarray")

        self.arrC = vtk.vtkFloatArray()
        self.arrC.SetName("yarray")

        numPoints = 5
        numPoints = 15
        inc = 7.5 / (numPoints - 1)

#        for i in range(0,numPoints):
#            self.arrX.InsertNextValue(i*inc)
#            self.arrC.InsertNextValue(math.cos(i * inc) + 0.0)

#        self.arrX.InsertNextValue(0.0)
#        self.arrC.InsertNextValue(0.0)
#        self.arrX.InsertNextValue(0.1)
#        self.arrC.InsertNextValue(0.1)

        self.table.AddColumn(self.arrX)
        self.table.AddColumn(self.arrC)

        # Now add the line plots with appropriate colors
        self.line = self.chart.AddPlot(0)
        self.line.SetInput(self.table,0,1)
        self.line.SetColor(0,0,255,255)
        self.line.SetWidth(1.0)


        self.view.GetRenderer().SetBackground([0.6,0.6,0.1])
        self.view.GetRenderer().SetBackground([1.0,1.0,1.0])
        self.view.GetScene().AddItem(self.chart)

        self.plotWindowInterfaceMutex.unlock()
    def testMultiTableOutputs(self):
        outputs = vtk.vtkStringArray()
        outputs.SetNumberOfComponents(1)
        outputs.SetNumberOfTuples(3)
        outputs.SetValue(0, "output1")
        outputs.SetValue(1, "output2")
        outputs.SetValue(2, "output3")
        rcal = vtk.vtkRCalculatorFilter()
        rcal.SetRscript("output1 = list(test=c(1,2,3,4))\n\
                         output2 = list(test=c(5,6,7,8))\n\
                         output3 = list(test=c(9,10,11,12))\n")

        rcal.GetTables(outputs)

        input = vtk.vtkTable()
        rcal.SetInputData(input)

        rcal.Update()

        t1 = rcal.GetOutput().GetPieceAsDataObject(0).GetColumnByName('test')
        value = 1

        for i in range(0, t1.GetNumberOfTuples()):
            self.assertEqual(value, t1.GetValue(i))
            value += 1

        t2 = rcal.GetOutput().GetPieceAsDataObject(1).GetColumnByName('test')
        for i in range(0, t2.GetNumberOfTuples()):
            self.assertEqual(value, t2.GetValue(i))
            value += 1

        t3 = rcal.GetOutput().GetPieceAsDataObject(2).GetColumnByName('test')
        for i in range(0, t3.GetNumberOfTuples()):
            self.assertEqual(value, t3.GetValue(i))
            value += 1
예제 #20
0
def calcPCA(xarray, yarray):
    ''' Computes the eigenvalues/eigenvectors of the covariance matrix for the terminal particle positions. '''
    
    #See: http://www.vtk.org/Wiki/VTK/Examples/Cxx/Utilities/PCAStatistics
    datasetTable = vtk.vtkTable()
    datasetTable.AddColumn(xarray)
    datasetTable.AddColumn(yarray)
    
    pcaStatistics = vtk.vtkPCAStatistics()
    
    pcaStatistics.SetInputData( vtk.vtkStatisticsAlgorithm.INPUT_DATA, datasetTable )
    
    pcaStatistics.SetColumnStatus('x', 1 )
    pcaStatistics.SetColumnStatus('y', 1 )
    pcaStatistics.RequestSelectedColumns()
    pcaStatistics.SetDeriveOption(True)
    pcaStatistics.Update()
 
    # Eigenvalues 
    eigenvalues = vtk.vtkDoubleArray()
    pcaStatistics.GetEigenvalues(eigenvalues)

    for idx in range(0,eigenvalues.GetNumberOfTuples()):
    #for eigenvalue in eigenvalues:
        print 'Eigenvalue ' + str(idx) + ' = ' + str(eigenvalues.GetValue(idx))
 
    # Eigenvectors 
    eigenvectors = vtk.vtkDoubleArray()
    pcaStatistics.GetEigenvectors(eigenvectors)
    
    for idx in range(0,eigenvectors.GetNumberOfTuples()):
        print 'Eigenvector ' + str(idx) + ' : '
        evec = [0]*eigenvectors.GetNumberOfComponents()
        eigenvectors.GetTuple(idx, evec)
        print evec
    def generateParallelCoordinatesPlot(self):
        input = self.inputModule().getOutput()
        ptData = input.GetPointData()
        narrays = ptData.GetNumberOfArrays()
        arrays = []
        # Create a table with some points in it...
        table = vtk.vtkTable()
        for iArray in range(narrays):
            table.AddColumn(ptData.GetArray(iArray))

        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
        #        view.SetRenderer( self.renderer )
        #        view.SetRenderWindow( self.renderer.GetRenderWindow() )
        view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        view.GetRenderWindow().SetSize(600, 300)

        plot = vtk.vtkPlotParallelCoordinates()
        plot.SetInput(table)

        view.GetScene().AddItem(plot)

        view.ResetCamera()
        view.Render()
        # Start interaction event loop
        view.GetInteractor().Start()
예제 #22
0
    def getFields(self):
        if not self.dataTable:
            # read a data file
            if '.csv' in self.inputFile:
                r = vtk.vtkDelimitedTextReader()
                r.DetectNumericColumnsOn()
                r.SetFileName(self.inputFile)
                r.SetHaveHeaders(True)
                r.Update()
                self.dataTable = r.GetOutput()
            else:
                reader = simple.OpenDataFile(self.inputFile)
                reader.UpdatePipeline()
                ds = reader.GetClientSideObject().GetOutputDataObject(0)
                if ds.IsA('vtkTable'):
                    self.dataTable = ds
                else:
                    self.dataTable = vtk.vtkTable()
                    fillTableWithDataSet(self.dataTable, ds)

        self.fields = {}
        self.columnNames = []
        self.numRows = self.dataTable.GetNumberOfRows()
        for i in range(self.dataTable.GetNumberOfColumns()):
            # Add a range for any numeric fields
            self.columnNames.append(self.dataTable.GetColumnName(i))
            arr = self.dataTable.GetColumn(i)
            if arr.GetDataTypeAsString() in NUMERIC_TYPES:
                self.fields[self.columnNames[i]] = {
                    'range': list(arr.GetRange())
                }

        return self.fields
예제 #23
0
 def RequestData(self, request, inInfo, outInfo):
     """Used by pipeline to get output data object for given time step. Constructs the ``vtkImageData``
     """
     # Get output:
     output = vtk.vtkImageData.GetData(outInfo)
     # Get requested time index
     i = _helpers.GetRequestedTime(self, outInfo)
     if self.NeedToRead():
         self._ReadUpFront()
     # Generate the data object
     n1, n2, n3 = self.__extent
     dx, dy, dz = self.__spacing
     ox, oy, oz = self.__origin
     output.SetDimensions(n1, n2, n3)
     output.SetExtent(0, n1 - 1, 0, n2 - 1, 0, n3 - 1)
     output.SetSpacing(dx, dy, dz)
     output.SetOrigin(ox, oy, oz)
     # Use table generater and convert because its easy:
     table = vtk.vtkTable()
     _helpers.placeArrInTable(self._GetRawData(idx=i), self.GetTitles(),
                              table)
     # now get arrays from table and add to point data of pdo
     for i in range(table.GetNumberOfColumns()):
         output.GetPointData().AddArray(table.GetColumn(i))
         #TODO: maybe we ought to add the data as cell data
     del (table)
     return 1
예제 #24
0
    def testBarGraph(self):
        "Test if bar graphs can be built with python"

        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
        view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        view.GetRenderWindow().SetSize(400, 300)
        chart = vtk.vtkChartXY()
        view.GetScene().AddItem(chart)

        # Create a table with some points in it
        table = vtk.vtkTable()

        arrMonth = vtk.vtkIntArray()
        arrMonth.SetName("Month")

        arr2008 = vtk.vtkIntArray()
        arr2008.SetName("2008")

        arr2009 = vtk.vtkIntArray()
        arr2009.SetName("2009")

        arr2010 = vtk.vtkIntArray()
        arr2010.SetName("2010")

        numMonths = 12

        for i in range(0, numMonths):
            arrMonth.InsertNextValue(i + 1)
            arr2008.InsertNextValue(data_2008[i])
            arr2009.InsertNextValue(data_2009[i])
            arr2010.InsertNextValue(data_2010[i])

        table.AddColumn(arrMonth)
        table.AddColumn(arr2008)
        table.AddColumn(arr2009)
        table.AddColumn(arr2010)

        # Now add the line plots with appropriate colors
        line = chart.AddPlot(2)
        line.SetInputData(table, 0, 1)
        line.SetColor(0, 255, 0, 255)

        line = chart.AddPlot(2)
        line.SetInputData(table, 0, 2)
        line.SetColor(255, 0, 0, 255)

        line = chart.AddPlot(2)
        line.SetInputData(table, 0, 3)
        line.SetColor(0, 0, 255, 255)

        view.GetRenderWindow().SetMultiSamples(0)
        view.GetRenderWindow().Render()

        img_file = "TestBarGraph.png"
        vtk.test.Testing.compareImage(
            view.GetRenderWindow(),
            vtk.test.Testing.getAbsImagePath(img_file),
            threshold=25)
        vtk.test.Testing.interact()
예제 #25
0
def main():
    view = vtk.vtkContextView()
    view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
    view.GetRenderWindow().SetSize(400, 300)

    chart = vtk.vtkChartXY()
    view.GetScene().AddItem(chart)
    chart.SetShowLegend(True)

    table = vtk.vtkTable()

    arrX = vtk.vtkFloatArray()
    arrX.SetName('X Axis')

    arrC = vtk.vtkFloatArray()
    arrC.SetName('Cosine')

    arrS = vtk.vtkFloatArray()
    arrS.SetName('Sine')

    arrT = vtk.vtkFloatArray()
    arrT.SetName('Sine-Cosine')

    table.AddColumn(arrC)
    table.AddColumn(arrS)
    table.AddColumn(arrX)
    table.AddColumn(arrT)

    numPoints = 40

    inc = 7.5 / (numPoints - 1)
    table.SetNumberOfRows(numPoints)
    for i in range(numPoints):
        table.SetValue(i, 0, i * inc)
        table.SetValue(i, 1, math.cos(i * inc))
        table.SetValue(i, 2, math.sin(i * inc))
        table.SetValue(i, 3, math.sin(i * inc) - math.cos(i * inc))

    points = chart.AddPlot(vtk.vtkChart.POINTS)
    points.SetInputData(table, 0, 1)
    points.SetColor(0, 0, 0, 255)
    points.SetWidth(1.0)
    points.SetMarkerStyle(vtk.vtkPlotPoints.CROSS)

    points = chart.AddPlot(vtk.vtkChart.POINTS)
    points.SetInputData(table, 0, 2)
    points.SetColor(0, 0, 0, 255)
    points.SetWidth(1.0)
    points.SetMarkerStyle(vtk.vtkPlotPoints.PLUS)

    points = chart.AddPlot(vtk.vtkChart.POINTS)
    points.SetInputData(table, 0, 3)
    points.SetColor(0, 0, 255, 255)
    points.SetWidth(1.0)
    points.SetMarkerStyle(vtk.vtkPlotPoints.CIRCLE)

    view.GetRenderWindow().SetMultiSamples(0)
    view.GetInteractor().Initialize()
    view.GetInteractor().Start()
예제 #26
0
def test_multi_block_init_vtk():
    multi = vtk.vtkMultiBlockDataSet()
    multi.SetBlock(0, vtk.vtkRectilinearGrid())
    multi.SetBlock(1, vtk.vtkTable())
    multi = pyvista.MultiBlock(multi)
    assert isinstance(multi, pyvista.MultiBlock)
    assert multi.n_blocks == 2
    assert isinstance(multi[0], pyvista.RectilinearGrid)
    assert isinstance(multi[1], vtk.vtkTable)
    multi = vtk.vtkMultiBlockDataSet()
    multi.SetBlock(0, vtk.vtkRectilinearGrid())
    multi.SetBlock(1, vtk.vtkTable())
    multi = pyvista.MultiBlock(multi, deep=True)
    assert isinstance(multi, pyvista.MultiBlock)
    assert multi.n_blocks == 2
    assert isinstance(multi[0], pyvista.RectilinearGrid)
    assert isinstance(multi[1], vtk.vtkTable)
예제 #27
0
파일: TestBarGraph.py 프로젝트: kramarb/VTK
    def testBarGraph(self):
        "Test if bar graphs can be built with python"

        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
        view.GetRenderer().SetBackground(1.0,1.0,1.0)
        view.GetRenderWindow().SetSize(400,300)
        chart = vtk.vtkChartXY()
        view.GetScene().AddItem(chart)

        # Create a table with some points in it
        table = vtk.vtkTable()

        arrMonth = vtk.vtkIntArray()
        arrMonth.SetName("Month")

        arr2008 = vtk.vtkIntArray()
        arr2008.SetName("2008")

        arr2009 = vtk.vtkIntArray()
        arr2009.SetName("2009")

        arr2010 = vtk.vtkIntArray()
        arr2010.SetName("2010")

        numMonths = 12

        for i in range(0,numMonths):
            arrMonth.InsertNextValue(i + 1)
            arr2008.InsertNextValue(data_2008[i])
            arr2009.InsertNextValue(data_2009[i])
            arr2010.InsertNextValue(data_2010[i])

        table.AddColumn(arrMonth)
        table.AddColumn(arr2008)
        table.AddColumn(arr2009)
        table.AddColumn(arr2010)

        # Now add the line plots with appropriate colors
        line = chart.AddPlot(2)
        line.SetInput(table,0,1)
        line.SetColor(0,255,0,255)

        line = chart.AddPlot(2)
        line.SetInput(table,0,2)
        line.SetColor(255,0,0,255);

        line = chart.AddPlot(2)
        line.SetInput(table,0,3)
        line.SetColor(0,0,255,255);

        view.GetRenderWindow().SetMultiSamples(0)
	view.GetRenderWindow().Render()

        img_file = "TestBarGraph.png"
        vtk.test.Testing.compareImage(view.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25)
        vtk.test.Testing.interact()
예제 #28
0
  def __init__(self):
    self.i = 0 
    self.props_name = {} 

    self.table = vtk.vtkTable() 
    self.view  = vtk.vtkContextView() 
    self.view.GetRenderer().SetBackground(1.0, 1.0, 1.0);

    print "+Vtk_plot"
예제 #29
0
def gslib(FileName, deli=' ', useTab=False, numIgLns=0, pdo=None):
    """
    Description
    -----------
    Reads a GSLIB file format to a vtkTable. The GSLIB file format has headers lines followed by the data as a space delimited ASCI file (this filter is set up to allow you to choose any single character delimiter). The first header line is the title and will be printed to the console. This line may have the dimensions for a grid to be made of the data. The second line is the number (n) of columns of data. The next n lines are the variable names for the data in each column. You are allowed up to ten characters for the variable name. The data follow with a space between each field (column).

    Parameters
    ----------
    `FileName` : str
    - The absolute file name with path to read.

    `deli` : str
    - The input files delimiter. To use a tab delimiter please set the `useTab`.

    `useTab` : boolean
    - A boolean that describes whether to use a tab delimiter.

    `numIgLns` : int
    - The integer number of lines to ignore.

    `pdo` : vtk.vtkTable, optional
    - A pointer to the output data object.

    Returns
    -------
    Returns a vtkTable of the input data file.

    """
    if pdo is None:
        pdo = vtk.vtkTable() # vtkTable

    if (useTab):
        deli = '\t'

    titles = []
    data = []
    with open(FileName) as f:
        reader = csv.reader(f, delimiter=deli)
        # Skip defined lines
        for i in range(numIgLns):
            next(f)

        # Get file header (part of format)
        header = next(f) # TODO: do something with the header
        #print(os.path.basename(FileName) + ': ' + header)
        # Get titles
        numCols = int(next(f))
        for i in range(numCols):
            titles.append(next(f).rstrip('\r\n'))

        # Read data
        for row in reader:
            data.append(row)

    _rows2table(data, titles, pdo)

    return pdo, header
예제 #30
0
 def initializeSelection(self):
   if not self.dataTableSelection:
     self.dataTableSelection = vtk.vtkTable()
     self.dataTableSelection.ShallowCopy(self.dataTable)
     self._userSelection = vtk.vtkUnsignedCharArray()
     self._userSelection.SetNumberOfTuples(self.numRows)
     self._userSelection.SetName(USER_SELECTION)
     self._userSelection.FillComponent(0, UNSELECTED_INDEX)
     self.dataTableSelection.AddColumn(self._userSelection)
예제 #31
0
 def setUp(self):
     # Create some input tables
     self.t0 = vtk.vtkTable()
     # Populate the tables
     self.n = 400
     self.title = 'Array 0'
     self.arr = np.random.random(self.n)  # Table 0
     self.t0.AddColumn(_helpers.numToVTK(self.arr, self.title))
     return
예제 #32
0
 def setUp(self):
     TestBase.setUp(self)
     # Create some input tables
     self.t0 = vtk.vtkTable()
     # Populate the tables
     self.n = 400
     self.title = 'Array 0'
     self.arr = np.random.random(self.n)  # Table 0
     self.t0.AddColumn(interface.convertArray(self.arr, self.title))
     return
예제 #33
0
    def __init__(self):
        self.i = 0
        self.props_name = {}

        self.table = vtk.vtkTable()
        self.view = vtk.vtkContextView()
        self.view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        self.view.GetRenderWindow().SetSize(600, 600)

        print "+Vtk_plot \'%s\'" % vtk.vtkVersion().GetVTKVersion()
예제 #34
0
def data_frame_to_table(df, pdo=None):
    """Converts a pandas DataFrame to a vtkTable"""
    if not isinstance(df, pd.DataFrame):
        raise PVGeoError('Input is not a pandas DataFrame')
    if pdo is None:
        pdo = vtk.vtkTable()
    for key in df.keys():
        VTK_data = convert_array(df[key].values, name=key)
        pdo.AddColumn(VTK_data)
    return wrap_vista(pdo)
예제 #35
0
파일: graph_widget.py 프로젝트: ladisk/DyS
    def __init__(self, measure_obj=None, parent=None):
        """
        Constructor
        """
        super(GraphWidget, self).__init__(parent=parent)

        #   parent
        self._parent = parent

        # self.frame = QtGui.QFrame()
        #
        # self.vl = QtGui.QVBoxLayout()
        self.view = vtk.vtkContextView()
        self.view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        # self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
        #
        # self.vl.addWidget(self.vtkWidget)

        self.view.SetInteractor(self.GetRenderWindow().GetInteractor())
        self.SetRenderWindow(self.view.GetRenderWindow())

        # self.ren = vtk.vtkRenderer()
        # self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        # self.interactor = self.vtkWidget.GetRenderWindow().GetInteractor()

        # self.frame.setLayout(self.vl)
        # self.setCentralWidget(self.frame)

        self.xy_data = vtk.vtkTable()
        self.arrX = vtk.vtkFloatArray()
        self.arrX.SetName("X Axis")
        self.xy_data.AddColumn(self.arrX)

        self.arrY = vtk.vtkFloatArray()
        self.arrY.SetName("Y value")
        self.xy_data.AddColumn(self.arrY)

        numPoints = 20
        inc = 7.5 / (numPoints - 1)
        self.xy_data.SetNumberOfRows(numPoints)
        for i in range(numPoints):
            self.xy_data.SetValue(i, 0, i * inc)
            self.xy_data.SetValue(i, 1, i * inc)

        # self.view = vtk.vtkContextView()
        # self.view.GetRenderer().SetBackground(1.0, 0.0, 1.0)
        #
        self.chart = vtk.vtkChartXY()
        self.chart.GetAxis(0).SetGridVisible(False)
        self.chart.GetAxis(1).SetGridVisible(False)

        self.view.GetScene().AddItem(self.chart)
        self.line = self.chart.AddPlot(vtk.vtkChart.LINE)
        self.line.SetInputData(self.xy_data, 0, 1)
예제 #36
0
 def setUp(self):
     # Create some input tables
     self.t0 = vtk.vtkTable()
     self.t1 = vtk.vtkTable()
     # Populate the tables
     self.n = 100
     self.titles = ('Array 0', 'Array 1', 'Array 2')
     self.arrs = [None, None, None]
     self.arrs[0] = np.random.random(self.n)  # Table 0
     self.arrs[1] = np.random.random(self.n)  # Table 0
     self.arrs[2] = np.random.random(self.n)  # Table 1
     self.t0.AddColumn(_helpers.numToVTK(self.arrs[0], self.titles[0]))
     self.t0.AddColumn(_helpers.numToVTK(self.arrs[1], self.titles[1]))
     self.t1.AddColumn(_helpers.numToVTK(self.arrs[2], self.titles[2]))
     # Now use the `CombineTables` filter:
     f = CombineTables()
     f.SetInputDataObject(0, self.t0)
     f.SetInputDataObject(1, self.t1)
     f.Update()
     self.TABLE = f.GetOutputDataObject(0)
예제 #37
0
 def setUp(self):
     # Create some input tables
     self.t0 = vtk.vtkTable()
     # Populate the tables
     self.arrs = [None, None]
     self.n = 400
     self.titles = ('Array 0', 'Array 1')
     self.arrs[0] = np.random.random(self.n)  # Table 0
     self.arrs[1] = np.random.random(self.n)  # Table 0
     self.t0.AddColumn(_helpers.numToVTK(self.arrs[0], self.titles[0]))
     self.t0.AddColumn(_helpers.numToVTK(self.arrs[1], self.titles[1]))
     return
예제 #38
0
    def generateParallelCoordinatesChart( self ):
        input = self.inputModule().getOutput() 
        ptData = input.GetPointData()
        narrays = ptData.GetNumberOfArrays()
        arrays = []
        # Create a table with some points in it...
        table = vtk.vtkTable()
        for iArray in range( narrays ):
            table.AddColumn(  ptData.GetArray( iArray ) )                  
        
        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
#        view.SetRenderer( self.renderer )    
#        view.SetRenderWindow( self.renderer.GetRenderWindow() )
        view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        view.GetRenderWindow().SetSize(600,300)
        
        chart = vtk.vtkChartParallelCoordinates()
        
        brush = vtk.vtkBrush()
        brush.SetColorF (0.1,0.1,0.1)
        chart.SetBackgroundBrush(brush)
        
        # 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
        chart.SetAnnotationLink(annotationLink)
        
        view.GetScene().AddItem(chart)
                
        
        chart.GetPlot(0).SetInput(table)
        
        def selectionCallback(caller, event):
                annSel = annotationLink.GetCurrentSelection()
                if annSel.GetNumberOfNodes() > 0:
                        idxArr = annSel.GetNode(0).GetSelectionList()
                        if idxArr.GetNumberOfTuples() > 0:
                                print VN.vtk_to_numpy(idxArr)
        
        # Set up callback to update 3d render window when selections are changed in 
        #       parallel coordinates view
        annotationLink.AddObserver("AnnotationChangedEvent", selectionCallback)
                
#        view.ResetCamera()
#        view.Render()       
#        view.GetInteractor().Start()
        return view 
예제 #39
0
	def GetNodeOneScaleCoeffTable(self, node_id):
		"""Returns a table of the wavelet coefficients at a single node at a single
		scale for plotting on a scatter plot. Relying on icicle_view already having
		called GetWaveletCoeffImages() with correct positions of leaf nodes in view,
		otherwise just using original Matlab-saved LeafNodes ordering.
		This version supports category labels."""

		if self.data_loaded:

			# For a given node_id, concatenate wavelet coeffs in proper order
			# (according to leaf node positions in icicle view if it was set already)
			# Columns of table will be rows of the wavelet coeffs image

			scale = self.Scales[node_id]

			leaf_offspring = N.array(list(self.get_leaf_children(self.cp, node_id)))
			offspring_idxs = self.LeafNodesImap[leaf_offspring]
			offspring_pos = self.mapped_leaf_pos[offspring_idxs]
			sorted_offspring_pos_idxs = N.argsort(offspring_pos)
			sorted_offspring_idxs = offspring_idxs[sorted_offspring_pos_idxs]
			img_tuple = tuple(pp for pp in self.CelCoeffs[sorted_offspring_idxs, scale])
			# The image comes out with shape (npts, ndims)
			# May need to reorder (reverse) this...?
			img = N.concatenate(img_tuple, axis=0)

			table = vtk.vtkTable()
			for ii in range(img.shape[1]):
				column = VN.numpy_to_vtk(img[:,ii].copy(), deep=True)
				column.SetName(str(scale) + '.' + str(ii))
				table.AddColumn(column)

			IDtuple = tuple(self.PointsInNet[xx] for xx in self.LeafNodes[sorted_offspring_idxs])
			IDarray = N.concatenate(IDtuple)
			# Trying to set PedigreeIds to that parallel coords selections have correct IDs
			IDvtk = VN.numpy_to_vtk(IDarray, deep=True)
			IDvtk.SetName('pedigree_ids')
			table.AddColumn(IDvtk)
			table.GetRowData().SetActivePedigreeIds('pedigree_ids')

			# Adding in category labels
			# Name needs to end in _ids so plots will ignore it
			if self.hasLabels:
				for ii in range(self.cat_labels.shape[0]):
					CATvtk = VN.numpy_to_vtk(self.cat_labels[ii,IDarray], deep=True)
					CATvtk.SetName(self.label_names[ii])
					table.AddColumn(CATvtk)

			return table


		else:
			raise IOError, "Can't get image until data is loaded successfully"
예제 #40
0
파일: plots.py 프로젝트: imclab/vistrails
    def createTable(self, matrix):
        table = vtk.vtkTable()
        for col, attr in zip(matrix.values.T, matrix.attributes):
            column = VN.numpy_to_vtk(col.copy(), deep=True)
            column.SetName(attr)
            table.AddColumn(column)
        self.chart.GetPlot(0).SetInput(table)

        min_ = matrix.values.min()-0.01
        max_ = matrix.values.max()+0.01
        for i in range(self.chart.GetNumberOfAxes()):
            self.chart.GetAxis(i).SetRange(min_, max_)
            self.chart.GetAxis(i).SetBehavior(vtk.vtkAxis.FIXED);
예제 #41
0
    def testTableOutput(self):
        rcal = vtk.vtkRCalculatorFilter()
        rcal.SetRscript("output = list(test=c(1,2,3,4))\n");
        rcal.GetTable('output')
        input = vtk.vtkTable()
        rcal.SetInputData(input)

        rcal.Update()

        t1 = rcal.GetOutput().GetColumnByName('test')
        value = 1

        for i in range(0, t1.GetNumberOfTuples()):
            self.assertEqual(value, t1.GetValue(i))
            value += 1
예제 #42
0
파일: TestEnsemble.py 프로젝트: 0004c/VTK
    def createSource(self):
        r = vtk.vtkEnsembleSource()

        aColumn = vtk.vtkIntArray()
        aColumn.SetName("Resolution")
        nrows = len(TestEnsemble.resolutions)
        for res in TestEnsemble.resolutions:
            aColumn.InsertNextValue(res)
        table = vtk.vtkTable()
        table.SetNumberOfRows(nrows)
        table.GetRowData().AddArray(aColumn)
        r.SetMetaData(table)

        for res in TestEnsemble.resolutions:
            c = vtk.vtkConeSource()
            c.SetResolution(res)
            r.AddMember(c)

        return r
def addPlot(chart, reader, name):
        data1 = reader.GetOutput()
        
        coords = vtk.vtkFloatArray()
        coords.SetName("Coords")

        for i in range(data1.GetNumberOfPoints()):
                x,y,z = data1.GetPoint(i)
		coords.InsertNextValue(y)

	scalars = data1.GetPointData().GetArray("P_w")
	scalars.SetName(name)

	table = vtk.vtkTable()
	table.AddColumn(coords)
	table.AddColumn(scalars)

        line1 = chart.AddPlot(vtk.vtkChart.LINE)
        line1.SetInput(table, 0, 1)
예제 #44
0
def PlotSelectedData(data, state, view, text_init):
    nb_sources = 0
    for i in range(data.GetPointData().GetNumberOfArrays()):
        if data.GetPointData().GetGlobalIds('Potentials-'+str(i)):
            nb_sources += 1
    view.GetRenderer().RemoveActor2D(text_init)
    chart = vtk.vtkChartXY()
    view.GetScene().RemoveItem(0)
    view.GetScene().AddItem(chart)
    chart.SetShowLegend(True)
    table = vtk.vtkTable()
    X = vtk.vtkDoubleArray(); X.SetName("X")
    if state:
        numPoints = data.GetNumberOfCells()
        chart.GetAxis(0).SetTitle('Current'); 
    else:
        numPoints = data.GetNumberOfPoints()
        chart.GetAxis(0).SetTitle('Potential'); 
    chart.GetAxis(0).SetRange(0,nb_sources)
    for j in range(nb_sources):
        X.InsertNextValue(j)
    table.AddColumn(X)
    for i in range(numPoints):
        Y = vtk.vtkDoubleArray()
        if state:
            Y.SetName("id"+str(data.GetCellData().GetGlobalIds('Indices').GetValue(i)))
        else:
            Y.SetName("id"+str(data.GetPointData().GetGlobalIds('Indices').GetValue(i)))
        for j in range(nb_sources):
            if state:
                Y.InsertNextValue(data.GetCellData().GetGlobalIds('Currents-'+str(j)).GetValue(i))
            else:
                Y.InsertNextValue(data.GetPointData().GetGlobalIds('Potentials-'+str(j)).GetValue(i))
        table.AddColumn(Y)
        # Now add the line plots
        line = chart.AddPlot(0)
        line.SetInput(table,0,i+1)
        line.SetColor(0,1,0)
        line.SetWidth(1.0)
    view.GetRenderWindow().Render()
 def testDistanceCalculator(self):
   "See whether the distance calculator evaluates functions properly."
   xv = vtk.vtkDoubleArray()
   yv = vtk.vtkDoubleArray()
   xv.SetName( 'x' )
   yv.SetName( 'y' )
   tab = vtk.vtkTable()
   xv.InsertNextValue( 0.0 )
   xv.InsertNextValue( 1.0 )
   xv.InsertNextValue( 0.0 )
   xv.InsertNextValue( 1.0 )
   xv.InsertNextValue( 5.0 )
   yv.InsertNextValue( 0.0 )
   yv.InsertNextValue( 0.0 )
   yv.InsertNextValue( 1.0 )
   yv.InsertNextValue( 1.0 )
   yv.InsertNextValue( 12.0 )
   tab.AddColumn( xv )
   tab.AddColumn( yv )
   km = vtk.vtkKMeansStatistics()
   km.SetDefaultNumberOfClusters( 1 )
   df = vtk.vtkKMeansDistanceFunctorCalculator()
   km.SetDistanceFunctor( df )
   df.SetDistanceExpression( 'sqrt( (x0-y0)*(x0-y0) + (x1-y1)*(x1-y1) )' )
   km.SetInput( tab )
   km.SetColumnStatus( 'x', 1 )
   km.SetColumnStatus( 'y', 1 )
   km.RequestSelectedColumns()
   km.SetLearnOption( 1 )
   km.SetDeriveOption( 1 )
   km.SetAssessOption( 1 )
   km.Update()
   av = km.GetOutput( 0 )
   # We should always converge to a cluster center at [ 1.4, 2.8 ]
   # These distances are the distances of each input observation to that cluster center:
   dists = [ 3.1304951684997055, 2.8284271247461898, 2.2803508501982757, 1.8439088914585773, 9.879271228182775 ]
   for i in range(5):
     self.failUnlessAlmostEqual( dists[i], av.GetColumn( 2 ).GetValue( i ) )
예제 #46
0
def calcPCA(xarray, yarray):
    ''' Returns the eigenvalue the covariance 
        matrix for the terminal particle positions. 
    '''
    
    datasetTable = vtk.vtkTable()
    datasetTable.AddColumn(xarray)
    datasetTable.AddColumn(yarray)
    
    pcaStatistics = vtk.vtkPCAStatistics()
    
    pcaStatistics.SetInputData( vtk.vtkStatisticsAlgorithm.INPUT_DATA, datasetTable )
    
    pcaStatistics.SetColumnStatus('x', 1 )
    pcaStatistics.SetColumnStatus('y', 1 )
    pcaStatistics.RequestSelectedColumns()
    pcaStatistics.SetDeriveOption(True)
    pcaStatistics.Update()
     
    eigenvalues = vtk.vtkDoubleArray()
    pcaStatistics.GetEigenvalues(eigenvalues)
    
    return eigenvalues.GetValue(0)
예제 #47
0
파일: Line.py 프로젝트: FHilty/moose
    def __init__(self, x_data=None, y_data=None, **kwargs):
        super(Line, self).__init__(**kwargs)

        # Storage for vtk line/point object
        self._vtkplot = None

        # Build the vtkTable that stores the data
        x = vtk.vtkFloatArray()
        x.SetName('x-data')
        y = vtk.vtkFloatArray()
        y.SetName('y-data')
        self._vtktable = vtk.vtkTable()
        self._vtktable.AddColumn(x)
        self._vtktable.AddColumn(y)

        # Storage for tracing lines
        self._xtracer = None
        self._ytracer = None

        # Set x,y data
        if x_data:
            self.setOption('x', x_data)
        if y_data:
            self.setOption('y', y_data)
예제 #48
0
    def testMultiTableOutputs(self):
        outputs = vtk.vtkStringArray()
        outputs.SetNumberOfComponents(1)
        outputs.SetNumberOfTuples(3)
        outputs.SetValue(0, "output1")
        outputs.SetValue(1, "output2")
        outputs.SetValue(2, "output3")
        rcal = vtk.vtkRCalculatorFilter()
        rcal.SetRscript("output1 = list(test=c(1,2,3,4))\n\
                         output2 = list(test=c(5,6,7,8))\n\
                         output3 = list(test=c(9,10,11,12))\n");

        rcal.GetTables(outputs)

        input = vtk.vtkTable()
        rcal.SetInputData(input)

        rcal.Update()


        t1 = rcal.GetOutput().GetPieceAsDataObject(0).GetColumnByName('test')
        value = 1

        for i in range(0, t1.GetNumberOfTuples()):
            self.assertEqual(value, t1.GetValue(i))
            value += 1

        t2  = rcal.GetOutput().GetPieceAsDataObject(1).GetColumnByName('test')
        for i in range(0, t2.GetNumberOfTuples()):
            self.assertEqual(value, t2.GetValue(i))
            value += 1

        t3  = rcal.GetOutput().GetPieceAsDataObject(2).GetColumnByName('test')
        for i in range(0, t3.GetNumberOfTuples()):
            self.assertEqual(value, t3.GetValue(i))
            value += 1
예제 #49
0
    def testStackedPlot(self):
        "Test if stacked plots can be built with python"

        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
        view.GetRenderer().SetBackground(1.0,1.0,1.0)
        view.GetRenderWindow().SetSize(400,300)
        chart = vtk.vtkChartXY()
        view.GetScene().AddItem(chart)

        # Create a table with some data in it
        table = vtk.vtkTable()

        arrMonthLabels = vtk.vtkStringArray()
        arrMonthPositions = vtk.vtkDoubleArray()

        arrMonth = vtk.vtkIntArray()
        arrMonth.SetName("Month")

        arrBooks = vtk.vtkIntArray()
        arrBooks.SetName("Books")

        arrNew = vtk.vtkIntArray()
        arrNew.SetName("New / Popular")

        arrPeriodical = vtk.vtkIntArray()
        arrPeriodical.SetName("Periodical")

        arrAudiobook = vtk.vtkIntArray()
        arrAudiobook.SetName("Audiobook")

        arrVideo = vtk.vtkIntArray()
        arrVideo.SetName("Video")

        numMonths = 12

        for i in range(0,numMonths):
            arrMonthLabels.InsertNextValue(month_labels[i])
            arrMonthPositions.InsertNextValue(float(i))

            arrMonth.InsertNextValue(i)
            arrBooks.InsertNextValue(book[i])
            arrNew.InsertNextValue(new_popular[i])
            arrPeriodical.InsertNextValue(periodical[i])
            arrAudiobook.InsertNextValue(audiobook[i])
            arrVideo.InsertNextValue(video[i])

        table.AddColumn(arrMonth)
        table.AddColumn(arrBooks)
        table.AddColumn(arrNew)
        table.AddColumn(arrPeriodical)
        table.AddColumn(arrAudiobook)
        table.AddColumn(arrVideo)

        # Set up the X Labels
        chart.GetAxis(1).SetCustomTickPositions(arrMonthPositions, arrMonthLabels)
        chart.GetAxis(1).SetMaximum(11)
        chart.GetAxis(1).SetBehavior(vtk.vtkAxis.FIXED)

        # Create the stacked plot
        stack = chart.AddPlot(3)
        stack.SetUseIndexForXSeries(True)
        stack.SetInputData(table)
        stack.SetInputArray(1,"Books")
        stack.SetInputArray(2,"New / Popular")
        stack.SetInputArray(3,"Periodical")
        stack.SetInputArray(4,"Audiobook")
        stack.SetInputArray(5,"Video")

        # Set up a nice color series
        colorSeries = vtk.vtkColorSeries()
        colorSeries.SetColorScheme(2)
        stack.SetColorSeries(colorSeries)

        view.GetRenderWindow().SetMultiSamples(0)
        view.GetRenderWindow().Render()

        img_file = "TestStackedPlot.png"
        vtk.test.Testing.compareImage(view.GetRenderWindow(),
                                      vtk.test.Testing.getAbsImagePath(img_file),
                                      threshold=25)
        vtk.test.Testing.interact()
예제 #50
0
	def __init__(self, parent = None):
	
		QtGui.QMainWindow.__init__(self, parent)
		self.ui = Ui_MainWindow()
		self.ui.setupUi(self)
		
		self.WordleView = vtkvtg.vtkQtWordleDebugView()
		
		# Set widget for the wordle view
		self.ui.centralWidget.layout().addWidget(self.WordleView.GetWidget())
		
		data_dir = '/Users/emonson/Data/Fodava/EMoGWDataSets/'
		data_file = data_dir + 'sciNews_20110216.mat'
			
		print 'Trying to load data set from .mat file...'

		try:
			MatInput = scipy.io.loadmat(data_file, struct_as_record=True, chars_as_strings=True)
		except:
			raise IOError, "Can't load supplied matlab file"
		
		self.mat_terms = MatInput['terms'].T[0]
		
		self.WavBases = []	# Wavelet bases
		self.Centers = [] # Center of each node
		# NodeWavCoeffs = []
		# NodeScalCoeffs = []
		for ii in range(MatInput['PointsInNet'].shape[1]):
			self.WavBases.append(N.mat(MatInput['WavBases'][0,ii]))			# matrix
			self.Centers.append(N.mat(MatInput['Centers'][0,ii][0]))		# matrix

		terms = vtk.vtkStringArray()
		terms.SetName('dictionary')
		terms.SetNumberOfComponents(1)
		for term in self.mat_terms:
			terms.InsertNextValue(term[0])
		
		self.basis_idx = 0
		
		coeffs = VN.numpy_to_vtk(self.WavBases[self.basis_idx][::-1,0]*100, deep=True)
		coeffs.SetName('coefficient')
		c_sign = VN.numpy_to_vtk(N.sign(self.WavBases[self.basis_idx][::-1,0]), deep=True)
		c_sign.SetName('sign')
		
		# Create a table with some points in it...
		self.table = vtk.vtkTable()
		self.table.AddColumn(terms)
		self.table.AddColumn(coeffs)
		self.table.AddColumn(c_sign)
		
		vt = vtk.vtkViewTheme()
		lut = vtk.vtkLookupTable()
		lut.SetHueRange(0, 0.66)
		lut.SetValueRange(0.7, 0.7)
		lut.SetSaturationRange(1, 1)
		lut.Build()
		# Set value for no color by array
		vt.SetPointColor(0,0,0)
		# Set LUT for color by array
		vt.SetPointLookupTable(lut)
		# ViewTheme Background color is black by default
		vt.SetBackgroundColor(1,1,1)

		self.WordleView.AddRepresentationFromInput(self.table)
		self.WordleView.SetFieldType(vtkvtg.vtkQtWordleView.ROW_DATA)
		self.WordleView.SetColorByArray(True)
		self.WordleView.SetColorArrayName('sign')
		self.WordleView.SetTermsArrayName('dictionary')
		self.WordleView.SetSizeArrayName('coefficient')
		self.WordleView.ApplyViewTheme(vt)
		self.WordleView.SetMaxNumberOfWords(150);
		self.WordleView.SetFontFamily("Rockwell")
		self.WordleView.SetFontStyle(vtkvtg.vtkQtWordleView.StyleNormal)
		self.WordleView.SetFontWeight(99)
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.HORIZONTAL)
		self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.MOSTLY_HORIZONTAL)
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.HALF_AND_HALF)
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.MOSTLY_VERTICAL)
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.VERTICAL)

		self.WordleView.SetLayoutPathShape(vtkvtg.vtkQtWordleView.CIRCULAR_PATH)
		# self.WordleView.SetLayoutPathShape(vtkvtg.vtkQtWordleView.SQUARE_PATH)

		QtCore.QObject.connect(self.ui.actionExit, QtCore.SIGNAL("triggered()"), self.fileExit)

		# Do first update before changing to debug mode...
		self.WordleView.Update()
		self.WordleView.ZoomToBounds()
		
# 		while(True):
# 			self.table.Modified()
# 			self.WordleView.Update()
				
		# DEBUG
		self.WordleView.SetWatchLayout(True)
		self.WordleView.SetWatchCollision(True)
		self.WordleView.SetWatchQuadTree(True)
		self.WordleView.SetWatchDelay(50000)
예제 #51
0
	def __init__(self, parent = None):
	
		QtGui.QMainWindow.__init__(self, parent)
		self.ui = Ui_MainWindow()
		self.ui.setupUi(self)
		
		self.WordleView = vtkvtg.vtkQtWordleView()
		
		# Set widget for the wordle view
		self.ui.centralWidget.layout().addWidget(self.WordleView.GetWidget())
		
		term_list = [
			"straw",
			"gold",
			"name",
			"miller",
			"manikin",
			"daughter",
			"little",
			"queen",
			"man",
			"came",
			"girl",
			"give",
			"spin",
			"full",
			"whirr",
			"spun",
			"night",
			"one",
			"child",
			"king",
			"room",
			"answered",
			"morning",
			"names",
			"took",
			"began",
			"thought",
			"time",
			"find",
			"world",
			"day",
			"leg",
			"whole",
			"another",
			"three",
			"rumpelstiltskin",
			"knew",
			"left",
			"help",
			"still",
			"crying",
			"gave",
			"good",
			"round",
			"wheel",
			"second",
			"opened",
			"messenger",
			"ever",
			"told",
			"quite",
			"alone",
			"mistress",
			"larger",
			"became",
			"first",
			"brought",
			"put",
			"ring",
			"devil",
			"next",
			"house",
			"taken",
			"life",
			"door",
			"fire",
			"reel",
			"glad",
			"must",
			"beautiful",
			"heard",
			"promised",
			"saw",
			"perhaps",
			"also",
			"poor",
			"shall",
			"third",
			"wife",
			"necklace",
			"bring",
			"daybreak",
			"earth",
			"hopped",
			"inquiries",
			"cried",
			"dearer",
			"front",
			"far",
			"bid",
			"early",
			"every",
			"hands",
			"foot",
			"course",
			"always",
			"cry",
			"become",
			"conrad",
			"art",
			"hare",
			"hard",
			"back",
			"alive",
			"die",
			"curious",
			"bake",
			"even",
			"appear",
			"fox",
			"enough",
			"finger",
			"harry",
			"caspar",
			"greedy",
			"found",
			"country",
			"days",
			"asked",
			"already",
			"afterwards",
			"burning",
			"imagine",
			"delighted",
			"frightened",
			"appeared",
			"idea",
			"clever",
			"else",
			"alas",
			"astonished",
			"grew",
			"happened",
			"heart",
			"deep",
			"high",
			"evening",
			"anger",
			"commanded",
			"happen",
			"beyond",
			"end",
			"able",
			"forest",
			"jumping",
			"brew",
			"important",
			"balthazar",
			"inquire",
			"glittering"
			]

		size_list = [
			12.0,
			10.0,
			10.0,
			9.0,
			9.0,
			9.0,
			9.0,
			8.0,
			8.0,
			8.0,
			7.0,
			7.0,
			6.0,
			6.0,
			6.0,
			5.0,
			5.0,
			5.0,
			5.0,
			5.0,
			5.0,
			4.0,
			4.0,
			4.0,
			4.0,
			4.0,
			4.0,
			4.0,
			3.0,
			3.0,
			3.0,
			3.0,
			3.0,
			3.0,
			3.0,
			3.0,
			3.0,
			3.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			2.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			1.0,
			]

		terms = vtk.vtkStringArray()
		terms.SetName('dictionary')
		terms.SetNumberOfComponents(1)
		for term in term_list:
			terms.InsertNextValue(term)
		
		coeffs = vtk.vtkDoubleArray()
		coeffs.SetName('coefficient')
		coeffs.SetNumberOfComponents(1)
		for size in size_list:
			coeffs.InsertNextValue(size)
		
		# Create a table with some points in it...
		self.table = vtk.vtkTable()
		self.table.AddColumn(terms)
		self.table.AddColumn(coeffs)
		
		self.vt = vtk.vtkViewTheme()
		lut = vtk.vtkLookupTable()
		lut.SetHueRange(0,0)
		lut.SetValueRange(0,1)
		lut.SetSaturationRange(1,1)
		lut.Build()
		# Set value for no color by array
		self.vt.SetPointColor(0,0,0)
		# Set LUT for color by array
		self.vt.SetPointLookupTable(lut)
		# ViewTheme Background color is black by default
		self.vt.SetBackgroundColor(1,1,1)

		self.vt2 = vtk.vtkViewTheme()
		lut2 = vtk.vtkLookupTable()
		lut2.SetHueRange(0, 0.66)
		lut2.SetValueRange(0.7, 0.7)
		lut2.SetSaturationRange(1, 1)
		lut2.Build()
		# Set value for no color by array
		self.vt2.SetPointColor(0,0,0)
		# Set LUT for color by array
		self.vt2.SetPointLookupTable(lut2)
		# ViewTheme Background color is black by default
		self.vt2.SetBackgroundColor(1,1,1)

		self.WordleView.AddRepresentationFromInput(self.table)
		self.WordleView.SetFieldType(vtkvtg.vtkQtWordleView.ROW_DATA)
		self.WordleView.SetColorByArray(True)
		self.WordleView.SetColorArrayName('coefficient')
		self.WordleView.SetTermsArrayName('dictionary')
		self.WordleView.SetSizeArrayName('coefficient')
		self.WordleView.SetOutputImageDataDimensions(200, 200)
		self.WordleView.ApplyViewTheme(self.vt)
		self.WordleView.SetMaxNumberOfWords(150);
		self.WordleView.SetFontFamily("Rockwell")
		self.WordleView.SetFontStyle(vtkvtg.vtkQtWordleView.StyleNormal)
		self.WordleView.SetFontWeight(99)
		
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.HORIZONTAL)
		self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.MOSTLY_HORIZONTAL)
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.HALF_AND_HALF)
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.MOSTLY_VERTICAL)
		# self.WordleView.SetOrientation(vtkvtg.vtkQtWordleView.VERTICAL)

		self.WordleView.SetLayoutPathShape(vtkvtg.vtkQtWordleView.CIRCULAR_PATH)
		# self.WordleView.SetLayoutPathShape(vtkvtg.vtkQtWordleView.SQUARE_PATH)

		self.WordleView.Update()
		self.WordleView.ZoomToBounds()
				
		self.color_by_array = True
		self.font_flag = True

		QtCore.QObject.connect(self.ui.actionExit, QtCore.SIGNAL("triggered()"), self.fileExit)
예제 #52
0
    def Execute(self):

        if (self.Mesh == None):
            self.PrintError('Error: no Mesh.')
        
        if (self.Source == None):
            self.PrintError('Error: no Source surface.')
        
        if (self.FirstTimeStep == None or self.LastTimeStep == None or self.IntervalTimeStep == None):
            timesteps = self.Mesh.GetFieldData().GetArray("timesteps")
            if (timesteps == None):
                self.PrintError('Error: no Timesteps.')
            indexList = []
            i = 0
            while i < self.Mesh.GetFieldData().GetArray("timesteps").GetNumberOfTuples():
                indexList.append(int(timesteps.GetTuple(i)[0]))
                i+=1
            firstTimeStep = indexList[0]
        else:
            indexList = range(self.FirstTimeStep,self.LastTimeStep+1,self.IntervalTimeStep)
            firstTimeStep = self.FirstTimeStep
        
        indexColumn = vtk.vtkIntArray()
        indexColumn.SetName("index")
        timeColumn = vtk.vtkDoubleArray()
        timeColumn.SetName("time")
        
        time = 0
        timeStepsTable = vtk.vtkTable()
        timeStepsTable.AddColumn(indexColumn)
        timeStepsTable.AddColumn(timeColumn)
        
        for index in indexList:
            time+=(1./(len(indexList)-1))
            indexColumn.InsertNextValue(index)
            timeColumn.InsertNextValue(time)
        
        u = self.Source.GetPointData().GetArray("u")
        if u:
            v = self.Source.GetPointData().GetArray("v")
            w = self.Source.GetPointData().GetArray("w")
        else:
            u = self.Source.GetPointData().GetArray("u_"+str(firstTimeStep))
            v = self.Source.GetPointData().GetArray("v_"+str(firstTimeStep))
            w = self.Source.GetPointData().GetArray("w_"+str(firstTimeStep))
        
        speed = vtk.vtkFloatArray()
        speed.SetNumberOfComponents(u.GetNumberOfComponents())
        speed.SetNumberOfTuples(u.GetNumberOfTuples())
        speed.SetName('speed')
        i=0
        while i<u.GetNumberOfTuples():
            speed.InsertTuple1(i, vtk.vtkMath.Norm((u.GetTuple(i)[0],v.GetTuple(i)[0],w.GetTuple(i)[0])))
            i+=1
    
        self.Source.GetPointData().AddArray(speed)
        
        if self.Subdivide:
            sd = vtk.vtkLinearSubdivisionFilter()
            sd.SetInputData(self.Source)
            sd.SetNumberOfSubdivisions(1)
            sd.Update()
            self.Source = sd.GetOutput()
            
        self.Source.GetPointData().SetActiveScalars('speed')
        cp = vtk.vtkClipPolyData()
        cp.SetInputData(self.Source)
        cp.GenerateClipScalarsOff()
        cp.SetValue(self.MinSpeed)
        cp.Update()
        self.Source = cp.GetOutput()
        
        tracer = vtkvmtk.vtkvmtkStaticTemporalStreamTracer()
        tracer.SetInputData(self.Mesh)
        tracer.SetIntegratorTypeToRungeKutta45()
        tracer.SetTimeStepsTable(timeStepsTable)
        tracer.SetSeedTime(self.SeedTime)
        tracer.SetMaximumPropagation(self.MaximumPropagation)
        tracer.SetInitialIntegrationStep(self.InitialIntegrationStep)
        tracer.SetMinimumIntegrationStep(self.MinimumIntegrationStep)
        tracer.SetMaximumIntegrationStep(self.MaximumIntegrationStep)
        tracer.SetMaximumNumberOfSteps(self.MaximumNumberOfSteps)
        if self.Vorticity:
            tracer.SetComputeVorticity(1)
        if self.IntegrationDirectionBoth:
            tracer.SetIntegrationDirectionToBoth()
        tracer.SetSourceData(self.Source)
        tracer.SetVelocityScale(self.VelocityScale)
        if self.VectorComponents:
            tracer.UseVectorComponentsOn()
        tracer.SetComponent0Prefix(self.Component0Prefix)
        tracer.SetComponent1Prefix(self.Component1Prefix)
        tracer.SetComponent2Prefix(self.Component2Prefix)
        if self.Periodic:
            tracer.PeriodicOn()
        tracer.Update()

        self.Traces = tracer.GetOutput()
    def testLinePlot(self):
        "Test if colored parallel coordinates plots can be built with python"

        # Set up a 2D scene, add a PC chart to it
        view = vtk.vtkContextView()
        view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        view.GetRenderWindow().SetSize(600,300)

        chart = vtk.vtkChartParallelCoordinates()
        view.GetScene().AddItem(chart)

        # Create a table with some points in it
        arrX = vtk.vtkFloatArray()
        arrX.SetName("XAxis")

        arrC = vtk.vtkFloatArray()
        arrC.SetName("Cosine")

        arrS = vtk.vtkFloatArray()
        arrS.SetName("Sine")

        arrS2 = vtk.vtkFloatArray()
        arrS2.SetName("Tan")

        numPoints = 200
        inc = 7.5 / (numPoints-1)

        for i in range(numPoints):
            arrX.InsertNextValue(i * inc)
            arrC.InsertNextValue(math.cos(i * inc) + 0.0)
            arrS.InsertNextValue(math.sin(i * inc) + 0.0)
            arrS2.InsertNextValue(math.tan(i * inc) + 0.5)

        table = vtk.vtkTable()
        table.AddColumn(arrX)
        table.AddColumn(arrC)
        table.AddColumn(arrS)
        table.AddColumn(arrS2)

        # Create blue to gray to red lookup table
        lut = vtk.vtkLookupTable()
        lutNum = 256
        lut.SetNumberOfTableValues(lutNum)
        lut.Build()

        ctf = vtk.vtkColorTransferFunction()
        ctf.SetColorSpaceToDiverging()
        cl = []
        # Variant of Colorbrewer RdBu 5
        cl.append([float(cc)/255.0 for cc in [202, 0, 32]])
        cl.append([float(cc)/255.0 for cc in [244, 165, 130]])
        cl.append([float(cc)/255.0 for cc in [140, 140, 140]])
        cl.append([float(cc)/255.0 for cc in [146, 197, 222]])
        cl.append([float(cc)/255.0 for cc in [5, 113, 176]])
        vv = [float(xx)/float(len(cl)-1) for xx in range(len(cl))]
        vv.reverse()
        for pt,color in zip(vv,cl):
            ctf.AddRGBPoint(pt, color[0], color[1], color[2])

        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)

        lut.SetAlpha(0.25)
        lut.SetRange(-1, 1)

        chart.GetPlot(0).SetInputData(table)
        chart.GetPlot(0).SetScalarVisibility(1)
        chart.GetPlot(0).SetLookupTable(lut)
        chart.GetPlot(0).SelectColorArray("Cosine")

        view.GetRenderWindow().SetMultiSamples(0)
        view.GetRenderWindow().Render()

        img_file = "TestParallelCoordinatesColors.png"
        vtk.test.Testing.compareImage(view.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25)
        vtk.test.Testing.interact()
for yr in range(1820,2010,10):
	
	print 'Year: ' + str(yr)
	
	# Break pipeline while set up new graph
	if yr != years_list[0]:
		layout.RemoveAllInputs()
		# del table, col0, col1, val, rawGraph, tgraph, currCoords, constraintArray, constraintData, yearData, vertexData
	
	# Build table of edges for correct year range
	start_n = start_node[cite_year < yr]
	end_n = end_node[cite_year < yr]
	all_n = N.unique(N.concatenate((start_n,end_n)))
	
	table = vtk.vtkTable()
	col0 = VN.numpy_to_vtk(start_n, deep=True)
	col0.SetName('start_node')
	col1 = VN.numpy_to_vtk(end_n, deep=True)
	col1.SetName('end_node')
	val = VN.numpy_to_vtk( N.ones(cite_year[cite_year < yr].shape) )
	val.SetName('weight')
	
	table.AddColumn(col0)
	table.AddColumn(col1)
	table.AddColumn(val)
	
	# Only use cases as nodes if they've cited others
	node_table = vtk.vtkTable()
	col2 = VN.numpy_to_vtk(all_n, deep=True)
	col2.SetName('case_id')
예제 #55
0
	def LoadData(self):
		
		# data_file = '/Users/emonson/Data/Fodava/EMoGWDataSets/yaleB_diffMap.mat'
		if os.path.exists('/Users/emonson/Data/Fodava/EMoGWDataSets'):
			self.openFilesDefaultPath = '/Users/emonson/Data/Fodava/EMoGWDataSets'
		else:
			self.openFilesDefaultPath = QtCore.QDir.homePath()
		
		picked_file = QtGui.QFileDialog.getOpenFileName(self,
				"Load Saved Matlab File",
				self.openFilesDefaultPath,
				"All Files (*);;Matlab Files (*.mat)")
		data_file = str(picked_file)
		
		# DataSource loads .mat file and can generate data from it for other views
		print "Loading data from ", str(data_file)
		
		self.last_data_dir = os.path.dirname(str(data_file))

		# Hack for labels
		if 'yaleB' in data_file:
			l_idx = 2
		else:
			l_idx = 0
			
		print 'Trying to really load now...'
		try:
			MatInput = scipy.io.loadmat(data_file, struct_as_record=True, chars_as_strings=True)
		except:
			print 'loadmat crapping out for some reason...'
			raise IOError, "Can't load supplied matlab file"
			# return

		# Create original multi-dimensional data matrix
		e_vecs = MatInput['EigenVecs']
		e_vals = MatInput['EigenVals']
		self.data = N.mat(e_vecs*e_vals.T[0])
		d = self.data.shape[1]
		
		# Try out fixed axis bounds for less distracting axis label switching
		# Still a problem that some points in in-between projections go out of these bounds...
		d_max = N.abs(self.data.max())
		d_min = N.abs(self.data.min())
		if d_max > d_min: 
			w_max = d_max
		else: 
			w_max = d_min
		
		# Rescale data so that max is 1.0
		self.data = self.data/w_max
		
		self.ui.horizontalSlider.setMaximum((d-2)*self.divs+1)
		self.ui.horizontalSlider.setPageStep(self.divs)
		self.ui.horizontalSlider.setValue(0)

		# Start by plotting the first two columns of the data
		# These column matrices will hold results of all later calculations
		# and share memory with the table columns plotted
		self.r0 = self.data[:,0].copy()
		self.r1 = self.data[:,1].copy()
		
		# Create a table with some points in it...
		self.table = vtk.vtkTable()
		self.rv0 = VN.numpy_to_vtk(self.r0)
		self.rv0.SetName('column0')
		self.rv1 = VN.numpy_to_vtk(self.r1)
		self.rv1.SetName('column1')
		self.table.AddColumn(self.rv0)
		self.table.AddColumn(self.rv1)
		
		# Color-by array
		labels_array = MatInput['Labels']
		self.cat_labels = N.zeros_like(labels_array)
		for ii in range(labels_array.shape[0]):
			cl_unique = set(labels_array[ii,:])
			cl_map = {}
			for jj,vv in enumerate(cl_unique):
				cl_map[vv] = jj
			self.cat_labels[ii,:] = N.array([cl_map[vv] for vv in labels_array[ii,:]])
		
		# Specifying a single label array here
		rvC = VN.numpy_to_vtk(self.cat_labels[l_idx,:].copy(),deep=True)
		rvC.SetName('color')		
		self.table.AddColumn(rvC)
		
		self.chart.ClearPlots()
		points1 = self.chart.AddPlot(vtk.vtkChart.POINTS)
		points1.SetInput(self.table, 0, 1)
		points1.SetColor(0, 0, 0, 255)
		points1.SetMarkerStyle(vtk.vtkPlotPoints.CIRCLE)
		points1.SetScalarVisibility(1)
		points1.SetLookupTable(self.GetCategoryLUT(l_idx))
		points1.SelectColorArray('color')
		
		sc = 1.01
		x_axis = self.chart.GetAxis(1)
		y_axis = self.chart.GetAxis(0)

		if not self.axis_rescale: 
			y_axis.SetBehavior(1)
			y_axis.SetNotation(2)
		y_axis.SetRange(-sc, sc)
		y_axis.RecalculateTickSpacing()
		y_axis.SetPrecision(1)
		if not self.axis_rescale: 
			x_axis.SetBehavior(1)
			x_axis.SetNotation(2)
		x_axis.SetRange(-sc, sc)
		x_axis.RecalculateTickSpacing()
		x_axis.SetPrecision(1)

		x_axis.GetTitleProperties().BoldOff()
		y_axis.GetTitleProperties().BoldOff()
		x_axis.GetTitleProperties().SetFontSize(10)
		y_axis.GetTitleProperties().SetFontSize(10)
		
		self.columnUpdate()
예제 #56
0
파일: vview.py 프로젝트: xhub/siconos

    # Warning! numpy support offer a view on numpy array
    # the numpy array must not be garbage collected!
    nxtime = solv_data[:, 0].copy()
    nxiters = solv_data[:, 1].copy()
    nprecs = solv_data[:, 2].copy()
    xtime = numpy_support.numpy_to_vtk(nxtime)
    xiters = numpy_support.numpy_to_vtk(nxiters)
    xprecs = numpy_support.numpy_to_vtk(nprecs)

    xtime.SetName('time')
    xiters.SetName('iterations')
    xprecs.SetName('precisions')

    table = vtk.vtkTable()
    table.AddColumn(xtime)
    table.AddColumn(xiters)
    table.AddColumn(xprecs)
    #table.Dump()

    tview_iter = vtk.vtkContextView()
    tview_prec = vtk.vtkContextView()

    chart_iter = vtk.vtkChartXY()
    chart_prec = vtk.vtkChartXY()
    tview_iter.GetScene().AddItem(chart_iter)
    tview_prec.GetScene().AddItem(chart_prec)
    iter_plot = chart_iter.AddPlot(vtk.vtkChart.LINE)
    iter_plot.SetLabel('Solver iterations')
    iter_plot.GetXAxis().SetTitle('time')
예제 #57
0
    def testStackedPlot(self):
        "Test if stacked plots can be built with python"

        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
        view.GetRenderer().SetBackground(1.0,1.0,1.0)
        view.GetRenderWindow().SetSize(400,300)
        chart = vtk.vtkChartXY()
        view.GetScene().AddItem(chart)

        # Create a table with some points in it
        table = vtk.vtkTable()

        arrMonthLabels = vtk.vtkStringArray()
        arrMonthPositions = vtk.vtkDoubleArray()

        arrMonth = vtk.vtkIntArray()
        arrMonth.SetName("Month")

        arrBooks = vtk.vtkIntArray()
        arrBooks.SetName("Books")

        arrNew = vtk.vtkIntArray()
        arrNew.SetName("New / Popular")

        arrPeriodical = vtk.vtkIntArray()
        arrPeriodical.SetName("Periodical")

        arrAudiobook = vtk.vtkIntArray()
        arrAudiobook.SetName("Audiobook")

        arrVideo = vtk.vtkIntArray()
        arrVideo.SetName("Video")

        numMonths = 12

        for i in range(0,numMonths):
            arrMonthLabels.InsertNextValue(month_labels[i])
            arrMonthPositions.InsertNextValue(float(i));

            arrMonth.InsertNextValue(i)
            arrBooks.InsertNextValue(book[i])
            arrNew.InsertNextValue(new_popular[i])
            arrPeriodical.InsertNextValue(periodical[i])
            arrAudiobook.InsertNextValue(audiobook[i])
            arrVideo.InsertNextValue(video[i])

        table.AddColumn(arrMonth)
        table.AddColumn(arrBooks)
        table.AddColumn(arrNew)
        table.AddColumn(arrPeriodical)
        table.AddColumn(arrAudiobook)
        table.AddColumn(arrVideo)

        # Now add the line plots with appropriate colors

        chart.GetAxis(1).SetTickLabels(arrMonthLabels)
        chart.GetAxis(1).SetTickPositions(arrMonthPositions)
        chart.GetAxis(1).SetMaximum(11)

        # Books
        line = chart.AddPlot(3)
        line.SetInput(table,0,1)
        line.SetColor(120,120,254,255)

        # New / Popular
        line = chart.AddPlot(3)
        line.SetInput(table,0,2)
        line.SetColor(254,118,118,255)

        # Periodical
        line = chart.AddPlot(3)
        line.SetInput(table,0,3)
        line.SetColor(170,170,254,255)

        # Audiobook
        line = chart.AddPlot(3)
        line.SetInput(table,0,4)
        line.SetColor(91,91,254,255)

        # Video
        line = chart.AddPlot(3)
        line.SetInput(table,0,5)
        line.SetColor(253,158,158,255)

        view.GetRenderWindow().SetMultiSamples(0)
        #view.GetRenderWindow().GetInteractor().Start()

        img_file = "TestStackedPlot.png"
        img_file2 = "TestStackedPlot0Hidden.png"
        vtk.test.Testing.compareImage(view.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25)
        vtk.test.Testing.interact()
        chart.GetPlot(0).SetVisible(False)
        vtk.test.Testing.compareImage(view.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file2),threshold=25)
        vtk.test.Testing.interact()
예제 #58
0
    def testLinePlot(self):
        "Test if colored scatter plots can be built with python"

        # Set up a 2D scene, add an XY chart to it
        view = vtk.vtkContextView()
        view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
        view.GetRenderWindow().SetSize(400, 300)

        chart = vtk.vtkChartXY()
        chart.SetShowLegend(True)
        view.GetScene().AddItem(chart)

        # Create a table with some points in it
        arrX = vtk.vtkFloatArray()
        arrX.SetName("XAxis")

        arrC = vtk.vtkFloatArray()
        arrC.SetName("Cosine")

        arrS = vtk.vtkFloatArray()
        arrS.SetName("Sine")

        arrS2 = vtk.vtkFloatArray()
        arrS2.SetName("Tan")

        numPoints = 40
        inc = 7.5 / (numPoints-1)

        for i in range(numPoints):
            arrX.InsertNextValue(i * inc)
            arrC.InsertNextValue(math.cos(i * inc) + 0.0)
            arrS.InsertNextValue(math.sin(i * inc) + 0.0)
            arrS2.InsertNextValue(math.tan(i * inc) + 0.5)

        table = vtk.vtkTable()
        table.AddColumn(arrX)
        table.AddColumn(arrC)
        table.AddColumn(arrS)
        table.AddColumn(arrS2)

        # Generate a black-to-red lookup table with fixed alpha
        lut = vtk.vtkLookupTable()
        lut.SetValueRange(0.2, 1.0)
        lut.SetSaturationRange(1, 1)
        lut.SetHueRange(0,0)
        lut.SetRampToLinear()
        lut.SetRange(-1,1)
        lut.SetAlpha(0.75)
        lut.Build()

        # Generate a black-to-blue lookup table with alpha range
        lut2 = vtk.vtkLookupTable()
        lut2.SetValueRange(0.2, 1.0)
        lut2.SetSaturationRange(1, 1)
        lut2.SetHueRange(0.6667, 0.6667)
        lut2.SetAlphaRange(0.4, 0.8)
        lut2.SetRampToLinear()
        lut2.SetRange(-1,1)
        lut2.Build()

        # Add multiple line plots, setting the colors etc
        points0 = chart.AddPlot(vtk.vtkChart.POINTS)
        points0.SetInputData(table, 0, 1)
        points0.SetColor(0, 0, 0, 255)
        points0.SetWidth(1.0)
        points0.SetMarkerStyle(vtk.vtkPlotPoints.CROSS)

        points1 = chart.AddPlot(vtk.vtkChart.POINTS)
        points1.SetInputData(table, 0, 2)
        points1.SetColor(0, 0, 0, 255)
        points1.SetMarkerStyle(vtk.vtkPlotPoints.DIAMOND)
        points1.SetScalarVisibility(1)
        points1.SetLookupTable(lut)
        points1.SelectColorArray(1)

        points2 = chart.AddPlot(vtk.vtkChart.POINTS)
        points2.SetInputData(table, 0, 3)
        points2.SetColor(0, 0, 0, 255)
        points2.ScalarVisibilityOn()
        points2.SetLookupTable(lut2)
        points2.SelectColorArray("Cosine")
        points2.SetWidth(4.0)

        view.GetRenderWindow().SetMultiSamples(0)
        view.GetRenderWindow().Render()

        img_file = "TestScatterPlotColors.png"
        vtk.test.Testing.compareImage(view.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25)
        vtk.test.Testing.interact()
def GetSource(dataType):
    s = vtk.vtkRTAnalyticSource()

    if dataType == 'ImageData':
        return s

    elif dataType == 'UnstructuredGrid':
        dst = vtk.vtkDataSetTriangleFilter()
        dst.SetInputConnection(s.GetOutputPort())
        return dst

    elif dataType == 'RectilinearGrid':
        s.Update()

        input = s.GetOutput()

        rg = vtk.vtkRectilinearGrid()
        rg.SetExtent(input.GetExtent())
        dims = input.GetDimensions()
        spacing = input.GetSpacing()

        x = vtk.vtkFloatArray()
        x.SetNumberOfTuples(dims[0])
        for i in range(dims[0]):
            x.SetValue(i, spacing[0]*i)

        y = vtk.vtkFloatArray()
        y.SetNumberOfTuples(dims[1])
        for i in range(dims[1]):
            y.SetValue(i, spacing[1]*i)

        z = vtk.vtkFloatArray()
        z.SetNumberOfTuples(dims[2])
        for i in range(dims[2]):
            z.SetValue(i, spacing[2]*i)

        rg.SetXCoordinates(x)
        rg.SetYCoordinates(y)
        rg.SetZCoordinates(z)

        rg.GetPointData().ShallowCopy(input.GetPointData())

        pf.SetInputData(rg)
        return pf

    elif dataType == 'StructuredGrid':
        s.Update()

        input = s.GetOutput()

        sg = vtk.vtkStructuredGrid()
        sg.SetExtent(input.GetExtent())
        pts = vtk.vtkPoints()
        sg.SetPoints(pts)
        npts = input.GetNumberOfPoints()
        for i in range(npts):
            pts.InsertNextPoint(input.GetPoint(i))
        sg.GetPointData().ShallowCopy(input.GetPointData())

        pf.SetInputData(sg)
        return pf

    elif dataType == 'Table':
        s.Update()
        input = s.GetOutput()

        table = vtk.vtkTable()
        RTData = input.GetPointData().GetArray(0)
        nbTuples = RTData.GetNumberOfTuples()

        array = vtk.vtkFloatArray()
        array.SetName("RTData")
        array.SetNumberOfTuples(nbTuples)

        for i in range(0, nbTuples):
            array.SetTuple1(i, float(RTData.GetTuple1(i)))

        table.AddColumn(array)

        pf.SetInputData(table)
        return pf