def unique_identifier(self): """ Return the unique identifier for this network, if it has one. If no identifier.yaml found (or we don't even have a model params folder) then return None :return: :rtype: """ try: path_to_network_params_folder = self.path_to_network_params_folder except ValueError: return None identifier_file = os.path.join(path_to_network_params_folder, 'identifier.yaml') if not os.path.exists(identifier_file): return None if not self.constructed_from_model_folder: return None d = utils.getDictFromYamlFilename(identifier_file) unique_identifier = d['id'] + "+" + self.config[ 'model_param_filename_tail'] return unique_identifier
def main(): model_file, dataset_name = get_DD_model_file() dataset_paths = exp_utils.get_dataset_paths(dataset_name) dataset_root = dataset_paths['dataset_root'] multi_episode_dict = DCDrakeSimEpisodeReader.load_dataset(dataset_root, max_num_episodes=None) camera_list = ['camera_1_top_down'] model_config_file = os.path.join(os.path.dirname(model_file), 'config.yaml') model_config = getDictFromYamlFilename(model_config_file) model_config['dataset']['data_augmentation'] = False dataset = DynamicDrakeSimDataset(model_config, multi_episode_dict, phase="valid") # could also use train data model = torch.load(model_file) model = model.cuda() model = model.eval() heatmap_vis = HeatmapVisualization(model_config, dataset, model, visualize_3D=False, camera_list=camera_list, verbose=True, sample_same_episode=False, display_confidence_value=False, use_custom_target_image_func=True) heatmap_vis.run()
def load_default_config(): dc_source_dir = utils.getDenseCorrespondenceSourceDir() config_file = os.path.join(dc_source_dir, 'config', 'dense_correspondence', 'training', 'training.yaml') config = utils.getDictFromYamlFilename(config_file) return config
def load_default_config(): dc_source_dir = utils.getDenseCorrespondenceSourceDir() config_file = os.path.join(dc_source_dir, 'config', 'dense_correspondence', 'training', 'training.yaml') config = utils.getDictFromYamlFilename(config_file) return config
def get_descriptor_target_from_yaml(self): """ Grabs a 1-dimensional numpy array of length D from the descriptor yaml file """ descriptor_filename = os.path.join(pdc_utils.getDenseCorrespondenceSourceDir(), "../config", "new_descriptor_picked.yaml") descriptor_dict = pdc_utils.getDictFromYamlFilename(descriptor_filename) descriptor_list = descriptor_dict["descriptor"] return np.asarray(descriptor_list)
def load_specific_dataset(self): dataset_config_filename = os.path.join( utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'rope_nonrigid_412vert_only.yaml') dataset_config = utils.getDictFromYamlFilename(dataset_config_filename) self._dataset = SpartanDataset(config=dataset_config)
def load_pick_point_config(self): """ Loads the config for the pick point. Stores the information on - which network to use - the descriptor to look for """ config_filename = os.path.join(get_config_directory(), PICK_POINT_CONFIG_FILENAME) self.pick_point_config = pdc_utils.getDictFromYamlFilename(config_filename)
def from_data_folder(data_folder, config=None): fr = FusionReconstruction() fr.data_dir = data_folder if config is None: config = FusionReconstruction.load_default_config() pose_data_filename = os.path.join(data_folder, 'images', 'pose_data.yaml') camera_info_filename = os.path.join(data_folder, 'images', 'camera_info.yaml') fr.config = config fr.kinematics_pose_data = utils.getDictFromYamlFilename(pose_data_filename) fr.camera_info = utils.getDictFromYamlFilename(camera_info_filename) fr.fusion_posegraph_filename = os.path.join(data_folder, 'images.posegraph') fr.fusion_pose_data.first_frame_to_world = transformUtils.copyFrame(fr._reconstruction_to_world) fr.reconstruction_filename = os.path.join(fr.data_dir, 'images.vtp') fr.setup() return fr
def load_specific_dataset(self): dataset_config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'caterpillar_only_9.yaml') # dataset_config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', # 'dense_correspondence', # 'dataset', 'composite', '4_shoes_all.yaml') # st() dataset_config = utils.getDictFromYamlFilename(dataset_config_filename) self._dataset = SpartanDataset(config=dataset_config)
def load_specific_dataset(self): dataset_config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'hats_3_demo_composite.yaml') dataset_config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', '4_shoes_all.yaml') dataset_config = utils.getDictFromYamlFilename(dataset_config_filename) self._dataset = SpartanDataset(config=dataset_config)
def load_training_dataset(self): """ Loads the dataset that this was trained on :return: a dataset object, loaded with the config as set in the dataset.yaml :rtype: SpartanDataset """ network_params_folder = self.path_to_network_params_folder network_params_folder = utils.convert_to_absolute_path(network_params_folder) dataset_config_file = os.path.join(network_params_folder, 'dataset.yaml') config = utils.getDictFromYamlFilename(dataset_config_file) return SpartanDataset(config_expanded=config)
def from_data_folder(data_folder, config=None, name=None, load_foreground_mesh=True): """ :param data_folder: The 'processed' subfolder of a top level log folder :type data_folder: :param config: YAML file containing parameters. The default file is change_detection.yaml. This file contains the parameters used to crop the fusion reconstruction and extract the foreground. :type config:YAML file :param name: :type name: :return: :rtype: """ fr = TSDFReconstruction(load_foreground_mesh) fr.data_dir = data_folder if name is None: name = "" if config is None: print "no config passed in, loading default" config = FusionReconstruction.load_default_config() pose_data_filename = os.path.join(data_folder, 'images', 'pose_data.yaml') camera_info_filename = os.path.join(data_folder, 'images', 'camera_info.yaml') fr.config = config fr.name = name fr.kinematics_pose_data = utils.getDictFromYamlFilename( pose_data_filename) fr.camera_info = utils.getDictFromYamlFilename(camera_info_filename) fr.setup() return fr
def from_model_folder(model_folder, load_stored_params=True, model_param_file=None, iteration=None): """ Loads a DenseCorrespondenceNetwork from a model folder :param model_folder: the path to the folder where the model is stored. This direction contains files like - 003500.pth - training.yaml :type model_folder: :return: a DenseCorrespondenceNetwork objecc t :rtype: """ model_folder = utils.convert_to_absolute_path(model_folder) if model_param_file is None: model_param_file, _, _ = utils.get_model_param_file_from_directory(model_folder, iteration=iteration) model_param_file = utils.convert_to_absolute_path(model_param_file) training_config_filename = os.path.join(model_folder, "training.yaml") training_config = utils.getDictFromYamlFilename(training_config_filename) config = training_config["dense_correspondence_network"] config["path_to_network_params_folder"] = model_folder fcn = resnet_dilated.Resnet34_8s(num_classes=config['descriptor_dimension']) dcn = DenseCorrespondenceNetwork(fcn, config['descriptor_dimension'], image_width=config['image_width'], image_height=config['image_height']) # load the stored params if load_stored_params: # old syntax try: dcn.load_state_dict(torch.load(model_param_file)) except: logging.info("loading params with the new style failed, falling back to dcn.fcn.load_state_dict") dcn.fcn.load_state_dict(torch.load(model_param_file)) # this is the new format # dcn.cuda() dcn.train() dcn.config = config return dcn
def make_default_caterpillar(): """ Makes a default SpartanDatase from the 10_scenes_drill data :return: :rtype: """ config_file = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'caterpillar_only.yaml') config = utils.getDictFromYamlFilename(config_file) dataset = SpartanDataset(mode="train", config=config) return dataset
def from_data_folder(data_folder, config=None, name=None): fr = TSDFReconstruction() fr.data_dir = data_folder if name is None: name = "" if config is None: print "no config passed in, loading default" config = FusionReconstruction.load_default_config() pose_data_filename = os.path.join(data_folder, 'images', 'pose_data.yaml') camera_info_filename = os.path.join(data_folder, 'images', 'camera_info.yaml') fr.config = config fr.name = name fr.kinematics_pose_data = utils.getDictFromYamlFilename(pose_data_filename) fr.camera_info = utils.getDictFromYamlFilename(camera_info_filename) fr.reconstruction_filename = os.path.join(fr.data_dir, 'fusion_mesh.ply') fr.setup() return fr
def load_dcn_network(self): """ Loads the DCN. """ config = pdc_utils.getDictFromYamlFilename(NETWORK_CONFIG_FILENAME) defaults_config = pdc_utils.get_defaults_config() pdc_utils.set_cuda_visible_devices([0]) dce = DenseCorrespondenceEvaluation(config) self.dcn = dce.load_network_from_config(NETWORK_NAME) self.dcn.eval() self.dataset = self.dcn.load_training_dataset( ) # why do we need to do this? print "finished loading dcn"
def __init__(self, config_filename='shoes_all.yaml'): with HiddenPrints(): self.config_filename = os.path.join( utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', config_filename) self.train_config_filename = os.path.join( utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'training', 'training.yaml') self.config = utils.getDictFromYamlFilename(self.config_filename) self.train_config = utils.getDictFromYamlFilename( self.train_config_filename) self.dataset = SpartanDataset(config=self.config) self.dataset.set_parameters_from_training_config(self.train_config) # holds centroid and radius for each scene # these are for min and max z values currently. maybe include x, y, and z in the future. # self.centroid_and_radius[scene_name]["centroid"] or self.centroid_and_radius[scene_name]["radius"] self.centroid_and_radius = {}
def main(): dataset_name = "push_box_hardware" dataset_name = "push_box_string_pull" model_file = None if dataset_name == "push_box_hardware": model_file = "/home/manuelli/data_ssd/key_dynam/trained_models/perception/dense_descriptors/2020-02-27-00-32-58_3D_loss_resnet50__dataset_real_push_box/net_dy_epoch_3_iter_1000_model.pth" elif dataset_name == "push_box_string_pull": # model_name = "data_aug_2020-07-02-02-39-27-400442" # model_file = os.path.join(get_data_root(), 'dev/experiments/22/dataset_push_box_string_pull/net_') model_file = "/home/manuelli/data/key_dynam/dev/experiments/22/dataset_push_box_string_pull/trained_models/perception/dense_descriptors/data_aug_2020-07-02-02-39-27-400442/net_best_model.pth" # dataset_paths = exp_utils.get_dataset_paths(dataset_name) dataset_paths = exp_utils.get_dataset_paths("push_box_hardware") episodes_config = dataset_paths['episodes_config'] episodes_root = dataset_paths['dataset_root'] multi_episode_dict = DCDynamicSpartanEpisodeReader.load_dataset(config=episodes_config, episodes_root=episodes_root) camera_list = ['d415_01'] target_camera_list = ['d415_01'] config = dev_utils.load_dataset_config() model_config_file = os.path.join(os.path.dirname(model_file), 'config.yaml') model_config = getDictFromYamlFilename(model_config_file) # model_config['dataset']['data_augmentation'] = False config['dataset']['data_augmentation'] = False dataset = DynamicDrakeSimDataset(config, multi_episode_dict, phase="train") # could also use train data model = torch.load(model_file) model = model.cuda() model = model.eval() heatmap_vis = HeatmapVisualization(config, dataset, model, visualize_3D=False, camera_list=camera_list, verbose=True, sample_same_episode=False, display_confidence_value=True, use_custom_target_image_func=False, target_camera_names=target_camera_list) heatmap_vis.run()
def from_data_folder(data_folder, config=None, name=None): """ :param data_folder: The 'processed' subfolder of a top level log folder :type data_folder: :param config: :type config: :param name: :type name: :return: :rtype: """ fr = TSDFReconstruction() fr.data_dir = data_folder if name is None: name = "" if config is None: print "no config passed in, loading default" config = FusionReconstruction.load_default_config() pose_data_filename = os.path.join(data_folder, 'images', 'pose_data.yaml') camera_info_filename = os.path.join(data_folder, 'images', 'camera_info.yaml') fr.config = config fr.name = name fr.kinematics_pose_data = utils.getDictFromYamlFilename( pose_data_filename) fr.camera_info = utils.getDictFromYamlFilename(camera_info_filename) fr.reconstruction_filename = os.path.join(fr.data_dir, 'fusion_mesh.ply') fr.setup() return fr
def from_data_folder(data_folder, config=None): fr = FusionReconstruction() fr.data_dir = data_folder if config is None: config = FusionReconstruction.load_default_config() pose_data_filename = os.path.join(data_folder, 'images', 'pose_data.yaml') camera_info_filename = os.path.join(data_folder, 'images', 'camera_info.yaml') fr.config = config fr.kinematics_pose_data = utils.getDictFromYamlFilename( pose_data_filename) fr.camera_info = utils.getDictFromYamlFilename(camera_info_filename) fr.fusion_posegraph_filename = os.path.join(data_folder, 'images.posegraph') fr.fusion_pose_data.first_frame_to_world = transformUtils.copyFrame( fr._reconstruction_to_world) fr.reconstruction_filename = os.path.join(fr.data_dir, 'images.vtp') fr.setup() return fr
def load_dcn_network(self): """ Loads the DCN. Currently just edit this function to change which """ config = pdc_utils.getDictFromYamlFilename(NETWORK_CONFIG_FILENAME) defaults_config = pdc_utils.get_defaults_config() pdc_utils.set_cuda_visible_devices([0]) dce = DenseCorrespondenceEvaluation(config) network_name = self.pick_point_config["network_name"] self.dcn = dce.load_network_from_config(network_name) self.dataset = self.dcn.load_training_dataset() # why do we need to do this? print "finished loading dcn"
def descriptor_image_stats(self): """ Returns the descriptor normalization parameters, if possible. If they have not yet been loaded then it loads them :return: :rtype: """ # if it isn't already set, then attempt to load it if self._descriptor_image_stats is None: path_to_params = utils.convert_to_absolute_path(self.path_to_network_params_folder) descriptor_stats_file = os.path.join(path_to_params, "descriptor_statistics.yaml") self._descriptor_image_stats = utils.getDictFromYamlFilename(descriptor_stats_file) return self._descriptor_image_stats
def from_model_folder(model_folder, load_stored_params=True, model_param_file=None, iteration=None): """ Loads a DenseCorrespondenceNetwork from a model folder :param model_folder: the path to the folder where the model is stored. This direction contains files like - 003500.pth - training.yaml :type model_folder: :return: a DenseCorrespondenceNetwork objecc t :rtype: """ from_model_folder = False model_folder = utils.convert_to_absolute_path(model_folder) if model_param_file is None: model_param_file, _, _ = utils.get_model_param_file_from_directory( model_folder, iteration=iteration) from_model_folder = True model_param_file = utils.convert_to_absolute_path(model_param_file) training_config_filename = os.path.join(model_folder, "training.yaml") training_config = utils.getDictFromYamlFilename( training_config_filename) config = training_config["dense_correspondence_network"] config["path_to_network_params_folder"] = model_folder config["model_param_filename_tail"] = os.path.split( model_param_file)[1] dcn = DenseCorrespondenceNetwork.from_config( config, load_stored_params=load_stored_params, model_param_file=model_param_file) # whether or not network was constructed from model folder dcn.constructed_from_model_folder = from_model_folder dcn.model_folder = model_folder return dcn
def run(data_folder, config_file=CONFIG_FILE, debug=False, globalsDict=None, background_scene_data_folder=None): """ Runs the change detection pipeline :param data_dir: The 'processed' subfolder of a top-level log folder :param config_file: :return: """ if globalsDict is None: globalsDict = globals() if background_scene_data_folder is None: background_scene_data_folder = data_folder config_file = CONFIG_FILE config = utils.getDictFromYamlFilename(config_file) changeDetection, obj_dict = change_detection.ChangeDetection.from_data_folder( data_folder, config=config, globalsDict=globalsDict, background_data_folder=background_scene_data_folder) app = obj_dict['app'] globalsDict['cd'] = changeDetection view = obj_dict['view'] # if debug: # changeDetection.background_reconstruction.visualize_reconstruction(view, name='background') def single_shot_function(): changeDetection.run() app.app.quit() if not debug: TimerCallback(callback=single_shot_function).singleShot(0) app.app.start(restoreWindow=True)
def run(data_folder, config_file=CONFIG_FILE, debug=False, globalsDict=None): """ Runs the change detection pipeline :param data_dir: :param config_file: :return: """ if globalsDict is None: globalsDict = globals() config_file = CONFIG_FILE config = utils.getDictFromYamlFilename(config_file) # make dimensions large so no cropping for key in config['crop_box']['dimensions']: config['crop_box']['dimensions'][key] = 10.0 # set it to 10 meteres changeDetection, obj_dict = change_detection.ChangeDetection.from_data_folder( data_folder, config=config, globalsDict=globalsDict, background_data_folder=data_folder) # set foreground mesh to actually be background mesh changeDetection.foreground_reconstruction = changeDetection.background_reconstruction app = obj_dict['app'] globalsDict['cd'] = changeDetection view = obj_dict['view'] # if debug: # changeDetection.background_reconstruction.visualize_reconstruction(view, name='background') def single_shot_function(): changeDetection.render_depth_images() app.app.quit() if not debug: TimerCallback(callback=single_shot_function).singleShot(0) app.app.start(restoreWindow=True)
def main(): set_cuda_visible_devices([get_freer_gpu()]) # # model_file, dataset_name = get_DD_model_file() dataset_name = "box_push_1000_top_down" dataset_name = "box_push_1000_angled" dataset_paths = exp_utils.get_dataset_paths(dataset_name) dataset_root = dataset_paths['dataset_root'] model_file = dataset_paths['dense_descriptor_model_chkpt'] multi_episode_dict = DCDrakeSimEpisodeReader.load_dataset( dataset_root, max_num_episodes=None) camera_list = [dataset_paths['main_camera_name']] target_camera_names = [dataset_paths['main_camera_name']] # camera_list = ['camera_1_top_down'] # target_camera_names = ['camera_1_top_down'] model_config_file = os.path.join(os.path.dirname(model_file), 'config.yaml') model_config = getDictFromYamlFilename(model_config_file) model_config['dataset']['data_augmentation'] = False dataset = DynamicDrakeSimDataset( model_config, multi_episode_dict, phase="valid") # could also use train data model = torch.load(model_file) model = model.cuda() model = model.eval() heatmap_vis = HeatmapVisualization(model_config, dataset, model, visualize_3D=False, camera_list=camera_list, target_camera_names=target_camera_names, verbose=True, sample_same_episode=False) heatmap_vis.run()
def run(data_folder, config_file=CONFIG_FILE, debug=False, globalsDict=None, background_scene_data_folder=None): """ Runs the change detection pipeline :param data_dir: :param config_file: :return: """ if globalsDict is None: globalsDict = globals() if background_scene_data_folder is None: background_scene_data_folder = data_folder config_file = CONFIG_FILE config = utils.getDictFromYamlFilename(config_file) changeDetection, obj_dict = change_detection.ChangeDetection.from_data_folder(data_folder, config=config, globalsDict=globalsDict, background_data_folder=background_scene_data_folder) app = obj_dict['app'] globalsDict['cd'] = changeDetection view = obj_dict['view'] # if debug: # changeDetection.background_reconstruction.visualize_reconstruction(view, name='background') def single_shot_function(): changeDetection.run() app.app.quit() if not debug: TimerCallback(callback=single_shot_function).singleShot(0) app.app.start(restoreWindow=True)
def run(data_folder, config_file=CONFIG_FILE, debug=False, globalsDict=None): """ Runs the change detection pipeline :param data_dir: :param config_file: :return: """ if globalsDict is None: globalsDict = globals() config_file = CONFIG_FILE config = utils.getDictFromYamlFilename(config_file) # make dimensions large so no cropping for key in config['crop_box']['dimensions']: config['crop_box']['dimensions'][key] = 10.0# set it to 10 meteres changeDetection, obj_dict = change_detection.ChangeDetection.from_data_folder(data_folder, config=config, globalsDict=globalsDict, background_data_folder=data_folder) app = obj_dict['app'] globalsDict['cd'] = changeDetection view = obj_dict['view'] # if debug: # changeDetection.background_reconstruction.visualize_reconstruction(view, name='background') def single_shot_function(): changeDetection.render_depth_images() app.app.quit() if not debug: TimerCallback(callback=single_shot_function).singleShot(0) app.app.start(restoreWindow=True)
def main(): model_file = "/home/manuelli/data/key_dynam/dev/experiments/drake_pusher_slider_box_on_side/dataset_dps_box_on_side_600/trained_models/perception/dense_descriptor/3D_loss_camera_angled_2020-05-13-23-39-35-818188/net_best_dy_model.pth" dataset_name = "dps_box_on_side_600" dataset_paths = get_dataset_paths(dataset_name) dataset_root = dataset_paths['dataset_root'] dataset_name = dataset_paths['dataset_name'] env_config = dataset_paths['config'] print("dataset_root", dataset_root) multi_episode_dict = DCDrakeSimEpisodeReader.load_dataset(dataset_root) camera_list = ["camera_angled"] # should really use validation data, but will use train for now . . . # will be cross-scene so that shouldn't matter . . . . model_config_file = os.path.join(os.path.dirname(model_file), 'config.yaml') model_config = getDictFromYamlFilename(model_config_file) dataset = DynamicDrakeSimDataset(model_config, multi_episode_dict, phase="train") # could also use train data model = torch.load(model_file) model = model.cuda() model = model.eval() heatmap_vis = HeatmapVisualization(model_config, dataset, model, visualize_3D=False, camera_list=camera_list, verbose=True, target_camera_names=['camera_angled', 'camera_angled_rotated']) heatmap_vis.run()
import copy import dense_correspondence_manipulation.utils.utils as utils dc_source_dir = utils.getDenseCorrespondenceSourceDir() sys.path.append(dc_source_dir) sys.path.append( os.path.join(dc_source_dir, "dense_correspondence", "correspondence_tools")) from dense_correspondence.dataset.spartan_dataset_masked import SpartanDataset, ImageType from dense_correspondence_manipulation.simple_pixel_correspondence_labeler.annotate_correspondences import label_colors, draw_reticle, pil_image_to_cv2, drawing_scale_config config_filename = os.path.join( utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'caterpillar_baymax_starbot_onlymulti_front.yaml') config = utils.getDictFromYamlFilename(config_filename) sd = SpartanDataset(config=config) sd.set_train_mode() annotated_data_yaml_filename = os.path.join(os.getcwd(), "new_annotated_pairs.yaml") annotated_data = utils.getDictFromYamlFilename(annotated_data_yaml_filename) index_of_pair_to_display = 0 def draw_points(img, img_points_picked): for index, img_point in enumerate(img_points_picked): color = label_colors[index % len(label_colors)] draw_reticle(img, int(img_point["u"]), int(img_point["v"]), color)
from dense_correspondence.network.dense_correspondence_network import DenseCorrespondenceNetwork import dense_correspondence.correspondence_tools.correspondence_finder as correspondence_finder sys.path.append( os.path.join(os.path.dirname(__file__), "../simple-pixel-correspondence-labeler")) from annotate_correspondences import label_colors, draw_reticle, pil_image_to_cv2, drawing_scale_config, numpy_to_cv2, label_colors COLOR_RED = np.array([0, 0, 255]) COLOR_GREEN = np.array([0, 255, 0]) utils.set_default_cuda_visible_devices() eval_config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'evaluation', 'evaluation.yaml') EVAL_CONFIG = utils.getDictFromYamlFilename(eval_config_filename) class HeatmapVisualization(object): """ Launches a live interactive heatmap visualization. Edit config/dense_correspondence/heatmap_vis/heatmap.yaml to specify which networks to visualize. Specifically add the network you want to visualize to the "networks" list. Make sure that this network appears in the file pointed to by EVAL_CONFIG Usage: Launch this file with python after sourcing the environment with `use_pytorch_dense_correspondence` Then `python live_heatmap_visualization.py`. """ def __init__(self, config): self._config = config self._dce = DenseCorrespondenceEvaluation(EVAL_CONFIG)
from dense_correspondence.training.training import * import sys import logging #utils.set_default_cuda_visible_devices() # utils.set_cuda_visible_devices([0]) # use this to manually set CUDA_VISIBLE_DEVICES from dense_correspondence.training.training import DenseCorrespondenceTraining from dense_correspondence.dataset.spartan_dataset_masked import SpartanDataset logging.basicConfig(level=logging.INFO) from dense_correspondence.evaluation.evaluation import DenseCorrespondenceEvaluation config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'toy.yaml') config = utils.getDictFromYamlFilename(config_filename) train_config_file = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'training', 'toy_training.yaml') train_config = utils.getDictFromYamlFilename(train_config_file) dataset = SpartanDataset(config=config) logging_dir = "/home/zhouxian/git/pytorch-dense-correspondence/pdc/trained_models/tutorials" d = 3 # the descriptor dimension name = "toy_hacker_%d" %(d) train_config["training"]["logging_dir_name"] = name train_config["training"]["logging_dir"] = logging_dir train_config["dense_correspondence_network"]["descriptor_dimension"] = d TRAIN = True
import sys import os import cv2 import numpy as np import copy import dense_correspondence_manipulation.utils.utils as utils dc_source_dir = utils.getDenseCorrespondenceSourceDir() sys.path.append(dc_source_dir) sys.path.append(os.path.join(dc_source_dir, "dense_correspondence", "correspondence_tools")) from dense_correspondence.dataset.spartan_dataset_masked import SpartanDataset, ImageType config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'star_bot_front_only.yaml') config = utils.getDictFromYamlFilename(config_filename) sd = SpartanDataset(config=config) sd.set_train_mode() USE_FIRST_IMAGE = False # force using first image in each log RANDOMIZE_TEST_TRAIN = False # randomize seletcting def numpy_to_cv2(numpy_img): return numpy_img[:, :, ::-1].copy() # open and convert between BGR and RGB def pil_image_to_cv2(pil_image): return np.array(pil_image)[:, :, ::-1].copy() # open and convert between BGR and RGB def get_cv2_img_pair_from_spartan(): scene_name_a = sd.get_random_scene_name() num_attempts = 50 for i in range(num_attempts):
from director import ioUtils import PythonQt from director import mainwindowapp from PythonQt import QtCore, QtGui import cv2 import dense_correspondence_manipulation.change_detection.change_detection as change_detection from dense_correspondence_manipulation.utils.constants import * import dense_correspondence_manipulation.utils.utils as utils import dense_correspondence_manipulation.utils.director_utils as director_utils from dense_correspondence_manipulation.fusion.fusion_reconstruction import FusionReconstruction, TSDFReconstruction from dense_correspondence_manipulation.mesh_processing.mesh_render import MeshColorizer CONFIG = utils.getDictFromYamlFilename(CHANGE_DETECTION_CONFIG_FILE) class ReconstructionProcessing(object): def __init__(self): pass def spawnCropBox(self, dims=None): if dims is None: dim_x = CONFIG['crop_box']['dimensions']['x'] dim_y = CONFIG['crop_box']['dimensions']['y'] dim_z = CONFIG['crop_box']['dimensions']['z'] dims = [dim_x, dim_y, dim_z] transform = director_utils.transformFromPose( CONFIG['crop_box']['transform'])
import dense_correspondence from dense_correspondence.evaluation.evaluation import * from dense_correspondence.evaluation.plotting import normalize_descriptor from dense_correspondence.network.dense_correspondence_network import DenseCorrespondenceNetwork sys.path.append(os.path.join(os.path.dirname(__file__), "../simple-pixel-correspondence-labeler")) from annotate_correspondences import label_colors, draw_reticle, pil_image_to_cv2, drawing_scale_config, numpy_to_cv2, label_colors COLOR_RED = np.array([0, 0, 255]) COLOR_GREEN = np.array([0,255,0]) utils.set_default_cuda_visible_devices() eval_config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'evaluation', 'lucas_evaluation.yaml') EVAL_CONFIG = utils.getDictFromYamlFilename(eval_config_filename) class HeatmapVisualization(object): def __init__(self, config): self._config = config self._dce = DenseCorrespondenceEvaluation(EVAL_CONFIG) self._load_networks() self._reticle_color = COLOR_GREEN # self.load_specific_dataset() # uncomment if you want to load a specific dataset def _load_networks(self): # we will use the dataset for the first network in the series self._dcn_dict = dict()
def load_default_config(): default_config_file = os.path.join( utils.getDenseCorrespondenceSourceDir(), 'config', 'stations', 'RLG_iiwa_1', 'change_detection.yaml') config = utils.getDictFromYamlFilename(default_config_file) return config
import PythonQt from director import mainwindowapp from PythonQt import QtCore, QtGui import cv2 import dense_correspondence_manipulation.change_detection.change_detection as change_detection from dense_correspondence_manipulation.utils.constants import * import dense_correspondence_manipulation.utils.utils as utils import dense_correspondence_manipulation.utils.director_utils as director_utils from dense_correspondence_manipulation.fusion.fusion_reconstruction import FusionReconstruction, TSDFReconstruction CONFIG = utils.getDictFromYamlFilename(CHANGE_DETECTION_CONFIG_FILE) class ReconstructionProcessing(object): def __init__(self): pass def spawnCropBox(self, dims=None): if dims is None: dim_x = CONFIG['crop_box']['dimensions']['x'] dim_y = CONFIG['crop_box']['dimensions']['y'] dim_z = CONFIG['crop_box']['dimensions']['z'] dims = [dim_x, dim_y, dim_z] transform = director_utils.transformFromPose(CONFIG['crop_box']['transform']) d = DebugData()
def load_default_config(): default_config_file = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'stations', 'RLG_iiwa_1', 'change_detection.yaml') config = utils.getDictFromYamlFilename(default_config_file) return config
import numpy as np import copy import dense_correspondence_manipulation.utils.utils as utils dc_source_dir = utils.getDenseCorrespondenceSourceDir() sys.path.append(dc_source_dir) sys.path.append( os.path.join(dc_source_dir, "dense_correspondence", "correspondence_tools")) from dense_correspondence.dataset.spartan_dataset_masked import SpartanDataset, ImageType config_filename = os.path.join(utils.getDenseCorrespondenceSourceDir(), 'config', 'dense_correspondence', 'dataset', 'composite', 'star_bot_front_only.yaml') config = utils.getDictFromYamlFilename(config_filename) sd = SpartanDataset(config=config) sd.set_train_mode() USE_FIRST_IMAGE = False # force using first image in each log RANDOMIZE_TEST_TRAIN = False # randomize seletcting def numpy_to_cv2(numpy_img): return numpy_img[:, :, ::-1].copy() # open and convert between BGR and RGB def pil_image_to_cv2(pil_image): return np.array( pil_image)[:, :, ::-1].copy() # open and convert between BGR and RGB
descriptor_filename = os.path.join( save_dir, SceneStructure.descriptor_image_filename(img_idx)) np.save(descriptor_filename, res) print("descriptor_filename", descriptor_filename) print("processing image %d of %d" % (counter, num_images)) counter += 1 if __name__ == "__main__": dc_source_dir = utils.getDenseCorrespondenceSourceDir() config_filename = os.path.join(dc_source_dir, 'config', 'dense_correspondence', 'evaluation', 'lucas_evaluation.yaml') eval_config = utils.getDictFromYamlFilename(config_filename) default_config = utils.get_defaults_config() utils.set_cuda_visible_devices(default_config['cuda_visible_devices']) dce = DenseCorrespondenceEvaluation(eval_config) network_name = "caterpillar_M_background_0.500_3" dcn = dce.load_network_from_config(network_name) dataset_config_file = os.path.join(dc_source_dir, 'config', 'dense_correspondence', 'dataset', 'composite', 'caterpillar_only_9.yaml') dataset_config = utils.getDictFromYamlFilename(dataset_config_file) dataset = SpartanDataset(config=dataset_config) scene_name = SCENE_NAME save_dir = SAVE_DIR