def run(dataset_dir): # determine the expected location of necessary files from # within the dataset timefile = dataset_filepaths.get_timesync_xml(dataset_dir) conffile = dataset_filepaths.get_hardware_config_xml(dataset_dir) # read the xml configuration file conf = backpackconfig.Configuration(conffile, True, dataset_dir) # iterate through the available URG scanners urgSensors = conf.find_sensors_by_type(URG_TYPE) for urg in urgSensors: # get the output dat file for this sensor datfile = os.path.abspath(os.path.join(dataset_dir, \ conf.find_sensor_prop(urg, URG_DAT_XPATH, URG_TYPE))) # get the fss file that will be generated for this sensor fssfile = dataset_filepaths.get_fss_file(datfile) # prepare the command-line arguments for the filter_urg_scans code args = [FILTER_EXE, datfile, fssfile, timefile] # run the filter_urg_scans code ret = subprocess.call(args, executable=FILTER_EXE, \ cwd=dataset_dir, stdout=None, stderr=None, \ stdin=None, shell=False) if ret != 0: print "filter_urg_scans program returned error", ret return -1 # success return 0
def run(datasetDir): # Read in the hardware config file configFile = dataset_filepaths.get_hardware_config_xml(datasetDir) conf = backpackconfig.Configuration(configFile, True, datasetDir) # Find all the active cameras in the file cameraList = conf.find_sensors_by_type("cameras") if len(cameraList) == 0 : print "No active cameras found in dataset " + datasetDir return 0; # get location of masks for any cameras MASK_DIR = dataset_filepaths.get_camera_masks_dir(datasetDir) # Then we loop over the cameraList generating the required things for cameraName in cameraList : print "" print "==== RECTIFYING : " + cameraName + " ====" # now we need to read find out what the input names should be calibFile = conf.find_sensor_prop(cameraName, "configFile/dalsa_fisheye_calibration_file", "cameras") calibFile = os.path.join(datasetDir, calibFile) metaDataFile = os.path.join(datasetDir, \ conf.find_sensor_prop(cameraName, \ "configFile/dalsa_metadata_outfile", "cameras")) metaDataFile = dataset_filepaths.get_color_metadata_file( \ cameraName, metaDataFile) rToCommon = conf.find_sensor_prop(cameraName, "rToCommon", "cameras").split(",") tToCommon = conf.find_sensor_prop(cameraName, "tToCommon", "cameras").split(",") extrinStr = " ".join((rToCommon + tToCommon)) outputDirectory = conf.find_sensor_prop(cameraName, "configFile/dalsa_output_directory", "cameras") outputDirectory = os.path.abspath(os.path.join( \ datasetDir, outputDirectory, '..', 'rectified')) # Adjust the maskdir maskDir = os.path.join(MASK_DIR, cameraName) # VODO The camera serial number camSerial = conf.find_sensor_prop(cameraName, "serialNum", "cameras") camSerial = re.sub("[^0-9]", "", camSerial) ### UP CAMERA print "---Up Images" # Make vcam specific inputs outDir = os.path.join(outputDirectory, 'up') K = " ".join([str(max(IMAGESIZE)/FUP), "0", str(IMAGESIZE[1]/2), "0", str(max(IMAGESIZE)/FUP), str(IMAGESIZE[0]/2), "0","0","1"]) rotation = "90 0 0" maskfile = os.path.join(maskDir, "up.jpg") serial = camSerial + "0" # Run the command command = [RECTIFY_EXE, "-ic", calibFile, "-id", datasetDir, "-iv", maskfile, "-ie", extrinStr, "-ik", K, "-im",metaDataFile, "-ir",rotation, "-is",str(IMAGESIZE[0]) + " " + str(IMAGESIZE[1]), "-od",outDir, "-os",serial] command = " ".join(command) ret = os.system(command) if ret != 0 : print "Error Processing " + cameraName + " up images" return 2; ### LEVEL CAMERA print "---Level Images" # Make vcam specific inputs outDir = os.path.join(outputDirectory, 'level') K = " ".join([str(max(IMAGESIZE)/FLEVEL), "0", str(IMAGESIZE[1]/2), "0", str(max(IMAGESIZE)/FLEVEL), str(IMAGESIZE[0]/2), "0","0","1"]) rotation = "0 0 0" maskfile = os.path.join(maskDir, "level.jpg") serial = camSerial + "1" # Run the command command = [RECTIFY_EXE, "-ic", calibFile, "-id", datasetDir, "-iv", maskfile, "-ie", extrinStr, "-ik", K, "-im",metaDataFile, "-ir",rotation, "-is",str(IMAGESIZE[0]) + " " + str(IMAGESIZE[1]), "-od",outDir, "-os",serial] command = " ".join(command) ret = os.system(command) if ret != 0 : print "Error Processing " + cameraName + " level images" return 2; ### DOWN CAMERA print "---Down Images" # Make vcam specific inputs outDir = os.path.join(outputDirectory, 'down') K = " ".join([str(max(IMAGESIZE)/FDOWN), "0", str(IMAGESIZE[1]/2), "0", str(max(IMAGESIZE)/FDOWN), str(IMAGESIZE[0]/2), "0","0","1"]) rotation = "-90 0 0" maskfile = os.path.join(maskDir, "down.jpg") serial = camSerial + "2" # Run the command command = [RECTIFY_EXE, "-ic", calibFile, "-id", datasetDir, "-iv", maskfile, "-ie", extrinStr, "-ik", K, "-im",metaDataFile, "-ir",rotation, "-is",str(IMAGESIZE[0]) + " " + str(IMAGESIZE[1]), "-od",outDir, "-os",serial] command = " ".join(command) ret = os.system(command) if ret != 0 : print "Error Processing " + cameraName + " down images" return 2; return 0;
def main() : # Parse the args from the command line args = handle_args() # Ensure that the given input files actually exist check_files_exist(args) # Read in the hardware config file so that we have access to the list of # active sensors that were used in this dataset conf = backpackconfig.Configuration( \ os.path.join(args.dataset_directory[0],CONFIGFILE_PATH), \ True, \ args.dataset_directory[0]) args.scanner_list = collect_scanners(args.scanner_list, conf) # if there are any time-of-flight (or any depth) cameras present # then we should include them in the geometry tof_list = collect_tof(conf) all_scanners = args.scanner_list + tof_list # Resolve the camera names that will be used in the colorizing the point # cloud args.camera_list = collect_cameras(args.color_by, args.camera_list, conf) # Ensure that the output folder exists args.output_directory = create_output_folder(args) # Create common filenames timeFile = os.path.join(args.dataset_directory[0], TIMEFILE_PATH) configFile = os.path.join(args.dataset_directory[0], CONFIGFILE_PATH) pathFileBase = os.path.splitext(os.path.basename(args.path_file[0]))[0] # Handle the units args.units = handle_units(args.units[0]) # Lastly run the executable for each scanner for scanner in all_scanners : print "" print "##### Generating Pointcloud for " + scanner + ". Colored by " \ + args.color_by + ". #####" print "" # Here is where the input arguments will be created cargs = [POINTCLOUD_EXE] # Tack on the time flag cargs.append('-t') cargs.append(timeFile) # Tack on the hardware config file cargs.append('-c') cargs.append(configFile) # Tack on the path cargs.append('-p') cargs.append(args.path_file[0]) # give the geometry scanner info if scanner in args.scanner_list: # Tack on the laser scanner info scannerDataFile = conf.find_sensor_prop(scanner, \ URG_DAT_XPATH, \ URG_TYPE) scannerDataFile = os.path.join(args.dataset_directory[0], \ scannerDataFile) cargs.append('-l') cargs.append(scanner) cargs.append(scannerDataFile) elif scanner in tof_list: # this is a tof sensor, which should have # a .fss file tofDatFile = conf.find_sensor_prop(scanner, \ TOF_DAT_XPATH, \ TOF_TYPE) tofFssFile = os.path.join( \ args.dataset_directory[0], \ dataset_filepaths.get_fss_file( \ tofDatFile)) cargs.append('--fss') cargs.append(tofFssFile) # Handle tacking on the colorization flag if args.color_by == 'cameras' : for camera in args.camera_list : # Give the information for the camera cmetadata = conf.find_sensor_prop(camera, \ DALSA_METADATA_XPATH, \ CAMERA_TYPE) cmetadata = os.path.dirname(cmetadata) cmetadata = os.path.join(args.dataset_directory[0], \ cmetadata, \ 'color_'+camera+'_metadata.txt') calibFile = conf.find_sensor_prop(camera, \ DALSA_CALIB_XPATH, \ CAMERA_TYPE) calibFile = os.path.join(args.dataset_directory[0], \ calibFile) imgDir = conf.find_sensor_prop(camera, \ DALSA_OUTPUTDIR_XPATH, \ CAMERA_TYPE) imgDir = os.path.normpath(os.path.join( \ args.dataset_directory[0], imgDir, '..', 'color')) cargs.append('-f') cargs.append(cmetadata) cargs.append(calibFile) cargs.append(imgDir) #Check if a mask exists and if so register it for the camera maskFile = conf.find_sensor_prop(camera, \ DALSA_MASKFILE_XPATH, \ CAMERA_TYPE) if maskFile != None : maskFile = os.path.join(args.dataset_directory[0], \ maskFile) cargs.append('-m') cargs.append(camera) cargs.append(maskFile) elif args.color_by == 'ir_cameras' : for camera in args.camera_list : # Give the information for the camera cmetadata = conf.find_sensor_prop(camera, \ FLIR_METADATA_XPATH, \ FLIR_TYPE) cmetadata = os.path.dirname(cmetadata) cmetadata = os.path.join(args.dataset_directory[0], \ cmetadata, \ 'normalized_'+camera+'_metadata.txt') calibFile = conf.find_sensor_prop(camera, \ FLIR_CALIB_XPATH, \ FLIR_TYPE) calibFile = os.path.join(args.dataset_directory[0], \ calibFile) imgDir = conf.find_sensor_prop(camera, \ FLIR_OUTPUTDIR_XPATH, \ FLIR_TYPE) imgDir = os.path.normpath(os.path.join( \ args.dataset_directory[0], imgDir, '..', 'normalized')) cargs.append('-q') cargs.append(cmetadata) cargs.append(calibFile) cargs.append(imgDir) elif args.color_by == 'time' : cargs.append('--color_by_time') elif args.color_by == 'height' : cargs.append('--color_by_height') # Tack on the units flag cargs.append('-u') cargs.append(str(args.units)) # Tack on the range limit flag if args.range_limit != None : cargs.append('-r') cargs.append(str(args.range_limit[0])) # Tack on the time buffer settings if not args.disable_time_buffer : cargs.append('--time_buffer') cargs.append(str(args.time_buffer[0])) cargs.append(str(args.time_buffer[1])) # if we are removing uncolored points tack them on if not args.keep_noncolored_points : cargs.append('--remove_noncolored_points') else : cargs.append('--default_color') cargs.append(str(args.default_color[0])) cargs.append(str(args.default_color[1])) cargs.append(str(args.default_color[2])) # Make the output file outFileName = os.path.join(args.output_directory, pathFileBase + "_" + scanner + "." + args.output_filetype) cargs.append("-o") cargs.append(outFileName) # Run the pointcloud code ret = os.system(" ".join(cargs)) if ret != 0 : exit(1)
def run(settings): # The first thing we need to do is import the # backpack configuration file # so that we can deduce the locations of all the files names confFile = path.join(settings['datasetDir'], "config", "backpack_config.xml") conf = backpackconfig.Configuration(confFile, True, \ settings['datasetDir']) # Create the image maps dir imagemapdir = path.join(settings['datasetDir'], 'imagemaps') # Then we need to get a list of all active cameras for this dataset cameras = conf.find_sensors_by_type("cameras") code_args = [] for camera in cameras: # We need to create first the camera pose file poseFiles = glob.glob(path.join(settings['datasetDir'], \ 'localization',settings['datasetName'], \ 'cameraposes',camera+"_poses.txt")) if (len(poseFiles) == 0): print ("No camera pose file for " \ + camera + " found in " \ + path.join(settings['datasetDir'], \ 'localization', \ settings['datasetName'], \ 'cameraposes')) return 1 poseFile = poseFiles[0] # Then we need to create the names of the depth # and normal files depthfile = path.join(imagemapdir, camera, "depthmaps", camera + "_imagelog.txt") normalfile = path.join(imagemapdir, camera, "normalmaps", camera + "_imagelog.txt") code_args.append(tuple([poseFile, depthfile, normalfile])) # Create the binary file name binFile = path.join(settings['binaryDir'], 'create_image_mapping') # Create the output file name imapfile = path.join(imagemapdir, "imagemap.imap") keyfile = path.join(imagemapdir, "imgids.txt") args = [ binFile, "-dir", settings['datasetDir'], "-o", imapfile, keyfile, "-r", str(settings['resolution']) ] for argset in code_args: args += ["-i"] args += argset[:] # Run the code ret = system(" ".join(args)) if ret != 0: print "Image mapping returned error : " + str(ret) # Return success return ret
def run(dataset_dir, pathfile, debug=False): # ensure abspath for input files dataset_dir = os.path.abspath(dataset_dir) pathfile = os.path.abspath(pathfile) # check that executable exists if not os.path.exists(SCANORAMA_EXE): print "Error! Could not find pointcloud", \ "generation executable:", \ SCANORAMA_EXE return None # verify that output directory exists scanoramadir = dataset_filepaths.get_scanorama_dir(dataset_dir) if not os.path.exists(scanoramadir): os.makedirs(scanoramadir) # get necessary files for this dataset scanoprefix = dataset_filepaths.get_scanorama_ptx_prefix(dataset_dir) metafile = dataset_filepaths.get_scanorama_metadata_file(dataset_dir) modelfile = dataset_filepaths.get_full_mesh_file(dataset_dir) config_xml = dataset_filepaths.get_hardware_config_xml(dataset_dir) conf = backpackconfig.Configuration(config_xml, True, dataset_dir) # Prepare arguments for program args = [SCANORAMA_EXE, '-c', config_xml, '-s', SETTINGS_XML, \ '-m', modelfile, \ '-p', pathfile, \ '-o', scanoprefix, \ '--meta', metafile] if debug: args = ['gdb', '--args'] + args #-------------------------------------------- # find all active FISHEYE cameras in the file #-------------------------------------------- cam_metas = [] cam_calibs = [] cam_dirs = [] cameraList = conf.find_sensors_by_type("cameras") for cameraName in cameraList: # check if this sensor is enabled e = conf.find_sensor_prop(cameraName, 'enable', 'cameras') if e == '0': continue # prepare the command-line arguments for this camera metafile = os.path.join(dataset_dir, \ conf.find_sensor_prop(cameraName, \ 'configFile/dalsa_metadata_outfile', 'cameras')) metafile = dataset_filepaths.get_color_metadata_file( \ cameraName, metafile) calibfile = os.path.join(dataset_dir, \ conf.find_sensor_prop(cameraName, \ 'configFile/dalsa_fisheye_calibration_file', 'cameras')) imgdir = os.path.join(dataset_dir, \ dataset_filepaths.get_color_image_dir( \ conf.find_sensor_prop(cameraName, \ 'configFile/dalsa_output_directory', 'cameras'))) # add to arguments lists cam_metas.append(metafile) cam_calibs.append(calibfile) cam_dirs.append(imgdir) # add FISHEYE camera information for ci in range(len(cam_metas)): args += ['-f', cam_metas[ci], \ cam_calibs[ci], cam_dirs[ci]] #----------------------------------------- # find all active FLIR cameras in the file #----------------------------------------- cam_metas = [] cam_calibs = [] cam_dirs = [] cameraList = conf.find_sensors_by_type("flirs") for cameraName in cameraList: # check if this sensor is enabled e = conf.find_sensor_prop(cameraName, 'enable', 'flirs') if e == '0': continue # prepare the command-line arguments for this camera metafile = os.path.join(dataset_dir, \ conf.find_sensor_prop(cameraName, \ 'configFile/flir_metadata_outfile', 'flirs')) metafile = dataset_filepaths.get_ir_normalized_metadata_file( \ cameraName, metafile) calibfile = os.path.join(dataset_dir, \ conf.find_sensor_prop(cameraName, \ 'configFile/flir_rectilinear_calibration_file', \ 'flirs')) imgdir = os.path.join(dataset_dir, \ dataset_filepaths.get_ir_normalized_image_dir( \ conf.find_sensor_prop(cameraName, \ 'configFile/flir_output_directory', 'flirs'))) # add to arguments lists cam_metas.append(metafile) cam_calibs.append(calibfile) cam_dirs.append(imgdir) # add RECTILINEAR camera information for ci in range(len(cam_metas)): args += ['-r', cam_metas[ci], \ cam_calibs[ci], cam_dirs[ci]] #---------------------------------- # run pointcloud generation program #---------------------------------- exe_to_run = SCANORAMA_EXE if debug: exe_to_run = 'gdb' ret = subprocess.call(args, executable=exe_to_run, \ cwd=dataset_dir, stdout=None, stderr=None, \ stdin=None, shell=False) if ret != 0: print "Error! Scanorama generation program", \ "returned",ret return ret # success return 0
def run(datasetDir, datasetName): # The first thing we need to do is import the backpack i # configuration file # so that we can deduce the locations of all the files names configFile = dataset_filepaths.get_hardware_config_xml(datasetDir) conf = backpackconfig.Configuration(configFile, True, datasetDir) meshfile = dataset_filepaths.get_full_mesh_file(datasetDir) # Then we need to get a list of all active cameras for this dataset cameras = conf.find_sensors_by_type("cameras") if len(cameraList) == 0: print "No active cameras found in dataset " + datasetDir return 0 # For each camera create the triplet of inputs code_args = [] for camera in cameras: # get the folder for this camera in the dataset datadir = conf.find_sensor_prop(camera, "configFile/dalsa_output_directory", "cameras") imageDir = path.normpath(path.join(datasetDir, datadir, '..')) # Then find the mcd file for this camera mcdFiles = glob.glob(path.join(imageDir, \ 'rectified', 'level', '*.mcd')) if (len(mcdFiles) == 0): print "No .mcd files found in " \ + path.join(imageDir,'rectified', 'level') return 1 if (len(mcdFiles) > 1): print( str(len(mcdFiles)) + " .mcd files found in " + path.join(imageDir, 'rectified', 'level')) return 2 # Store the final mcd file mcdFile = mcdFiles[0] # Then locate the pose file for the camera poseFiles = glob.glob( path.join(datasetDir, 'localization', datasetName, 'cameraposes', camera + "_poses.txt")) if (len(poseFiles) == 0): print( "No camera pose file for " + camera + " found in " + path.join(settings['datasetDir'], 'localization', datasetName, 'cameraposes')) return 1 # Store the pose file poseFile = poseFiles[0] # Create the output directory name outDir = path.join(datasetDir, 'imagemaps', camera) # Store as a tuple code_args.append(tuple([mcdFile, poseFile, outDir, camera])) # Create the arguments for the C++ code args = [ MESH2IMAGE_EXE, "-dir", datasetDir, "-model", meshfile, "-depth", '12' ] for argset in code_args: args += ["-i"] args += argset[:] # Run the code ret = system(" ".join(args)) if ret != 0: print "Depth mapping returned error : " + str(ret) # Return success return ret
def pointcloud_gen(dataset_dir, madfile): # the following constants are used to interface with the system # hardware configuration CAMERA_TYPE = 'cameras' CAMERA_METAFILE_XPATH = 'configFile/dalsa_metadata_outfile' CAMERA_RECTCALIB_XPATH = 'configFile/flir_rectilinear_calibration_file' CAMERA_IMAGEDIR_XPATH = 'configFile/dalsa_output_directory' CAMERA_WHITELIST = ['tango_color'] # get the necessary file paths from the dataset conffile = dataset_filepaths.get_hardware_config_xml(dataset_dir) timefile = dataset_filepaths.get_timesync_xml(dataset_dir) fssfiles = dataset_filepaths.get_all_fss_files(dataset_dir) xyzfile = os.path.join( \ dataset_filepaths.get_colored_pc_dir(dataset_dir), \ dataset_filepaths.get_name_from_madfile(madfile) \ + '_tango.xyz') # check if the appropriate camera(s) is/are defined conf = backpackconfig.Configuration(conffile, True, dataset_dir) cameraSensors = conf.find_sensors_by_type(CAMERA_TYPE) # prepare the command-line arguments for this executable args = [POINTCLOUD_EXE, \ '-t', timefile, \ '-c', conffile, \ '-p', madfile, \ '-u', '1000', \ ] # add all available sensors for f in fssfiles: args += ['--fss', f] # add all available cameras that are in the whitelist colorbycamera = False for c in cameraSensors: if c in CAMERA_WHITELIST: # we should use this camera for color colorbycamera = True # get the argument files for this camera cmetadata = dataset_filepaths.get_color_metadata_file( \ c, \ os.path.join(dataset_dir, \ conf.find_sensor_prop(c, \ CAMERA_METAFILE_XPATH, \ CAMERA_TYPE))) crectcalib = os.path.join(dataset_dir, \ conf.find_sensor_prop(c, \ CAMERA_RECTCALIB_XPATH, \ CAMERA_TYPE)) cimagedir = os.path.join(dataset_dir, \ conf.find_sensor_prop(c, \ CAMERA_IMAGEDIR_XPATH, \ CAMERA_TYPE)) # add to the command-line args args += ['-q', cmetadata, crectcalib, cimagedir] # prepare output file outdir = os.path.dirname(xyzfile) if not os.path.exists(outdir): os.makedirs(outdir) args += ['-o', xyzfile] # call the pointcloud executable ret = subprocess.call(args, executable=POINTCLOUD_EXE, \ cwd=dataset_dir, stdout=None, stderr=None, \ stdin=None, shell=False) if ret != 0: print "Pointcloud generation code returned error",ret return None # return the xyzfile as success return xyzfile