def main(args):
app = Application(name="detection_pose_estimation_inference")
# Load subgraph and get interface node
app.load("packages/object_pose_estimation/apps/pose_cnn_decoder/"\
"detection_pose_estimation_cnn_inference.subgraph.json",
prefix="detection_pose_estimation")
detection_pose_estimation_interface = app.nodes["detection_pose_estimation.interface"]\
.components["Subgraph"]
# Load configuration
app.load(args.config)
# Configure detection model
detection_model = app.nodes["detection_pose_estimation.object_detection.tensor_r_t_inference"]\
.components["isaac.ml.TensorRTInference"]
if args.detection_model_file_path is not None:
detection_model.config.model_file_path = args.detection_model_file_path
if args.etlt_password is not None:
detection_model.config.etlt_password = args.etlt_password
# Configure pose estimation model
pose_estimation_model = app.nodes\
["detection_pose_estimation.object_pose_estimation.pose_encoder"]\
.components["TensorRTInference"]
if args.pose_estimation_model_file_path is not None:
pose_estimation_model.config.model_file_path = args.pose_estimation_model_file_path
# Configure detection decoder
decoder = app.nodes["detection_pose_estimation.object_detection.detection_decoder"]\
.components["isaac.detect_net.DetectNetDecoder"]
decoder.config.output_scale = [args.rows, args.cols]
if args.confidence_threshold is not None:
decoder.config.confidence_threshold = args.confidence_threshold
if args.nms_threshold is not None:
decoder.config.non_maximum_suppression_threshold = args.nms_threshold
# Configure bounding box encoder
bbox_encoder = app.nodes\
["detection_pose_estimation.object_pose_estimation.detection_convertor"]\
.components["BoundingBoxEncoder"]
bbox_encoder.config.image_dimensions = [args.rows, args.cols]
# Take ros Image and Intrinsic input
app.load("packages/ros_bridge/apps/ros_to_perception.subgraph.json", prefix="ros")
RosToImage = app.nodes["ros.ros_converters"].components["RosToImage"]
RosToCameraIntrinsics = app.nodes["ros.ros_converters"].components["RosToCameraIntrinsics"]
# Connect the output of RosToImage and RosToCameraIntrinsics to the detection subgraph
app.connect(RosToImage, "proto", detection_pose_estimation_interface, "color")
app.connect(RosToCameraIntrinsics, "proto", detection_pose_estimation_interface, "intrinsics")
app.run()
def main(args):
'''
Creates and runs block pose estimation app on RGBD image. Input image may come from sim (
default), cask recording or realsense camera
To run with sim (sim needs to be running first):
bazel run apps/samples/pick_and_place:block_pose_estimation
To see all options:
bazel run apps/samples/pick_and_place:block_pose_estimation -- --help
'''
app = Application(name="block_pose_estimation")
perception_interface = create_block_pose_estimation(app, use_refinement=args.refinement)
if args.mode == 'cask':
assert args.cask is not None, "cask path not specified. use --cask to set."
# Load replay subgraph and configure interface node
app.load("packages/cask/apps/replay.subgraph.json", prefix="replay")
source = app.nodes["replay.interface"].components["output"]
source.config.cask_directory = args.cask
source.config.loop = True
elif args.mode == "realsense":
# Create realsense camera codelet
app.load_module("realsense")
source = app.add("camera").add(app.registry.isaac.RealsenseCamera)
source.config.rows = 720
source.config.cols = 1280
source.config.color_framerate = 15
source.config.depth_framerate = 15
elif args.mode == "sim":
app.load(filename='packages/navsim/apps/navsim_tcp.subgraph.json', prefix='simulation')
source = app.nodes["simulation.interface"]["output"]
app.connect(source, "color", perception_interface, "color")
app.connect(source, "depth", perception_interface, "depth")
app.connect(source, "color_intrinsics", perception_interface, "intrinsics")
app.load_module("utils")
pose_node = app.add("pose")
pose_injector = pose_node.add(app.registry.isaac.utils.DetectionsToPoseTree)
pose_injector.config.detection_frame = "camera"
app.connect(perception_interface, "output_poses", pose_injector, "detections")
app.run()
# Load components
ur_interface = app.nodes["ur.subgraph"]["interface"]
ur_controller = app.nodes["ur.controller"]["ScaledMultiJointController"]
ur_driver = app.nodes["ur.universal_robots"]["UniversalRobots"]
# Configs
ur_controller.config.control_mode = "joint position"
ur_driver.config.control_mode = "joint position"
ur_driver.config.robot_ip = args.robot_ip
ur_driver.config.headless_mode = args.headless_mode
ur_driver.config.tool_digital_out_names = ["valve", "pump"]
ur_driver.config.tool_digital_in_names = ["unknown", "gripper"]
# Edges
app.connect(ur_interface, "arm_state", behavior_interface, "joint_state")
app.connect(ur_interface, "io_state", behavior_interface, "io_state")
app.connect(behavior_interface, "io_command", ur_interface, "io_command")
app.connect(behavior_interface, "joint_target", ur_interface, "joint_target")
# Sequence nodes
sequence_behavior = app.nodes["behavior.sequence_behavior"]
repeat_behavior = app.nodes["behavior.repeat_behavior"]
nodes_stopped = True
# Enable sight
widget = app.add("sight").add(app.registry.isaac.sight.SightWidget, "IO")
widget.config.type = "plot"
widget.config.channels = [
{
"name": "ur.universal_robots/UniversalRobots/gripper"
def main(args):
app = Application(name="detection_pose_estimation_inference")
# Load subgraph and get interface node
app.load("packages/object_pose_estimation/apps/pose_cnn_decoder/"\
"detection_pose_estimation_cnn_inference.subgraph.json",
prefix="detection_pose_estimation")
detection_pose_estimation_interface = app.nodes["detection_pose_estimation.interface"]\
.components["Subgraph"]
# Load configuration
app.load(args.config)
# Configure detection model
detection_model = app.nodes["detection_pose_estimation.object_detection.tensor_r_t_inference"]\
.components["isaac.ml.TensorRTInference"]
if args.detection_model_file_path is not None:
detection_model.config.model_file_path = args.detection_model_file_path
if args.etlt_password is not None:
detection_model.config.etlt_password = args.etlt_password
# Configure pose estimation model
pose_estimation_model = app.nodes\
["detection_pose_estimation.object_pose_estimation.pose_encoder"]\
.components["TensorRTInference"]
if args.pose_estimation_model_file_path is not None:
pose_estimation_model.config.model_file_path = args.pose_estimation_model_file_path
# Configure detection decoder
decoder = app.nodes["detection_pose_estimation.object_detection.detection_decoder"]\
.components["isaac.detect_net.DetectNetDecoder"]
decoder.config.output_scale = [args.rows, args.cols]
if args.confidence_threshold is not None:
decoder.config.confidence_threshold = args.confidence_threshold
if args.nms_threshold is not None:
decoder.config.non_maximum_suppression_threshold = args.nms_threshold
# Configure bounding box encoder
bbox_encoder = app.nodes\
["detection_pose_estimation.object_pose_estimation.detection_convertor"]\
.components["BoundingBoxEncoder"]
bbox_encoder.config.image_dimensions = [args.rows, args.cols]
# Configure detections filter
detections_filter = app.nodes\
["detection_pose_estimation.object_pose_estimation.detection_filter"]\
.components["FilterDetections"]
detections_filter.config.image_cols = args.cols
if args.mode == 'cask':
# Load replay subgraph and configure interface node
app.load("packages/cask/apps/replay.subgraph.json", prefix="replay")
replay_interface = app.nodes["replay.interface"].components["output"]
replay_interface.config.cask_directory = args.cask_directory
# Connect the output of the replay subgraph to the detection subgraph
app.connect(replay_interface, "color",
detection_pose_estimation_interface, "color")
app.connect(replay_interface, "color_intrinsics",
detection_pose_estimation_interface, "intrinsics")
elif args.mode == 'sim':
# Load simulation subgraph and get interface node
app.load("packages/object_pose_estimation/apps/pose_cnn_decoder"\
"/pose_estimation_sim.subgraph.json",\
prefix="simulation")
simulation_interface = app.nodes["simulation.interface"].components[
"TcpSubscriber"]
# Connect the output of the simulation with user-specified channel to the detection subgraph
app.connect(simulation_interface, args.image_channel,
detection_pose_estimation_interface, "color")
app.connect(simulation_interface, args.intrinsics_channel,
detection_pose_estimation_interface, "intrinsics")
# Set the scenario manager config options if scene name is provided
if (args.scenario_scene is not None):
scenario_manager = app.nodes[
"simulation.scenario_manager"].components["ScenarioManager"]
scenario_manager.config.scene = args.scenario_scene
if (args.scenario_robot_prefab is not None):
scenario_manager.config.robot_prefab = args.scenario_robot_prefab
elif args.mode == 'realsense':
app.load_module('realsense')
# Create and configure realsense camera codelet
camera = app.add("camera").add(app.registry.isaac.RealsenseCamera)
camera.config.rows = args.rows
camera.config.cols = args.cols
camera.config.color_framerate = args.fps
camera.config.depth_framerate = args.fps
camera.config.enable_ir_stereo = False
# Connect the output of the camera node to the detection subgraph
app.connect(camera, "color", detection_pose_estimation_interface,
"color")
app.connect(camera, "color_intrinsics",
detection_pose_estimation_interface, "intrinsics")
elif args.mode == 'v4l':
app.load_module('sensors:v4l2_camera')
# Create and configure V4L camera codelet
camera = app.add("camera").add(app.registry.isaac.V4L2Camera)
camera.config.device_id = 0
camera.config.rows = args.rows
camera.config.cols = args.cols
camera.config.rate_hz = args.fps
# Connect the output of the camera node to the detection subgraph
app.connect(camera, "frame", detection_pose_estimation_interface,
"color")
app.connect(camera, "intrinsics", detection_pose_estimation_interface,
"intrinsics")
elif args.mode == 'image':
app.load_module('message_generators')
# Create feeder node
feeder = app.add("feeder").add(
app.registry.isaac.message_generators.ImageLoader)
feeder.config.color_glob_pattern = args.image_directory
feeder.config.tick_period = "1Hz"
# Create intrinsic node
intrinsic = app.add("intrinsic").add(
app.registry.isaac.message_generators.CameraIntrinsicsGenerator)
intrinsic.config.focal_length = [args.focal_length, args.focal_length]
intrinsic.config.optical_center = [
args.optical_center_rows, args.optical_center_cols
]
intrinsic.config.distortion_coefficients = [
0.01, 0.01, 0.01, 0.01, 0.01
]
# Connect the output of the image feeder node to the detection subgraph
app.connect(feeder, "color", detection_pose_estimation_interface,
"color")
# Connect the output of the intrinsic node to the detection subgraph
app.connect(feeder, "color", intrinsic, "image")
app.connect(intrinsic, "intrinsics",
detection_pose_estimation_interface, "intrinsics")
else:
raise ValueError('Not supported mode {}'.format(args.mode))
app.run()
raise ValueError("pose must be a 7-element list, got {0}".format(
len(args.pose)))
app = Application(name="End Effector Control", modules=['sight'])
# add controller subgraph/codelets
lqr_interface, cartesian_planner = add_cartesian_control(
app, args.arm, args.end_effector, args.pose, args.speed,
args.acceleration)
# load sim subgraph or driver codelet
if args.mode == 'sim':
app.load("packages/navsim/apps/navsim_tcp.subgraph.json",
prefix="simulation")
sim_in = app.nodes["simulation.interface"]["input"]
sim_out = app.nodes["simulation.interface"]["output"]
app.connect(sim_out, "joint_state", lqr_interface, "joint_state")
app.connect(sim_out, "joint_state", cartesian_planner, "joint_state")
app.connect(lqr_interface, "joint_command", sim_in, "joint_position")
elif args.mode == 'hardware':
if args.arm == 'kinova':
app.load_module("kinova_jaco")
arm = app.add("arm").add(app.registry.isaac.kinova_jaco.KinovaJaco)
arm.config.kinematic_tree = "lqr.kinematic_tree"
arm.config.kinova_jaco_sdk_path = args.kinova_api
arm.config.tick_period = "10ms"
# for kinova hardware we use speed control, since it's much smoother. angle control
# seems to only able to move one joint at a time and thus very jerky
arm.config.control_mode = "joint velocity"
controller = app.nodes["lqr.controller"]["MultiJointController"]
controller.config.control_mode = "speed"
controller.config.command_delay = 0.1
app.load("packages/flatsim/apps/flatsim.subgraph.json", prefix="flatsim")
app.load("packages/flatsim/apps/{}.json".format(demo))
if args.build_graph:
app.load(
"packages/path_planner/apps/pose2_graph_builder.subgraph.json")
if args.use_graph_planner:
app.load("packages/flatsim/apps/pose2_graph_planner.config.json")
if (args.robot):
app.load("packages/flatsim/apps/{}.config.json".format(args.robot))
if args.mission_robot_name:
# Load the mission subgraph and set the config based on the input parameters
app.load("packages/behavior_tree/apps/missions.graph.json")
app.nodes["tcp_client"].components["JsonTcpClient"].config[
"host"] = args.mission_host
app.nodes["tcp_client"].components["JsonTcpClient"].config[
"port"] = args.mission_port
app.nodes["mission_control"].components["NodeGroup"].config["node_names"] = \
["flatsim.goals.goal_behavior"]
app.nodes["robot_name"].components["JsonMockup"].config["json_mock"] = \
{"text":args.mission_robot_name}
app.nodes["flatsim.goals.goal_behavior"].config[
"disable_automatic_start"] = True
# Send the navigation output back through the json tcp client
app.connect(
app.nodes["flatsim.navigation.subgraph"].components["interface"],
"feedback", app.nodes["tcp_client"].components["JsonTcpClient"],
"feedback")
app.run()
] * len(arm_joint_names)
# Load driver/sim subgraph, use driver_in / driver_out as the component for arm and camera data
if args.hardware:
# Placeholder, should add hardware subgraph for each arm later
raise ValueError("Hardware not supported for arm {0}".format(args.arm))
else:
# Omniverse needs to be running and configured properly. Load the subgraphs required for
# connecting to Omniverse.
app.load('packages/navsim/apps/navsim_tcp.subgraph.json', 'simulation')
driver_in = app.nodes['simulation.interface']['input']
driver_out = app.nodes['simulation.interface']['output']
# Connect the LQR planner arm input/output
controller_interface = app.nodes['controller.subgraph']['interface']
app.connect(driver_out, 'joint_state', controller_interface, 'joint_state')
app.connect(controller_interface, 'joint_command', driver_in,
'joint_position')
# The mission tasks used in this example: picking and placing objects.
task_graphs = [
app.nodes['pick_task.interface']['Subgraph'],
app.nodes['place_task.interface']['Subgraph']
]
# Go through all task graphs and connect their channels to the appropriate infrastructure nodes.
for task_graph in task_graphs:
# Connect the edges between the task, the controller, and the state observation node.
app.connect(driver_out, 'joint_state', task_graph, 'joint_state')
app.connect(task_graph, 'joint_command', controller_interface,
'joint_target')
# Create and start the app
app = Application(name="Shuffle Box")
# load bebavior subgraph. this contains the sequency behavior to move the arm between
# waypoints and control suction on/off
app.load("apps/samples/manipulation/shuffle_box_behavior.subgraph.json",
prefix="behavior")
behavior_interface = app.nodes["behavior.interface"]["subgraph"]
app.nodes["behavior.atlas"]["CompositeAtlas"].config.cask = args.cask
app.load("packages/planner/apps/multi_joint_lqr_control.subgraph.json",
prefix="lqr")
# load multi joint lqr control subgraph
lqr_interface = app.nodes["lqr.subgraph"]["interface"]
kinematic_tree = app.nodes["lqr.kinematic_tree"]["KinematicTree"]
lqr_planner = app.nodes["lqr.local_plan"]["MultiJointLqrPlanner"]
app.connect(behavior_interface, "joint_target", lqr_interface,
"joint_target")
kinematic_tree.config.kinematic_file = kinematic_file
lqr_planner.config.speed_min = [-1.5] + [-1.0] * (len(joints) - 1)
lqr_planner.config.speed_max = [1.5] + [1.0] * (len(joints) - 1)
lqr_planner.config.acceleration_min = [-1.5] + [-1.0] * (len(joints) - 1)
lqr_planner.config.acceleration_max = [1.5] + [1.0] * (len(joints) - 1)
# load perception subgraph for KLTBox detection in ur10 usecase
use_perception = False
if args.arm == "ur10":
use_perception = True
app.load(
"packages/object_pose_estimation/apps/pose_cnn_decoder" \
"/detection_pose_estimation_cnn_inference.subgraph.json",
prefix="detection_pose_estimation")
perception_interface = app.nodes[
def main(args):
app = Application(name="detect_net_inference")
# Load subgraph and get interface node
app.load("packages/detect_net/apps/detect_net_inference.subgraph.json",
prefix="detect_net_inference")
detect_net_inferface = app.nodes["detect_net_inference.subgraph"]\
.components["interface"]
# Load configuration
app.load(args.config)
# Configure detection model
detection_model = app.nodes["detect_net_inference.tensor_r_t_inference"]\
.components["isaac.ml.TensorRTInference"]
if args.detection_model_file_path is not None:
detection_model.config.model_file_path = args.detection_model_file_path
if args.etlt_password is not None:
detection_model.config.etlt_password = args.etlt_password
# Configure detection decoder
decoder = app.nodes["detect_net_inference.detection_decoder"]\
.components["isaac.detect_net.DetectNetDecoder"]
decoder.config.output_scale = [args.rows, args.cols]
if args.confidence_threshold is not None:
decoder.config.confidence_threshold = args.confidence_threshold
if args.nms_threshold is not None:
decoder.config.non_maximum_suppression_threshold = args.nms_threshold
if args.mode == 'cask':
# Load replay subgraph and configure interface node
app.load("packages/cask/apps/replay.subgraph.json", prefix="replay")
replay_interface = app.nodes["replay.interface"].components["output"]
replay_interface.config.cask_directory = args.cask_directory
# Connect the output of the replay subgraph to the detection subgraph
app.connect(replay_interface, "color", detect_net_inferface, "image")
elif args.mode == 'sim':
# Load simulation subgraph and get interface node
app.load("packages/navsim/apps/navsim_training.subgraph.json",\
prefix="simulation")
simulation_interface = app.nodes["simulation.interface"].components[
"output"]
# Connect the output of the simulation with user-specified channel to the detection subgraph
app.connect(simulation_interface, args.image_channel,
detect_net_inferface, "image")
elif args.mode == 'realsense':
app.load_module('realsense')
# Create and configure realsense camera codelet
camera = app.add("camera").add(app.registry.isaac.RealsenseCamera)
camera.config.rows = args.rows
camera.config.cols = args.cols
camera.config.color_framerate = args.fps
camera.config.depth_framerate = args.fps
camera.config.enable_ir_stereo = False
# Connect the output of the camera node to the detection subgraph
app.connect(camera, "color", detect_net_inferface, "image")
elif args.mode == 'v4l':
app.load_module('sensors:v4l2_camera')
# Create and configure V4L camera codelet
camera = app.add("camera").add(app.registry.isaac.V4L2Camera)
camera.config.device_id = 0
camera.config.rows = args.rows
camera.config.cols = args.cols
camera.config.rate_hz = args.fps
# Connect the output of the camera node to the detection subgraph
app.connect(camera, "frame", detect_net_inferface, "image")
elif args.mode == 'image':
app.load_module('message_generators')
# Create feeder node
feeder = app.add("feeder").add(
app.registry.isaac.message_generators.ImageLoader)
feeder.config.color_glob_pattern = args.image_directory
feeder.config.tick_period = "1Hz"
# Connect the output of the image feeder node to the detection subgraph
app.connect(feeder, "color", detect_net_inferface, "image")
else:
raise ValueError('Not supported mode {}'.format(args.mode))
app.run()
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']
tracker.config.horizontal_stereo_camera = True
tracker.config.process_imu_readings = args.imu
tracker.config.lhs_camera_frame = "zed_left_camera"
tracker.config.rhs_camera_frame = "zed_right_camera"
tracker.config.imu_frame = "zed_imu"
if (args.imu):
camera_imu_reader = app.nodes['camera'].add(
app.registry.isaac.zed.ZedImuReader)
camera_imu_reader.config.tick_period = "300Hz"
camera_imu_reader.config.vendor_imu_calibration = False
app.connect(camera_imu_reader, "imu_raw", svo_interface, "imu")
app.connect(camera, "left_camera_gray", svo_interface, "left_image")
app.connect(camera, "left_intrinsics", svo_interface, "left_intrinsics")
app.connect(camera, "right_camera_gray", svo_interface, "right_image")
app.connect(camera, "right_intrinsics", svo_interface, "right_intrinsics")
app.run()
"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")
simulation_interface = app.nodes['simulation.interface']
simulation_output = simulation_interface["output"]
# connect the simulation with navigation stack
navigation_interface = app.nodes['navigation.subgraph'].components[
'interface']
app.connect(simulation_output, "base_state", navigation_interface, "state")
app.connect(simulation_output, "imu_raw", navigation_interface, "imu_raw")
noisy = simulation_interface["noisy"]
app.connect(noisy, "flatscan", navigation_interface,
"flatscan_for_localization")
app.connect(noisy, "flatscan", navigation_interface,
"flatscan_for_obstacles")
app.connect(navigation_interface, "command", simulation_interface["input"],
"base_command")
# connect the navigation with goals
goals_interface = app.nodes['goals.subgraph'].components['interface']
app.connect(goals_interface, "goal", navigation_interface, "goal")
app.connect(navigation_interface, "feedback", goals_interface, "feedback")
# connect the simulation mini Sight with navigation
def main(args):
app = Application(name="dope_inference")
# Load dope inference subgraph
app.load(
"packages/object_pose_estimation/apps/dope/dope_inference.subgraph.json",
"detection_pose_estimation")
detection_pose_estimation_interface = app.nodes[
"detection_pose_estimation.interface"]["subgraph"]
if args.mode == 'cask':
# Load replay subgraph and configure interface node
app.load("packages/cask/apps/replay.subgraph.json", prefix="replay")
replay = app.nodes["replay.interface"].components["output"]
replay.config.cask_directory = args.file
app.connect(replay, "color", detection_pose_estimation_interface,
"color")
app.connect(replay, "color_intrinsics",
detection_pose_estimation_interface, "intrinsics")
elif args.mode == "realsense":
app.load_module('realsense')
# Create and configure realsense camera codelet
camera = app.add("camera").add(app.registry.isaac.RealsenseCamera)
camera.config.rows = 360
camera.config.cols = 640
camera.config.color_framerate = 15
camera.config.depth_framerate = 15
camera.config.enable_ir_stereo = False
app.connect(camera, "color", detection_pose_estimation_interface,
"color")
app.connect(camera, "color_intrinsics",
detection_pose_estimation_interface, "intrinsics")
elif args.mode == "sim":
app.load(filename='packages/navsim/apps/navsim_tcp.subgraph.json',
prefix='simulation')
sim = app.nodes["simulation.interface"]["output"]
app.connect(sim, "color", detection_pose_estimation_interface, "color")
app.connect(sim, "color_intrinsics",
detection_pose_estimation_interface, "intrinsics")
elif args.mode == "image":
app.load_module("message_generators")
image_loader = app.add("image").add(
app.registry.isaac.message_generators.ImageLoader, "ImageLoader")
image_loader.config.color_filename = args.file
image_loader.config.tick_period = "1Hz"
app.connect(image_loader, "color", detection_pose_estimation_interface,
"color")
# Create intrinsic node
intrinsic = app.add("intrinsic").add(
app.registry.isaac.message_generators.CameraIntrinsicsGenerator)
intrinsic.config.focal_length = [args.focal, args.focal]
intrinsic.config.optical_center = args.optical_center
intrinsic.config.distortion_coefficients = [
0.01, 0.01, 0.01, 0.01, 0.01
]
app.connect(image_loader, "color", intrinsic, "image")
app.connect(intrinsic, "intrinsics",
detection_pose_estimation_interface, "intrinsics")
# TensorRT inference
trt = app.nodes["detection_pose_estimation.inference"]["TensorRTInference"]
trt.config.model_file_path = args.model
dir, filename = os.path.split(args.model)
trt.config.engine_file_path = "{0}/{1}.plan".format(
dir,
os.path.splitext(filename)[0])
# Dope decoder
decoder = app.nodes["detection_pose_estimation.decoder"]["DopeDecoder"]
decoder.config.box_dimensions = args.box
decoder.config.label = args.label
# Detections3Viewer
detection3_viewer = app.nodes["detection_pose_estimation.viewers"][
"Detections3Viewer"]
detection3_viewer.config.box_dimensions = args.box
if args.camera_pose is not None:
app.load_module("utils")
pose_node = app.add("pose")
detection_injector = pose_node.add(
app.registry.isaac.utils.DetectionsToPoseTree)
detection_injector.config.detection_frame = "camera"
app.connect(decoder, "output_poses", detection_injector, "detections")
camera_initializer = pose_node.add(
app.registry.isaac.alice.PoseInitializer)
camera_initializer.config.lhs_frame = "world"
camera_initializer.config.rhs_frame = "camera"
camera_initializer.config.pose = args.camera_pose
app.run()
dest='rows',
type=int,
default=720,
help='The vertical resolution of the camera images')
parser.add_argument('--cols',
dest='cols',
type=int,
default=1280,
help='The horizontal resolution of the camera images')
args, _ = parser.parse_known_args()
app = Application(name="record_dummy",
modules=["message_generators", "cask"])
app.load_module('sight')
# Create recorder node
app.load_module('cask')
recorder = app.add("recorder").add(app.registry.isaac.cask.Recorder)
recorder.config.base_directory = args.base_directory
# Create dummy camera codelet
camera = app.add("cam").add(
app.registry.isaac.message_generators.CameraGenerator)
camera.config.rows = args.rows
camera.config.cols = args.cols
camera.config.tick_period = str(args.fps) + "Hz"
app.connect(camera, "color_left", recorder, "color")
app.connect(camera, "depth", recorder, "depth")
app.run()
args, _ = parser.parse_known_args()
app = Application(name="record_realsense",
modules=["cask", "realsense", "sight"])
if args.mode == '720p':
rows = 720
cols = 1280
elif args.mode == '640x480':
rows = 640
cols = 480
else:
raise ValueError('Not supported camera resolution')
# Create recorder node
recorder = app.add("recorder").add(app.registry.isaac.cask.Recorder)
recorder.config.base_directory = args.base_directory
# Create realsense camera codelet
camera = app.add("cam").add(app.registry.isaac.RealsenseCamera)
camera.config.rows = rows
camera.config.cols = cols
camera.config.color_framerate = args.fps
camera.config.depth_framerate = args.fps
app.connect(camera, "color", recorder, "color")
app.connect(camera, "color_intrinsics", recorder, "color_intrinsics")
app.connect(camera, "depth", recorder, "depth")
app.connect(camera, "depth_intrinsics", recorder, "depth_intrinsics")
app.run()
class TestApplication(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_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 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 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_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_module_explorer(self):
self._app = Application()
self._app.load_module('json')
self._app.registry.isaac.json.JsonToProto
with self.assertRaises(RuntimeError):
self._app.registry.isaac.foo
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_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_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_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()
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_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_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 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_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_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_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_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')
app.load(
"packages/navigation/apps/differential_base_imu_odometry.subgraph.json",
"odometry")
app.load(
"packages/navigation/apps/differential_base_commander.subgraph.json",
"commander")
app.load(
"packages/visual_slam/apps/stereo_visual_odometry_rgb.subgraph.json",
"svo")
simulation_interface = app.nodes['simulation.interface']
simulation_output = simulation_interface["output"]
# connect the simulation with the odometry and commander
odometry_interface = app.nodes['odometry.subgraph'].components['interface']
app.connect(simulation_output, "base_state", odometry_interface,
"base_state")
app.connect(simulation_output, "imu_raw", odometry_interface, "imu_raw")
commander_interface = app.nodes['commander.subgraph'].components[
'interface']
app.connect(commander_interface, "command", simulation_interface["input"],
"base_command")
# connect the simulation with SVIO
svo_interface = app.nodes['svo.subgraph'].components['interface']
app.connect(simulation_output, "color_left", svo_interface, "left_image")
app.connect(simulation_output, "color_left_intrinsics", svo_interface,
"left_intrinsics")
app.connect(simulation_output, "color_right", svo_interface, "right_image")
app.connect(simulation_output, "color_right_intrinsics", svo_interface,
"right_intrinsics")
app = Application(name='station_mission', modules=['engine_tcp_udp', 'sight'])
app.nodes["websight"]["WebsightServer"].config.port = args.sight_port
# Add TCP publisher for task
simulation_node = app.add("simulation")
simulation_node.add(app.registry.isaac.alice.TimeSynchronizer)
tcp_publisher = simulation_node.add(app.registry.isaac.alice.TcpPublisher)
tcp_publisher.config.port = args.sim_port
task_manager_node = app.add("task_manager")
cube_manager = task_manager_node.add(TeleportManager, 'CubeManager')
cube_manager.config.num_assets = args.num_cubes
cube_manager.config.type = 'cube'
cube_manager.config.name = "/environments/cubes/green_block_{0:02d}/Cube"
app.connect(cube_manager, "teleport", tcp_publisher, "teleport")
mission_server = MissionServer(port=args.mission_port)
station_manager = task_manager_node.add(RobotManager, 'StationManager')
station_manager.config.idle_threshold = 3
station_manager.config.robot_name = "station"
task_manager_node.add(MissionCoordinator, 'MissionCoordinator')
scenario = Scenario(["station", "cube"])
# Set scenario and mission server (if applicable) for all PyCodelets
for _, frontend in app._pycodelet_frontends.items():
frontend.scenario = scenario
if isinstance(frontend, RobotManager):
frontend.mission_server = mission_server
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited.
'''
from isaac import Application
import argparse
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Measures recording performance')
args = parser.parse_args()
app = Application(name="write_speed_test", modules=[
"message_generators",
"cask",
"sight",
])
img_gen_node = app.add("img_gen")
img_gen = img_gen_node.add(app.registry.isaac.message_generators.CameraGenerator)
img_gen.config.rows = 720
img_gen.config.cols = 1080
img_gen.config.tick_period = "15 Hz"
recorder_node = app.add("recorder")
recorder = recorder_node.add(app.registry.isaac.cask.Recorder)
recorder.config.use_compression = True
app.connect(img_gen, "color_left", recorder, "img1")
app.connect(img_gen, "color_right", recorder, "img2")
app.start_wait_stop(duration=10.0)
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))
app.run()
'realsense',
])
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.RealsenseCamera)
camera.config.align_to_color = False
camera.config.auto_exposure_priority = False
camera.config.enable_color = False
camera.config.cols = 640
camera.config.rows = 360
camera.config.enable_depth = False
camera.config.enable_depth_laser = False
camera.config.enable_ir_stereo = True
camera.config.ir_framerate = 30
tracker = app.nodes['svo.tracker'].components['StereoVisualOdometry']
tracker.config.horizontal_stereo_camera = True
tracker.config.process_imu_readings = False
tracker.config.lhs_camera_frame = "left_ir_camera"
tracker.config.rhs_camera_frame = "right_ir_camera"
app.connect(camera, "left_ir", svo_interface, "left_image")
app.connect(camera, "left_ir_intrinsics", svo_interface, "left_intrinsics")
app.connect(camera, "right_ir", svo_interface, "right_image")
app.connect(camera, "right_ir_intrinsics", svo_interface, "right_intrinsics")
app.run()
camera_out_channel = "color"
elif args.camera == "v4l2":
camera = app.add('input_images').add(app.registry.isaac.V4L2Camera)
if args.device_id == None:
raise ValueError('Could not set None. Please provide device id')
camera.config.device_id = args.device_id
camera.config.cols, camera.config.rows = tuple(
[int(arg) for arg in args.resolution.split('x')])
camera.config.rate_hz = args.framerate
camera_out_channel = "frame"
else:
raise ValueError('Not supported Camera type {}'.format(args.camera))
# Setup april tag node
tags_detection = app.add('april_tags_detection').add(
app.registry.isaac.fiducials.AprilTagsDetection)
tags_detection.config.max_tags = 50
fiducials_viewer = app.nodes['april_tags_detection'].add(
app.registry.isaac.viewers.FiducialsViewer)
# Setup viewer node
viewer = app.add('image_viewers').add(
app.registry.isaac.viewers.ImageViewer)
# Connect message channels
app.connect(camera, camera_out_channel, tags_detection, "image")
app.connect(camera, "intrinsics", tags_detection, "intrinsics")
app.connect(tags_detection, "april_tags", fiducials_viewer, "fiducials")
app.connect(camera, camera_out_channel, viewer, "image")
app.load("apps/samples/april_tags/april_tags_python.config.json")
app.run()
def main(args):
# Check that the provided directories are different, otherwise
if (args.base_directory_images == args.base_directory_gt):
print("Base directory for image and ground truth logs must not be the same.")
return
app = Application(name="record_sim_ground_truth", modules=["viewers"])
app_uuid = app.uuid
# Load simulation subgraph and get interface node
app.load("packages/navsim/apps/navsim_training.subgraph.json",\
prefix="simulation")
simulation_interface = app.nodes["simulation.interface"].components["output"]
# Load record subgraph for images
app.load("packages/cask/apps/record.subgraph.json", prefix="image_record")
image_record_interface = app.nodes["image_record.interface"].components["input"]
image_record_interface.config.base_directory = args.base_directory_images
# Load record subgraph for ground truth
app.load("packages/cask/apps/record.subgraph.json", prefix="ground_truth_record")
ground_truth_record_interface = app.nodes["ground_truth_record.interface"].components["input"]
ground_truth_record_interface.config.base_directory = args.base_directory_gt
# Create viewer codelets
image_viewer = app.add("image_viewer").add(app.registry.isaac.viewers.ImageViewer)
image_viewer.config.camera_name = "camera"
# Connect the image and bounding boxes channels to the record interface
app.connect(simulation_interface, args.image_channel, image_record_interface, "color")
app.connect(simulation_interface, args.image_channel, image_viewer, "image")
app.connect(simulation_interface, args.intrinsics_channel, image_record_interface,\
"color_intrinsics")
app.connect(simulation_interface, args.intrinsics_channel, image_viewer, "intrinsics")
# Set the scenario manager config options if scene name is provided
if (args.scenario_scene is not None):
print(args.detections3viewer_box_dimensions)
scenario_manager = app.nodes["simulation.scenario_manager"].components["scenario_manager"]
scenario_manager.config.scene = args.scenario_scene
if (args.scenario_robot_prefab is not None):
scenario_manager.config.robot_prefab = args.scenario_robot_prefab
# Connect ground truth data channels according to user input
mode = args.mode
if (mode == 'bounding_box' or mode == 'all'):
detections_viewer = app.add("detections_viewer").add(
app.registry.isaac.viewers.DetectionsViewer)
bbox_conversion = app.nodes["simulation.bounding_boxes"].components["conversion"]
app.connect(simulation_interface, args.segmentation_channel + "_class", bbox_conversion,
"class_segmentation")
app.connect(simulation_interface, args.segmentation_channel + "_instance",
bbox_conversion, "instance_segmentation")
app.connect(simulation_interface, args.segmentation_channel + "_labels", bbox_conversion,
"class_labels")
app.connect(simulation_interface, "bounding_boxes", ground_truth_record_interface,
"bounding_boxes")
app.connect(simulation_interface, "bounding_boxes", detections_viewer, "detections")
if (mode == 'pose' or mode == 'all'):
app.load_module('ml')
detections3_viewer = app.add("detections3_viewer").add(
app.registry.isaac.viewers.Detections3Viewer)
pose_bodies = app.add("rigid_body_to_detections3").add(
app.registry.isaac.ml.RigidbodyToDetections3)
detections3_viewer.config.frame = "camera"
if (args.detections3viewer_box_dimensions is not None):
# Enable 3D detections in the viewer
detections3_viewer.config.box_dimensions = eval(args.detections3viewer_box_dimensions)
detections3_viewer.config.object_T_box_center = eval(
args.detections3viewer_object_T_box_center)
app.connect(simulation_interface, "bodies", pose_bodies, "rigid_bodies")
app.connect(pose_bodies, "detections", ground_truth_record_interface, "gt_poses")
app.connect(pose_bodies, "detections", detections3_viewer, "detections")
app.connect(simulation_interface, args.intrinsics_channel, ground_truth_record_interface,
"image_intrinsics")
# Run application
app.run(args.runtime)
# Write metadata to JSON data per output cask. The metadata servers to associate
# corresponding image and ground truth casks. As per RACI evaluation workflow
# and data management, image casks and ground truth casks are stored in separate
# directories.
if args.raci_metadata:
# Populate image cask metadata
image_metadata_json = {}
image_metadata_json["Robot_Name"] = ""
image_metadata_json["Location/Scene"] = ""
image_metadata_json["Domain"] = "simulation"
image_metadata_json["Recording_Time"] = str(datetime.datetime.now().strftime("%Y-%m-%d"))
# Write image cask metadata
image_metadata_path = os.path.join(args.base_directory_images, app_uuid + "_md.json")
with open(image_metadata_path, 'w') as f:
json.dump(image_metadata_json, f, indent=2)
# Populate ground truth cask metadata
ground_truth_metadata_json = {}
ground_truth_metadata_json["Image_Cask_File"] = app.uuid
ground_truth_metadata_json["Data_Source"] = "ground_truth"
# Write ground truth cask metadata
ground_truth_metadata_path = os.path.join(args.base_directory_gt, app_uuid + "_md.json")
with open(ground_truth_metadata_path, 'w') as f:
json.dump(ground_truth_metadata_json, f, indent=2)
