def main():
print("Running...")
input_type = sl.InputType()
input_type.set_from_camera_id(0)
init = sl.InitParameters()
init.input = input_type
init.camera_resolution = sl.RESOLUTION.HD720
#init.camera_linux_id = 0
init.camera_fps = 30 # The framerate is lowered to avoid any USB3 bandwidth issues
cam = sl.Camera()
if not cam.is_opened():
print("Opening ZED Camera 1...")
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
input_type.set_from_camera_id(1)
init.input = input_type
cam2 = sl.Camera()
if not cam2.is_opened():
print("Opening ZED Camera 2...")
status = cam2.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
runtime = sl.RuntimeParameters()
mat = sl.Mat()
mat2 = sl.Mat()
print_camera_information(cam)
print_camera_information(cam2)
key = ''
while key != 113: # for 'q' key
# The computation could also be done in a thread, one for each camera
err = cam.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
cam.retrieve_image(mat, sl.VIEW.LEFT)
cv2.imshow("ZED 1", mat.get_data())
err = cam2.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
cam2.retrieve_image(mat2, sl.VIEW.LEFT)
cv2.imshow("ZED 2", mat2.get_data())
key = cv2.waitKey(5)
cv2.destroyAllWindows()
cam.close()
print("\nFINISH")
def main():
zed1 = sl.Camera()
zed2 = sl.Camera()
print("Running...")
init_params = sl.InitParameters()
init_params.camera_resolution = res
init_params.camera_fps = fps
init_params.camera_linux_id = 0
if not zed1.is_opened():
print("Opening ZED Camera 1 ...")
err = zed1.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
print(repr(err))
init_params.camera_linux_id = 1 # Specify the camera index
if not zed2.is_opened():
print("Opening ZED Camera 2 ...")
err = zed2.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
print(repr(err))
runtime = sl.RuntimeParameters()
mat1 = sl.Mat()
mat2 = sl.Mat()
print_camera_information(zed1)
print_camera_information(zed2)
key = ''
while key != 113: # for 'q' key
# print('reading')
err = zed1.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
zed1.retrieve_image(mat1, sl.VIEW.VIEW_LEFT)
cv2.imshow("ZED 1", mat1.get_data())
err = zed2.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
zed2.retrieve_image(mat2, sl.VIEW.VIEW_LEFT)
cv2.imshow("ZED 2", mat2.get_data())
key = cv2.waitKey(5)
cv2.destroyAllWindows()
zed1.close()
zed2.close()
print("\nFINISH")
def zed_init():
'''
##作者:左家乐
##日期：2020-08-01
##功能：Init the ZED
##IN-para : no
##return ： err()
'''
camera_settings = sl.VIDEO_SETTINGS.BRIGHTNESS
str_camera_settings = "BRIGHTNESS"
step_camera_settings = 1
print("3.Detected the ZED...")
global cam
cam = sl.Camera()
init_params = sl.InitParameters()
init_params.depth_mode = sl.DEPTH_MODE.PERFORMANCE # Use PERFORMANCE depth mode
init_params.coordinate_units = sl.UNIT.METER # Use meter units (for depth measurements)
init_params.camera_resolution = sl.RESOLUTION.HD720
err = cam.open(init_params) #if failed to open zed ,return 0
global runtime_parameters
runtime_parameters = sl.RuntimeParameters()
runtime_parameters.sensing_mode = sl.SENSING_MODE.STANDARD # Use STANDARD sensing mode
runtime_parameters.confidence_threshold = 100
runtime_parameters.textureness_confidence_threshold = 100
global mat
mat = sl.Mat()
global depth
depth = sl.Mat()
global point_cloud
point_cloud = sl.Mat()
mirror_ref = sl.Transform()
mirror_ref.set_translation(sl.Translation(2.75, 4.0, 0))
tr_np = mirror_ref.m
return err
def main():
# Get input parameters
svo_input_path = 'zed/12_0_y.svo'
# Specify SVO path parameter
init_params = sl.InitParameters()
init_params.svo_input_filename = str(svo_input_path)
init_params.svo_real_time_mode = False # Don't convert in realtime
init_params.coordinate_units = sl.UNIT.UNIT_MILLIMETER # Use milliliter units (for depth measurements)
# Create ZED objects
zed = sl.Camera()
# Open the SVO file specified as a parameter
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
sys.stdout.write(repr(err))
zed.close()
exit()
# Get image size
image_size = zed.get_resolution()
width = image_size.width
height = image_size.height
width_sbs = width * 2
print(image_size.width)
print(image_size.height)
print(zed.get_camera_fps())
def main():
# Create a ZEDCamera object
zed = sl.Camera()
# Create a InitParameters object and set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.RESOLUTION_HD720 # Use HD720 video mode (default fps: 60)
# Use a right-handed Y-up coordinate system
init_params.coordinate_system = sl.COORDINATE_SYSTEM.COORDINATE_SYSTEM_RIGHT_HANDED_Y_UP
init_params.coordinate_units = sl.UNIT.UNIT_METER # Set units in meters
# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
# Enable positional tracking with default parameters.
# Positional tracking needs to be enabled before using spatial mapping
py_transform = sl.Transform()
tracking_parameters = sl.TrackingParameters(init_pos=py_transform)
err = zed.enable_tracking(tracking_parameters)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
# Enable spatial mapping
mapping_parameters = sl.SpatialMappingParameters(map_type=sl.SPATIAL_MAP_TYPE.SPATIAL_MAP_TYPE_FUSED_POINT_CLOUD)
err = zed.enable_spatial_mapping(mapping_parameters)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
# Grab data during 3000 frames
i = 0
py_fpc = sl.FusedPointCloud() # Create a Mesh object
runtime_parameters = sl.RuntimeParameters()
while i < 3000:
# For each new grab, mesh data is updated
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
# In the background, spatial mapping will use newly retrieved images, depth and pose to update the mesh
mapping_state = zed.get_spatial_mapping_state()
print("\rImages captured: {0} / 3000 || {1}".format(i, mapping_state))
i = i + 1
print("\n")
# Extract, filter and save the mesh in an obj file
print("Extracting Point Cloud...\n")
err = zed.extract_whole_spatial_map(py_fpc)
print(repr(err))
#print("Filtering Mesh...\n")
#py_mesh.filter(sl.MeshFilterParameters()) # Filter the mesh (remove unnecessary vertices and faces)
print("Saving Point Cloud...\n")
py_fpc.save("fpc.obj")
# Disable tracking and mapping and close the camera
zed.disable_spatial_mapping()
zed.disable_tracking()
zed.close()
def __init__(self, input_pipe=None, output_pipes=None):
"""Basic initilization of camera"""
self.input_pipe = input_pipe
# make output pipe a list by default
if not isinstance(output_pipes, (list, )):
output_pipes = [output_pipes]
self.output_pipes = output_pipes
# These are the variables that will be shared across all zed nodes
self.image_time = None
self.image = None
self.depth = None
# These variables are used only in the zed node opening the camera
# create a save directory, drop ms from datestring
self.savedir = '_'.join(timestamp().split('_')[:-1])
self.savedir = os.path.join(os.getcwd(), self.savedir)
self.init = sl.InitParameters(**param)
self.cam = sl.Camera()
self.zed_param = None
self.zedStatus = None
self.runtime_param = None
self._image = sl.Mat()
self._depth = sl.Mat()
self.max_depth = 10 # max depth in map, meters
def __init__(self, fileName, FPS=30, startFrame=0, startTime=0):
self.fileName = fileName
self.cam = sl.Camera()
init = sl.InitParameters(svo_input_filename=self.fileName,
svo_real_time_mode=False)
init.depth_mode = sl.DEPTH_MODE.DEPTH_MODE_ULTRA
init.coordinate_units = sl.UNIT.UNIT_METER
init.depth_minimum_distance = 2 # meter
status = self.cam.open(init)
assert status == sl.ERROR_CODE.SUCCESS, repr(status)
left_cam = self.cam.get_camera_information().calibration_parameters.left_cam
self.left_mtx = [[left_cam.fx, 0, left_cam.cx], [0, left_cam.fy, left_cam.cy], [0, 0, 1]]
self.left_disto = left_cam.disto
self.T = self.cam.get_camera_information().calibration_parameters.T
self.R = self.cam.get_camera_information().calibration_parameters.R
self.cam.set_depth_max_range_value(40) # meter
self.width = self.cam.get_resolution().width;
self.height = self.cam.get_resolution().height;
self.cam.set_svo_position(startFrame-1)
self.runtime = sl.RuntimeParameters()
self.runtime.sensing_mode = sl.SENSING_MODE.SENSING_MODE_FILL
self.cam.grab(self.runtime)
self.camTime = self.cam.get_timestamp(sl.TIME_REFERENCE.TIME_REFERENCE_IMAGE)
self.camTime += startTime*1e9
self.mat_L = sl.Mat()
self.mat_R = sl.Mat()
self.mat_D = sl.Mat()
self.mat_3D = sl.Mat()
def main(size=320):
runtime = sl.RuntimeParameters(enable_depth=False, enable_point_cloud=False)
mat = sl.Mat()
with open('config.json', 'r') as f:
config = json.load(f)
base_dir = config['svo_path']
cuts = {}
load(cuts, base_dir=base_dir)
cuts = sum(cuts.values(), [])
types = {cut.type for cut in cuts}
with File('cuts.h5', mode='w') as file:
for t in types:
group = file.create_group('type_%d' % t)
group.attrs['type'] = t
group.attrs['class_name'] = channel_names[t]
for idx, cut in enumerate(filter(lambda c: c.type == t, cuts)):
init = sl.InitParameters(svo_input_filename=join(base_dir, cut.file), svo_real_time_mode=False)
cam = sl.Camera()
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
cam.set_svo_position(cut.start)
stop = (cut.stop if cut.stop is not None else cam.get_svo_number_of_frames())
ds = group.create_dataset('cut_%d' % (idx + 1), shape=(stop - cut.start, 3, size, size), dtype=np.uint8)
for pos in range(stop - cut.start):
err = cam.grab(runtime)
assert err == sl.ERROR_CODE.SUCCESS
cam.retrieve_image(mat)
data = np.moveaxis(mat.get_data()[cut.top:cut.top + size, cut.left:cut.left + size, :3], -1, 0)
ds[pos] = data
cam.close()
print('Writed cut:', cut)
def main():
init = sl.InitParameters()
init.camera_resolution = sl.RESOLUTION.HD720
init.depth_mode = sl.DEPTH_MODE.PERFORMANCE
if (len(sys.argv) > 1) :
ip = sys.argv[1]
init.set_from_stream(ip)
else :
print('Usage : python3 streaming_receiver.py ip')
exit(1)
cam = sl.Camera()
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit(1)
runtime = sl.RuntimeParameters()
mat = sl.Mat()
key = ''
print(" Quit : CTRL+C\n")
while key != 113:
err = cam.grab(runtime)
if (err == sl.ERROR_CODE.SUCCESS) :
cam.retrieve_image(mat, sl.VIEW.LEFT)
cv2.imshow("ZED", mat.get_data())
key = cv2.waitKey(1)
else :
key = cv2.waitKey(1)
cam.close()
def main():
# Create a camera object
zed = sl.Camera()
# Create a InitParameters object and set confifuration parameteres
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.RESOLUTION_HD1080
init_params.camera_fps = 30
# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
# Capture 1 frame and stop
image = sl.Mat()
runtime_parameters = sl.RuntimeParameteres()
# Grab an image, a RuntimeParameters object must be given to grab()
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
# A new image is available if grab() returns SUCCESS
zed.retrieve_image(image, sl.VIEW.VIEW_LEFT)
# Get the timestamp at the time the image was captured
timestamp = zed.get_timestamp(sl.TIME_REFERENCE.TIME_REFERENCE_CURRENT)
print("Image resolution: {0} x {1} || Image timestamp: {2}\n".format(
image.get_width(), image.get_height(), timestamp))
zed.close()
def init_params(menu, cam_id=0):
global save_dir
zed = EasyDict({})
zed.cam = sl.Camera()
zed.mat = EasyDict({
'pose': sl.Pose(),
'translation': sl.Translation(),
'transform': sl.Transform(),
'image': sl.Mat(), # image_map
'depth': sl.Mat(), # depth_map
'point_cloud': sl.Mat(),
'sensors': sl.SensorsData() # sensors_data
})
zed.param = EasyDict({
'init':
sl.InitParameters(
camera_resolution=mode.resolution[menu.cam.resolution],
depth_mode=mode.depth[menu.mode.depth],
coordinate_units=mode.unit[menu.unit],
coordinate_system=mode.coordinate_system[menu.coordinate_system],
depth_minimum_distance=menu.depth_range.min,
depth_maximum_distance=menu.depth_range.max,
sdk_verbose=verbose),
'runtime':
sl.RuntimeParameters(sensing_mode=mode.sensing[menu.mode.sensing]),
'tracking':
sl.PositionalTrackingParameters(zed.mat.transform)
})
#######
zed.param.init.set_from_camera_id(cam_id)
save_dir = save_dir_fmt.format(cam_id)
return zed
def main():
if len(sys.argv) != 2:
exit()
filepath = sys.argv[1]
print("Reading SVO file: {0}".format(filepath))
input_type = sl.InputType()
input_type.set_from_svo_file(filepath)
init = sl.InitParameters(input_t=input_type, svo_real_time_mode=False)
#init.depth_minimum_distance = 1
init.depth_mode = sl.DEPTH_MODE.ULTRA
cam = sl.Camera()
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
runtime = sl.RuntimeParameters()
runtime.sensing_mode = sl.SENSING_MODE.FILL
mat = sl.Mat()
while cv2.waitKey(1) != ord("q"): # for 'q' key
err = cam.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
#cam.retrieve_image(mat)
cam.retrieve_image(mat, sl.VIEW.DEPTH)
cv2.imshow("ZED", mat.get_data())
cv2.destroyAllWindows()
cam.close()
print("\nFINISH")
def main():
# Create a Camera object
zed = sl.Camera()
# Create a InitParameters object and set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD1080 # Use HD1080 video mode
init_params.camera_fps = 30 # Set fps at 30
# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
# Capture 50 frames and stop
i = 0
image = sl.Mat()
runtime_parameters = sl.RuntimeParameters()
while i < 50:
# Grab an image, a RuntimeParameters object must be given to grab()
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
# A new image is available if grab() returns SUCCESS
zed.retrieve_image(image, sl.VIEW.LEFT)
timestamp = zed.get_timestamp(
sl.TIME_REFERENCE.CURRENT
) # Get the timestamp at the time the image was captured
print(
"Image resolution: {0} x {1} || Image timestamp: {2}\n".format(
image.get_width(), image.get_height(),
timestamp.get_milliseconds()))
i = i + 1
# Close the camera
zed.close()
def __init__(self):
# Create a Camera object
self.zed = sl.Camera()
# Create a InitParameters object and set configureation parameters
self.init_params = sl.InitParameters()
self.init_params.depth_mode = sl.DEPTH_MODE.PERFORMANCE # Use PERFORMANCE depth mode
self.init_params.coordinate_units = sl.UNIT.METER # Use meter units (for depth measurements)
self.init_params.camera_resolution = sl.RESOLUTION.HD720 # HD1080
self.init_params.camera_fps = 30 # Set fps at 30
# Open the camera
err = self.zed.open(self.init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
# Create and set RuntimeParameters after opening the camera
self.runtime_parameters = sl.RuntimeParameters()
self.runtime_parameters.sensing_mode = sl.SENSING_MODE.STANDARD # Use STANDARD sensing mode
# Setting the depth confidence parameters
self.runtime_parameters.confidence_threshold = 100
self.runtime_parameters.textureness_confidence_threshold = 100
# Data options
self.im_height = 720
self.im_width = 1280
self.buffer_size = 4098
def main(filepath):
print("Reading SVO file: {0}".format(filepath))
init = sl.InitParameters(svo_input_filename=filepath, svo_real_time_mode=False)
cam = sl.Camera()
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
runtime = sl.RuntimeParameters()
left = sl.Mat()
right = sl.Mat()
if not os.path.exists(f'{filepath[0:-4]}/left'):
os.makedirs(f'{filepath[0:-4]}/left')
if not os.path.exists(f'{filepath[0:-4]}/right'):
os.makedirs(f'{filepath[0:-4]}/right')
i = 0
while True:
err = cam.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
cam.retrieve_image(left, sl.VIEW.VIEW_LEFT)
#cam.retrieve_image(right, sl.VIEW.VIEW_RIGHT)
left.write(f'{filepath[0:-4]}/left/{i}.png')
#right.write(f'{filepath[0:-4]}/right/{i}.png')
else:
print(repr(err))
break
i+=1
cam.close()
print("\nFINISH")
def main():
print("Running...")
init = sl.InitParameters()
cam = sl.Camera()
if not cam.is_opened():
print("Opening ZED Camera...")
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
runtime = sl.RuntimeParameters()
mat = sl.Mat()
print_camera_information(cam)
print_help()
key = ''
while key != 113: # for 'q' key
err = cam.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
cam.retrieve_image(mat, sl.VIEW.LEFT)
cv2.imshow("ZED", mat.get_data())
key = cv2.waitKey(5)
settings(key, cam, runtime, mat)
else:
key = cv2.waitKey(5)
cv2.destroyAllWindows()
cam.close()
print("\nFINISH")
def intializeCamera(self, initParams):
self.cam = sl.Camera()
status = self.cam.open(initParams)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
self.cam = None
def main():
zed = sl.Camera()
point_cloud = sl.Mat()
# Set configuration parameters
input_type = sl.InputType()
input_type.set_from_svo_file('/home/ianmcvann/Documents/ZED/recent.svo')
init_params = sl.InitParameters(input_t=input_type,
svo_real_time_mode=False)
# init_params = sl.InitParameters()
init_params.depth_mode = sl.DEPTH_MODE.ULTRA # Use PERFORMANCE depth mode
init_params.coordinate_units = sl.UNIT.INCH # Use milliliter units (for depth measurements)
init_params.camera_resolution = sl.RESOLUTION.VGA
init_params.camera_fps = 100
init_params.depth_maximum_distance = 400
# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(-1)
image = sl.Mat()
zed.set_camera_settings(sl.VIDEO_SETTINGS.EXPOSURE, 15)
runtime_parameters = sl.RuntimeParameters()
while True:
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
zed.retrieve_measure(point_cloud, sl.MEASURE.XYZRGBA)
# A new image is available if grab() returns SUCCESS
zed.retrieve_image(image, sl.VIEW.RIGHT) # Retrieve the left image
frame = image.get_data()
process_pic(frame)
cv2.destroyAllWindows()
def run(self):
init = sl.InitParameters()
cam = sl.Camera()
if not cam.is_opened():
print("Opening ZED Camera...")
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
runtime = sl.RuntimeParameters()
mat = sl.Mat()
encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90]
while not self.stopped:
err = cam.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
cam.retrieve_image(mat, sl.VIEW.VIEW_LEFT)
frameLocal = cv2.resize(
mat.get_data(), (self.image_shape[1], self.image_shape[0]))
# Transform a PNG frame to JPG, removing the last dimension.
frameLocal = frameLocal[:, :, 0:3]
self.frame = np.array(
helper.predict(self.sess, frameLocal, self.input_image,
self.keep_prob, self.logits,
self.image_shape))
def main():
init = sl.InitParameters(camera_resolution=sl.RESOLUTION.HD720,
depth_mode=sl.DEPTH_MODE.PERFORMANCE,
coordinate_units=sl.UNIT.METER,
coordinate_system=sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP,
sdk_verbose=True)
cam = sl.Camera()
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
transform = sl.Transform()
tracking_params = sl.PositionalTrackingParameters(transform)
cam.enable_positional_tracking(tracking_params)
runtime = sl.RuntimeParameters()
camera_pose = sl.Pose()
viewer = tv.PyTrackingViewer()
viewer.init()
py_translation = sl.Translation()
start_zed(cam, runtime, camera_pose, viewer, py_translation)
viewer.exit()
glutMainLoop()
def main():
init = sl.InitParameters()
init.camera_resolution = sl.RESOLUTION.HD720
init.depth_mode = sl.DEPTH_MODE.NONE
cam = sl.Camera()
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit(1)
runtime = sl.RuntimeParameters()
stream = sl.StreamingParameters()
stream.codec = sl.STREAMING_CODEC.H264
stream.bitrate = 4000
status = cam.enable_streaming(stream)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit(1)
print(" Quit : CTRL+C\n")
while True:
err = cam.grab(runtime)
cam.disable_streaming()
cam.close()
def _connect_to_camera(self):
# road option from config file
with open(self._config) as f_in:
self._config = json.load(f_in)
self._params = sl.InitParameters()
if 'resolution' in self._config:
self._params.camera_resolution = self._key_to_res[
self._config['resolution']]
else:
self._params.camera_resolution = sl.RESOLUTION.RESOLUTION_HD720
if 'fps' in self._config:
self._params.camera_fps = self._config['fps']
else:
self._params.camera_fps = 30
self._cam = sl.Camera()
status = self._cam.open(self._params)
if status != sl.ERROR_CODE.SUCCESS:
print(status)
raise Exception('Unable to connect to Stereo Camera')
self._runtime = sl.RuntimeParameters()
self._left_frame = sl.Mat()
self._right_frame = sl.Mat()
def __init__(self):
# Create a Camera object
zed = sl.Camera()
# Create a InitParameters object and set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.RESOLUTION_HD1080 # Use HD1080 video mode, should be res
init_params.camera_fps = 30 # Set fps at 30, should be fps
# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
image_left = sl.Mat()
runtime_parameters = sl.RuntimeParameters()
# Get the Camera Matrix and distortion coefficients
Calib_data = load('Calibration.npz')
# Calib_data.files >>> ['CameraMtx', 'DistortionVec']
K = Calib_data['CameraMtx']
d = Calib_data['DistortionVec']
self.zed = zed
self.left_image = image_left # self.right_image =
self.params = runtime_parameters
self.K = K
self.d = d
self.t = None
self.R = None
def main():
# Create a Camera object
zed = sl.Camera()
#init
init_params = sl.InitParameters()
init_params.depth_mode = sl.DEPTH_MODE.PERFORMANCE # Use PERFORMANCE depth mode
init_params.coordinate_units = sl.UNIT.MILLIMETER # Use milliliter units (for depth measurements)
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
runtime_parameters = sl.RuntimeParameters()
runtime_parameters.sensing_mode = sl.SENSING_MODE.STANDARD # Use STANDARD sensing mode
# Capture 50 images and depth, then stop
i = 0
image = sl.Mat()
depth = sl.Mat()
point_cloud = sl.Mat()
mirror_ref = sl.Transform()
mirror_ref.set_translation(sl.Translation(2.75, 4.0, 0))
tr_np = mirror_ref.m
while i < 50:
# A new image is available if grab() returns SUCCESS
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
# Retrieve left image
zed.retrieve_image(image, sl.VIEW.LEFT)
zed.retrieve_measure(depth, sl.MEASURE.DEPTH)
zed.retrieve_measure(point_cloud, sl.MEASURE.XYZRGBA)
x = round(image.get_width() / 2)
y = round(image.get_height() / 2)
print("width: ", x)
print("height: ", y)
err, point_cloud_value = point_cloud.get_value(x, y)
#distance formula
distance = math.sqrt(point_cloud_value[0] * point_cloud_value[0] +
point_cloud_value[1] * point_cloud_value[1] +
point_cloud_value[2] * point_cloud_value[2])
point_cloud_np = point_cloud.get_data()
point_cloud_np.dot(tr_np)
if not np.isnan(distance) and not np.isinf(distance):
distance = round(distance)
print("Distance to Camera at ({0}, {1}): {2} mm\n".format(
x, y, distance))
# Increment the loop
i = i + 1
else:
print("invalid\n")
sys.stdout.flush()
zed.close()
def main():
#if len(sys.argv) != 2:
# print("Please specify path to .svo file.")
# exit()
#filepath = sys.argv[1]
#print("Reading SVO file: {0}".format(filepath))
cam = sl.Camera()
#init = sl.InitParameters(svo_input_filename=filepath)
init = sl.InitParameters()
#new
init.camera_resolution = sl.RESOLUTION.RESOLUTION_HD720 # Use HD720 video mode (default
# Use a right-handed Y-up coordinate system
init.coordinate_system = sl.COORDINATE_SYSTEM.COORDINATE_SYSTEM_RIGHT_HANDED_Y_UP
init.coordinate_units = sl.UNIT.UNIT_METER # Set units in meters
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
runtime = sl.RuntimeParameters()
spatial = sl.SpatialMappingParameters()
transform = sl.Transform()
tracking = sl.TrackingParameters(transform)
cam.enable_tracking(tracking)
cam.enable_spatial_mapping(spatial)
pymesh = sl.Mesh()
print("Processing...")
#for i in range(200):
while True:
try:
cam.grab(runtime)
cam.request_mesh_async()
except KeyboardInterrupt:
cam.extract_whole_mesh(pymesh)
cam.disable_tracking()
cam.disable_spatial_mapping()
filter_params = sl.MeshFilterParameters()
filter_params.set(sl.MESH_FILTER.MESH_FILTER_HIGH)
print("Filtering params : {0}.".format(
pymesh.filter(filter_params)))
apply_texture = pymesh.apply_texture(
sl.MESH_TEXTURE_FORMAT.MESH_TEXTURE_RGBA)
print("Applying texture : {0}.".format(apply_texture))
print_mesh_information(pymesh, apply_texture)
save_filter(filter_params)
save_mesh(pymesh)
cam.close()
print("\nFINISH")
raise
def __new_camera(self):
"""
The method to close the current and create a new camera for sampling
:return: void
"""
self.camera = sl.Camera()
self.counter = 1
print("\nCreated a new camera, counter reset.\n")
def main(filepath, callback = None):
if callback:
callback.emit("Reading SVO file: {0} for views and depths".format(filepath))
print("Reading SVO file: {0} for views and depths".format(filepath))
init = sl.InitParameters()
init.set_from_svo_file(filepath)
init.svo_real_time_mode = False # Don't convert in realtime
init.enable_right_side_measure = True
init.coordinate_units = sl.UNIT.METER # Измерения в метрах
cam = sl.Camera()
status = cam.open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
runtime = sl.RuntimeParameters()
right = sl.Mat()
right_measure = sl.Mat()
file_name = PurePath(filepath).name[0:-4]
print(filepath)
print(file_name)
filepath = data_dir + "\\" + file_name
print(filepath)
if not os.path.exists(f'{filepath}\\right'):
os.makedirs(f'{filepath}\\right')
if not os.path.exists(f'{filepath}\\right_measure'):
os.makedirs(f'{filepath}\\right_measure')
i = 0
while True:
err = cam.grab(runtime)
if err == sl.ERROR_CODE.SUCCESS:
# Правое изображение
cam.retrieve_image(right, sl.VIEW.RIGHT)
# Правая глубина
cam.retrieve_measure(right_measure, sl.MEASURE.DEPTH_RIGHT)
# Время
time = cam.get_timestamp(sl.TIME_REFERENCE.IMAGE)
# Сохранение изображения
right.write(f'{filepath}\\right\\{i}.png')
# Сохранение измерений глубины и времени
data = {'time': time.get_milliseconds(), 'measures': right_measure.get_data().tolist()}
save_to_json(data, f'{filepath}\\right_measure\\{i}.json')
else:
print(repr(err))
break
i+=1
cam.close()
if callback:
callback.emit("Views and depths saved")
print("Views and depths saved")
return "ok"
def main():
global stop_signal
global zed_list
global left_list
global depth_list
global timestamp_list
global thread_list
signal.signal(signal.SIGINT, signal_handler)
print("Running...")
init = sl.InitParameters()
init.camera_resolution = sl.RESOLUTION.HD720
init.camera_fps = 30 # The framerate is lowered to avoid any USB3 bandwidth issues
#List and open cameras
cameras = sl.Camera.get_device_list()
index = 0
for cam in cameras:
init.set_from_serial_number(cam.serial_number)
zed_list.append(sl.Camera())
left_list.append(sl.Mat())
depth_list.append(sl.Mat())
timestamp_list.append(0)
print("Opening ZED Camera {}...".format(cam.serial_number))
status = zed_list[index].open(init)
if status != sl.ERROR_CODE.SUCCESS:
print(repr(status))
exit()
index = index + 1
#Start camera threads
for index in range(0, len(zed_list)):
thread_list.append(threading.Thread(target=grab_run, args=(index, )))
thread_list[index].start()
#Display camera images
key = ''
while key != 113: # for 'q' key
for index in range(0, len(zed_list)):
if timestamp_list[index] > 0:
name = "ZED {}".format(
zed_list[index].get_camera_information().serial_number)
cv2.imshow(name, left_list[index].get_data())
x = round(depth_list[index].get_width() / 2)
y = round(depth_list[index].get_height() / 2)
err, depth_value = depth_list[index].get_value(x, y)
if not np.isnan(depth_value) and not np.isinf(depth_value):
print("{} depth at center: {}".format(name, depth_value))
key = cv2.waitKey(5)
cv2.destroyAllWindows()
#Stop the threads
stop_signal = True
for index in range(0, len(thread_list)):
thread_list[index].join()
print("\nFINISH")
def main():
# Create a Camera object
zed = sl.Camera()
# Create a InitParameters object and set configuration parameters
init_params = sl.InitParameters()
init_params.depth_mode = sl.DEPTH_MODE.DEPTH_MODE_PERFORMANCE # Use PERFORMANCE depth mode
init_params.coordinate_units = sl.UNIT.UNIT_MILLIMETER # Use milliliter units (for depth measurements)
# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
# Create and set RuntimeParameters after opening the camera
runtime_parameters = sl.RuntimeParameters()
runtime_parameters.sensing_mode = sl.SENSING_MODE.SENSING_MODE_STANDARD # Use STANDARD sensing mode
# Capture 50 images and depth, then stop
i = 0
image = sl.Mat()
depth = sl.Mat()
point_cloud = sl.Mat()
while i < 50:
# A new image is available if grab() returns SUCCESS
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
# Retrieve left image
zed.retrieve_image(image, sl.VIEW.VIEW_LEFT)
# Retrieve depth map. Depth is aligned on the left image
zed.retrieve_measure(depth, sl.MEASURE.MEASURE_DEPTH)
# Retrieve colored point cloud. Point cloud is aligned on the left image.
zed.retrieve_measure(point_cloud, sl.MEASURE.MEASURE_XYZRGBA)
# Get and print distance value in mm at the center of the image
# We measure the distance camera - object using Euclidean distance
x = round(image.get_width() / 2)
y = round(image.get_height() / 2)
err, point_cloud_value = point_cloud.get_value(x, y)
distance = math.sqrt(point_cloud_value[0] * point_cloud_value[0] +
point_cloud_value[1] * point_cloud_value[1] +
point_cloud_value[2] * point_cloud_value[2])
if not np.isnan(distance) and not np.isinf(distance):
distance = round(distance)
print("Distance to Camera at ({0}, {1}): {2} mm\n".format(
x, y, distance))
# Increment the loop
i = i + 1
else:
print(
"Can't estimate distance at this position, move the camera\n"
)
sys.stdout.flush()
# Close the camera
zed.close()
def main():
# Create a Camera object
zed = sl.Camera()
# Create a InitParameters object and set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD1080 # Use HD1080 video mode
# https://www.stereolabs.com/docs/depth-sensing/depth-settings/
# Several depth modes are available to improve performance in certain applications
init_params.depth_mode = sl.DEPTH_MODE.ULTRA
init_params.coordinate_units = sl.UNIT.METER
init_params.camera_fps = 30
# init_params.depth_minimum_distance = 0.15
init_params.depth_maximum_distance = 20
# zed.set_depth_max_range_value(20)
# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
exit(1)
image = sl.Mat()
depth = sl.Mat()
point_cloud = sl.Mat()
runtime_parameters = sl.RuntimeParameters()
runtime_parameters.sensing_mode = sl.SENSING_MODE.STANDARD
runtime_parameters.sensing_mode = sl.SENSING_MODE.FILL # FILL STANDARD
# Setting the depth confidence parameters
# https://www.stereolabs.com/docs/ros/zed-node/
# A lower value means more confidence and precision
# [1, 100], default: 100
runtime_parameters.confidence_threshold = 100
runtime_parameters.textureness_confidence_threshold = 100
while True:
# Grab an image, a RuntimeParameters object must be given to grab()
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
zed.retrieve_image(image, sl.VIEW.LEFT)
### The 32-bit depth map can be displayed as a grayscale 8-bit image.
### 0 (black) represents the most distant possible depth value. We call this process depth normalization
### 不太準，可能用點雲自己轉換比較準?
zed.retrieve_image(depth, sl.VIEW.DEPTH)
### extract the depth map of a scene
# zed.retrieve_measure(depth, sl.MEASURE.DEPTH)
zed.retrieve_measure(point_cloud, sl.MEASURE.XYZRGBA)
############
img_process(image, depth)
dis = get_depth_value(depth)
# print("D: ", dis)
dis = get_point_cloud_depth_value(point_cloud)
print("p: ", dis)
############
# Close the camera
zed.close()
