def __init__(self, bgcolor='Silver', size=(800, 600)):
self.colors = vtk.vtkNamedColors()
# Camera
self.camera = vtk.vtkCamera()
self.camera.SetPosition(0, 0, 0)
self.camera.SetFocalPoint(0, 0, 0)
# A renderer and render window
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(self.colors.GetColor3d(bgcolor))
# self.renderer.SetActiveCamera(self.camera)
# self.camera = self.renderer.GetActiveCamera()
# render window
self.renwin = vtk.vtkRenderWindow()
self.renwin.SetWindowName("Croma - Visualization Tool")
self.renwin.AddRenderer(self.renderer)
self.renwin.SetSize(size[0], size[1])
# An interactor
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetRenderWindow(self.renwin)
style = vtk.vtkInteractorStyleTerrain()
self.interactor.SetInteractorStyle(style)
self.interactor.Initialize()
self.sources = []
self.mappers = []
self.actors = []
self.callbacks = []
def testStyleTerrain(self):
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
testStyleBaseSpike = TestStyleBaseSpike.StyleBaseSpike(
ren, renWin, iRen)
# Set interactor style
inStyle = vtk.vtkInteractorStyleTerrain()
iRen.SetInteractorStyle(inStyle)
# Test style
testStyleBase = TestStyleBase.TestStyleBase(ren)
testStyleBase.test_style(inStyle)
# render and interact with data
img_file = "TestStyleTerrain.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def setPickerMode(self,state):
import utilities.pointPicker as pStyle
print(pStyle)
print(state)
if state==2:
self.interactor.SetInteractorStyle(pStyle.testStyle(self.emitPickedPoint))
else:
self.interactor.SetInteractorStyle(vtk.vtkInteractorStyleTerrain())
def main(argv):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('path', type=str, help='Map to draw.')
parser.add_argument(
'-a',
'--anchoring',
action='store_true',
help='Draw the map according to the anchoring (in seed frame).')
options = parser.parse_args(argv)
# Load the map from the given file.
(current_graph, current_waypoints, current_waypoint_snapshots,
current_edge_snapshots, current_anchors,
current_anchored_world_objects) = load_map(options.path)
# Create the renderer.
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.05, 0.1, 0.15)
if options.anchoring:
if len(current_graph.anchoring.anchors) == 0:
print('No anchors to draw.')
sys.exit(-1)
avg_pos = create_anchored_graph_objects(
current_graph, current_waypoint_snapshots, current_waypoints,
current_anchors, current_anchored_world_objects, renderer)
else:
avg_pos = create_graph_objects(current_graph,
current_waypoint_snapshots,
current_waypoints, renderer)
camera_pos = avg_pos + np.array([-1, 0, 5])
camera = renderer.GetActiveCamera()
camera.SetViewUp(0, 0, 1)
camera.SetPosition(camera_pos[0], camera_pos[1], camera_pos[2])
# Create the VTK renderer and interactor.
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName(options.path)
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindow.SetSize(1280, 720)
style = vtk.vtkInteractorStyleTerrain()
renderWindowInteractor.SetInteractorStyle(style)
renderer.ResetCamera()
# Start rendering.
renderWindow.Render()
renderWindow.Start()
renderWindowInteractor.Start()
def ViewVTK(self):
polydata = vtk.vtkPolyData()
polydata.SetPoints(self.points)
polydata.SetLines(self.lines)
pdmap = vtk.vtkPolyDataMapper()
pdmap.SetInput(polydata)
pdact = vtk.vtkActor()
pdact.SetMapper(pdmap)
pdact.GetProperty().SetColor(0.3, 0.8, 1.0)
ren = vtk.vtkRenderer()
ren.AddActor(pdact)
for scol in self.acareas:
apoints, atriangs = self.acareas[scol]
dpd = vtk.vtkPolyData()
dpd.SetPoints(apoints)
dpd.SetPolys(atriangs)
dmap = vtk.vtkPolyDataMapper()
dmap.SetInput(dpd)
dact = vtk.vtkActor()
dact.SetMapper(dmap)
dact.GetProperty().SetColor(
eval("0x" + scol[1:3]) / 256.0,
eval("0x" + scol[3:5]) / 256.0,
eval("0x" + scol[5:7]) / 256.0)
dact.GetProperty().SetAmbient(0.2)
ren.AddActor(dact)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(250, 250)
iren = vtk.vtkRenderWindowInteractor()
istyle = vtk.vtkInteractorStyleTerrain()
iren.SetInteractorStyle(istyle)
# "here", istyle, istyle.__str__()
iren.SetRenderWindow(renWin)
iren.Initialize()
renWin.Render()
#print "there", iren.GetInteractorStyle(), iren.GetInteractorStyle().__str__
iren.Start()
def testStyleTerrain(self):
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
testStyleBaseSpike = TestStyleBaseSpike.StyleBaseSpike(ren, renWin, iRen)
# Set interactor style
inStyle = vtk.vtkInteractorStyleTerrain()
iRen.SetInteractorStyle(inStyle)
# Test style
testStyleBase = TestStyleBase.TestStyleBase(ren)
testStyleBase.test_style(inStyle)
# render and interact with data
img_file = "TestStyleTerrain.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def main(argv):
# Load the map from the given file.
path = argv[0]
(current_graph, current_waypoints, current_waypoint_snapshots,
current_edge_snapshots) = load_map(path)
# Create the renderer.
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.05, 0.1, 0.15)
avg_pos = create_graph_objects(current_graph, current_waypoint_snapshots,
current_waypoints, renderer)
# Compute the average waypoint position to place the camera appropriately.
avg_pos /= len(current_waypoints)
camera_pos = avg_pos + np.array([-1, 0, 5])
camera = renderer.GetActiveCamera()
camera.SetViewUp(0, 0, 1)
camera.SetPosition(camera_pos[0], camera_pos[1], camera_pos[2])
# Create the VTK renderer and interactor.
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName(path)
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindow.SetSize(1280, 720)
style = vtk.vtkInteractorStyleTerrain()
renderWindowInteractor.SetInteractorStyle(style)
renderer.ResetCamera()
# Start rendering.
renderWindow.Render()
renderWindow.Start()
renderWindowInteractor.Start()
def main(argv):
"""Main rendering loop for the API streaming visualizer."""
# Setup the robot.
parser = argparse.ArgumentParser()
bosdyn.client.util.add_common_arguments(parser)
parser.add_argument('--local-grid', choices=['no-step', 'obstacle-distance', 'terrain'],
help='Which local grid to visualize', default=['terrain'], action='append')
options = parser.parse_args(argv)
sdk = bosdyn.client.create_standard_sdk('SpotViz')
sdk.load_app_token(options.app_token)
robot = sdk.create_robot(options.hostname)
robot.authenticate(options.username, options.password)
robot.time_sync.wait_for_sync()
# Set up the clients for getting Spot's perception scene.
local_grid_client = robot.ensure_client(LocalGridClient.default_service_name)
robot_state_client = robot.ensure_client(RobotStateClient.default_service_name)
world_object_client = robot.ensure_client(WorldObjectClient.default_service_name)
# Create the renderer and camera.
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.05, 0.1, 0.15)
camera = renderer.GetActiveCamera()
camera.SetViewUp(0, 0, 1)
camera.SetPosition(0, 0, 5)
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("API Visualizer")
renderWindow.SetSize(1280, 720)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.SetInteractorStyle(vtk.vtkInteractorStyleTerrain())
# Setup the time-based event callbacks for each vtk actor to be visualized.
robot_state_timer = RobotStateTimedCallbackEvent(robot_state_client)
robot_state_actor = robot_state_timer.get_actor()
renderer.AddActor(robot_state_actor)
local_grid_timer = LocalGridTimedCallbackEvent(local_grid_client, robot_state_client, options.local_grid)
grid_actors = local_grid_timer.get_actors()
for actor in grid_actors:
renderer.AddActor(actor)
world_object_timer = WorldObjectTimedCallbackEvent(world_object_client)
world_object_actors = world_object_timer.get_actors()
for actor in world_object_actors:
renderer.AddActor(actor)
renderWindow.AddRenderer(renderer)
renderer.ResetCamera()
renderWindow.Render()
# Initilize the render windows and set the timed callbacks.
renderWindowInteractor.Initialize()
renderWindowInteractor.AddObserver(vtk.vtkCommand.TimerEvent,
robot_state_timer.update_state_actor)
renderWindowInteractor.AddObserver(vtk.vtkCommand.TimerEvent,
local_grid_timer.update_local_grid_actors)
renderWindowInteractor.AddObserver(vtk.vtkCommand.TimerEvent,
world_object_timer.update_world_object_actor)
timerId = renderWindowInteractor.CreateRepeatingTimer(100)
renderWindowInteractor.Start()
return True
import logging
from atom.api import Atom, Dict, Str, observe, Value, Int, Tuple, List
from functools import partial
import vtk
logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s',
level=logging.DEBUG)
INTERACTION_STYLES = {
'TrackBallActor': vtk.vtkInteractorStyleTrackballActor(),
'TrackBallCamera':
vtk.vtkInteractorStyleTrackballCamera(), # default style
'JoystickCamera': vtk.vtkInteractorStyleJoystickCamera(),
'JoystickActor': vtk.vtkInteractorStyleJoystickActor(),
'Terrain': vtk.vtkInteractorStyleTerrain(),
}
class VTKRenderController(Atom):
""" vtk render controller - supply renderers to VTKCanvas """
zoomFactor = Value()
numOfRenderers = Int()
callbacks = Dict()
customPorts = Dict()
customBackgrounds = Dict()
interactorStyle = Str()
style = Value()
bgColor = Tuple()
motionFactor = Int()
demMapper16.SetInputConnection(normals16.GetOutputPort())
demMapper16.SetScalarRange(lo, hi)
demMapper16.SetLookupTable(lut)
demMapper16.ImmediateModeRenderingOn()
demMapper16.Update()
demActor.AddLODMapper(demMapper16)
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
t = vtk.vtkInteractorStyleTerrain()
iren.SetInteractorStyle(t)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(demActor)
ren.SetBackground(.4, .4, .4)
iren.SetDesiredUpdateRate(1)
def TkCheckAbort(__vtk__temp0=0, __vtk__temp1=0):
foo = renWin.GetEventPending()
if (foo != 0):
renWin.SetAbortRender(1)
pass
demMapper16.SetInputConnection(normals16.GetOutputPort())
demMapper16.SetScalarRange(lo, hi)
demMapper16.SetLookupTable(lut)
demMapper16.ImmediateModeRenderingOn()
demMapper16.Update()
demActor.AddLODMapper(demMapper16)
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
t = vtk.vtkInteractorStyleTerrain()
iren.SetInteractorStyle(t)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(demActor)
ren.SetBackground(.4, .4, .4)
iren.SetDesiredUpdateRate(1)
def TkCheckAbort (__vtk__temp0=0, __vtk__temp1=0):
foo = renWin.GetEventPending()
if (foo != 0):
renWin.SetAbortRender(1)
pass
renWin.AddObserver("AbortCheckEvent", TkCheckAbort)
def run_simulation(**kwds):
from math import pi, sqrt
from vtk import (vtkInteractorStyleTerrain,
vtkRenderWindowInteractor,
vtkRenderWindow,
vtkRenderer,
vtkActor,
vtkPolyDataMapper,
vtkSphereSource,
vtkCylinderSource,
vtkTransform)
from vtk.util.colors import red, blue, brown
M0 = kwds.get("mass0", DEFAULT_M0)
M1 = kwds.get("mass1", DEFAULT_M1)
L0 = kwds.get("length0", DEFAULT_L0)
L1 = kwds.get("length1", DEFAULT_L1)
iTH0 = kwds.get("theta0", DEFAULT_ITH0)
iTH1 = kwds.get("theta1", DEFAULT_ITH1)
iW0 = kwds.get("omega0", DEFAULT_IW0)
iW1 = kwds.get("omega1", DEFAULT_IW1)
G = kwds.get("gravity", DEFAULT_G)
dt = kwds.get("time_step", DEFAULT_DT)
duration = kwds.get("duration", DEFAULT_DURATION)
sim = Pen2Sim(iTH0, iTH1, iW0, iW1, M0, M1, L0, L1, G, dt)
sphere0 = vtkSphereSource()
sphere1 = vtkSphereSource()
cylinder0 = vtkCylinderSource()
cylinder1 = vtkCylinderSource()
sphere0.SetCenter(0.0, 0.0, 0.0)
sphere1.SetCenter(0.0, 0.0, 0.0)
sphere0.SetRadius(0.25*sqrt(M0/pi))
sphere1.SetRadius(0.25*sqrt(M1/pi))
cylinder0.SetRadius(0.04)
cylinder1.SetRadius(0.04)
cTran0 = vtkTransform()
cTran1 = vtkTransform()
sMap0 = vtkPolyDataMapper()
sMap1 = vtkPolyDataMapper()
cMap0 = vtkPolyDataMapper()
cMap1 = vtkPolyDataMapper()
sMap0.SetInputConnection(sphere0.GetOutputPort())
sMap1.SetInputConnection(sphere1.GetOutputPort())
cMap0.SetInputConnection(cylinder0.GetOutputPort())
cMap1.SetInputConnection(cylinder1.GetOutputPort())
sAct0 = vtkActor()
sAct1 = vtkActor()
sAct0.SetMapper(sMap0)
sAct1.SetMapper(sMap1)
sAct0.GetProperty().SetColor(red)
sAct1.GetProperty().SetColor(blue)
cAct0 = vtkActor()
cAct1 = vtkActor()
cAct0.SetMapper(cMap0)
cAct1.SetMapper(cMap1)
cAct0.GetProperty().SetColor(brown)
cAct1.GetProperty().SetColor(brown)
renderer = vtkRenderer()
renderWindow = vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtkRenderWindowInteractor()
interactor.SetInteractorStyle(vtkInteractorStyleTerrain())
interactor.SetRenderWindow(renderWindow)
renderer.AddActor(sAct0)
renderer.AddActor(sAct1)
renderer.AddActor(cAct0)
renderer.AddActor(cAct1)
renderer.SetBackground(0.1, 0.2, 0.4)
renderer.GetActiveCamera().Dolly(0.125)
renderWindow.SetSize(800, 600)
renderWindow.Render()
interactor.Initialize()
state = [None]
def callback(*args, **kwds):
if state[0] is None:
state[0] = list(sim.initial_state())
cylinder0.SetHeight(state[0][5])
cylinder1.SetHeight(state[0][6])
else:
state[0][:] = sim.advance()
x0, x1, y0, y1, t, L0, L1, th0, th1 = state[0][:9]
cTran0.Identity()
cTran1.Identity()
cTran1.Translate(x0, y0, 0.0)
cTran0.RotateZ(180.0 * th0 / pi)
cTran1.RotateZ(180.0 * th1 / pi)
cTran0.Translate(0.0, -0.5*L0, 0.0)
cTran1.Translate(0.0, -0.5*L1, 0.0)
cAct0.SetUserTransform(cTran0)
cAct1.SetUserTransform(cTran1)
sAct0.SetPosition(x0, y0, 0.0)
sAct1.SetPosition(x1, y1, 0.0)
renderWindow.Render()
if duration is not None and t >= duration:
interactor.RemoveObserver(timerid)
interactor.ExitCallback()
interactor.AddObserver("TimerEvent", callback)
timerid = interactor.CreateRepeatingTimer(int(1000*dt))
interactor.Start()
import logging
from atom.api import Atom, Dict, Str, observe, Value, Int, Tuple, List
from functools import partial
import vtk
logging.basicConfig(format="%(asctime)s: %(levelname)s: %(message)s", level=logging.DEBUG)
INTERACTION_STYLES = {
"TrackBallActor": vtk.vtkInteractorStyleTrackballActor(),
"TrackBallCamera": vtk.vtkInteractorStyleTrackballCamera(), # default style
"JoystickCamera": vtk.vtkInteractorStyleJoystickCamera(),
"JoystickActor": vtk.vtkInteractorStyleJoystickActor(),
"Terrain": vtk.vtkInteractorStyleTerrain(),
}
class VTKRenderController(Atom):
""" vtk render controller - supply renderers to VTKCanvas """
zoomFactor = Value()
numOfRenderers = Int()
callbacks = Dict()
customPorts = Dict()
customBackgrounds = Dict()
interactorStyle = Str()
style = Value()
bgColor = Tuple()
motionFactor = Int()
def __init__(self, parent, dataPath):
super(XYZviewer,self).__init__(parent)
self.interactor = QVTKRenderWindowInteractor(self)
self.layout = QtWidgets.QHBoxLayout()
self.layout.addWidget(self.interactor)
self.layout.setContentsMargins(0,0,0,0)
self.setLayout(self.layout)
self.pointCloud = VtkPointCloud()
self.pcdCollection=[]
self.actors = []
self.pickedID=[]
self.e=ErrorObserver()
self.interactor.AddObserver("ErrorEvent",self.e)
if self.e.ErrorOccurred():
print(e.ErrorMessage)
#self.load_data(loadPath)
if dataPath != None:
self.add_data(dataPath)
# Renderer
self.renderer = vtk.vtkRenderer()
self.cubeAxesActor = vtk.vtkCubeAxesActor()
self.setCubeAxesActor()
self.cubeAxesActor.SetBounds(0,100,0,100,0,100)
self.renderer.AddActor(self.cubeAxesActor)
# Scalar Bar
self.scalarBarActor = vtk.vtkScalarBarActor()
self.setScalarBar()
self.renderer.AddActor(self.scalarBarActor)
#renderer.SetBackground(.2, .3, .4)
#colors=vtk.vtkNamedColors()
#colors.SetColor("BkgColor",[179,204,255,255])
#renderer.SetBackground(colors.GetColor3d("BkgColor"))
self.pointCloud.setLUTRange(0,10)
#cam=self.renderer.GetActiveCamera()
#cam.Azimuth(-45)
#cam.Elevation(0)
#cam.Roll(90)
#cam.SetViewUp(0,0,1)
#cam.SetPosition(0,1,0)
#cam.SetParallelProjection(0)
#cam.Elevation(-10)
#self.renderer.SetActiveCamera(cam)
#self.renderer.ResetCamera()
#renderer.SetLayer(1)
# Render Window
renderWindow = self.interactor.GetRenderWindow()
#renderWindow = vtk.vtkRenderWindow()
#print(renderWindow)
#renderWindow.SetNumberOfLayers(2)
renderWindow.AddRenderer(self.renderer)
#renderWindow.AddRenderer(self.addLogo())
# Interactor
#renderWindowInteractor = vtk.vtkRenderWindowInteractor()
self.interactor.SetRenderWindow(renderWindow)
self.interactor.SetInteractorStyle(vtk.vtkInteractorStyleTerrain())
# Scalar Bar
#self.addScalarBar(self.pointCloud.getLUT())
#renderWindow.SetInteractor(self.interactor)
# Logo
#self.addLogo()
self.renderer.ResetCamera()
# Begin Interaction
renderWindow.Render()
renderWindow.SetWindowName("XYZ Data Viewer:"+ "xyz")
self.interactor.Start()
