def __init__(self,data_reader,main_renderer,main_interactor,chart,pts): self.widget=vtk.vtkLineWidget() self.widget.SetCurrentRenderer(main_renderer) #interactor = vtk.vtkRenderWindowInteractor() self.widget.SetInteractor(vtk.vtkRenderWindowInteractor()) self.widget.SetInput(data_reader.get_data_set()) self.widget.ClampToBoundsOff() self.widget.SetResolution(1000) self.widget.SetAlignToNone() self.point1=[pts[0],pts[1],pts[2]] self.point2=[pts[3],pts[4],pts[5]] self.widget.SetPoint1(self.point1) self.widget.SetPoint2(self.point2) self.widget.PlaceWidget() self.widget.AddObserver("InteractionEvent",self.PrepareProfile(chart)) self.widget.On()
def __init__(self, data_reader, main_renderer, main_interactor, chart, pts): self.widget = vtk.vtkLineWidget() self.widget.SetCurrentRenderer(main_renderer) #interactor = vtk.vtkRenderWindowInteractor() self.widget.SetInteractor(vtk.vtkRenderWindowInteractor()) self.widget.SetInput(data_reader.get_data_set()) self.widget.ClampToBoundsOff() self.widget.SetResolution(1000) self.widget.SetAlignToNone() self.point1 = [pts[0], pts[1], pts[2]] self.point2 = [pts[3], pts[4], pts[5]] self.widget.SetPoint1(self.point1) self.widget.SetPoint2(self.point2) self.widget.PlaceWidget() self.widget.AddObserver("InteractionEvent", self.PrepareProfile(chart)) self.widget.On()
import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Start by loading some data. pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3d_output = pl3d.GetOutput().GetBlock(0) # The line widget is used seed the streamlines. lineWidget = vtk.vtkLineWidget() seeds = vtk.vtkPolyData() lineWidget.SetInputData(pl3d_output) lineWidget.SetAlignToYAxis() lineWidget.PlaceWidget() lineWidget.GetPolyData(seeds) lineWidget.ClampToBoundsOn() rk4 = vtk.vtkRungeKutta4() streamer = vtk.vtkStreamTracer() streamer.SetInputData(pl3d_output) streamer.SetSourceData(seeds) streamer.SetMaximumPropagation(100) streamer.SetInitialIntegrationStep(.2) streamer.SetIntegrationDirectionToForward() streamer.SetComputeVorticity(1)
def add_line_widget(self, callback, bounds=None, factor=1.25, resolution=100, color=None, use_vertices=False, pass_widget=False): """Add a line widget to the scene. This is useless without a callback function. You can pass a callable function that takes a single argument, the PolyData line output from this widget, and performs a task with that line. Parameters ---------- callback : callable The method called every time the line is updated. This has two options: Take a single argument, the ``PolyData`` line (default) or if ``use_vertices=True``, then it can take two arguments of the coordinates of the line's end points. bounds : tuple(float) Length 6 tuple of the bounding box where the widget is placed. factor : float, optional An inflation factor to expand on the bounds when placing resolution : int The number of points in the line created color : string or 3 item list, optional, defaults to white Either a string, rgb list, or hex color string. use_vertices : bool, optional Changess the arguments of the callback method to take the end points of the line instead of a PolyData object. pass_widget : bool If true, the widget will be passed as the last argument of the callback """ if hasattr(self, 'notebook') and self.notebook: raise AssertionError( 'Line widget not available in notebook plotting') if not hasattr(self, 'iren'): raise AttributeError( 'Widgets must be used with an intereactive renderer. No off screen plotting.' ) if not hasattr(self, "line_widgets"): self.line_widgets = [] if bounds is None: bounds = self.bounds if color is None: color = rcParams['font']['color'] def _the_callback(widget, event_id): pointa = widget.GetPoint1() pointb = widget.GetPoint2() if hasattr(callback, '__call__'): if use_vertices: args = [pointa, pointb] else: the_line = pyvista.Line(pointa, pointb, resolution=resolution) args = [the_line] if pass_widget: args.append(widget) try_callback(callback, *args) return line_widget = vtk.vtkLineWidget() line_widget.GetLineProperty().SetColor(parse_color(color)) line_widget.SetInteractor(self.iren) line_widget.SetCurrentRenderer(self.renderer) line_widget.SetPlaceFactor(factor) line_widget.PlaceWidget(bounds) line_widget.SetResolution(resolution) line_widget.Modified() line_widget.On() line_widget.AddObserver(vtk.vtkCommand.EndInteractionEvent, _the_callback) _the_callback(line_widget, None) self.line_widgets.append(line_widget) return line_widget
try: import vtk except: print "Cannot import vtk" sys.exit(1) try: print dir(vtk) except: print "Cannot print dir(vtk)" sys.exit(1) try: try: try: o = vtk.vtkLineWidget() print "Using Hybrid" except: o = vtk.vtkActor() print "Using Rendering" except: o = vtk.vtkObject() print "Using Common" except: print "Cannot create vtkObject" sys.exit(1) try: print o print "Reference count: %d" % o.GetReferenceCount() print "Class name: %s" % o.GetClassName()
import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Start by loading some data. pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3d_output = pl3d.GetOutput().GetBlock(0) # The line widget is used seed the streamlines. lineWidget = vtk.vtkLineWidget() seeds = vtk.vtkPolyData() lineWidget.SetInputData(pl3d_output) lineWidget.SetAlignToYAxis() lineWidget.PlaceWidget() lineWidget.GetPolyData(seeds) lineWidget.ClampToBoundsOn() rk4 = vtk.vtkRungeKutta4() streamer = vtk.vtkStreamLine() streamer.SetInputData(pl3d_output) streamer.SetSourceData(seeds) streamer.SetMaximumPropagationTime(100) streamer.SetIntegrationStepLength(0.2) streamer.SetStepLength(0.001) streamer.SetNumberOfThreads(1)
try: import vtk except: print "Cannot import vtk" qt.QApplication.exit(1) try: print dir(vtk) except: print "Cannot print dir(vtk)" qt.QApplication.exit(1) try: try: try: o = vtk.vtkLineWidget() print "Using Hybrid" except: o = vtk.vtkActor() print "Using Rendering" except: o = vtk.vtkObject() print "Using Common" except: print "Cannot create vtkObject" qt.QApplication.exit(1) try: print o print "Reference count: %d" % o.GetReferenceCount() print "Class name: %s" % o.GetClassName()
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 main(): colors = vtk.vtkNamedColors() fileName1, fileName2, numOfStreamLines, illustration = get_program_parameters( ) if illustration: numOfStreamLines = 25 # Start by loading some data. pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(fileName1) pl3d.SetQFileName(fileName2) pl3d.SetScalarFunctionNumber(100) # Density pl3d.SetVectorFunctionNumber(202) # Momentum pl3d.Update() pl3d_output = pl3d.GetOutput().GetBlock(0) # Create the Renderer, RenderWindow and RenderWindowInteractor. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Needed by: vtkStreamTracer and vtkLineWidget. seeds = vtk.vtkPolyData() streamline = vtk.vtkActor() seeds2 = vtk.vtkPolyData() streamline2 = vtk.vtkActor() # The line widget is used seed the streamlines. lineWidget = vtk.vtkLineWidget() lineWidget.SetResolution(numOfStreamLines) lineWidget.SetInputData(pl3d_output) lineWidget.GetPolyData(seeds) if illustration: lineWidget.SetAlignToNone() lineWidget.SetPoint1(0.974678, 5.073630, 31.217961) lineWidget.SetPoint2(0.457544, -4.995921, 31.080175) else: lineWidget.SetAlignToYAxis() lineWidget.ClampToBoundsOn() lineWidget.PlaceWidget() # Associate the line widget with the interactor and setup callbacks. lineWidget.SetInteractor(iren) lineWidget.AddObserver("StartInteractionEvent", EnableActorCallback(streamline)) lineWidget.AddObserver("InteractionEvent", GenerateStreamlinesCallback(seeds, renWin)) # The second line widget is used seed more streamlines. lineWidget2 = vtk.vtkLineWidget() lineWidget2.SetResolution(numOfStreamLines) lineWidget2.SetInputData(pl3d_output) lineWidget2.GetPolyData(seeds2) lineWidget2.SetKeyPressActivationValue('L') lineWidget2.SetAlignToZAxis() lineWidget.ClampToBoundsOn() lineWidget2.PlaceWidget() # Associate the line widget with the interactor and setup callbacks. lineWidget2.SetInteractor(iren) lineWidget2.AddObserver("StartInteractionEvent", EnableActorCallback(streamline2)) lineWidget2.AddObserver("InteractionEvent", GenerateStreamlinesCallback(seeds2, renWin)) # Here we set up two streamlines. rk4 = vtk.vtkRungeKutta4() streamer = vtk.vtkStreamTracer() streamer.SetInputData(pl3d_output) streamer.SetSourceData(seeds) streamer.SetMaximumPropagation(100) streamer.SetInitialIntegrationStep(0.2) streamer.SetIntegrationDirectionToForward() streamer.SetComputeVorticity(1) streamer.SetIntegrator(rk4) rf = vtk.vtkRibbonFilter() rf.SetInputConnection(streamer.GetOutputPort()) rf.SetWidth(0.1) rf.SetWidthFactor(5) streamMapper = vtk.vtkPolyDataMapper() streamMapper.SetInputConnection(rf.GetOutputPort()) streamMapper.SetScalarRange(pl3d_output.GetScalarRange()) streamline.SetMapper(streamMapper) streamline.VisibilityOff() streamer2 = vtk.vtkStreamTracer() streamer2.SetInputData(pl3d_output) streamer2.SetSourceData(seeds2) streamer2.SetMaximumPropagation(100) streamer2.SetInitialIntegrationStep(0.2) streamer2.SetIntegrationDirectionToForward() streamer2.SetComputeVorticity(1) streamer2.SetIntegrator(rk4) rf2 = vtk.vtkRibbonFilter() rf2.SetInputConnection(streamer2.GetOutputPort()) rf2.SetWidth(0.1) rf2.SetWidthFactor(5) streamMapper2 = vtk.vtkPolyDataMapper() streamMapper2.SetInputConnection(rf2.GetOutputPort()) streamMapper2.SetScalarRange(pl3d_output.GetScalarRange()) streamline2.SetMapper(streamMapper2) streamline2.VisibilityOff() # Get an outline of the data set for context. outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(pl3d_output) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.GetProperty().SetColor(colors.GetColor3d("Black")) outlineActor.SetMapper(outlineMapper) # Add the actors to the renderer, set the background and size. ren.AddActor(outlineActor) ren.AddActor(streamline) ren.AddActor(streamline2) renWin.SetSize(512, 512) cam = ren.GetActiveCamera() if illustration: # We need to directly display the streamlines in this case. lineWidget.EnabledOn() streamline.VisibilityOn() lineWidget.GetPolyData(seeds) renWin.Render() cam.SetClippingRange(14.216207, 68.382915) cam.SetFocalPoint(9.718210, 0.458166, 29.399900) cam.SetPosition(-15.827551, -16.997463, 54.003120) cam.SetViewUp(0.616076, 0.179428, 0.766979) ren.SetBackground(colors.GetColor3d("Silver")) else: cam.SetClippingRange(3.95297, 50) cam.SetFocalPoint(9.71821, 0.458166, 29.3999) cam.SetPosition(2.7439, -37.3196, 38.7167) cam.SetViewUp(-0.16123, 0.264271, 0.950876) ren.SetBackground(colors.GetColor3d("Silver")) iren.Initialize() renWin.Render() iren.Start()