def __init__(self,data_reader,main_renderer,main_interactor,chart_points):
self.poly_data=vtk.vtkPolyData()
self.lw=Line_Widget(data_reader,main_renderer,main_interactor,self,chart_points)
self.probe_filter=vtk.vtkProbeFilter()
self.probe_filter.SetInput(self.poly_data)
self.probe_filter.SetSource(data_reader.get_data_set())
self.actor=vtk.vtkXYPlotActor()
self.actor.AddInput(self.probe_filter.GetOutput())
self.actor.GetPositionCoordinate().SetValue(0.05,0.05,0)
self.actor.GetPosition2Coordinate().SetValue(0.95,0.95,0)
self.actor.SetYRange(data_reader.get_scalar_range())
self.actor.SetXValuesToArcLength()
self.actor.SetNumberOfXLabels(6)
self.actor.SetTitle("Data")
self.actor.SetXTitle("s")
self.actor.SetYTitle("f(s)")
self.actor.GetProperty().SetColor(0,0,0)
self.actor.GetProperty().SetLineWidth(2)
self.actor.SetLabelFormat("%g")
self.actor.GetTitleTextProperty().SetFontFamilyToArial()
#main_renderer.AddActor2D(self.actor)
#main_renderer.Render()
# tu wystartuje nowy watek z wykresem w nowym oknie
newwin = New_Render_Widget_Package(self.actor)
#newwin.widget.add_actor(actor)
newwin.start()
def __init__(self, data_reader, main_renderer, main_interactor,
chart_points):
self.poly_data = vtk.vtkPolyData()
self.lw = Line_Widget(data_reader, main_renderer, main_interactor,
self, chart_points)
self.probe_filter = vtk.vtkProbeFilter()
self.probe_filter.SetInput(self.poly_data)
self.probe_filter.SetSource(data_reader.get_data_set())
self.actor = vtk.vtkXYPlotActor()
self.actor.AddInput(self.probe_filter.GetOutput())
self.actor.GetPositionCoordinate().SetValue(0.05, 0.05, 0)
self.actor.GetPosition2Coordinate().SetValue(0.95, 0.95, 0)
self.actor.SetYRange(data_reader.get_scalar_range())
self.actor.SetXValuesToArcLength()
self.actor.SetNumberOfXLabels(6)
self.actor.SetTitle("Data")
self.actor.SetXTitle("s")
self.actor.SetYTitle("f(s)")
self.actor.GetProperty().SetColor(0, 0, 0)
self.actor.GetProperty().SetLineWidth(2)
self.actor.SetLabelFormat("%g")
self.actor.GetTitleTextProperty().SetFontFamilyToArial()
#main_renderer.AddActor2D(self.actor)
#main_renderer.Render()
# tu wystartuje nowy watek z wykresem w nowym oknie
newwin = New_Render_Widget_Package(self.actor)
#newwin.widget.add_actor(actor)
newwin.start()
def __init__(self, mod_m):
debug("In Locator::__init__ ()")
Common.state.busy()
Base.Objects.Module.__init__(self, mod_m)
self.root = None
self.axesactor = None
self.slider = []
self.resoln_var = []
self.probes = []
self.maxlen = 0.0
self.graph_var = Tkinter.IntVar()
self.tubesize_var = Tkinter.DoubleVar()
self.linelenres_var = Tkinter.DoubleVar()
self.npoints_var = Tkinter.IntVar()
self.data_out = self.mod_m.GetOutput()
self.plot = self.actor = vtkpython.vtkXYPlotActor()
self.probes.append(PlotLineProbe(self.renwin))
self._initialize()
self.renwin.add_actors(self.probes[0].GetActor())
# self.renwin.add_actors (self.plot)
# self.pipe_objs = self.plot
self.renwin.Render()
Common.state.idle()
def __init__ (self, mod_m):
debug ("In Locator::__init__ ()")
Common.state.busy ()
Base.Objects.Module.__init__ (self, mod_m)
self.root = None
self.axesactor = None
self.slider = []
self.resoln_var = []
self.maxlen=0.0
self.plotline_var = Tkinter.IntVar ()
self.tubesize_var = Tkinter.DoubleVar ()
self.linelenres_var = Tkinter.DoubleVar ()
self.npoints_var = Tkinter.IntVar ()
self.data_out = self.mod_m.GetOutput ()
self.line=vtkpython.vtkLineSource()
self.probe=vtkpython.vtkProbeFilter()
self.plotline = self.actor = vtkpython.vtkXYPlotActor ()
self.tuber = vtkpython.vtkTubeFilter()
self.lineactor = vtkpython.vtkActor()
self.mapper = vtkpython.vtkPolyDataMapper()
self.axes=vtkpython.vtkAxes()
self.trans = vtkpython.vtkTransform()
self.axesactor = vtkpython.vtkActor()
self._initialize ()
self.renwin.add_actors (self.lineactor)
self.renwin.add_actors (self.plotline)
self.pipe_objs = self.plotline
self.renwin.Render ()
Common.state.idle ()
def xyplot(points, title='', c='b', corner=1, lines=False):
"""
Return a vtkActor that is a plot of 2D points in x and y.
Use corner to assign its position:
1=topleft,
2=topright,
3=bottomleft,
4=bottomright.
"""
c = vc.getColor(c) # allow different codings
array_x = vtk.vtkFloatArray()
array_y = vtk.vtkFloatArray()
array_x.SetNumberOfTuples(len(points))
array_y.SetNumberOfTuples(len(points))
for i, p in enumerate(points):
array_x.InsertValue(i, p[0])
array_y.InsertValue(i, p[1])
field = vtk.vtkFieldData()
field.AddArray(array_x)
field.AddArray(array_y)
data = vtk.vtkDataObject()
data.SetFieldData(field)
plot = vtk.vtkXYPlotActor()
plot.AddDataObjectInput(data)
plot.SetDataObjectXComponent(0, 0)
plot.SetDataObjectYComponent(0, 1)
plot.SetXValuesToValue()
plot.SetXTitle(title)
plot.SetYTitle('')
plot.ExchangeAxesOff()
plot.PlotPointsOn()
if not lines: plot.PlotLinesOff()
plot.GetProperty().SetPointSize(5)
plot.GetProperty().SetLineWidth(2)
plot.SetNumberOfXLabels(3) #not working
plot.GetProperty().SetColor(0, 0, 0)
plot.GetProperty().SetOpacity(0.7)
plot.SetPlotColor(0, c[0], c[1], c[2])
tprop = plot.GetAxisLabelTextProperty()
tprop.SetColor(0, 0, 0)
tprop.SetOpacity(0.7)
tprop.SetFontFamily(0)
tprop.BoldOff()
tprop.ItalicOff()
tprop.ShadowOff()
tprop.SetFontSize(3) #not working
plot.SetAxisTitleTextProperty(tprop)
plot.SetAxisLabelTextProperty(tprop)
plot.SetTitleTextProperty(tprop)
if corner == 1: plot.GetPositionCoordinate().SetValue(.0, .8, 0)
if corner == 2: plot.GetPositionCoordinate().SetValue(.7, .8, 0)
if corner == 3: plot.GetPositionCoordinate().SetValue(.0, .0, 0)
if corner == 4: plot.GetPositionCoordinate().SetValue(.7, .0, 0)
plot.GetPosition2Coordinate().SetValue(.3, .2, 0)
return plot
def plot(self):
"""
plot visualization of data
"""
self.ren.RemoveAllViewProps()
# self.marker_widget.EnabledOff()
active_scalar = self.data.grid[
self.current_timestep].GetPointData().GetScalars()
# print 'active scalar is', active_scalar.GetName()
line = vtk.vtkLineSource()
line.SetResolution(30)
line.SetPoint1(self.line_points[0])
line.SetPoint2(self.line_points[1])
probe = vtk.vtkProbeFilter()
probe.SetInputConnection(line.GetOutputPort())
probe.SetSourceData(self.data.grid[self.current_timestep])
tuber = vtk.vtkTubeFilter()
tuber.SetInputConnection(probe.GetOutputPort())
tuber.SetRadius(0.02)
line_mapper = vtk.vtkPolyDataMapper()
line_mapper.SetInputConnection(tuber.GetOutputPort())
line_actor = vtk.vtkActor()
line_actor.SetMapper(line_mapper)
# self.ren.AddActor(line_actor)
xyplot = vtk.vtkXYPlotActor()
if vtk.VTK_MAJOR_VERSION <= 5:
xyplot.AddInput(probe.GetOutput())
else:
xyplot.AddDataSetInputConnection(probe.GetOutputPort())
xyplot.GetPositionCoordinate().SetValue(0.05, 0.05, 0.0)
xyplot.GetPosition2Coordinate().SetValue(0.9, 0.9,
0.0) #relative to Position
xyplot.SetXValuesToArcLength()
xyplot.SetNumberOfXLabels(6)
xyplot.SetNumberOfYLabels(6)
xyplot.SetTitle("title")
xyplot.SetXTitle("length")
xyplot.SetYTitle("var")
# xyplot.SetXRange(.1, .35)
# xyplot.SetYRange(.2, .4)
# xyplot.GetProperty().SetColor(0, 0, 0)
xyplot.GetProperty().SetLineWidth(2)
self.ren.AddActor2D(xyplot)
# self.xyplotWidget = vtk.vtkXYPlotWidget()
# self.xyplotWidget.SetXYPlotActor(xyplot)
# self.xyplotWidget.SetInteractor(self.iren)
# self.xyplotWidget.EnabledOn()
self.ren_win.Render()
def plot(self):
"""
plot visualization of data
"""
self.ren.RemoveAllViewProps()
# self.marker_widget.EnabledOff()
active_scalar = self.data.grid[self.current_timestep].GetPointData().GetScalars()
# print 'active scalar is', active_scalar.GetName()
line = vtk.vtkLineSource()
line.SetResolution(30)
line.SetPoint1(self.line_points[0])
line.SetPoint2(self.line_points[1])
probe = vtk.vtkProbeFilter()
probe.SetInputConnection(line.GetOutputPort())
probe.SetSourceData(self.data.grid[self.current_timestep])
tuber = vtk.vtkTubeFilter()
tuber.SetInputConnection(probe.GetOutputPort())
tuber.SetRadius(0.02)
line_mapper = vtk.vtkPolyDataMapper()
line_mapper.SetInputConnection(tuber.GetOutputPort())
line_actor = vtk.vtkActor()
line_actor.SetMapper(line_mapper)
# self.ren.AddActor(line_actor)
xyplot = vtk.vtkXYPlotActor()
if vtk.VTK_MAJOR_VERSION <= 5:
xyplot.AddInput(probe.GetOutput())
else:
xyplot.AddDataSetInputConnection(probe.GetOutputPort())
xyplot.GetPositionCoordinate().SetValue(0.05, 0.05, 0.0)
xyplot.GetPosition2Coordinate().SetValue(0.9, 0.9, 0.0) #relative to Position
xyplot.SetXValuesToArcLength()
xyplot.SetNumberOfXLabels(6)
xyplot.SetNumberOfYLabels(6)
xyplot.SetTitle("title")
xyplot.SetXTitle("length")
xyplot.SetYTitle("var")
# xyplot.SetXRange(.1, .35)
# xyplot.SetYRange(.2, .4)
# xyplot.GetProperty().SetColor(0, 0, 0)
xyplot.GetProperty().SetLineWidth(2)
self.ren.AddActor2D(xyplot)
# self.xyplotWidget = vtk.vtkXYPlotWidget()
# self.xyplotWidget.SetXYPlotActor(xyplot)
# self.xyplotWidget.SetInteractor(self.iren)
# self.xyplotWidget.EnabledOn()
self.ren_win.Render()
def plot(values):
# convert data from python list of tuples => vtkFieldData
xCoords = vtk.vtkFloatArray()
yCoords = vtk.vtkFloatArray()
xCoords.SetNumberOfTuples(len(values))
yCoords.SetNumberOfTuples(len(values))
for i, v in enumerate(values):
xCoords.SetTuple1(i, v[0])
yCoords.SetTuple1(i, v[1])
curve = vtk.vtkFieldData()
curve.AddArray(xCoords)
curve.AddArray(yCoords)
# create vtkDataObject
plot = vtk.vtkDataObject()
plot.SetFieldData(curve)
# build a vtkXYPlotActor
xyplot = vtk.vtkXYPlotActor()
xyplot.AddDataObjectInput(plot)
#xyplot.SetDataObjectPlotModeToRows()
xyplot.SetDataObjectXComponent(0, 0)
xyplot.SetDataObjectYComponent(0, 1)
xyplot.GetPositionCoordinate().SetValue(0, 0.0, 0)
xyplot.GetPosition2Coordinate().SetValue(1, 1, 0)
xyplot.PlotPointsOn()
xyplot.PlotLinesOn()
xyplot.GetProperty().SetPointSize(5)
#xyplot.SetXRange(0, 100)
#xyplot.SetYRange(0, 20)
xyplot.SetPlotColor(0, 1, 1, 0)
# setup renderer / window / interactor
ren = vtk.vtkRenderer()
ren.SetBackground(0.1, 0.2, 0.4)
ren.AddActor2D(xyplot)
renWin = vtk.vtkRenderWindow()
renWin.SetSize(1000, 800)
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renWin.Render()
iren.Start()
def __init__(self, parent):
self.Parent = parent
self.iren = wxVTKRenderWindowInteractor(self.Parent, -1, size=self.Parent.GetSize())
self.iren.SetPosition((0, 0))
self.renwin = self.iren.GetRenderWindow()
self.renwin.StereoCapableWindowOn()
self.renwin.StereoRenderOff()
self.renScope = VtkSNRender("SINGLE")
self.renScope.SetMode("scope")
self.renwin.AddRenderer(self.renScope)
self.points = vtk.vtkPoints()
self.values = vtk.vtkIntArray()
self.values.SetName("Volts")
for i in range(800):
self.points.InsertPoint(i, 0, 0, 0)
self.values.InsertNextValue(i + 10)
self.polydata1 = vtk.vtkPolyData()
self.polydata1.SetPoints(self.points)
self.polydata1.GetPointData().SetScalars(self.values)
# self.polydata1.SetLines(self.lines)
self.xyplot = vtk.vtkXYPlotActor()
self.xyplot.AddInput(self.polydata1)
self.xyplot.GetProperty().SetColor(0, 0, 0)
self.xyplot.GetProperty().SetLineWidth(2)
self.xyplot.SetTitle("Scope")
self.xyplot.SetXTitle("")
self.xyplot.SetYTitle("")
self.xyplot.GetPositionCoordinate().SetValue(0.1, 0.1, 0)
self.xyplot.GetPosition2Coordinate().SetValue(0.9, 0.9, 0)
self.xyplot.SetXRange(0, 800)
self.xyplot.SetYRange(0, 1023)
self.renScope.AddActor2D(self.xyplot)
def getWindow(self):
wins = vtk.vtkRenderWindow();
wins.SetSize(*self.size[len(self.polyDataSet)-1]);
for index,polyData in enumerate(self.polyDataSet):
ren = vtk.vtkRenderer();
ren.SetBackground(*self.background[index]);
plot = vtk.vtkXYPlotActor()
plot.ExchangeAxesOff();
plot.SetLabelFormat( "%g" );
plot.SetXTitle( "Scale Val" );
plot.SetYTitle( "Voxel Count" );
plot.SetXValuesToValue();
plot.AddDataSetInput( polyData );
plot.SetPlotColor(index,self.color[index]);
plot.SetPlotLabel(index,self.label[index]);
ren.AddViewProp(plot);
xMin,xMax = self.xViewPort[len(self.polyDataSet)-1][index]
yMin,yMax = self.yViewPort[len(self.polyDataSet)-1][index]
ren.SetViewport(xMin,yMin,xMax,yMax);
ren.ResetCamera();
wins.AddRenderer(ren);
del self.polyDataSet[:];
return wins;
def UpdateSampleHistogram(obj, ev):
# For viewport 3, construct the histogram of the sampled data using vtkImageAccumulate class
histogram = vtk.vtkImageAccumulate()
# retrieve the scalar range of the plane widget using GetScalarRange()
range = obj.GetResliceOutput().GetScalarRange()
r = int(range[1] - range[0])
# using GetResliceOutput() function to get sampled data from vtkImagePlaneWidget object
histogram.SetInputData(obj.GetResliceOutput())
histogram.SetComponentExtent(0, r - 1, 0, 0, 0, 0)
histogram.SetComponentOrigin(range[0], 0.0, 0.0)
histogram.SetComponentSpacing(100, 0, 0)
histogram.Update()
# In viewport 3, using vtkXYPlotActor class for plotting the histogram
plot = vtk.vtkXYPlotActor()
plot.AddDataSetInputConnection(histogram.GetOutputPort())
plot.SetXRange(range[0], range[1])
plot.SetLabelFormat("%g")
plot.SetXTitle("Scalar Value")
plot.SetYTitle("Frequency")
plot.SetXValuesToValue()
ren[2].AddActor(plot)
def addBSpline(self,
path,
degree,
color,
thick=False,
thickness=_DEFAULT_BSPLINE_THICKNESS):
self._addedBSpline = True
tau, u, spline, splineD1, splineD2, splineD3, curv, tors, arcLength, polLength = path.splinePoints(
)
self._textActor.SetInput("Length: " + str(arcLength))
numIntervals = len(tau) - 1
curvPlotActor = vtk.vtkXYPlotActor()
curvPlotActor.SetTitle("Curvature")
curvPlotActor.SetXTitle("")
curvPlotActor.SetYTitle("")
curvPlotActor.SetXValuesToIndex()
torsPlotActor = vtk.vtkXYPlotActor()
torsPlotActor.SetTitle("Torsion")
torsPlotActor.SetXTitle("")
torsPlotActor.SetYTitle("")
torsPlotActor.SetXValuesToIndex()
uArrays = []
curvArrays = []
torsArrays = []
for i in range(numIntervals):
uArrays.append(vtk.vtkDoubleArray())
uArrays[i].SetName("t")
curvArrays.append(vtk.vtkDoubleArray())
curvArrays[i].SetName("Curvature")
torsArrays.append(vtk.vtkDoubleArray())
torsArrays[i].SetName("Torsion")
curvTorsArray = vtk.vtkDoubleArray()
#minCurv = minTors = minNd1Xd2 = float("inf")
#maxCurv = maxTors = float("-inf")
for i in range(len(u)):
for j in range(numIntervals):
if u[i] >= tau[j] and u[i] < tau[j + 1]:
break
uArrays[j].InsertNextValue(u[i])
curvArrays[j].InsertNextValue(curv[i])
torsArrays[j].InsertNextValue(tors[i])
curvTorsArray.InsertNextValue(curv[i]) # + abs(tors[i]))
#print("minCurv: {:e}; maxCurv: {:e}; minTors: {:e}; maxTors: {:e}; minNd1Xd2: {:e}".format(minCurv, maxCurv, minTors, maxTors, minNd1Xd2))
for inter in range(numIntervals):
plotTable = vtk.vtkTable()
plotTable.AddColumn(uArrays[inter])
plotTable.AddColumn(curvArrays[inter])
plotTable.AddColumn(torsArrays[inter])
points = self._chartXYCurv.AddPlot(vtk.vtkChart.LINE)
points.SetInputData(plotTable, 0, 1)
points.SetColor(self.COLOR_PLOT_CURV[0], self.COLOR_PLOT_CURV[1],
self.COLOR_PLOT_CURV[2])
points.SetWidth(1.0)
if inter > 0:
points.SetLegendVisibility(False)
points = self._chartXYTors.AddPlot(vtk.vtkChart.LINE)
points.SetInputData(plotTable, 0, 2)
points.SetColor(self.COLOR_PLOT_TORS[0], self.COLOR_PLOT_TORS[1],
self.COLOR_PLOT_TORS[2])
points.SetWidth(1.0)
if inter > 0:
points.SetLegendVisibility(False)
vtkPoints = vtk.vtkPoints()
for point in spline:
vtkPoints.InsertNextPoint(point[0], point[1], point[2])
polyDataLabelP = vtk.vtkPolyData()
polyDataLabelP.SetPoints(vtkPoints)
labels = vtk.vtkStringArray()
labels.SetNumberOfValues(len(spline))
labels.SetName("labels")
for i in range(len(spline)):
if i == 0:
labels.SetValue(i, "S")
elif i == len(spline) - 1:
labels.SetValue(i, "E")
else:
labels.SetValue(i, "")
polyDataLabelP.GetPointData().AddArray(labels)
sizes = vtk.vtkIntArray()
sizes.SetNumberOfValues(len(spline))
sizes.SetName("sizes")
for i in range(len(spline)):
if i == 0 or i == len(spline) - 1:
sizes.SetValue(i, 10)
else:
sizes.SetValue(i, 1)
polyDataLabelP.GetPointData().AddArray(sizes)
pointMapper = vtk.vtkPolyDataMapper()
pointMapper.SetInputData(polyDataLabelP)
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointSetToLabelHierarchyFilter = vtk.vtkPointSetToLabelHierarchy()
pointSetToLabelHierarchyFilter.SetInputData(polyDataLabelP)
pointSetToLabelHierarchyFilter.SetLabelArrayName("labels")
pointSetToLabelHierarchyFilter.SetPriorityArrayName("sizes")
pointSetToLabelHierarchyFilter.GetTextProperty().SetColor(
self.COLOR_LABELS)
pointSetToLabelHierarchyFilter.GetTextProperty().SetFontSize(15)
pointSetToLabelHierarchyFilter.GetTextProperty().SetBold(True)
pointSetToLabelHierarchyFilter.Update()
labelMapper = vtk.vtkLabelPlacementMapper()
labelMapper.SetInputConnection(
pointSetToLabelHierarchyFilter.GetOutputPort())
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
self._rendererScene.AddActor(labelActor)
if thick:
cellArray = vtk.vtkCellArray()
cellArray.InsertNextCell(len(spline))
for i in range(len(spline)):
cellArray.InsertCellPoint(i)
polyData = vtk.vtkPolyData()
polyData.SetPoints(vtkPoints)
polyData.SetLines(cellArray)
polyData.GetPointData().SetScalars(curvTorsArray)
tubeFilter = vtk.vtkTubeFilter()
tubeFilter.SetNumberOfSides(8)
tubeFilter.SetInputData(polyData)
tubeFilter.SetRadius(thickness)
tubeFilter.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(tubeFilter.GetOutputPort())
else:
unstructuredGrid = vtk.vtkUnstructuredGrid()
unstructuredGrid.SetPoints(vtkPoints)
for i in range(1, len(spline)):
unstructuredGrid.InsertNextCell(vtk.VTK_LINE, 2, [i - 1, i])
unstructuredGrid.GetPointData().SetScalars(curvArray)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(unstructuredGrid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(color)
self._rendererScene.AddActor(actor)
def addBSpline(self, path, degree, color, thick=False, thickness=_DEFAULT_BSPLINE_THICKNESS):
self._addedBSpline = True
tau, u, spline, splineD1, splineD2, splineD3, curv, tors, arcLength, polLength = path.splinePoints()
self._textActor.SetInput("Length: "+str(arcLength))
numIntervals = len(tau)-1
curvPlotActor = vtk.vtkXYPlotActor()
curvPlotActor.SetTitle("Curvature")
curvPlotActor.SetXTitle("")
curvPlotActor.SetYTitle("")
curvPlotActor.SetXValuesToIndex()
torsPlotActor = vtk.vtkXYPlotActor()
torsPlotActor.SetTitle("Torsion")
torsPlotActor.SetXTitle("")
torsPlotActor.SetYTitle("")
torsPlotActor.SetXValuesToIndex()
uArrays = []
curvArrays = []
torsArrays = []
for i in range(numIntervals):
uArrays.append(vtk.vtkDoubleArray())
uArrays[i].SetName("t")
curvArrays.append(vtk.vtkDoubleArray())
curvArrays[i].SetName("Curvature")
torsArrays.append(vtk.vtkDoubleArray())
torsArrays[i].SetName("Torsion")
curvTorsArray = vtk.vtkDoubleArray()
#minCurv = minTors = minNd1Xd2 = float("inf")
#maxCurv = maxTors = float("-inf")
for i in range(len(u)):
for j in range(numIntervals):
if u[i] >= tau[j] and u[i] < tau[j+1]:
break
uArrays[j].InsertNextValue(u[i])
curvArrays[j].InsertNextValue(curv[i])
torsArrays[j].InsertNextValue(tors[i])
curvTorsArray.InsertNextValue(curv[i])# + abs(tors[i]))
#print("minCurv: {:e}; maxCurv: {:e}; minTors: {:e}; maxTors: {:e}; minNd1Xd2: {:e}".format(minCurv, maxCurv, minTors, maxTors, minNd1Xd2))
for inter in range(numIntervals):
plotTable = vtk.vtkTable()
plotTable.AddColumn(uArrays[inter])
plotTable.AddColumn(curvArrays[inter])
plotTable.AddColumn(torsArrays[inter])
points = self._chartXYCurv.AddPlot(vtk.vtkChart.LINE)
points.SetInputData(plotTable, 0, 1)
points.SetColor(self.COLOR_PLOT_CURV[0], self.COLOR_PLOT_CURV[1], self.COLOR_PLOT_CURV[2])
points.SetWidth(1.0)
if inter > 0:
points.SetLegendVisibility(False)
points = self._chartXYTors.AddPlot(vtk.vtkChart.LINE)
points.SetInputData(plotTable, 0, 2)
points.SetColor(self.COLOR_PLOT_TORS[0], self.COLOR_PLOT_TORS[1], self.COLOR_PLOT_TORS[2])
points.SetWidth(1.0)
if inter > 0:
points.SetLegendVisibility(False)
vtkPoints = vtk.vtkPoints()
for point in spline:
vtkPoints.InsertNextPoint(point[0], point[1], point[2])
polyDataLabelP = vtk.vtkPolyData()
polyDataLabelP.SetPoints(vtkPoints)
labels = vtk.vtkStringArray()
labels.SetNumberOfValues(len(spline))
labels.SetName("labels")
for i in range(len(spline)):
if i == 0:
labels.SetValue(i, "S")
elif i == len(spline)-1:
labels.SetValue(i, "E")
else:
labels.SetValue(i, "")
polyDataLabelP.GetPointData().AddArray(labels)
sizes = vtk.vtkIntArray()
sizes.SetNumberOfValues(len(spline))
sizes.SetName("sizes")
for i in range(len(spline)):
if i == 0 or i == len(spline)-1:
sizes.SetValue(i, 10)
else:
sizes.SetValue(i,1)
polyDataLabelP.GetPointData().AddArray(sizes)
pointMapper = vtk.vtkPolyDataMapper()
pointMapper.SetInputData(polyDataLabelP)
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointSetToLabelHierarchyFilter = vtk.vtkPointSetToLabelHierarchy()
pointSetToLabelHierarchyFilter.SetInputData(polyDataLabelP)
pointSetToLabelHierarchyFilter.SetLabelArrayName("labels")
pointSetToLabelHierarchyFilter.SetPriorityArrayName("sizes")
pointSetToLabelHierarchyFilter.GetTextProperty().SetColor(self.COLOR_LABELS)
pointSetToLabelHierarchyFilter.GetTextProperty().SetFontSize(15)
pointSetToLabelHierarchyFilter.GetTextProperty().SetBold(True)
pointSetToLabelHierarchyFilter.Update()
labelMapper = vtk.vtkLabelPlacementMapper()
labelMapper.SetInputConnection(pointSetToLabelHierarchyFilter.GetOutputPort())
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
self._rendererScene.AddActor(labelActor)
if thick:
cellArray = vtk.vtkCellArray()
cellArray.InsertNextCell(len(spline))
for i in range(len(spline)):
cellArray.InsertCellPoint(i)
polyData = vtk.vtkPolyData()
polyData.SetPoints(vtkPoints)
polyData.SetLines(cellArray)
polyData.GetPointData().SetScalars(curvTorsArray)
tubeFilter = vtk.vtkTubeFilter()
tubeFilter.SetNumberOfSides(8)
tubeFilter.SetInputData(polyData)
tubeFilter.SetRadius(thickness)
tubeFilter.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(tubeFilter.GetOutputPort())
else:
unstructuredGrid = vtk.vtkUnstructuredGrid()
unstructuredGrid.SetPoints(vtkPoints)
for i in range(1, len(spline)):
unstructuredGrid.InsertNextCell(vtk.VTK_LINE, 2, [i-1, i])
unstructuredGrid.GetPointData().SetScalars(curvArray)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(unstructuredGrid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(color)
self._rendererScene.AddActor(actor)
appendF.AddInputConnection(probe2.GetOutputPort())
appendF.AddInputConnection(probe3.GetOutputPort())
# Create a tube filter to represent the lines as tubes. Set up the
# associated mapper and actor.
tuber = vtk.vtkTubeFilter()
tuber.SetInputConnection(appendF.GetOutputPort())
tuber.SetRadius(0.1)
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(tuber.GetOutputPort())
lineActor = vtk.vtkActor()
lineActor.SetMapper(lineMapper)
# Create an xy-plot using the output of the 3 probe filters as input.
# The x-values we are plotting are arc length.
xyplot = vtk.vtkXYPlotActor()
xyplot.AddDataSetInputConnection(probe.GetOutputPort())
xyplot.AddDataSetInputConnection(probe2.GetOutputPort())
xyplot.AddDataSetInputConnection(probe3.GetOutputPort())
xyplot.GetPositionCoordinate().SetValue(0.0, 0.67, 0)
xyplot.GetPosition2Coordinate().SetValue(1.0, 0.33, 0) #relative to Position
xyplot.SetXValuesToArcLength()
xyplot.SetNumberOfXLabels(6)
xyplot.SetTitle("Pressure vs. Arc Length (Zoomed View)")
xyplot.SetXTitle("")
xyplot.SetYTitle("P")
xyplot.SetXRange(.1, .35)
xyplot.SetYRange(.2, .4)
xyplot.GetProperty().SetColor(0, 0, 0)
xyplot.GetProperty().SetLineWidth(2)
# Set text prop color (same color for backward compat with test)
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
# linha start
# => src_update1
self.range_in = self.src.GetOutput().GetScalarRange()
b = self.range_bo = self.src.GetOutput().GetBounds()
print 'reader scalars', self.range_in
print 'reader bounds', self.range_bo
# Create three the line source to use for the probe lines.
# p1 = ((b[0]+b[1])/2.0, b[2], (b[4]+b[5])/2.0)
# p2 = ((b[0]+b[1])/2.0, b[3], (b[4]+b[5])/2.0)
p1 = (b[0], b[2], b[4])
p2 = (b[1], b[3], b[5])
self.line = vtk.vtkLineSource()
self.line.SetResolution(100)
#self.line.SetPoint1(p1)
#self.line.SetPoint2(p2)
self.line.SetPoint1((0, 0, 0))
self.line.SetPoint2((1, 1, 1))
self.probe = probe = vtk.vtkProbeFilter()
probe.SetInputConnection(self.line.GetOutputPort())
# si es cell data, lo transforma a point data, porque vtkProbeFilter parece ser que no soporta cell data.
if self.data1.get('fielddomain') == 'cell':
self.cdtpd = vtk.vtkCellDataToPointData()
self.cdtpd.SetInputConnection(self.src.GetOutputPort())
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
probe.SetSource(self.cdtpd.GetOutput())
else:
probe.SetSourceConnection(self.cdtpd.GetOutputPort())
else:
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
probe.SetSource(self.src.GetOutput())
else:
probe.SetSourceConnection(self.src.GetOutputPort())
# lineMapper = vtk.vtkPolyDataMapper()
# lineMapper.SetInputConnection(probe.GetOutputPort())
# lineMapper.ScalarVisibilityOff()
# self.lineActor = vtk.vtkActor()
# self.lineActor.SetMapper(lineMapper)
# self.lineActor.GetProperty().SetColor(Plot.probe_line_color)
# linha end
self.wireM = vtk.vtkDataSetMapper()
self.wireM.SetInputConnection(self.src.GetOutputPort())
# reverse rainbow [red->blue] -> [blue->red]
self.look = look = self.wireM.GetLookupTable()
self.scalarrange.local_set(self.src.GetOutput().GetScalarRange())
self.add_scalarbar_2(look)
self.add_outline_2(self.src)
self.wireA = vtk.vtkActor()
self.wireA.SetMapper(self.wireM)
self.wireA.GetProperty().SetRepresentationToSurface()
self.wireA.GetProperty().SetColor(Plot.edges_color)
self.wireA.GetProperty().SetEdgeColor(Plot.edges_color)
self.add_swe_2(self.wireA) # wireframe/surface/surface+edges
self.add_opacity_2([self.wireA]) # Opacity: 100%/75%/50%/25%/0%
# test mover liña interactivamente 2 INICIO
self.lineI = vtk.vtkLineWidget()
self.lineI.GetLineProperty().SetColor(Plot.probe_line_color)
seeds = vtk.vtkPolyData()
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
self.lineI.SetInput(self.src.GetOutput())
else:
self.lineI.SetInputConnection(self.src.GetOutputPort())
self.lineI.PlaceWidget()
self.lineI.GetPolyData(seeds)
iren = self.widget.GetRenderWindow().GetInteractor()
self.lineI.SetInteractor(iren)
self.lineI.On()
self.lineI.AddObserver("StartInteractionEvent", self.event_start)
# self.lineI.AddObserver("InteractionEvent", self.event)
self.lineI.AddObserver("EndInteractionEvent", self.event_end)
# test mover liña interactivamente 2 FIN
p1 = self.lineI.GetPoint1()
p2 = self.lineI.GetPoint2()
self.line.SetPoint1(p1)
self.line.SetPoint2(p2)
self.rens[0].AddActor(self.wireA)
# self.rens[0].AddActor(self.lineActor)
#self.rens[0].SetViewport(0, 0, 0.5, 1)
# end
# xy start
# The x-values we are plotting are the underlying point data values.
self.xyplot3 = xyplot3 = vtk.vtkXYPlotActor()
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
xyplot3.AddInput(probe.GetOutput())
else:
xyplot3.AddDataSetInputConnection(probe.GetOutputPort())
xyplot3.GetPositionCoordinate().SetValue(0.0, 0.0, 0)
xyplot3.GetPosition2Coordinate().SetValue(1.0, 0.95,
0) #relative to Position
# xyplot3.SetXValuesToIndex()
# SetXValuesToNormalizedArcLength()
xyplot3.SetXValuesToArcLength()
# xyplot3.SetXValuesToValue()
xyplot3.SetPointComponent(0, 1)
xyplot3.SetNumberOfXLabels(6)
xyplot3.SetTitle(" ")
xyplot3.SetXTitle(" ")
xyplot3.SetYTitle(" ")
xyplot3.PlotPointsOn()
xyplot3.GetProperty().SetColor(1, 1, 1)
xyplot3.GetProperty().SetPointSize(3)
# Set text prop color (same color for backward compat with test)
# Assign same object to all text props
tprop = xyplot3.GetTitleTextProperty()
tprop.SetColor(xyplot3.GetProperty().GetColor())
xyplot3.SetAxisTitleTextProperty(tprop)
xyplot3.SetAxisLabelTextProperty(tprop)
# self.ren2 = self.add_ren()
ren = vtk.vtkRenderer()
self.widget2.GetRenderWindow().AddRenderer(ren)
#ren.SetViewport(0.5, 0, 1, 1)
ren.AddActor(xyplot3)
# xy end
# se é esta en branco o leaf float, encheo de valores extremos
if self.is_empty(struct):
self.fill(struct, p1, p2)
# le os datos do leaf float
self.copy_params(struct)
self.done = True
def __init__(self, parent,title,nchannel=1):
self.Parent = parent
self.nchannel = nchannel
self.iren = wxVTKRenderWindowInteractor(self.Parent,-1,size = self.Parent.GetSize())
self.iren.SetPosition((0,0))
self.renwin = self.iren.GetRenderWindow()
self.renwin.StereoCapableWindowOn()
self.renwin.StereoRenderOff()
self.renScope = {}
self.mode = '%dchScope'%nchannel
for i in range(nchannel):
name = '%d_%dchScope'%(i+1,nchannel)
self.renScope[i] = {}
new_render = VtkSNRender(name)
new_render.SetMode(self.mode)
new_render.SetQuadrant(name)
self.renwin.AddRenderer(new_render)
self.renScope[i]['render'] = new_render
self.renScope[i]['name'] = name
#Constantes de tela
self.H_MAX = 800
self.V_MAX = 1030
self.V_MAX_UNIT = 100.0
self.H_MAX_UNIT = 1.0
self.V_DIG_MAX_UNIT = 10.0
self.H_DIG_MAX_UNIT = 4098
for render in self.renScope:
self.renScope[render]['points'] = vtk.vtkPoints()
self.renScope[render]['values'] = vtk.vtkFloatArray()
self.PontosNaTela = 0
self.renScope[render]['values'].SetName("Values")
toggle = 0.0
edge = 500
#For fast render time
self.renScope[render]['points'].SetNumberOfPoints(self.H_DIG_MAX_UNIT)
self.renScope[render]['values'].SetNumberOfValues(self.H_DIG_MAX_UNIT)
for i in range(self.H_DIG_MAX_UNIT):
#self.renScope[render]['points'].InsertPoint(i,0,0,0)
#self.renScope[render]['values'].InsertValue(i,toggle)
#For fast render time in conjuction with SetNumberOfPoints and SetNumberOfValues
self.renScope[render]['points'].SetPoint(i,0,0,0)
self.renScope[render]['values'].SetValue(i,toggle)
if i == edge:
if toggle:
toggle = 0.0
else:
toggle = self.V_MAX_UNIT/2
edge = edge + 500
self.PontosNaTela += 1
self.renScope[render]['polydata'] = vtk.vtkPolyData()
self.renScope[render]['polydata'].SetPoints(self.renScope[render]['points'])
self.renScope[render]['polydata'].GetPointData().SetScalars(self.renScope[render]['values'])
self.renScope[render]['xyplot'] = vtk.vtkXYPlotActor()
self.renScope[render]['xyplot'].AddInput(self.renScope[render]['polydata'])
self.renScope[render]['xyplot'].GetProperty().SetColor(0, 1, 0)
self.renScope[render]['xyplot'].GetProperty().SetLineWidth(1)
self.renScope[render]['xyplot'].GetProperty().SetPointSize(2)
self.renScope[render]['xyplot'].GetAxisLabelTextProperty().SetFontSize(1)
self.renScope[render]['xyplot'].GetAxisLabelTextProperty().BoldOff()
self.renScope[render]['xyplot'].PlotPointsOn()
self.renScope[render]['xyplot'].PlotLinesOn()
self.renScope[render]['xyplot'].SetTitle(title)
self.renScope[render]['xyplot'].SetXTitle("")
self.renScope[render]['xyplot'].SetYTitle("")
self.renScope[render]['xyplot'].GetPositionCoordinate().SetValue(0.02, 0.1, 0)
self.renScope[render]['xyplot'].GetPosition2Coordinate().SetValue(0.99, 0.9, 0)
#self.renScope[render]['plotwidget'] = vtk.vtkXYPlotWidget()
#self.renScope[render]['plotwidget'].SetXYPlotActor(self.renScope[render]['xyplot'])
#self.renScope[render]['plotwidget'].SetInteractor(self.iren)
self.renScope[render]['render'].AddActor2D(self.renScope[render]['xyplot'])
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
_yData.SetTuple1(i,y[i])
# create a field data object
# (I think this is as a containter to hold the data arrays)
_fieldData = vtk.vtkFieldData()
_fieldData.AllocateArrays(2)
_fieldData.AddArray(_xData)
_fieldData.AddArray(_yData)
# now put the field data object into a data object so that can add it as
# input to the xyPlotActor
_dataObject = vtk.vtkDataObject()
_dataObject.SetFieldData(_fieldData)
# set up the actor
_plot = vtk.vtkXYPlotActor()
_plot.AddDataObjectInput(_dataObject)
# set the title and stuff
_plot.SetTitle("Example 2D plot")
_plot.SetXTitle("x")
_plot.SetYTitle("x^2")
_plot.SetXValuesToValue()
# set which parts of the data object are to be used for which axis
_plot.SetDataObjectXComponent(0,0)
_plot.SetDataObjectYComponent(0,1)
# add the actor
_ren.AddActor2D(_plot)
array1.InsertNextValue(2)
array2 = vtk.vtkFloatArray()
array2.InsertNextValue(3)
array2.InsertNextValue(0)
array2.InsertNextValue(2)
array2.InsertNextValue(1)
unstructuredGrid.GetPointData().SetScalars(array1)
unstructuredGrid2 = vtk.vtkUnstructuredGrid()
unstructuredGrid2.CopyStructure(unstructuredGrid)
unstructuredGrid2.GetPointData().SetScalars(array2)
#polyData = vtk.vtkPolyData()
#polyData.GetPointData().SetScalars(array1)
plotActor = vtk.vtkXYPlotActor()
plotActor.SetTitle("Ma Sticazzi?")
#plotActor.AddDataSetInput(polyData)
plotActor.AddDataSetInput(unstructuredGrid)
plotActor.AddDataSetInput(unstructuredGrid2)
plotWidget = vtk.vtkXYPlotWidget()
#plotWidget.SetOutlineColor(0.9300, 0.5700, 0.1300)
plotWidget.SetXYPlotActor(plotActor)
plotWidget.SetInteractor(renderWindowInteractor)
#plotWidget.SetViewport(0.2, 0.2, 0.4, 0.4)
plotWidget.SetEnabled(True)
#plotWidget.InteractiveOn()
#plotWidget = vtk.QVTKWidget()
#view = vtk.vtkContextView()
#view.SetInteractor(renderWindowInteractor)
def cornerPlot(points, pos=1, s=0.2, title="", c="b", bg="k", lines=True):
"""
Return a ``vtkXYPlotActor`` that is a plot of `x` versus `y`,
where `points` is a list of `(x,y)` points.
:param int pos: assign position:
- 1, topleft,
- 2, topright,
- 3, bottomleft,
- 4, bottomright.
"""
if len(points) == 2: # passing [allx, ally]
#points = list(zip(points[0], points[1]))
points = np.stack((points[0], points[1]), axis=1)
c = colors.getColor(c) # allow different codings
array_x = vtk.vtkFloatArray()
array_y = vtk.vtkFloatArray()
array_x.SetNumberOfTuples(len(points))
array_y.SetNumberOfTuples(len(points))
for i, p in enumerate(points):
array_x.InsertValue(i, p[0])
array_y.InsertValue(i, p[1])
field = vtk.vtkFieldData()
field.AddArray(array_x)
field.AddArray(array_y)
data = vtk.vtkDataObject()
data.SetFieldData(field)
plot = vtk.vtkXYPlotActor()
plot.AddDataObjectInput(data)
plot.SetDataObjectXComponent(0, 0)
plot.SetDataObjectYComponent(0, 1)
plot.SetXValuesToValue()
plot.SetAdjustXLabels(0)
plot.SetAdjustYLabels(0)
plot.SetNumberOfXLabels(3)
plot.GetProperty().SetPointSize(5)
plot.GetProperty().SetLineWidth(2)
plot.GetProperty().SetColor(colors.getColor(bg))
plot.SetPlotColor(0, c[0], c[1], c[2])
plot.SetXTitle(title)
plot.SetYTitle("")
plot.ExchangeAxesOff()
plot.PlotPointsOn()
if not lines:
plot.PlotLinesOff()
if pos == 1:
plot.GetPositionCoordinate().SetValue(0.0, 0.8, 0)
elif pos == 2:
plot.GetPositionCoordinate().SetValue(0.76, 0.8, 0)
elif pos == 3:
plot.GetPositionCoordinate().SetValue(0.0, 0.0, 0)
elif pos == 4:
plot.GetPositionCoordinate().SetValue(0.76, 0.0, 0)
else:
plot.GetPositionCoordinate().SetValue(pos[0], pos[1], 0)
plot.GetPosition2Coordinate().SetValue(s, s, 0)
return plot
def extract_profiles_vtk(name):
gridreader = vtk.vtkXMLStructuredGridReader()
gridreader.SetFileName(name)
gridreader.Update()
grid = gridreader.GetOutput()
data = grid.GetPointData()
points = grid.GetPoints()
dims = grid.GetDimensions()
velocity = data.GetArray("Velocity")
phase = data.GetArray("Phase")
#data.SetActiveScalars("Phase")
phase_image = vtk.vtkImageData()
phase_image.SetSpacing(1.0, 1.0, 1.0)
phase_image.SetOrigin(0.0, 0.0, 0.0)
phase_image.SetDimensions(dims[0], dims[1], dims[2])
phase_image.GetPointData().SetScalars(phase)
phase_image.GetPointData().SetVectors(velocity)
extract = vtk.vtkExtractVOI()
extract.SetInput(phase_image)
extract.SetVOI(0, 0, 0, dims[1] - 1, 0, dims[2] - 1)
extract.Update()
#Create a contour
#contour=vtk.vtkOutlineFilter()
contour = vtk.vtkContourFilter()
contour.SetInputConnection(extract.GetOutputPort())
#contour.SetInput(phase_image)
contour.SetValue(0, 0.0)
contour.Update()
#cont_points=contour.GetOutput().GetPoints()
probe = vtk.vtkProbeFilter()
probe.SetInputConnection(contour.GetOutputPort())
probe.SetSource(extract.GetOutput())
probe.Update()
filt_points = vtk.vtkMaskPoints()
filt_points.SetInputConnection(probe.GetOutputPort())
#filt_points.SetMaximumNumberOfPoints(200)
#filt_points.SetRandomMode(1)
filt_points.SetOnRatio(10)
arrow = vtk.vtkArrowSource()
glyph = vtk.vtkGlyph3D()
glyph.SetInputConnection(filt_points.GetOutputPort())
glyph.SetSourceConnection(arrow.GetOutputPort())
glyph.SetVectorModeToUseVector()
glyph.SetScaleModeToScaleByVector()
glyph.SetScaleFactor(400.0)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glyph.GetOutputPort())
glyphActor = vtk.vtkActor()
glyphActor.SetMapper(glyphMapper)
glyphActor.GetProperty().SetColor(0.1, 0.5, 0.2)
print glyphActor.GetProperty().GetColor()
#print "Probe=", probe.GetOutput()
calc = vtk.vtkArrayCalculator()
calc.SetInput(probe.GetOutput())
#calc.AddVectorArrayName("Velocity",1,1,1)
calc.AddScalarVariable("Vz", "Velocity", 2)
calc.SetResultArrayName("Velocity comp 2")
calc.SetFunction("Vz")
#calc.SetResultArrayName("Velocity Magnitude")
#calc.SetFunction("mag(Velocity)")
calc.Update()
print calc.GetOutput()
xyplot = vtk.vtkXYPlotActor()
vel = probe.GetOutput().GetPointData().GetArray("Velocity")
#exam=vtk.vtkDoubleArray()
#vel.GetData(0,vel.GetNumberOfTuples()-1,2,2,exam)
xyplot.AddInput(calc.GetOutput())
#xyplot.GetPositionCoordinate().SetValue(0.0, 0.67, 0)
#xyplot.GetPosition2Coordinate().SetValue(1.0, 0.33, 0) #relative to Position
xyplot.SetXValuesToArcLength()
#xyplot.SetNumberOfXLabels(6)
#xyplot.SetTitle("Pressure vs. Arc Length (Zoomed View)")
#xyplot.SetXTitle("")
#xyplot.SetYTitle("P")
#xyplot.SetXRange(.1, .35)
#xyplot.SetYRange(.2, .4)
xyplot.GetProperty().SetColor(0, 0, 0)
xyplot.GetProperty().SetLineWidth(2)
# Set text prop color (same color for backward compat with test)
# Assign same object to all text props
tprop = xyplot.GetTitleTextProperty()
tprop.SetColor(xyplot.GetProperty().GetColor())
xyplot.SetAxisTitleTextProperty(tprop)
xyplot.SetAxisLabelTextProperty(tprop)
#glyph=vtk.vtkGlyph3D()
#glyph.SetInput(contour.GetOutput())
contourMapper = vtk.vtkPolyDataMapper()
#contourMapper.SetScalarRange(phase.GetRange())
contourMapper.SetInputConnection(contour.GetOutputPort())
sliceMapper = vtk.vtkImageMapper()
#sliceMapper = vtk.vtkDataSetMapper()
sliceMapper.SetInput(extract.GetOutput())
sliceMapper.SetColorLevel(1000)
sliceMapper.SetColorWindow(2000)
#sliceMapper.SetColorModeToMapScalars()
#print polydata.GetClassName()
contourActor = vtk.vtkActor()
contourActor.SetMapper(contourMapper)
sliceActor = vtk.vtkActor2D()
sliceActor.SetMapper(sliceMapper)
ren = vtk.vtkRenderer()
#ren.AddActor(contourActor)
ren.AddActor2D(sliceActor)
#ren.AddActor(glyphActor)
ren.SetBackground(0.1, 0.2, 0.4)
#ren.SetColor(0.1,0.5,0.2)
#ren.SetViewport(0, 0, .3, 1)
ren2 = vtk.vtkRenderer()
ren2.SetBackground(1, 1, 1)
ren2.SetViewport(0.3, 0.0, 1.0, 1.0)
ren2.AddActor2D(xyplot)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
#renWin.AddRenderer(ren2)
renWin.SetSize(500, 500)
#win=vtk.vtkWindowToImageFilter()
#win.SetInput(renWin)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.Initialize()
renWin.Render()
iren.Start()
appendF.AddInputConnection(probe2.GetOutputPort())
appendF.AddInputConnection(probe3.GetOutputPort())
# Create a tube filter to represent the lines as tubes. Set up the
# associated mapper and actor.
tuber = vtk.vtkTubeFilter()
tuber.SetInputConnection(appendF.GetOutputPort())
tuber.SetRadius(0.1)
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(tuber.GetOutputPort())
lineActor = vtk.vtkActor()
lineActor.SetMapper(lineMapper)
# Create an xy-plot using the output of the 3 probe filters as input.
# The x-values we are plotting are arc length.
xyplot = vtk.vtkXYPlotActor()
xyplot.AddDataSetInputConnection(probe.GetOutputPort())
xyplot.AddDataSetInputConnection(probe2.GetOutputPort())
xyplot.AddDataSetInputConnection(probe3.GetOutputPort())
xyplot.GetPositionCoordinate().SetValue(0.0, 0.67, 0)
xyplot.GetPosition2Coordinate().SetValue(1.0, 0.33, 0) #relative to Position
xyplot.SetXValuesToArcLength()
xyplot.SetNumberOfXLabels(6)
xyplot.SetTitle("Pressure vs. Arc Length (Zoomed View)")
xyplot.SetXTitle("")
xyplot.SetYTitle("P")
xyplot.SetXRange(.1, .35)
xyplot.SetYRange(.2, .4)
xyplot.GetProperty().SetColor(0, 0, 0)
xyplot.GetProperty().SetLineWidth(2)
# Set text prop color (same color for backward compat with test)
array1.InsertNextValue(2)
array2 = vtk.vtkFloatArray()
array2.InsertNextValue(3)
array2.InsertNextValue(0)
array2.InsertNextValue(2)
array2.InsertNextValue(1)
unstructuredGrid.GetPointData().SetScalars(array1)
unstructuredGrid2 = vtk.vtkUnstructuredGrid()
unstructuredGrid2.CopyStructure(unstructuredGrid)
unstructuredGrid2.GetPointData().SetScalars(array2)
#polyData = vtk.vtkPolyData()
#polyData.GetPointData().SetScalars(array1)
plotActor = vtk.vtkXYPlotActor()
plotActor.SetTitle("Ma Sticazzi?")
#plotActor.AddDataSetInput(polyData)
plotActor.AddDataSetInput(unstructuredGrid)
plotActor.AddDataSetInput(unstructuredGrid2)
plotWidget = vtk.vtkXYPlotWidget()
#plotWidget.SetOutlineColor(0.9300, 0.5700, 0.1300)
plotWidget.SetXYPlotActor(plotActor)
plotWidget.SetInteractor(renderWindowInteractor)
#plotWidget.SetViewport(0.2, 0.2, 0.4, 0.4)
plotWidget.SetEnabled(True)
#plotWidget.InteractiveOn()
#plotWidget = vtk.QVTKWidget()
#view = vtk.vtkContextView()
#view.SetInteractor(renderWindowInteractor)
