def test_component_config(self): self._app = Application() self._app.add('node') node = self._app.nodes['node'] self.assertIsNotNone(node) result = self._app.load_module('viewers') self.assertTrue(result) component = node.add(self._app.registry.isaac.viewers.ImageViewer) self.assertTrue(isinstance(component, Component.Component)) self.assertIsNotNone(component) self.assertIsNotNone(component.config) component.config.reduce_scale = 2.0 self.assertEqual(component.config.reduce_scale, 2.0) self.assertEqual(component.config['reduce_scale'], 2.0) component.config['reduce_scale'] = 3.0 self.assertEqual(component.config['reduce_scale'], 3.0) self.assertEqual(component.config.reduce_scale, 3.0) self._app.start() self._app.stop()
def test_component_access(self): self._app = Application() self._app.add('node') node = self._app.nodes['node'] self.assertIsNotNone(node) result = self._app.load_module('viewers') self.assertTrue(result) node.add(self._app.registry.isaac.viewers.ImageViewer) component = node.components['ImageViewer'] self.assertTrue(isinstance(component, Component.Component)) self.assertIsNotNone(component) self.assertEqual(node.components['ImageViewer'].config['target_fps'], 30.0) component = node.components['ImageViewer'] self.assertTrue(isinstance(component, Component.Component)) self.assertIsNotNone(component) self.assertEqual(node.components['ImageViewer'].config['target_fps'], 30.0) node.components['ImageViewer'].config['target_fps'] = 45.0 self.assertEqual(node.components['ImageViewer'].config['target_fps'], 45.0)
def test_load_subgraph_in_asset_path(self): self._app = Application() self._app.add('node') # override the asset path to point to our test location self._app._asset_path = 'packages/pyalice/tests/mock_asset_path' # loads subgraph and checks if the node/component are created, config is good self._app.load('mock_installed_application_test.subgraph.json', 'foo') pynode = self._app.nodes['foo.camera_viewer'] self.assertIsNotNone(pynode) component = pynode['ImageViewer'] self.assertIsNotNone(component) fps_readback = self._app.nodes['foo.camera_viewer'].components[ 'ImageViewer'].config['target_fps'] self.assertEqual(fps_readback, 11) camera_name_readback = self._app.nodes['foo.camera_viewer'].components[ 'ImageViewer'].config['camera_name'] self.assertEqual(camera_name_readback, 'bar') self._app.start() self._app.stop()
def test_pose(self): self._app = Application() self._app.start() self.assertTrue( self._app.atlas.set_pose( 'foo', 'bar', 1.0, [np.quaternion(1.0, 0.0, 0.0, 0.0), np.array([0.0, 0.0, 0.0])])) self.assertTrue( self._app.atlas.set_pose( 'foo', 'bar', 2.0, [np.quaternion(1.0, 0.0, 0.0, 0.0), np.array([1.0, 2.0, 3.0])])) read_pose = self._app.atlas.pose('foo', 'bar', 1.5) self.assertIsNotNone(read_pose) self.assertEqual(len(read_pose), 2) q = read_pose[0] t = read_pose[1] self.assertLess(q.w - 1.0, 1e-6) self.assertLess(q.x - 0.0, 1e-6) self.assertLess(q.y - 0.0, 1e-6) self.assertLess(q.z - 0.0, 1e-6) self.assertLess(t[0] - 0.5, 1e-6) self.assertLess(t[1] - 1.0, 1e-6) self.assertLess(t[2] - 1.5, 1e-6) self._app.stop()
def test_wait_for_node_timeout(self): self._app = Application() self._app.load_module('behavior_tree') self._app.add('node').add( self._app.registry.isaac.behavior_tree.TimerBehavior) self._app.start() status = self._app.wait_for_node('node', duration=0.1) self._app.stop() self.assertEqual(str(status), 'Status.Running', 'Should still be in Status.Running')
def test_wait_for_node(self): self._app = Application() self._app.load_module('behavior_tree') self._app.add('node').add( self._app.registry.isaac.behavior_tree.TimerBehavior) self._app.start() status = self._app.wait_for_node('node') self._app.stop() self.assertEqual(str(status), 'Status.Success', 'Should reach Status.Success in 1 second.')
def test_load_module(self): self._app = Application() result = self._app.load_module('message_generators') self.assertTrue(result) component = self._app.registry.isaac.message_generators.ImageLoader self.assertIsNotNone(component) self.assertEqual(str(component), "['isaac::message_generators::ImageLoader']")
def test_clock(self): self._app = Application() self._app.start() clock = self._app.clock self.assertIsNotNone(clock) self.assertIsNotNone(clock.time) cur_time = clock.time self.assertGreater(cur_time, 0.0) self.assertGreater(clock.time, cur_time) self._app.stop()
def test_perf_report(self): PERF_REPORT_PATH = '/tmp/perf_report' if os.path.exists(PERF_REPORT_PATH): os.remove(PERF_REPORT_PATH) self._app = Application( argv=['--performance_report_out', PERF_REPORT_PATH]) self._app.load_module('behavior_tree') self._app.add('node').add( self._app.registry.isaac.behavior_tree.TimerBehavior) self._app.run(0.2) self.assertTrue(os.path.exists(PERF_REPORT_PATH))
def test_load_bogus_subgraph(self): bogus_json_filename = '' with tempfile.NamedTemporaryFile('w') as f: f.write('this is bogus json') bogus_json_filename = f.name self._app = Application() with self.assertRaises(ValueError): self._app.load('/no/such/file') with self.assertRaises(ValueError): self._app.load(bogus_json_filename)
def test_run_until_failure(self): now_secs = time.time() self._app = Application() self._app.add('failure') node_failure = self._app.nodes['failure'] self.assertIsNotNone(node_failure) self._app.nodes['failure'].add(FailureLaterCodelet) self._app.run('failure') delta_secs = time.time() - now_secs self.assertGreater(delta_secs, 0.4)
def test_run_until_succeed(self): now_secs = time.time() self._app = Application() self._app.add('success') node_success = self._app.nodes['success'] self.assertIsNotNone(node_success) self._app.nodes['success'].add(SucceedLaterCodelet) self._app.run('success') delta_secs = time.time() - now_secs self.assertGreater(delta_secs, 0.4)
def main(): # patching capnp paths. Needed if using isaac python API. patch_capnp_paths() # creating app app = Application(app_filename="app/graphs/graph.app.json") # adding python codelet to the hello_node in graph app.nodes["hello_node"].add(HelloWorld, "print") # configuring Websight webroot and assetroot. Needed if using isaac python API. configure_websight_root(app) # running the application app.run()
def test_expand_asset(self): self._app = Application() ws, path = self._app._app.expand_asset_path('@workspace_//foo/bar') self.assertEqual(path, 'external/workspace_/foo/bar') self.assertEqual(ws, 'workspace_') ws1 = self._app.home_workspace_name self.assertEqual(len(ws1), 0) self._app.home_workspace_name = 'workspace_' ws2 = self._app.home_workspace_name self.assertEqual(ws2, 'workspace_') ws3, path3 = self._app._app.expand_asset_path('@workspace_//foo/bar') self.assertEqual(ws3, 'workspace_') self.assertEqual(path3, 'foo/bar')
def main(): # patching capnp paths. Needed if using isaac python API. patch_capnp_paths() # creating app app = Application(app_filename="apps/hello_world_py/graphs/graph.app.json") # adding python codelets to graph app.nodes["sender"].add(Sender, "sender_component") app.nodes["receiver"].add(Receiver, "receiver_component") # configuring Websight webroot and assetroot. Needed if using isaac python API. configure_websight_root(app) # running the application app.run()
def test_get_component(self): self._app = Application() self._app.add('node') node = self._app.nodes['node'] self.assertIsNotNone(node) # Get None if no component has such name component = node['ledger'] self.assertIsNone(component) component = node['MessageLedger'] self.assertIsNotNone(component) self._app.start() self._app.stop()
def main(): parser = argparse.ArgumentParser() parser.add_argument( "--simulate", action="store_true", help="uses issac sim unity3d instead of a v4l2 camera.", ) args = parser.parse_args() if args.simulate: app_file = "apps/isaac_object_detection/graphs/detection_unity3d.app.json" else: app_file = "apps/isaac_object_detection/graphs/detection.app.json" app = Application(app_filename=app_file) app.nodes["edge_detector.subgraph.edge_detector"].add(EdgeDetector, "detector") app.run()
def test_node_start_stop(self): self._app = Application() result = self._app.load_module('message_generators') self.assertTrue(result) node = self._app.add('src') self.assertIsNotNone(node) component = node.add( self._app.registry.isaac.message_generators.PanTiltStateGenerator, 'pantilt') component.config['tick_period'] = '20 Hz' self.assertIsNotNone(component) node_sink = self._app.add('sink') self.assertIsNotNone(node_sink) self._app.connect(component, 'target', node_sink.components['MessageLedger'], 'rcv') self._app.start() time.sleep(0.1) msg = self._app.receive('sink', 'MessageLedger', 'rcv') self.assertIsNotNone(msg) node.stop() msg = self._app.receive('sink', 'MessageLedger', 'rcv') time.sleep(0.1) msg = self._app.receive('sink', 'MessageLedger', 'rcv') self.assertIsNone(msg) time.sleep(0.1) msg = self._app.receive('sink', 'MessageLedger', 'rcv') self.assertIsNone(msg) node.start() time.sleep(0.1) msg = self._app.receive('sink', 'MessageLedger', 'rcv') self.assertIsNotNone(msg) self._app.stop() with self.assertRaises(RuntimeError): self._app.stop()
class TestPyCodeletStatus(unittest.TestCase): ''' Test loading subgraph via the application API ''' @classmethod def setUpClass(cls): # method will be ran once before any test is ran pass @classmethod def tearDownClass(cls): # method will be ran once after all tests have run pass def setUp(self): # ran before each test return super().setUp() def tearDown(self): # ran after each test return super().tearDown() def test_report_status(self): self._app = Application() self._app.add('success') self._app.add('failure') node_success = self._app.nodes['success'] self.assertIsNotNone(node_success) component = node_success.add(self._app.registry.isaac.alice.PyCodelet) self.assertIsNotNone(component) node_failure = self._app.nodes['failure'] self.assertIsNotNone(node_failure) component = node_failure.add(self._app.registry.isaac.alice.PyCodelet) self.assertIsNotNone(component) self._app.nodes['success'].add(AlwaysSucceedCodelet) self._app.nodes['failure'].add(AlwaysFailureCodelet) self._app.start_wait_stop(1.5) self.assertEqual(node_success.status, Status.Success) self.assertEqual(node_failure.status, Status.Failure)
def test_node_accesor(self): self._app = Application() self._app.load_module('json') node = self._app.add('foo1') self.assertIsNotNone(node) component = node.add(self._app.registry.isaac.json.JsonToProto, 'bar1') self.assertIsNotNone(component) node = self._app.add('foo2') self.assertIsNotNone(node) component = node.add(self._app.registry.isaac.json.ProtoToJson, 'bar2') self.assertIsNotNone(component) self.assertIsNotNone(self._app.nodes['foo1']) self.assertIsNotNone(self._app.nodes['foo2']) self.assertIsNone(self._app.nodes['foo3']) self._app.start() self._app.stop()
def test_max_duration(self): time_now = time.time() self._app = Application(argv=['--max_duration', '0.5s']) self._app.load_module('behavior_tree') self._app.add('node').add( self._app.registry.isaac.behavior_tree.TimerBehavior) self._app.run(2.0) time_dt = time.time() - time_now self.assertLess(time_dt, 1.0) time_now = time.time() self._app = Application(argv=['--max_duration', '0.5s']) self._app.load_module('behavior_tree') self._app.add('node').add( self._app.registry.isaac.behavior_tree.TimerBehavior) self._app.run(2) time_dt = time.time() - time_now self.assertLess(time_dt, 1.0)
def test_report_status(self): self._app = Application() self._app.add('success') self._app.add('failure') node_success = self._app.nodes['success'] self.assertIsNotNone(node_success) component = node_success.add(self._app.registry.isaac.alice.PyCodelet) self.assertIsNotNone(component) node_failure = self._app.nodes['failure'] self.assertIsNotNone(node_failure) component = node_failure.add(self._app.registry.isaac.alice.PyCodelet) self.assertIsNotNone(component) self._app.nodes['success'].add(AlwaysSucceedCodelet) self._app.nodes['failure'].add(AlwaysFailureCodelet) self._app.start_wait_stop(1.5) self.assertEqual(node_success.status, Status.Success) self.assertEqual(node_failure.status, Status.Failure)
def run(task): ''' Given a task description, starts the application, waits for the node to stop running or for the duration to lapse. Stops the application after the execution. Can be used standalone or with the run_parallel helper. Example: >>> task = { >>> 'app_filename' : 'packages/detect_net/apps/apriltags_process.app.json', >>> 'more_json' : { >>> "config": { >>> "replay.interface": {"output": {"cask_directory": root}}, >>> "record.interface": {"input": {"base_directory": apriltags_root}} >>> } >>> }, >>> 'success_node': "replay.interface", >>> 'duration': 2040.0, 'poll_interval': 1.0, 'exit_interval': 1.0 >>> } >>> >>> run(task) Args: task['app_filename'] (str): the main application json filename task['more_json'] (dict): a dictionary containing additional configuration, to serialize into json and load as more_jsons to the app task['more_jsons'] (str): a comma-separated string of additional jsons to load task['name'] (str): the name of the application task['modules'] (List(str)): a list of modules to be loaded task['argv']: Command line arguments from sys.argv task['success_node'] (string): the name of the node to wait to stop running task['duration'] (float): timeout in seconds, can run forever, if duration is None task['exit_interval'] (float): exit interval in seconds Returns: True, if the success status had been reached. False otherwise. ''' with tempfile.NamedTemporaryFile(mode='w+t', suffix='.json', delete=True) as more_json: json.dump(task['more_json'], more_json) more_json.flush() more_jsons = ((task['more_jsons'] + ',') if 'more_jsons' in task else '') + more_json.name app = Application(app_filename=task['app_filename'], more_jsons=more_jsons, name=task.get('name', None), modules=task.get('modules', None), argv=task.get('argv', sys.argv)) app.start() status = app.wait_for_node(task['success_node'], task['duration']) time.sleep(task['exit_interval']) app.stop() return status == bindings.Status.Success
def test_print_node(self): self._app = Application() self._app.add('foo') node_names = self._app.nodes._names self.assertTrue(isinstance(node_names, list) and 'foo' in node_names) self._app.add('bar') node_names = self._app.nodes._names self.assertTrue( isinstance(node_names, list) and 'foo' in node_names and 'bar' in node_names) foo_node = None bar_node = None for n in self._app.nodes: if n.name == 'foo': foo_node = n if n.name == 'bar': bar_node = n self.assertIsNotNone(foo_node) self.assertIsNotNone(bar_node)
def test_load_subgraph(self): self._app = Application() self._app.add('node') # loads subgraph and checks if the node/component are created, config is good self._app.load('packages/pyalice/tests/application_test.subgraph.json', 'foo') node = self._app.nodes['foo.camera_viewer'] component = node['ImageViewer'] self.assertIsNotNone(component) fps_readback = self._app.nodes['foo.camera_viewer'].components[ 'ImageViewer'].config['target_fps'] self.assertEqual(fps_readback, 11) camera_name_readback = self._app.nodes['foo.camera_viewer'].components[ 'ImageViewer'].config['camera_name'] self.assertEqual(camera_name_readback, 'bar') # loads the subgraph again with different prefix name self._app.load('packages/pyalice/tests/application_test.subgraph.json', 'foo1') node = self._app.nodes['foo1.camera_viewer'] component = node['ImageViewer'] self.assertIsNotNone(component) fps_readback = self._app.nodes['foo1.camera_viewer'].components[ 'ImageViewer'].config['target_fps'] self.assertEqual(fps_readback, 11) camera_name_readback = self._app.nodes[ 'foo1.camera_viewer'].components['ImageViewer'].config[ 'camera_name'] self._app.start() self._app.stop()
def main(): patch_capnp_paths() parser = argparse.ArgumentParser() parser.add_argument( "--simulate", action="store_true", help="uses issac sim unity3d instead of a v4l2 camera.", ) args = parser.parse_args() if args.simulate: app_file = "app/graphs/edge_detection_unity3d.app.json" else: app_file = "app/graphs/edge_detection.app.json" # creating app app = Application(app_filename=app_file) # adding EdgeDetector codelet to the detector component of the edge_detector node app.nodes["edge_detector"].add(EdgeDetector, "detector") configure_websight_root(app) # running the application app.run()
parser.add_argument('--framerate', dest='framerate', action='store', type=int, default=60, help='Camera framerate') parser.add_argument('--device_id', dest='device_id', action='store', type=int, help='Camera device id') args = parser.parse_args() # Create april_tag_python application app = Application(name="april_tags_python", modules=[ "//packages/fiducials:april_tags", "realsense", "sensors:v4l2_camera", "sight", "viewers", "zed" ]) # Setup camera node camera = None if args.camera == "zed": camera = app.add('input_images').add(app.registry.isaac.ZedCamera) camera.config.resolution = args.resolution camera.config.camera_fps = args.framerate camera_out_channel = "left_camera_rgb" elif args.camera == "realsense": camera = app.add('input_images').add( app.registry.isaac.RealsenseCamera) camera.config.cols, camera.config.rows = tuple( [int(arg) for arg in args.resolution.split('x')]) camera.config.color_framerate = args.framerate
description='Demonstrates the simulation integration with SVIO') parser.add_argument( "--map_json", help="The path to the map json to load into simulation", default="apps/assets/maps/virtual_medium_warehouse.json") parser.add_argument( "--robot_json", help="The path to the robot json to load into simulation", default="packages/navsim/robots/carter_stereo_with_bumper.json") parser.add_argument( "--more", help="A comma separated list of additional json files to load") args = parser.parse_args() # Create the app and load the required subgraphs app = Application(name="sim_svio") app.load_module("atlas") app.load_module('behavior_tree') app.load_module('sight') app.load_module('utils') app.load_module("viewers") app.load("packages/navsim/apps/navsim_navigation.subgraph.json", "simulation") app.load( "packages/navigation/apps/differential_base_navigation.subgraph.json", "navigation") app.load("packages/navigation/apps/goal_generators.subgraph.json", "goals") app.load( "packages/visual_slam/apps/stereo_visual_odometry_rgb.subgraph.json", "svo")
help='The directory in which log files will be stored') parser.add_argument('--num_nodes', dest='num_nodes', default=10, help='Number of virtual lidar nodes to run') parser.add_argument('--points_per_message', dest='points_per_message', default=10, help='Number of virtual lidar points to generate at each tick per node') parser.add_argument('--node_tick_rate', dest='node_tick_rate', default='50Hz', help='Rate at which each node should generate sets of points') args, _ = parser.parse_known_args() app = Application(name="record_small_point_clouds_test", modules=["message_generators", "cask", "sight"]) app.load_module("cask") app.load_module("sight") recorder = app.add("recorder").add(app.registry.isaac.cask.Recorder) recorder.config.base_directory = args.base_directory generators = list() for i in range(int(args.num_nodes)): pcd = app.add("cam" + str(i)).add(app.registry.isaac.message_generators.PointCloudGenerator) pcd.config.point_count = 100000000 pcd.config.point_per_message = int(args.points_per_message) pcd.config.tick_period = args.node_tick_rate generators.append(pcd) app.connect(generators[i - 1], "point_cloud", recorder, "point_cloud" + str(i))
' using the live stereo image feed obtained from the ZED (Mini) camera.' ) parser.add_argument( '--imu', dest='imu', action='store_true', help='Enables the support for the on-board camera IMU.') parser.add_argument( '--no-imu', dest='imu', action='store_false', help='Disables the support for the on-board camera IMU.') parser.set_defaults(imu=False) args, _ = parser.parse_known_args() app = Application(name="svo_zed", modules=["zed"]) app.load( "packages/visual_slam/apps/stereo_visual_odometry_grayscale.subgraph.json", "svo") svo_interface = app.nodes["svo.subgraph"].components["interface"] camera = app.add('camera').add(app.registry.isaac.ZedCamera) camera.config.enable_factory_rectification = True camera.config.enable_imu = args.imu camera.config.camera_fps = 60 camera.config.resolution = "672x376" camera.config.gray_scale = True camera.config.rgb = False tracker = app.nodes['svo.tracker'].components['StereoVisualOdometry']