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 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 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(): signal.signal(signal.SIGINT, interrupt_handler) init = sl.InitParameters() init.camera_resolution = sl.RESOLUTION.VGA init.camera_fps = 100 init.depth_mode = sl.DEPTH_MODE.ULTRA init.coordinate_units = sl.UNIT.METER init.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP status = cam.open(init) if status != sl.ERROR_CODE.SUCCESS: print('Camera.open failed') print(repr(status)) exit(1) path_output = "Datalog/Receiver/RXDATA/{0}.svo".format( datetime.now().strftime('%m-%d-%Y_%H:%M:%S')) recording_param = sl.RecordingParameters(path_output, sl.SVO_COMPRESSION_MODE.H264) err = cam.enable_recording(recording_param) if err != sl.ERROR_CODE.SUCCESS: print('Enable Recording failed') print(repr(err)) exit(1) runtime = sl.RuntimeParameters() while True: cam.grab(runtime)
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(): 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 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 main(): if not sys.argv or len(sys.argv) != 2: print( "Only the path of the output SVO file should be passed as argument." ) exit(1) init = sl.InitParameters() init.camera_resolution = sl.RESOLUTION.HD720 init.depth_mode = sl.DEPTH_MODE.NONE status = cam.open(init) if status != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit(1) path_output = sys.argv[1] recording_param = sl.RecordingParameters(path_output, sl.SVO_COMPRESSION_MODE.H264) err = cam.enable_recording(recording_param) if err != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit(1) runtime = sl.RuntimeParameters() print("SVO is Recording, use Ctrl-C to stop.") frames_recorded = 0 while True: if cam.grab(runtime) == sl.ERROR_CODE.SUCCESS: frames_recorded += 1 print("Frame count: " + str(frames_recorded), end="\r")
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 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(): 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 __open_camera(self, svo_path, depth_mode): """ Method to open a :return: void """ if self.input_mode == 'default': init = sl.InitParameters() init.svo_input_filename = svo_path init.svo_real_time_mode = False init.camera_resolution = self.resolution if depth_mode == 'performance': init.depth_mode = sl.DEPTH_MODE.DEPTH_MODE_PERFORMANCE if depth_mode == 'medium': init.depth_mode = sl.DEPTH_MODE.DEPTH_MODE_MEDIUM if depth_mode == 'quality': init.depth_mode = sl.DEPTH_MODE.DEPTH_MODE_QUALITY if depth_mode == 'ultra': init.depth_mode = sl.DEPTH_MODE.DEPTH_MODE_ULTRA # TODO: other input mode e.g real time mode # create and open a camera print("\nLoading camera...") status = self.camera.open(init) if status != sl.ERROR_CODE.SUCCESS: print(repr(status)) else: print("Camera successfully loaded\n")
def start(): path_output = "recoding.svo" mat = sl.Mat() init = sl.InitParameters() init.camera_resolution = sl.RESOLUTION.HD1080 #init.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Z_UP #init.depth_mode = sl.DEPTH_MODE.QUALITY init.camera_fps = 30 status = cam.open(init) if status != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit(1) err = status #recording_param = sl.RecordingParameters(path_output, sl.SVO_COMPRESSION_MODE.LOSSLESS) #err = cam.enable_recording(recording_param) if err != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit(1) runtime = sl.RuntimeParameters() print("SVO is Recording, use Ctrl-C to stop.") frames_recorded = 0 while True: if cam.grab(runtime) == sl.ERROR_CODE.SUCCESS: frames_recorded += 1 cam.retrieve_image(mat, sl.VIEW.LEFT) image = mat.get_data() print("Frame count: " + str(frames_recorded), end="\r") if frames_recorded % 20 == 0: cv2.imshow("ZED", image)
def main(): if not sys.argv or len(sys.argv) != 2: exit(1) init = sl.InitParameters() init.camera_resolution = sl.RESOLUTION.HD720 init.camera_fps = 30 init.depth_mode = sl.DEPTH_MODE.ULTRA # Use ULTRA depth mode init.coordinate_units = sl.UNIT.METER init.depth_minimum_distance = 0.15 status = cam.open(init) if status != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit(1) path_output = sys.argv[1] recording_param = sl.RecordingParameters(path_output, sl.SVO_COMPRESSION_MODE.LOSSLESS) err = cam.enable_recording(recording_param) if err != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit(1) runtime = sl.RuntimeParameters() print("SVO is Recording, use Ctrl-C to stop.") frames_recorded = 0 while True: if cam.grab(runtime) == sl.ERROR_CODE.SUCCESS: frames_recorded += 1 print("Frame count: " + str(frames_recorded), end="\r")
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 __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 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 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(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(): 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(): 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 _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 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 __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 default_init_params(self): init_params = sl.InitParameters() init_params.set_from_svo_file(self.svo_path) init_params.camera_resolution = sl.RESOLUTION.HD720 # Use HD720 video mode (default fps: 60) init_params.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Z_UP_X_FWD # Use ROS-style coordinate system init_params.coordinate_units = sl.UNIT.METER # Set units in meters init_params.depth_maximum_distance = 40.0 return init_params
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()