def visualize_animation():
k = KinectImage.Kinect()
k.start()
pcd = open3d.PointCloud()
vis = open3d.Visualizer()
vis.create_window()
before = time.time()
for i in range(10):
pointcloud = k.get_pointcloud()
d = pointcloud[:, :3]
c = pointcloud[:, 3:]
pcd.points = open3d.Vector3dVector(d)
pcd.colors = open3d.Vector3dVector(c)
vis.add_geometry(pcd)
vis.update_geometry()
vis.reset_view_point(True)
vis.poll_events()
vis.update_renderer()
after = time.time()
print("Loop time:", after - before)
k.stop()
def main_display_cloud():
global received_ros_cloud
# Set viewer
open3d_cloud = open3d.PointCloud()
vis = open3d.Visualizer()
vis.create_window()
vis.add_geometry(open3d_cloud)
# Loop
rate = rospy.Rate(100)
cnt = 0
while not rospy.is_shutdown():
if received_ros_cloud is not None:
cnt += 1
idx_method = 1
if idx_method == 1:
tmp = convertCloudFromRosToOpen3d(received_ros_cloud)
copyOpen3dCloud(tmp, open3d_cloud)
vis.add_geometry(open3d_cloud)
if idx_method == 2: # this is not working!!!
open3d_cloud = convertCloudFromRosToOpen3d(received_ros_cloud)
if idx_method == 3: # this is keep adding clouds to viewer
open3d_cloud = convertCloudFromRosToOpen3d(received_ros_cloud)
vis.add_geometry(open3d_cloud)
vis.update_geometry()
print("Updating geometry for the {}th time".format(cnt))
received_ros_cloud = None # clear
vis.poll_events()
vis.update_renderer()
rate.sleep()
# print("Updating viewer")
# Return
vis.destroy_window()
def camera_shape_create():
'''
生成相机的外形
Returns:
'''
triangle_points = 0.05 * np.array([[1, 1, 2], [1, -1, 2], [-1, -1, 2],[-1, 1,2],[0, 0, 0]], dtype=np.float32)
lines = [[0, 1], [1, 2], [2, 3],[0,3],[0,4],[1,4],[2,4],[3,4]] # Right leg
colors = [[0, 0, 1] for i in range(len(lines))] # Default blue
# 定义三角形的三个角点
point_pcd = open3d.geometry.PointCloud() # 定义点云
point_pcd.points = open3d.Vector3dVector(triangle_points)
# 定义三角形三条连接线
line_pcd = open3d.LineSet()
line_pcd.lines = open3d.Vector2iVector(lines)
line_pcd.colors = open3d.Vector3dVector(colors)
line_pcd.points = open3d.Vector3dVector(triangle_points)
open3d.write_line_set("../data/testDate/a.ply",line_pcd)
vis = open3d.Visualizer()
vis.create_window(window_name='Open3D_1', width=600, height=600, left=10, top=10, visible=True)
vis.get_render_option().point_size = 20
vis.add_geometry(line_pcd)
while True:
vis.update_geometry()
vis.poll_events()
vis.update_renderer()
cv2.waitKey(100)
def main():
parser = argparse.ArgumentParser(description="Argument Parser")
parser.add_argument("--floor_height",
type=float,
default=0.03,
help="the z coordinate of the floor")
args = parser.parse_args()
np.set_printoptions(precision=4, suppress=True)
bot = Robot("locobot")
bot.camera.set_pan_tilt(0, 0.7, wait=True)
bot.arm.go_home()
bot.arm.set_joint_positions([1.96, 0.52, -0.51, 1.67, 0.01], plan=False)
vis = open3d.Visualizer()
vis.create_window("3D Map")
pcd = open3d.PointCloud()
coord = open3d.create_mesh_coordinate_frame(1, [0, 0, 0])
vis.add_geometry(pcd)
vis.add_geometry(coord)
while True:
pts, colors = bot.camera.get_current_pcd(in_cam=False)
pts, colors = filter_points(pts, colors, z_lowest=args.floor_height)
pcd.clear()
# note that open3d.Vector3dVector is slow
pcd.points = open3d.Vector3dVector(pts)
pcd.colors = open3d.Vector3dVector(colors / 255.0)
vis.update_geometry()
vis.poll_events()
vis.update_renderer()
time.sleep(0.1)
def main():
bot = Robot("kinect2")
vis = open3d.Visualizer()
vis.create_window("3D Map")
pcd = open3d.PointCloud()
coord = open3d.create_mesh_coordinate_frame(1, [0, 0, 0])
vis.add_geometry(pcd)
vis.add_geometry(coord)
# We update the viewer every a few seconds
update_time = 4
while True:
start_time = time.time()
pts, colors = bot.camera.get_current_pcd()
pcd.clear()
# note that open3d.Vector3dVector is slow
pcd.points = open3d.Vector3dVector(pts)
pcd.colors = open3d.Vector3dVector(colors / 255.0)
vis.update_geometry()
vis.poll_events()
vis.update_renderer()
s_t = time.time()
while time.time() - s_t < update_time:
vis.poll_events()
vis.update_renderer()
time.sleep(0.1)
end_time = time.time()
process_time = end_time - start_time
print("Updating every {0:.2f}s".format(process_time))
def __init__(self, pn_model):
self.vis = pn.Visualizer()
self.vis.create_window()
self.camera_representation = pn.LineSet()
self.camera_trace = pn.LineSet()
self.vis.add_geometry(pn_model)
self.vis.add_geometry(self.camera_representation)
self.vis.run()
return
def __init__(self):
self.k = Kinect(debug=True)
self.k.start()
self.k.wait_for_init()
self.pcd = open3d.PointCloud()
self.vis = open3d.Visualizer()
self.vis.create_window()
def draw_geometries_with_back_face(geometries):
visualizer = o3d.Visualizer()
visualizer.create_window()
render_option = visualizer.get_render_option()
render_option.mesh_show_back_face = True
for geometry in geometries:
visualizer.add_geometry(geometry)
visualizer.run()
visualizer.destroy_window()
def custom_draw_geometry_load_option(geometry_list):
vis = open3d.Visualizer()
vis.create_window()
for geometry in geometry_list:
vis.add_geometry(geometry)
ctr = vis.get_view_control()
ctr.rotate(0.0, 3141.0, 0)
vis.run()
vis.destroy_window()
def draw_geometries_dark_background(geometries):
vis = open3d.Visualizer()
vis.create_window()
opt = vis.get_render_option()
opt.background_color = np.asarray([0, 0, 0])
for geometry in geometries:
vis.add_geometry(geometry)
vis.run()
vis.destroy_window()
def train_one_epoch():
""" ops: dict mapping from string to tf ops """
is_training = True
# Shuffle train samples
train_idxs = np.arange(0, len(TRAIN_DATASET))
np.random.shuffle(train_idxs)
num_batches = len(TRAIN_DATASET) // BATCH_SIZE
from utils.open3d_util import np_to_open3d_pc
import open3d
vis = open3d.Visualizer()
vis.create_window()
pc1_ = open3d.geometry.PointCloud()
pc2_ = open3d.geometry.PointCloud()
b = False
o = vis.get_render_option()
o.point_show_normal = True
for batch_idx in range(num_batches):
start_idx = batch_idx * BATCH_SIZE
end_idx = (batch_idx + 1) * BATCH_SIZE
batch_data, batch_label, batch_mask, batch_normals = get_batch(
TRAIN_DATASET, train_idxs, start_idx, end_idx)
for i in range(BATCH_SIZE):
pc1 = batch_data[i, :NUM_POINT, :]
pc2 = batch_data[i, NUM_POINT:, :]
pc1_.normals = open3d.Vector3dVector(batch_normals[i, ...])
pc1_.points = open3d.Vector3dVector(batch_data[i, :NUM_POINT, :3])
pc1_.colors = open3d.Vector3dVector(batch_data[i, :NUM_POINT, 3:])
#np.asarray(pc1_.points)[...] += np.asarray(pc1_.normals) + 0.001
pc2_.points = open3d.Vector3dVector(batch_data[i, NUM_POINT:, :3])
pc2_.colors = open3d.Vector3dVector(batch_data[i, NUM_POINT:, 3:])
pc1_.normals = open3d.Vector3dVector([])
pc2_.normals = open3d.Vector3dVector([])
if not b:
vis.add_geometry(pc1_)
vis.add_geometry(pc2_)
b = True
pc1_.paint_uniform_color([1, 0.706, 0])
pc2_.paint_uniform_color([0.706, 0, 1])
#open3d.draw_geometries([pc1, pc2])
vis.update_geometry()
vis.update_renderer()
vis.poll_events()
vis.run()
input()
vis.destroy_window()
def view_multi(joints, axes, amounts):
vis = o3d.Visualizer()
vis.create_window()
vis.add_geometry(get_smpl(joints, axes, amounts))
lbl = 'Joints {} {} {} dark min red max'.format(joints, axes, amounts)
vis.add_geometry(text_3d(lbl, (0, 1, 0), font_size=200, density=0.2))
vis.run()
vis.destroy_window()
def __init__(self): self.graph = open3d.PoseGraph() self.keyframes = [] self.last_frame_transformation = numpy.identity(4) self.keyframe_angle_thresh_deg = 15.0 self.keyframe_trans_thresh_m = 1.0 self.vis = open3d.Visualizer() self.vis.create_window()
def __init__(self, save=False, keep_window=True):
#Create Visualizer Window etc
self._vis = o3.Visualizer()
self._vis.create_window()
opt = self._vis.get_render_option()
opt.background_color = np.asarray([0.0, 0.0167, 0.1186])
opt.point_size = 1.5
self._save = save
self._keep_window = keep_window
self._cnt = 0
self._currpc = o3.geometry.PointCloud()
def __init__(self):
self.model = open3d.PointCloud()
self.vis = open3d.Visualizer()
self.vis.create_window(window_name='Laser 3D Pointcloud',
width=800L,
height=600L,
left=50L,
right=50L)
self.ctr = self.vis.get_view_control()
self.ctr.rotate(10, 0)
self.ctr.translate(-1, -1, 1)
def __enter__(self):
self.steps = 0
if self.visualize:
if self.viz_mode == 'o3d':
self.vis_o3d = o3d.Visualizer()
self.vis_o3d.create_window()
self.body_o3d = o3d.TriangleMesh()
self.scan = o3d.PointCloud()
else:
self.mv = MeshViewer(body_color=self.body_color)
return self
def render_pointcloud(pcd):
vis = open3d.Visualizer()
vis.create_window()
vis.add_geometry(pcd)
ctr = vis.get_view_control()
ctr.rotate(202.0, 202.0)
vis.update_geometry()
vis.poll_events()
vis.update_renderer()
image = np.asarray(vis.capture_screen_float_buffer(False))
return image
def visualise_rgbd_cloud(key_list, resolution_height, resolution_width,
device_manager, coordinate_dimentions,
transformation_devices):
# enable visualiser
align = rs.align(rs.stream.depth)
vis = o3d.Visualizer()
vis.create_window('PCD', width=1280, height=720)
pointcloud = o3d.PointCloud()
geom_added = False
voxel_size = 0.005
while True:
cloud_pcd = o3d.PointCloud()
for (serial, device) in device_manager._enabled_devices.items():
frames = device.pipeline.wait_for_frames()
frames = align.process(frames)
profile = frames.get_profile()
depth_frame = frames.get_depth_frame()
color_frame = frames.get_color_frame()
if not depth_frame or not color_frame:
continue
# Convert images to numpy arrays
depth_image = np.asanyarray(depth_frame.get_data())
color_image = np.asanyarray(color_frame.get_data())
img_depth = o3d.Image(depth_image)
img_color = o3d.Image(color_image)
rgbd = o3d.create_rgbd_image_from_color_and_depth(
img_color, img_depth, convert_rgb_to_intensity=False)
intrinsics = profile.as_video_stream_profile().get_intrinsics()
pinhole_camera_intrinsic = o3d.PinholeCameraIntrinsic(
intrinsics.width, intrinsics.height, intrinsics.fx,
intrinsics.fy, intrinsics.ppx, intrinsics.ppy)
pcd = o3d.create_point_cloud_from_rgbd_image(
rgbd, pinhole_camera_intrinsic)
pcd.transform(transformation_devices[serial].pose_mat)
pointcloud.points = pcd.points
pointcloud.colors = pcd.colors
cloud_pcd = cloud_pcd + pointcloud
#pcd = o3d.geometry.voxel_down_sample(cloud_pcd,
# voxel_size=voxel_size)
while True:
if geom_added == False:
vis.add_geometry(cloud_pcd)
geom_added = True
vis.update_geometry()
vis.poll_events()
vis.update_renderer()
def custom_draw_geometry(pcd): """Used for black background""" # The following code achieves the same effect as: # draw_geometries([pcd]) vis = open3d.Visualizer() vis.create_window() opt = vis.get_render_option() opt.background_color = np.asarray([0, 0, 0]) vis.add_geometry(pcd) vis.run() vis.destroy_window()
def showTrajectory(self, windows):
self.trajectoryVis = o3d.Visualizer()
self.trajectoryVis.create_window(window_name=windows["windowsName"],
width=windows["width"],
height=windows["height"],
left=windows["left"],
top=windows["top"],
visible=True)
self.trajectoryVis.get_render_option().point_size = 5
axis_pcd = o3d.geometry.create_mesh_coordinate_frame(size=0.5,
origin=[0, 0, 0])
self.trajectoryVis.add_geometry(axis_pcd)
def show_traj(windows):
pcl = open3d.io.read_point_cloud("../data/testDate/a.ply")
vis = open3d.Visualizer()
vis.create_window(window_name=windows["windowsName"], width=windows["width"], height=windows["height"], left=windows["left"], top=windows["top"], visible=True)
vis.add_geometry(pcl)
param = vis.get_view_control().convert_to_pinhole_camera_parameters()
open3d.write_pinhole_camera_parameters("../config/externalCamera.json",param)
while True:
vis.update_geometry()
vis.poll_events()
vis.update_renderer()
cv2.waitKey(100)
def intialize_visualizer(self):
'''
Function to add geometry (cannot destroy)
'''
self.vis = o3.Visualizer()
self.vis.create_window()
self.vis.get_render_option().load_from_json(
"static_data/renderoption.json")
self.vis.add_geometry(self.base)
self.trajectory = o3.read_pinhole_camera_trajectory(
"static_data/pinholeCameraTrajectory3.json")
self.custom_view()
self.vis.run()
def visualize(pointcloud):
d = pointcloud[:, :3]
c = pointcloud[:, 3:]
pcd = open3d.PointCloud()
pcd.points = open3d.Vector3dVector(d)
pcd.colors = open3d.Vector3dVector(c)
vis = open3d.Visualizer()
vis.create_window()
vis.add_geometry(pcd)
vis.run()
vis.destroy_window()
def save_depth_maps(mesh, intrinsic, extrinsics, filenames):
glb = save_depth_maps
glb.index = -1
# intrinsics assumed by the renderer - corrected later
cx = intrinsic.width/2.0-0.5
cy = intrinsic.height/2.0-0.5
f = max(intrinsic.get_focal_length())
glb.intrinsic = open3d.PinholeCameraIntrinsic(intrinsic.width, intrinsic.height,
f, f, cx, cy)
glb.extrinsics = extrinsics
glb.filenames = filenames
glb.vis = open3d.Visualizer()
# affine matrix for correction
offset_x = intrinsic.get_principal_point()[0] - \
intrinsic.get_focal_length()[0]/f*cx
offset_y = intrinsic.get_principal_point()[1] - \
intrinsic.get_focal_length()[1]/f*cy
glb.affine_M = np.asarray([
[intrinsic.get_focal_length()[0]/f, 0, offset_x],
[0, intrinsic.get_focal_length()[1]/f, offset_y]],
dtype=np.float32)
def callback(vis):
ctr = vis.get_view_control()
glb = save_depth_maps
if glb.index >= 0:
depth = np.asarray(vis.capture_depth_float_buffer(False), dtype=np.float32)
# correct the depth map (useful if your camera has non-ideal intrinsics)
depth = cv2.warpAffine(depth, glb.affine_M,
(depth.shape[1], depth.shape[0]), cv2.WARP_INVERSE_MAP,
cv2.BORDER_CONSTANT, 0)
cv2.imwrite(glb.filenames[glb.index], np.uint16(np.asarray(depth) * 1000))
glb.index = glb.index + 1
if glb.index < len(glb.extrinsics):
ctr.convert_from_pinhole_camera_parameters(glb.intrinsic,
glb.extrinsics[glb.index])
else:
glb.vis.register_animation_callback(None)
return False
vis = glb.vis
vis.create_window(width=intrinsic.width, height=intrinsic.height)
vis.add_geometry(mesh)
vis.register_animation_callback(callback)
vis.run()
vis.destroy_window()
def __init__(self, source, target, save=False, keep_window=True):
self._vis = o3.Visualizer()
self._vis.create_window()
self._source = source
self._target = target
self._result = copy.deepcopy(self._source)
self._save = save
self._keep_window = keep_window
self._source.paint_uniform_color([1, 0, 0])
self._target.paint_uniform_color([0, 1, 0])
self._result.paint_uniform_color([0, 0, 1])
self._vis.add_geometry(self._source)
self._vis.add_geometry(self._target)
self._vis.add_geometry(self._result)
self._cnt = 0
def video(img_list, depth_list):
pcd = o3d.PointCloud()
vis = o3d.Visualizer()
vis.create_window()
opt = vis.get_render_option()
opt.background_color = np.asarray([0.1, 0.1, 0.1])
vis.add_geometry(pcd)
# render_option = vis.get_render_option()
# render_option.point_size = 0.1
to_reset_view_point = True
Cam_coords = []
Rgb = []
for i in tqdm(range(len(img_list))):
# load image, depth
rgb = load_image(img_list[i])
depth = load_depth_png(depth_list[i])
# Get intrinsic parameters from field of view fov
height, width, _ = rgb.shape
K = intrinsic_from_fov(height, width, 90) # +- 45 degrees
K_inv = np.linalg.inv(K)
# Get pixel coordinates
pixel_coords = pixel_coord_np(width, height) # [3, npoints]
# Apply back-projection: K_inv @ pixels * depth
cam_coords = K_inv[:3, :3] @ pixel_coords * depth.flatten()
rgb = rgb.reshape((height * width, 3)).transpose()
# Limit points to 150m in the z-direction for visualisation
rgb = rgb[:, np.where(cam_coords[2] <= 150)[0]]
cam_coords = cam_coords[:, np.where(cam_coords[2] <= 150)[0]]
Cam_coords.append(cam_coords.T[:, :3])
Rgb.append(rgb.T.astype('float64') / 255.0)
while True:
for i in range(len(img_list)):
pcd.points = o3d.Vector3dVector(Cam_coords[i])
pcd.transform([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0],
[0, 0, 0, 1]])
pcd.colors = o3d.Vector3dVector(Rgb[i])
vis.update_geometry()
if to_reset_view_point:
vis.reset_view_point(True)
to_reset_view_point = False
vis.poll_events()
vis.update_renderer()
time.sleep(0.1)
vis.destroy_window()
def __init__(self):
self.k = Kinect(debug=True)
self.k.start()
self.k.wait_for_init()
self.is_running = True
self.pcd1 = open3d.PointCloud()
self.pcd2 = open3d.PointCloud()
self.vis = open3d.Visualizer()
#self.vis = open3d.VisualizerWithKeyCallback()
#self.vis.register_key_callback(ord('k'), self.callback_test)
self.vis.create_window()
self.vis.add_geometry(self.pcd1)
self.vis.add_geometry(self.pcd2)
def decorated(*args, **kwargs):
vis = open3d.Visualizer()
vis.create_window(window_name='Human',
width=570,
height=700,
left=720,
top=180,
visible=True)
pygame.init()
setting = Setting()
screen = pygame.display.set_mode(setting.win_size)
pygame.display.set_caption('roll')
mesh = [
open3d.TriangleMesh(),
open3d.TriangleMesh(),
open3d.TriangleMesh()
]
attr = Attribute()
line_group, cir_group, text_group = [], {}, list()
con_rect_cir(screen, setting, line_group, cir_group)
con_text(setting, line_group, text_group)
im = Import(screen, setting)
ex = Export(screen, setting, im)
HOLD_ON = pygame.USEREVENT + 1 #自定义事件
pygame.time.set_timer(HOLD_ON, 60)
model = Model(30, 32, 42, 54, 66, 78, 90, 100)
model.load_state_dict(torch.load('human_net.pkl'))
while True:
check_events(screen, setting, cir_group, im, ex, HOLD_ON, attr,
model, mesh, vis)
update_screen(screen, setting, line_group, cir_group, text_group,
im, ex)
if setting.suc_imp == 1:
obj_to_mesh(''.join(im.s), mesh)
vis.add_geometry(mesh[0])
mesh[0].compute_vertex_normals()
ctr = vis.get_view_control()
ctr.rotate(0.0, -500.0)
attr_reflict_cir(setting, cir_group, attr)
setting.suc_imp = 2
vis.update_geometry()
vis.poll_events()
def view_fit(joint, translation=(0, 0, 0)):
translation = np.array(translation)
vis = o3d.Visualizer()
vis.create_window()
vis.add_geometry(get_smpl([joint], [0], [0.5], translation=translation))
for i in range(6):
trans = translation + (int(i / 2) * 1.5 + 1, 0, 0)
vis.add_geometry(get_smpl([joint], [i / 2], [i % 2],
translation=trans))
lbl = 'Joint {} dark min red max'.format(joint)
vis.add_geometry(
text_3d(lbl, translation + (0, 1, 0), font_size=200, density=0.2))
vis.run()
vis.destroy_window()
def __init__(self, camera_conf):
self.camera_conf = camera_conf
self.flip_transform = [[1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]]
# Create Open3D Visualizer
self.vis = open3d.Visualizer()
self.vis.create_window('Open3D_1', width=self.camera_conf.depth_width, height=self.camera_conf.depth_height,
left=10, top=10)
self.vis.get_render_option().point_size = 3
# 定义图像点云
self.image_pcd = open3d.PointCloud()
# 定义原点
self.origin_point = open3d.geometry.create_mesh_coordinate_frame(size=0.5, origin=[0, 0, 0])
# 定义关节点点云连接线：24关节点连接线
self.bone_line_pcd = open3d_tools.create_line_set_bones(np.zeros((24, 3), dtype=np.float32),
joint_line=self.camera_conf.joint_lines)
