def show(self, chain, showMeshes=False):
if 'google.colab' in sys.modules:
server_args = ['--ngrok_http_tunnel']
# Start a single meshcat server instance to use for the remainder of this notebook.
from meshcat.servers.zmqserver import start_zmq_server_as_subprocess
proc, zmq_url, web_url = start_zmq_server_as_subprocess(
server_args=server_args)
vis = meshcat.Visualizer(zmq_url=zmq_url)
else:
vis = meshcat.Visualizer().open()
if showMeshes:
for i, link in enumerate(chain.linkArray):
if link.meshObj == None:
print("No mesh: " + link.name)
continue
boxVis = vis["link:" + link.name]
boxVis.set_object(
link.meshObj,
g.MeshLambertMaterial(color=0xffffff, reflectivity=0.8))
rotationMatrix = np.pad(link.absoluteOrientation, [(0, 1),
(0, 1)],
mode='constant')
rotationMatrix[-1][-1] = 1
boxVis.set_transform(
tf.translation_matrix(link.absoluteBase) @ rotationMatrix)
else:
for i, link in enumerate(chain.linkArray):
boxVis = vis["link:" + link.name]
if link.primitiveObj != None:
if isinstance(link.primitiveObj, primitives.Box):
box = meshcat.geometry.Box(link.primitiveObj.size)
boxVis.set_object(box)
if isinstance(link.primitiveObj, primitives.Cylinder):
cylinder = meshcat.geometry.Cylinder(
link.primitiveObj.length, link.primitiveObj.radius)
boxVis.set_object(cylinder)
if isinstance(link.primitiveObj, primitives.Sphere):
sphere = meshcat.geometry.Sphere(
link.primitiveObj.radius)
boxVis.set_object(cylinder)
rotationMatrix = np.pad(link.absoluteOrientation, [(0, 1),
(0, 1)],
mode='constant')
rotationMatrix[-1][-1] = 1
boxVis.set_transform(
tf.translation_matrix(link.absoluteBase)
@ rotationMatrix)
boxVis = vis["skeleton"]
boxVis.set_object(
g.Line(g.PointsGeometry(chain.get_vertex_coords().T)))
def __init__(self,
camera,
rbt,
draw_timestep=0.033333,
prefix="RBCameraViz",
zmq_url="tcp://127.0.0.1:6000"):
LeafSystem.__init__(self)
self.set_name('camera meshcat visualization')
self.timestep = draw_timestep
self._DeclarePeriodicPublish(draw_timestep, 0.0)
self.camera = camera
self.rbt = rbt
self.prefix = prefix
self.camera_input_port = \
self._DeclareAbstractInputPort(
"depth_im",
AbstractValue.Make(Image[PixelType.kDepth32F](
self.camera.depth_camera_info().width(),
self.camera.depth_camera_info().height())))
self.state_input_port = \
self._DeclareInputPort(PortDataType.kVectorValued,
rbt.get_num_positions() +
rbt.get_num_velocities())
# Set up meshcat
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
self.vis[prefix].delete()
def _create_meshcat_backend():
import meshcat
from contextlib import redirect_stdout
with redirect_stdout(None):
Viewer._backend_obj = meshcat.Visualizer()
Viewer._backend_proc = Viewer._backend_obj.window.server_proc
def visualize(self, states, dt):
import meshcat
import meshcat.geometry as g
import meshcat.transformations as tf
import time
# Create a new visualizer
vis = meshcat.Visualizer()
vis.open()
vis["/Cameras/default"].set_transform(
tf.translation_matrix([0, 0, 0]).dot(
tf.euler_matrix(0, np.radians(-30), -np.pi / 2)))
vis["/Cameras/default/rotated/<object>"].set_transform(
tf.translation_matrix([1, 0, 0]))
vis["Quadrotor"].set_object(
g.StlMeshGeometry.from_file('systems/crazyflie2.stl'))
while True:
for state in states:
vis["Quadrotor"].set_transform(
tf.translation_matrix([state[0], state[1], state[2]]).dot(
tf.quaternion_matrix(state[6:10])))
time.sleep(dt)
def __init__(self,
open_meshcat=False,
print_url=False,
wait_for_open=False,
zmq_url=None,
show_frames=False,
frame_scale=1.,
object_prefix="objects",
render_to_animation=False,
animation_fps=30,
**kwargs) -> None:
super().__init__()
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
if open_meshcat:
self.vis.open()
if print_url:
self.vis.url()
if wait_for_open:
self.vis.wait()
self.vis["/Background"].set_property("top_color", [1] * 3)
self.vis["/Background"].set_property("bottom_color", [1] * 3)
self.actors_and_offsets = []
self.show_frames = show_frames
self.frame_scale = frame_scale
self.object_prefix = object_prefix
self.animation = meshcat.animation.Animation(
default_framerate=animation_fps) if render_to_animation else None
self.itr = 0
self._vis_group = None
def __init__(self,
scene_graph,
draw_period=0.033333,
prefix="drake",
zmq_url="tcp://127.0.0.1:6000"):
"""
Args:
scene_graph: A SceneGraph object.
draw_period: The rate at which this class publishes to the
visualizer.
prefix: Appears as the root of the tree structure in the meshcat
data structure
zmq_url: Optionally set a non-default url to connect to the
visualizer. The default value is the url obtained by
running `meshcat-server` in another terminal. If
zmp_url=None, then then a new server will be automatically
started (as a child of this process).
"""
LeafSystem.__init__(self)
self.set_name('meshcat_visualizer')
self._DeclarePeriodicPublish(draw_period, 0.0)
# Pose bundle (from SceneGraph) input port.
self._DeclareInputPort("lcm_visualization",
PortDataType.kAbstractValued, 0)
# Set up meshcat.
self.prefix = prefix
print("Connecting to meshcat-server...")
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
print("Connected.")
self.vis[self.prefix].delete()
self._scene_graph = scene_graph
def __init__(self, scene_graph, prefix="SceneGraph", zmq_url="tcp://127.0.0.1:6000"):
self._zmq_url = zmq_url
self._scene_graph = scene_graph
self._scene_graph_output = scene_graph.AllocateOutput()
self.prefix = prefix
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
self.vis[self.prefix].delete()
def show_cloud(pc, use_native=False, **kwargs):
# kwargs go to ctor.
builder = DiagramBuilder()
# Add point cloud visualization.
if use_native:
viz = meshcat.Visualizer(zmq_url=ZMQ_URL)
else:
plant, scene_graph = AddMultibodyPlantSceneGraph(builder)
plant.Finalize()
viz = builder.AddSystem(
MeshcatVisualizer(scene_graph,
zmq_url=ZMQ_URL,
open_browser=False))
builder.Connect(scene_graph.get_pose_bundle_output_port(),
viz.get_input_port(0))
pc_viz = builder.AddSystem(
MeshcatPointCloudVisualizer(viz, **kwargs))
# Make sure the system runs.
diagram = builder.Build()
diagram_context = diagram.CreateDefaultContext()
context = diagram.GetMutableSubsystemContext(
pc_viz, diagram_context)
context.FixInputPort(
pc_viz.GetInputPort("point_cloud_P").get_index(),
AbstractValue.Make(pc))
simulator = Simulator(diagram, diagram_context)
simulator.set_publish_every_time_step(False)
simulator.StepTo(sim_time)
def __init__(self,
rbtree,
old_mrbv=None,
draw_timestep=0.033333,
prefix="RBViz",
zmq_url="tcp://127.0.0.1:6000",
draw_collision=False,
clear_vis=False):
LeafSystem.__init__(self)
self.set_name('meshcat_visualization')
self.timestep = draw_timestep
self._DeclarePeriodicPublish(draw_timestep, 0.0)
self.rbtree = rbtree
self.draw_collision = draw_collision
self._DeclareInputPort(
PortDataType.kVectorValued,
self.rbtree.get_num_positions() + self.rbtree.get_num_velocities())
# Set up meshcat
self.prefix = prefix
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
self.old_mrbv = old_mrbv
# Don't both with caching logic if prefixes are different
if self.old_mrbv is not None and self.old_mrbv.prefix != self.prefix:
raise ValueError("Can't do any caching since old_mrbv has ",
"different prefix than current mrbv.")
self.body_names = []
if clear_vis:
self.vis.delete()
# Publish the tree geometry to get the visualizer started
self.PublishAllGeometry()
def __init__(self, zmq_url=None, max_histories=10000, open_browser=False):
super(MeshcatRenderer, self).__init__()
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
if open_browser:
self.vis.open()
self.ray_histories = deque(maxlen=max_histories)
self.max_histories = max_histories
self.added_index = 0
def draw_scene_tree_meshcat(scene_tree,
zmq_url=None,
alpha=1.0,
node_sphere_size=0.1):
pruned_tree = scene_tree.get_tree_without_production_rules()
# Do actual drawing in meshcat, starting from root of tree
# So first find the root...
root_node = get_tree_root(pruned_tree)
vis = meshcat.Visualizer(zmq_url=zmq_url or "tcp://127.0.0.1:6000")
vis["scene_tree"].delete()
node_queue = [root_node]
# Assign functionally random colors to each new node
# type we discover.
node_class_to_color_dict = {}
cmap = plt.cm.get_cmap('jet')
cmap_counter = 0.
k = 0
while len(node_queue) > 0:
node = node_queue.pop(0)
children = list(pruned_tree.successors(node))
node_queue += children
# Draw this node
node_type_string = node.__class__.__name__
if node_type_string in node_class_to_color_dict.keys():
color = node_class_to_color_dict[node_type_string]
else:
color = rgb_2_hex(cmap(cmap_counter))
node_class_to_color_dict[node_type_string] = color
cmap_counter = np.fmod(cmap_counter + np.pi * 2., 1.)
vis["scene_tree"][node.name + "%d" % k].set_object(
meshcat_geom.Sphere(node_sphere_size),
meshcat_geom.MeshToonMaterial(color=color,
opacity=alpha,
transparent=(alpha != 1.)))
tf = node.tf.cpu().detach().numpy()
vis["scene_tree"][node.name + "%d" % k].set_transform(tf)
# Draw connections to children
verts = []
for child in children:
verts.append(node.tf[:3, 3].cpu().detach().numpy())
verts.append(child.tf[:3, 3].cpu().detach().numpy())
if len(verts) > 0:
verts = np.vstack(verts).T
vis["scene_tree"][node.name + "%d" % k +
"_child_connections"].set_object(
meshcat_geom.Line(
meshcat_geom.PointsGeometry(verts),
meshcat_geom.LineBasicMaterial(
linewidth=10, color=color)))
k += 1
def setUp(self):
# the blocking_vis will take up the default fileserver and ZMQ ports
self.blocking_vis = meshcat.Visualizer()
# this should still work, by chosing a new port
self.vis = meshcat.Visualizer()
if "CI" in os.environ:
port = self.vis.url().split(":")[-1].split("/")[0]
self.dummy_proc = subprocess.Popen([
sys.executable, "-m", "meshcat.tests.dummy_websocket_client",
str(port)
])
else:
self.vis.open()
self.dummy_proc = None
self.vis.wait()
def setUp(self):
self.vis = meshcat.Visualizer()
if "CI" in os.environ:
port = self.vis.url().split(":")[-1].split("/")[0]
self.dummy_proc = subprocess.Popen([sys.executable, "-m", "meshcat.tests.dummy_websocket_client", str(port)])
else:
self.vis.open()
self.dummy_proc = None
self.vis.wait()
def main():
parser = argparse.ArgumentParser()
# four-frame | simple_frame | djmm_test_block | mars_bubble | sig_artopt-bunny | topopt-100 | topopt-205 | topopt-310 | voronoi
parser.add_argument('-p', '--problem', default='simple_frame', help='The name of the problem to solve')
parser.add_argument('-cl', '--check_log', default='none',
help='e.g. backward_sp, forward_random. It will search for <problem>_backward_sp_csp_log.json')
parser.add_argument('-vd', '--viz_deform', action='store_true', help='visualize deformation, default to false')
parser.add_argument('-vp', '--viz_pose', action='store_true', help='visualize feasible ee poses, default to false')
parser.add_argument('-s', '--scale', type=float, default=5.0, help='The vis scale')
parser.add_argument('-dt', '--delta_t', type=float, default=0.5, help='Vis time step')
parser.add_argument('-dl', '--dir_len', type=float, default=0.05, help='EE direction len')
args = parser.parse_args()
print('Arguments:', args)
# Create a new visualizer
vis = meshcat.Visualizer()
try:
vis.open()
except:
vis.url()
try:
elements, node_points, ground_nodes, shape_file_path = load_extrusion(args.problem, parse_layers=True)
node_order = list(range(len(node_points)))
print('file path: {0}'.format(shape_file_path))
# sc = None
# if args.viz_deform:
sc = stiffness_checker(json_file_path=shape_file_path, verbose=False)
sc.set_self_weight_load(True)
# vert indices sanity check
ground_nodes = [n for n in ground_nodes if n in node_order]
elements = [element for element in elements if all(n in node_order for n in element.node_ids)]
assembly_network = AssemblyNetwork(node_points, elements, ground_nodes)
# TODO: safeguarding
if args.check_log != 'none':
assign_history = read_csp_log_json(args.problem, specs=args.check_log)
meshcat_visualize_csp_log(vis, assembly_network, assign_history,
scale=args.scale, time_step=args.delta_t,
stiffness_checker=sc)
else:
element_seq, seq_poses = read_seq_json(args.problem)
meshcat_visualize_assembly_sequence(vis, assembly_network, element_seq, seq_poses,
stiffness_checker=sc, viz_pose=args.viz_pose, viz_deform=args.viz_deform,
scale=args.scale, direction_len=args.dir_len, time_step=args.delta_t)
except:
vis.delete()
# TODO: better exit to release meshcat port
user_input('ctrl-c to exit...')
def visualizer(self):
'''
Visualizer property. Initializes the visualizer if it hasn't been
initialized yet.
'''
if self._visualizer is None:
self._visualizer = meshcat.Visualizer(zmq_url=self.zmq_url)
self._visualizer.open()
self._visualizer["pendulum"].set_object(
meshcat.geometry.Box([0.1, 0.1, 0.1]))
return self._visualizer
def test_sampling_baseline(set_seed):
vis = meshcat.Visualizer()
# Draw a random sample from the grammar and visualize it.
grammar = SpatialSceneGrammar(
root_node_type = DishBinBaseline,
root_node_tf = torch.eye(4)
)
torch.random.manual_seed(42)
tree = grammar.sample_tree()
assert torch.isfinite(tree.score(verbose=True)), "Sampled tree was infeasible."
def main():
#time_step = 0.0002 # TODO: context.get_continuous_state_vector() fails
time_step = 2e-3
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--cfree', action='store_true',
help='Disables collisions when planning')
parser.add_argument('-d', '--deterministic', action='store_true',
help='Manually sets the random seeds used by the stream generators')
parser.add_argument('-s', '--simulate', action='store_true',
help='Simulates the system')
args = parser.parse_args()
if args.deterministic:
# TODO: still not fully deterministic
random.seed(0)
np.random.seed(0)
import meshcat
meshcat_vis = meshcat.Visualizer()
task, diagram, state_machine = load_station(time_step=time_step)
print(task)
plant = task.mbp
#dump_plant(plant)
#dump_models(plant)
RenderSystemWithGraphviz(diagram) # Useful for getting port names
context = diagram.GetMutableSubsystemContext(plant, task.diagram_context)
task.publish()
initial_state = get_state(plant, context)
trajectories = plan_trajectories(task, context, collisions=not args.cfree)
if trajectories is None:
return
##################################################
set_state(plant, context, initial_state)
if args.simulate:
from manipulation_station.robot_plans import JointSpacePlan
splines, gripper_setpoints = convert_splines(plant, task.robot, task.gripper, context, trajectories)
sim_duration = compute_duration(splines)
plan_list = [JointSpacePlan(spline) for spline in splines]
print('Splines: {}\nDuration: {:.3f} seconds'.format(len(splines), sim_duration))
task, diagram, state_machine = load_station(time_step=time_step, plan=(plan_list, gripper_setpoints))
task.set_initial()
#set_state(plant, context, initial_state)
#state_machine.Load(plan_list, gripper_setpoints)
simulate_splines(task.diagram, task.diagram_context, sim_duration)
else:
step_trajectories(diagram, task.diagram_context, context, trajectories, time_step=0.001)
def draw_clearance_geometry_meshcat(scene_tree, zmq_url=None, alpha=0.25):
vis = meshcat.Visualizer(zmq_url=zmq_url or "tcp://127.0.0.1:6000")
vis["clearance_geom"].delete()
builder, mbp, scene_graph = compile_scene_tree_clearance_geometry_to_mbp_and_sg(scene_tree)
mbp.Finalize()
vis = ConnectMeshcatVisualizer(builder, scene_graph,
zmq_url="default", prefix="clearance")
diagram = builder.Build()
context = diagram.CreateDefaultContext()
vis.load(vis.GetMyContextFromRoot(context))
diagram.Publish(context)
def test_sampling():
vis = meshcat.Visualizer()
# Draw a random sample from the grammar and visualize it.
grammar = SpatialSceneGrammar(root_node_type=Desk,
root_node_tf=torch.eye(4))
torch.random.manual_seed(42)
tree = grammar.sample_tree()
assert torch.isfinite(
tree.score(verbose=True)), "Sampled tree was infeasible."
draw_scene_tree_contents_meshcat(tree, zmq_url=vis.window.zmq_url)
draw_scene_tree_structure_meshcat(tree, zmq_url=vis.window.zmq_url)
def do_generation_and_simulation(sim_time=10):
vis = meshcat.Visualizer(zmq_url="tcp://127.0.0.1:6000")
scene_tree, satisfied_clearance = rejection_sample_feasible_tree(num_attempts=1000)
scene_tree, satisfied_feasibility = project_tree_to_feasibility(scene_tree, num_attempts=3)
serialize_scene_tree_to_yamls_and_sdfs(scene_tree, package_name='save', package_dir=".", remove_directory=True)
# Draw generated tree in meshcat.
#draw_scene_tree_meshcat(scene_tree, alpha=1.0, node_sphere_size=0.1)
# Draw its clearance geometry for debugging.
#draw_clearance_geometry_meshcat(scene_tree, alpha=0.3)
# Simulate the resulting scene, with a PR2 for scale.
builder, mbp, scene_graph = compile_scene_tree_to_mbp_and_sg(
scene_tree, timestep=0.001)
# Add PR2 and shift it back in front of where I know the table will be.
parser = Parser(mbp)
pr2_model_path = "/home/gizatt/drake/build/install/share/drake/examples/pr2/models/pr2_description/urdf/pr2_simplified.urdf"
parser.package_map().PopulateUpstreamToDrake(pr2_model_path);
pr2_model_id = parser.AddModelFromFile(
file_name=pr2_model_path, model_name="PR2_for_scale")
# Get the tf of the robot spawn node, and put the PR2 at that xy location.
robot_spawn_tf = scene_tree.find_nodes_by_type(RobotSpawnLocation)[0].tf.numpy()
mbp.GetJointByName("x", model_instance=pr2_model_id).set_default_translation(robot_spawn_tf[0, 3])
mbp.GetJointByName("y", model_instance=pr2_model_id).set_default_translation(robot_spawn_tf[1, 3])
mbp.Finalize()
visualizer = ConnectMeshcatVisualizer(builder, scene_graph,
zmq_url="default")
diagram = builder.Build()
diag_context = diagram.CreateDefaultContext()
mbp_context = diagram.GetMutableSubsystemContext(mbp, diag_context)
# Fix input port for PR2 to zero.
actuation_port = mbp.get_actuation_input_port(model_instance=pr2_model_id)
nu = mbp.num_actuated_dofs(model_instance=pr2_model_id)
actuation_port.FixValue(mbp_context, np.zeros(nu))
sim = Simulator(diagram, diag_context)
sim.set_target_realtime_rate(1.0)
if not satisfied_clearance:
print("WARNING: SCENE TREE NOT SATISFYING CLEARANCE")
if not satisfied_feasibility:
print("WARNING: SCENE TREE NOT SATISFYING FEASIBILITY, SIM MAY FAIL")
try:
sim.AdvanceTo(sim_time)
except RuntimeError as e:
print("Encountered error in sim: ", e)
def initViewer(self, viewer=None, open=False, loadModel=False):
"""Start a new MeshCat server and client.
Note: the server can also be started separately using the "meshcat-server" command in a terminal:
this enables the server to remain active after the current script ends.
"""
import meshcat
self.viewer = meshcat.Visualizer() if viewer is None else viewer
if open:
self.viewer.open()
if loadModel:
self.loadViewerModel()
def __init__(self, num_landmarks: int, seed: int,
bbox_length=1., landmarks_offset=(0, 0)):
random.seed(seed)
self.nl = num_landmarks
# edge length of the square in which the robot runs.
bbox_length = bbox_length
self.box_length = bbox_length
self.r_range_max = 1
self.r_range_min = 0.2
# coordinates of landmarks.
self.l_xy = (random.rand(self.nl, 2) * bbox_length - bbox_length / 2 +
np.array(landmarks_offset))
# self.l_xy = np.array([[0, 0.5], [-0.6, 0.1], [-0.7, -0.2]])
# visualizer
self.vis = meshcat.Visualizer(zmq_url="tcp://127.0.0.1:6000")
self.vis.delete()
x_min = -min(self.l_xy[:, 0]) - 1
x_max = max(self.l_xy[:, 0]) + 1
y_min = -min(self.l_xy[:, 1]) - 1
y_max = max(self.l_xy[:, 1]) + 1
set_orthographic_camera_xy(self.vis)
self.draw_landmarks()
# initialize robot
self.X_WB = meshcat.transformations.rotation_matrix(
np.pi/2, np.array([1., 0, 0]), np.zeros(3))
material0 = meshcat.geometry.MeshLambertMaterial(
color=0xff0000, opacity=1.0)
material1 = meshcat.geometry.MeshLambertMaterial(
color=0xff0000, opacity=0.2)
self.vis["robot"]["sensing"].set_object(
meshcat.geometry.Cylinder(height=0.005, radius=self.r_range_max),
material1)
self.vis["robot"]["body"].set_object(
meshcat.geometry.Cylinder(height=0.2, radius=0.04),
material0)
self.vis["robot"].set_transform(self.X_WB)
# noise
self.sigma_odometry = 0.05
self.sigma_range = 0.05
self.sigma_bearing = 0.05
# von-mises distribution.
self.kappa_bearing = 1 / self.sigma_bearing ** 2
def visualize(self, states, dt):
import meshcat
import meshcat.geometry as g
import meshcat.transformations as tf
import time
# import meshcat.animation as anim
# Create a new visualizer
vis = meshcat.Visualizer()
vis.open()
vis["cart"].set_object(g.Box([0.2, 0.5, 0.2]))
vis["pole"].set_object(g.Cylinder(self.length_pole, 0.01))
# animation = anim.Animation()
# for i, state in enumerate(states):
# with animation.at_frame(vis, i*10) as frame:
# print(frame)
# frame["cart"].set_transform(tf.translation_matrix([0, state[0], 0]))
# frame["pole"].set_transform(
# tf.translation_matrix([0, state[0] + self.length_pole/2, 0]).dot(
# tf.rotation_matrix(np.pi/2 + state[1], [1,0,0], [0,-self.length_pole/2,0])))
# vis.set_animation(animation, play=True, repeat=10)
# time.sleep(10)
# # anim.convert_frame_to_video()
while True:
# vis["cart"].set_transform(tf.translation_matrix([0, 0, 0]))
# vis["pole"].set_transform(
# tf.translation_matrix([0, 0 + self.length_pole/2, 0]).dot(
# tf.rotation_matrix(np.pi/2 + 0, [1,0,0], [0,-self.length_pole/2,0])))
# time.sleep(dt)
for state in states:
vis["cart"].set_transform(
tf.translation_matrix([0, state[0], 0]))
vis["pole"].set_transform(
tf.translation_matrix(
[0, state[0] + self.length_pole / 2, 0]).dot(
tf.rotation_matrix(np.pi / 2 + state[1], [1, 0, 0],
[0, -self.length_pole / 2, 0])))
time.sleep(dt)
def __init__(self,
rbtree,
draw_timestep=0.033333,
prefix="RBViz",
zmq_url="tcp://127.0.0.1:6000",
draw_collision=False):
self.timestep = draw_timestep
self.rbtree = rbtree
self.draw_collision = draw_collision
# Set up meshcat
self.prefix = prefix
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
self.vis[self.prefix].delete()
# Publish the tree geometry to get the visualizer started
self.PublishAllGeometry()
def __init__(self):
self.vis = meshcat.Visualizer()
self.cube = self.vis["cube"]
self.pivot = self.cube["pivot"]
self.wheel = self.pivot["wheel"]
# create and draw the cube
self.cube_dim = [1.0, 1.0, 1.0] # x,y,z
self.cube.set_object(g.Box(self.cube_dim))
# pivot and wheel
self.pivot.set_transform(tf.translation_matrix(
[0, 0, 0])) # set location of pole
wheel_dim = [1.5, .5, .5] # x,y,z
self.wheel.set_object(g.Box(wheel_dim))
self.initialize()
def __init__(
self,
prefix='RBViz', # type: str
zmq_url='tcp://127.0.0.1:6000' # type: str
):
# The help info
print('Please make sure meshcat-server is running in another terminal')
# Setup the visualizer
self._prefix = prefix
self._meshcat_vis = meshcat.Visualizer(zmq_url=zmq_url)
self._meshcat_vis[self._prefix].delete()
# The map from key to rigid body tree
# Note that rbt would be copied
self._rbt_map = dict() # type: Dict[str, RigidBodyTree]
self._rbt_geometry_element_set = set()
# The set of point cloud keys
self._pointcloud_set = set()
def __init__(self,
scene_graph,
draw_timestep=0.033333,
prefix="SceneGraph",
zmq_url="tcp://127.0.0.1:6000"):
LeafSystem.__init__(self)
self.set_name('meshcat_visualization')
self.timestep = draw_timestep
self._DeclarePeriodicPublish(draw_timestep, 0.0)
# Pose bundle (from SceneGraph) input port.
self._DeclareInputPort(PortDataType.kAbstractValued, 0)
# Set up meshcat.
self.prefix = prefix
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
self.vis[self.prefix].delete()
self._scene_graph = scene_graph
def __init__(self,
zmq_url=None,
max_histories=10000,
open_browser=False,
wireframe=False,
transparency=True,
opacity=0.5,
reflectivity=1.0):
super(MeshcatRenderer, self).__init__()
self.vis = meshcat.Visualizer(zmq_url=zmq_url)
if open_browser:
self.vis.open()
self.ray_histories = deque(maxlen=max_histories)
self.max_histories = max_histories
self.added_index = 0
self.wireframe = wireframe
self.transparency = transparency
self.opacity = opacity
self.reflectivity = reflectivity
def setUp(self):
self.zmq_url = "tcp://127.0.0.1:5560"
args = ["meshcat-server", "--zmq-url", self.zmq_url]
if "CI" not in os.environ:
args.append("--open")
self.server_proc = subprocess.Popen(args)
self.vis = meshcat.Visualizer(self.zmq_url)
# self.vis = meshcat.Visualizer()
# self.vis.open()
if "CI" in os.environ:
port = self.vis.url().split(":")[-1].split("/")[0]
self.dummy_proc = subprocess.Popen([sys.executable, "-m", "meshcat.tests.dummy_websocket_client", str(port)])
else:
# self.vis.open()
self.dummy_proc = None
self.vis.wait()
def show_cloud(pc, pc2=None, use_native=False, **kwargs):
# kwargs go to ctor.
builder = DiagramBuilder()
# Add point cloud visualization.
if use_native:
viz = meshcat.Visualizer(zmq_url=ZMQ_URL)
else:
plant, scene_graph = AddMultibodyPlantSceneGraph(builder, 0.0)
plant.Finalize()
viz = builder.AddSystem(
MeshcatVisualizer(scene_graph,
zmq_url=ZMQ_URL,
open_browser=False))
builder.Connect(scene_graph.get_pose_bundle_output_port(),
viz.get_input_port(0))
pc_viz = builder.AddSystem(
MeshcatPointCloudVisualizer(viz, **kwargs))
if pc2:
pc_viz2 = builder.AddSystem(
MeshcatPointCloudVisualizer(viz,
name='second_point_cloud',
X_WP=se3_from_xyz([0, 0.3, 0]),
default_rgb=[0., 255., 0.]))
# Make sure the system runs.
diagram = builder.Build()
diagram_context = diagram.CreateDefaultContext()
context = diagram.GetMutableSubsystemContext(
pc_viz, diagram_context)
# TODO(eric.cousineau): Replace `AbstractValue.Make(pc)` with just
# `pc` (#12086).
pc_viz.GetInputPort("point_cloud_P").FixValue(
context, AbstractValue.Make(pc))
if pc2:
context = diagram.GetMutableSubsystemContext(
pc_viz2, diagram_context)
pc_viz2.GetInputPort("point_cloud_P").FixValue(
context, AbstractValue.Make(pc2))
simulator = Simulator(diagram, diagram_context)
simulator.set_publish_every_time_step(False)
simulator.AdvanceTo(sim_time)