def test_three_image(self): # Step: Create an adjacency graph adjacency = get_path('three_image_adjacency.json') basepath = get_path('Apollo15') cg = CandidateGraph.from_adjacency(adjacency, basepath) self.assertEqual(3, cg.number_of_nodes()) self.assertEqual(3, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(extractor_parameters={'nfeatures':500}) for i, node, in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) cg.match_features(k=5) for source, destination, edge in cg.edges_iter(data=True): edge.symmetry_check() edge.ratio_check(clean_keys=['symmetry'], ratio=0.99) cg.apply_func_to_edges("compute_homography", clean_keys=['symmetry', 'ratio']) cg.compute_fundamental_matrices(clean_keys=['symmetry', 'ratio']) # Step: And create a C object cg.generate_cnet(clean_keys=['symmetry', 'ratio', 'ransac']) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, 'TestThreeImageMatching_fromlist.lis') # Step: Create a correspondence network cg.generate_cnet(clean_keys=['symmetry', 'ratio', 'ransac'], deepen=True) to_isis('TestThreeImageMatching.net', cg, mode='wb', networkid='TestThreeImageMatching', targetname='Moon')
def match_images(args, config_dict): # Matches the images in the input file using various candidate graph methods # produces two files usable in isis try: cg = CandidateGraph.from_adjacency(find_in_dict(config_dict, 'inputfile_path') + args.input_file, basepath=find_in_dict(config_dict, 'basepath')) except: cg = CandidateGraph.from_filelist(find_in_dict(config_dict, 'inputfile_path') + args.input_file) # Apply SIFT to extract features cg.extract_features(method=config_dict['extract_features']['method'], extractor_parameters=find_in_dict(config_dict, 'extractor_parameters')) # Match cg.match_features(k=config_dict['match_features']['k']) # Apply outlier detection cg.apply_func_to_edges('symmetry_check') cg.apply_func_to_edges('ratio_check', ratio=find_in_dict(config_dict, 'ratio'), mask_name=find_in_dict(config_dict, 'mask_name'), single=find_in_dict(config_dict, 'single')) # Compute a homography and apply RANSAC cg.apply_func_to_edges('compute_fundamental_matrix', clean_keys=find_in_dict(config_dict, 'fundamental_matrices')['clean_keys'], method=find_in_dict(config_dict, 'fundamental_matrices')['method'], reproj_threshold=find_in_dict(config_dict, 'reproj_threshold'), confidence=find_in_dict(config_dict, 'confidence')) cg.apply_func_to_edges('subpixel_register', clean_keys=find_in_dict(config_dict, 'subpixel_register')['clean_keys'], template_size=find_in_dict(config_dict, 'template_size'), threshold=find_in_dict(config_dict, 'threshold'), search_size=find_in_dict(config_dict, 'search_size'), max_x_shift=find_in_dict(config_dict, 'max_x_shift'), max_y_shift=find_in_dict(config_dict, 'max_y_shift'), tiled=find_in_dict(config_dict, 'tiled'), upsampling = find_in_dict(config_dict, 'upsampling'), error_check = find_in_dict(config_dict, 'error_check')) cg.apply_func_to_edges('suppress', clean_keys=find_in_dict(config_dict, 'suppress')['clean_keys'], k=find_in_dict(config_dict, 'suppress')['k'], min_radius=find_in_dict(config_dict, 'min_radius'), error_k=find_in_dict(config_dict, 'error_k')) cnet = cg.to_cnet(clean_keys=find_in_dict(config_dict, 'cnet_conversion')['clean_keys'], isis_serials=True) filelist = cg.to_filelist() write_filelist(filelist, find_in_dict(config_dict, 'outputfile_path') + args.output_file + '.lis') to_isis(find_in_dict(config_dict, 'outputfile_path') + args.output_file + '.net', cnet, mode='wb', networkid=find_in_dict(config_dict, 'networkid'), targetname=find_in_dict(config_dict, 'targetname'), description=find_in_dict(config_dict, 'description'), username=find_in_dict(config_dict, 'username'))
def test_two_image(self): # Step: Create an adjacency graph adjacency = get_path("two_image_adjacency.json") basepath = get_path("Apollo15") cg = CandidateGraph.from_adjacency(adjacency, basepath=basepath) self.assertEqual(2, cg.number_of_nodes()) self.assertEqual(1, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(method="sift", extractor_parameters={"nfeatures": 500}) for i, node in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) # Step: Compute the coverage ratios truth_ratios = [0.95351579, 0.93595664] for i, node in cg.nodes_iter(data=True): ratio = node.coverage_ratio() self.assertIn(round(ratio, 8), truth_ratios) cg.match_features(k=2) # Perform the symmetry check cg.symmetry_checks() # Perform the ratio check cg.ratio_checks(clean_keys=["symmetry"], single=True) # Create fundamental matrix cg.compute_fundamental_matrices(clean_keys=["symmetry", "ratio"]) for source, destination, edge in cg.edges_iter(data=True): # Perform the symmetry check self.assertIn(edge.masks["symmetry"].sum(), range(400, 600)) # Perform the ratio test self.assertIn(edge.masks["ratio"].sum(), range(225, 275)) # Range needs to be set self.assertIn(edge.masks["fundamental"].sum(), range(200, 250)) # Step: Compute the homographies and apply RANSAC cg.compute_homographies(clean_keys=["symmetry", "ratio"]) # Apply AMNS cg.suppress(k=30, suppression_func=error) # Step: Compute subpixel offsets for candidate points cg.subpixel_register(clean_keys=["suppression"]) # Step: And create a C object cg.generate_cnet(clean_keys=["subpixel"]) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, path="fromlis.lis") # Step: Output a control network to_isis("TestTwoImageMatching.net", cg, mode="wb", networkid="TestTwoImageMatching", targetname="Moon")
def test_two_image(self): # Step: Create an adjacency graph adjacency = get_path('two_image_adjacency.json') cg = CandidateGraph.from_adjacency(adjacency) self.assertEqual(2, cg.number_of_nodes()) self.assertEqual(1, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(extractor_parameters={"nfeatures":500}) for node, attributes in cg.nodes_iter(data=True): self.assertIn(len(attributes['keypoints']), range(490, 511)) # Step: Then apply a FLANN matcher fl = FlannMatcher() for node, attributes in cg.nodes_iter(data=True): fl.add(attributes['descriptors'], key=node) fl.train() for node, attributes in cg.nodes_iter(data=True): descriptors = attributes['descriptors'] matches = fl.query(descriptors, node, k=5) cg.add_matches(matches) for source, destination, attributes in cg.edges_iter(data=True): matches = attributes['matches'] # Perform the symmetry check symmetry_mask = od.mirroring_test(matches) self.assertIn(symmetry_mask.sum(), range(430, 461)) attributes['symmetry'] = symmetry_mask # Perform the ratio test ratio_mask = od.distance_ratio(matches, ratio=0.95) self.assertIn(ratio_mask.sum(), range(390, 451)) attributes['ratio'] = ratio_mask mask = np.array(ratio_mask * symmetry_mask) self.assertIn(len(matches.loc[mask]), range(75,101)) # Step: Compute the homographies and apply RANSAC cg.compute_homographies(clean_keys=['symmetry', 'ratio']) # Step: Compute subpixel offsets for candidate points cg.compute_subpixel_offsets(clean_keys=['symmetry', 'ratio', 'ransac']) # Step: And create a C object cnet = cg.to_cnet(clean_keys=['symmetry', 'ratio', 'ransac', 'subpixel']) # Step update the serial numbers nid_to_serial = {} for node, attributes in cg.nodes_iter(data=True): nid_to_serial[node] = self.serial_numbers[attributes['image_name']] cnet.replace({'nid': nid_to_serial}, inplace=True) # Step: Output a control network to_isis('TestTwoImageMatching.net', cnet, mode='wb', networkid='TestTwoImageMatching', targetname='Moon')
def test_two_image(self): # Step: Create an adjacency graph adjacency = get_path("two_image_adjacency.json") cg = CandidateGraph.from_adjacency(adjacency) self.assertEqual(2, cg.number_of_nodes()) self.assertEqual(1, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(500) for node, attributes in cg.nodes_iter(data=True): self.assertIn(len(attributes["keypoints"]), range(490, 511)) # Step: Then apply a FLANN matcher fl = FlannMatcher() for node, attributes in cg.nodes_iter(data=True): fl.add(attributes["descriptors"], key=node) fl.train() for node, attributes in cg.nodes_iter(data=True): descriptors = attributes["descriptors"] matches = fl.query(descriptors, node, k=5) cg.add_matches(matches) for source, destination, attributes in cg.edges_iter(data=True): matches = attributes["matches"] # Perform the symmetry check symmetry_mask = od.mirroring_test(matches) self.assertIn(symmetry_mask.sum(), range(430, 461)) attributes["symmetry"] = symmetry_mask # Perform the ratio test ratio_mask = od.distance_ratio(matches, ratio=0.95) self.assertIn(ratio_mask.sum(), range(400, 451)) attributes["ratio"] = ratio_mask mask = np.array(ratio_mask * symmetry_mask) self.assertIn(len(matches.loc[mask]), range(75, 101)) cg.compute_homographies(clean_keys=["symmetry", "ratio"]) # Step: And create a C object cnet = cg.to_cnet(clean_keys=["symmetry", "ratio", "ransac"]) # Step update the serial numbers nid_to_serial = {} for node, attributes in cg.nodes_iter(data=True): nid_to_serial[node] = self.serial_numbers[attributes["image_name"]] cnet.replace({"nid": nid_to_serial}, inplace=True) # Step: Output a control network to_isis("TestTwoImageMatching.net", cnet, mode="wb", networkid="TestTwoImageMatching", targetname="Moon")
def test_three_image(self): # Step: Create an adjacency graph adjacency = get_path('three_image_adjacency.json') cg = CandidateGraph.from_adjacency(adjacency) self.assertEqual(3, cg.number_of_nodes()) self.assertEqual(3, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(extractor_parameters={'nfeatures':500}) for node, attributes in cg.nodes_iter(data=True): self.assertIn(len(attributes['keypoints']), range(490, 511)) fl = FlannMatcher() for node, attributes in cg.nodes_iter(data=True): fl.add(attributes['descriptors'], key=node) fl.train() for node, attributes in cg.nodes_iter(data=True): descriptors = attributes['descriptors'] matches = fl.query(descriptors, node, k=5) cg.add_matches(matches) for source, destination, attributes in cg.edges_iter(data=True): matches = attributes['matches'] # Perform the symmetry check symmetry_mask = od.mirroring_test(matches) attributes['symmetry'] = symmetry_mask # Perform the ratio test ratio_mask = od.distance_ratio(matches, ratio=0.8) attributes['ratio'] = ratio_mask cg.compute_homographies(clean_keys=['symmetry', 'ratio']) # Step: And create a C object cnet = cg.to_cnet(clean_keys=['symmetry', 'ratio', 'ransac']) # Step update the serial numbers nid_to_serial = {} for node, attributes in cg.nodes_iter(data=True): nid_to_serial[node] = self.serial_numbers[attributes['image_name']] cnet.replace({'nid': nid_to_serial}, inplace=True) # Step: Output a control network to_isis('TestThreeImageMatching.net', cnet, mode='wb', networkid='TestThreeImageMatching', targetname='Moon')
def test_three_image(self): # Step: Create an adjacency graph adjacency = get_path('three_image_adjacency.json') basepath = get_path('Apollo15') cg = CandidateGraph.from_adjacency(adjacency, basepath) self.assertEqual(3, cg.number_of_nodes()) self.assertEqual(3, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(extractor_parameters={'nfeatures': 500}) for i, node, in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) cg.match_features(k=5) for source, destination, edge in cg.edges_iter(data=True): matches = edge.matches edge.symmetry_check() edge.ratio_check(ratio=0.8) cg.compute_homographies(clean_keys=['symmetry', 'ratio']) # Step: And create a C object cnet = cg.to_cnet(clean_keys=['symmetry', 'ratio', 'ransac']) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, 'TestThreeImageMatching_fromlist.lis') # Step update the serial numbers nid_to_serial = {} for i, node in cg.nodes_iter(data=True): nid_to_serial[i] = self.serial_numbers[node.image_name] cnet.replace({'nid': nid_to_serial}, inplace=True) # Step: Output a control network to_isis('TestThreeImageMatching.net', cnet, mode='wb', networkid='TestThreeImageMatching', targetname='Moon')
def test_three_image(self): # Step: Create an adjacency graph adjacency = get_path('three_image_adjacency.json') basepath = get_path('Apollo15') cg = CandidateGraph.from_adjacency(adjacency, basepath) self.assertEqual(3, cg.number_of_nodes()) self.assertEqual(3, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(extractor_parameters={'nfeatures': 500}) for i, node, in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) cg.match_features(k=5) for source, destination, edge in cg.edges_iter(data=True): edge.symmetry_check() edge.ratio_check(clean_keys=['symmetry'], ratio=0.99) cg.apply_func_to_edges("compute_homography", clean_keys=['symmetry', 'ratio']) cg.compute_fundamental_matrices(clean_keys=['symmetry', 'ratio']) # Step: And create a C object cg.generate_cnet(clean_keys=['symmetry', 'ratio', 'ransac']) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, 'TestThreeImageMatching_fromlist.lis') # Step: Create a correspondence network cg.generate_cnet(clean_keys=['symmetry', 'ratio', 'ransac'], deepen=True) to_isis('TestThreeImageMatching.net', cg, mode='wb', networkid='TestThreeImageMatching', targetname='Moon')
def test_three_image(self): # Step: Create an adjacency graph adjacency = get_path('three_image_adjacency.json') basepath = get_path('Apollo15') cg = CandidateGraph.from_adjacency(adjacency, basepath) self.assertEqual(3, cg.number_of_nodes()) self.assertEqual(3, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(extractor_parameters={'nfeatures':500}) for i, node, in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) cg.match_features(k=5) for source, destination, edge in cg.edges_iter(data=True): matches = edge.matches edge.symmetry_check() edge.ratio_check(ratio=0.8) cg.compute_homographies(clean_keys=['symmetry', 'ratio']) # Step: And create a C object cnet = cg.to_cnet(clean_keys=['symmetry', 'ratio', 'ransac']) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, 'TestThreeImageMatching_fromlist.lis') # Step update the serial numbers nid_to_serial = {} for i, node in cg.nodes_iter(data=True): nid_to_serial[i] = self.serial_numbers[node.image_name] cnet.replace({'nid': nid_to_serial}, inplace=True) # Step: Output a control network to_isis('TestThreeImageMatching.net', cnet, mode='wb', networkid='TestThreeImageMatching', targetname='Moon')
def test_three_image(self): # Step: Create an adjacency graph adjacency = get_path("three_image_adjacency.json") basepath = get_path("Apollo15") cg = CandidateGraph.from_adjacency(adjacency, basepath) self.assertEqual(3, cg.number_of_nodes()) self.assertEqual(3, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(extractor_parameters={"nfeatures": 500}) for i, node in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) cg.match_features(k=5) for source, destination, edge in cg.edges_iter(data=True): edge.symmetry_check() edge.ratio_check(clean_keys=["symmetry"], ratio=0.99) cg.apply_func_to_edges("compute_homography", clean_keys=["symmetry", "ratio"]) # Step: And create a C object cnet = cg.to_cnet(clean_keys=["symmetry", "ratio", "ransac"]) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, "TestThreeImageMatching_fromlist.lis") # Step update the serial numbers nid_to_serial = {} for i, node in cg.nodes_iter(data=True): nid_to_serial[i] = self.serial_numbers[node.image_name] cnet.replace({"nid": nid_to_serial}, inplace=True) # Step: Output a control network to_isis("TestThreeImageMatching.net", cnet, mode="wb", networkid="TestThreeImageMatching", targetname="Moon")
def test_two_image(self): # Step: Create an adjacency graph adjacency = get_path('two_image_adjacency.json') basepath = get_path('Apollo15') cg = CandidateGraph.from_adjacency(adjacency, basepath=basepath) self.assertEqual(2, cg.number_of_nodes()) self.assertEqual(1, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(method='sift', extractor_parameters={"nfeatures":500}) for i, node in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) #Step: Compute the coverage ratios truth_ratios = [0.95351579, 0.93595664] for i, node in cg.nodes_iter(data=True): ratio = node.coverage_ratio() self.assertIn(round(ratio,8), truth_ratios) # Step: apply Adaptive non-maximal suppression for i, node in cg.nodes_iter(data=True): pass #node.anms() #self.assertNotEqual(node.nkeypoints, sum(node._mask_arrays['anms'])) cg.match_features(k=5) for source, destination, edge in cg.edges_iter(data=True): # Perform the symmetry check edge.symmetry_check() self.assertIn(edge.masks['symmetry'].sum(), range(430, 461)) # Perform the ratio test edge.ratio_check(ratio=0.9, clean_keys=['symmetry']) self.assertIn(edge.masks['ratio'].sum(), range(25, 50)) # Step: Compute the homographies and apply RANSAC cg.compute_homographies(clean_keys=['symmetry', 'ratio']) # Step: Compute the overlap ratio and coverage ratio for s, d, edge in cg.edges_iter(data=True): ratio = edge.coverage_ratio(clean_keys=['symmetry', 'ratio']) # Step: Compute subpixel offsets for candidate points cg.subpixel_register(clean_keys=['ransac']) # Step: And create a C object cnet = cg.to_cnet(clean_keys=['symmetry', 'ratio', 'ransac', 'subpixel']) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, path="fromlis.lis") # Step update the serial numbers nid_to_serial = {} for i, node in cg.nodes_iter(data=True): nid_to_serial[i] = self.serial_numbers[node.image_name] cnet.replace({'nid': nid_to_serial}, inplace=True) # Step: Output a control network to_isis('TestTwoImageMatching.net', cnet, mode='wb', networkid='TestTwoImageMatching', targetname='Moon')
def test_two_image(self): # Step: Create an adjacency graph adjacency = get_path('two_image_adjacency.json') basepath = get_path('Apollo15') cg = CandidateGraph.from_adjacency(adjacency, basepath=basepath) self.assertEqual(2, cg.number_of_nodes()) self.assertEqual(1, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(method='sift', extractor_parameters={"nfeatures": 500}) for i, node in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) # Step: Compute the coverage ratios truth_ratios = [0.95351579, 0.93595664] for i, node in cg.nodes_iter(data=True): ratio = node.coverage_ratio() self.assertIn(round(ratio, 8), truth_ratios) cg.match_features(k=2) # Perform the symmetry check cg.symmetry_checks() # Perform the ratio check cg.ratio_checks(clean_keys=['symmetry'], single=True) # Create fundamental matrix cg.compute_fundamental_matrices(clean_keys=['symmetry', 'ratio']) for source, destination, edge in cg.edges_iter(data=True): # Perform the symmetry check self.assertIn(edge.masks['symmetry'].sum(), range(400, 600)) # Perform the ratio test self.assertIn(edge.masks['ratio'].sum(), range(225, 275)) # Range needs to be set self.assertIn(edge.masks['fundamental'].sum(), range(200, 250)) # Step: Compute the homographies and apply RANSAC cg.compute_homographies(clean_keys=['symmetry', 'ratio']) # Apply AMNS cg.suppress(k=30, suppression_func=error) # Step: Compute subpixel offsets for candidate points cg.subpixel_register(clean_keys=['suppression']) # Step: And create a C object cg.generate_cnet(clean_keys=['subpixel']) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, path="fromlis.lis") # Step: Output a control network to_isis('TestTwoImageMatching.net', cg, mode='wb', networkid='TestTwoImageMatching', targetname='Moon')
def test_two_image(self): # Step: Create an adjacency graph adjacency = get_path('two_image_adjacency.json') basepath = get_path('Apollo15') cg = CandidateGraph.from_adjacency(adjacency, basepath=basepath) self.assertEqual(2, cg.number_of_nodes()) self.assertEqual(1, cg.number_of_edges()) # Step: Extract image data and attribute nodes cg.extract_features(method='sift', extractor_parameters={"nfeatures":500}) for i, node in cg.nodes_iter(data=True): self.assertIn(node.nkeypoints, range(490, 511)) #Step: Compute the coverage ratios truth_ratios = [0.95351579, 0.93595664] for i, node in cg.nodes_iter(data=True): ratio = node.coverage_ratio() self.assertIn(round(ratio,8), truth_ratios) # Step: apply Adaptive non-maximal suppression for i, node in cg.nodes_iter(data=True): pass #node.anms() #self.assertNotEqual(node.nkeypoints, sum(node._mask_arrays['anms'])) cg.match_features(k=5) for source, destination, edge in cg.edges_iter(data=True): # Perform the symmetry check edge.symmetry_check() self.assertIn(edge._mask_arrays['symmetry'].sum(), range(430, 461)) # Perform the ratio test edge.ratio_check(ratio=0.8) self.assertIn(edge._mask_arrays['ratio'].sum(), range(250, 350)) # Step: Compute the homographies and apply RANSAC cg.compute_homographies(clean_keys=['symmetry', 'ratio']) # Step: Compute the overlap ratio and coverage ratio for s, d, edge in cg.edges_iter(data=True): ratio = edge.coverage_ratio(clean_keys=['symmetry', 'ratio']) # Step: Compute subpixel offsets for candidate points cg.compute_subpixel_offsets(clean_keys=['ransac']) # Step: And create a C object cnet = cg.to_cnet(clean_keys=['symmetry', 'ratio', 'ransac', 'subpixel']) # Step: Create a fromlist to go with the cnet and write it to a file filelist = cg.to_filelist() write_filelist(filelist, path="fromlis.lis") # Step update the serial numbers nid_to_serial = {} for i, node in cg.nodes_iter(data=True): nid_to_serial[i] = self.serial_numbers[node.image_name] cnet.replace({'nid': nid_to_serial}, inplace=True) # Step: Output a control network to_isis('TestTwoImageMatching.net', cnet, mode='wb', networkid='TestTwoImageMatching', targetname='Moon')
def match_images(args, config_dict): # Matches the images in the input file using various candidate graph methods # produces two files usable in isis try: cg = CandidateGraph.from_adjacency( find_in_dict(config_dict, 'inputfile_path') + args.input_file, basepath=find_in_dict(config_dict, 'basepath')) except: cg = CandidateGraph.from_filelist( find_in_dict(config_dict, 'inputfile_path') + args.input_file) # Apply SIFT to extract features cg.extract_features(method=config_dict['extract_features']['method'], extractor_parameters=find_in_dict( config_dict, 'extractor_parameters')) # Match cg.match_features(k=config_dict['match_features']['k']) # Apply outlier detection cg.apply_func_to_edges('symmetry_check') cg.apply_func_to_edges('ratio_check', ratio=find_in_dict(config_dict, 'ratio'), mask_name=find_in_dict(config_dict, 'mask_name'), single=find_in_dict(config_dict, 'single')) # Compute a homography and apply RANSAC cg.apply_func_to_edges( 'compute_fundamental_matrix', clean_keys=find_in_dict(config_dict, 'fundamental_matrices')['clean_keys'], method=find_in_dict(config_dict, 'fundamental_matrices')['method'], reproj_threshold=find_in_dict(config_dict, 'reproj_threshold'), confidence=find_in_dict(config_dict, 'confidence')) cg.apply_func_to_edges( 'subpixel_register', clean_keys=find_in_dict(config_dict, 'subpixel_register')['clean_keys'], template_size=find_in_dict(config_dict, 'template_size'), threshold=find_in_dict(config_dict, 'threshold'), search_size=find_in_dict(config_dict, 'search_size'), max_x_shift=find_in_dict(config_dict, 'max_x_shift'), max_y_shift=find_in_dict(config_dict, 'max_y_shift'), tiled=find_in_dict(config_dict, 'tiled'), upsampling=find_in_dict(config_dict, 'upsampling'), error_check=find_in_dict(config_dict, 'error_check')) cg.apply_func_to_edges('suppress', clean_keys=find_in_dict(config_dict, 'suppress')['clean_keys'], k=find_in_dict(config_dict, 'suppress')['k'], min_radius=find_in_dict(config_dict, 'min_radius'), error_k=find_in_dict(config_dict, 'error_k')) cnet = cg.to_cnet(clean_keys=find_in_dict(config_dict, 'cnet_conversion')['clean_keys'], isis_serials=True) filelist = cg.to_filelist() write_filelist( filelist, find_in_dict(config_dict, 'outputfile_path') + args.output_file + '.lis') to_isis(find_in_dict(config_dict, 'outputfile_path') + args.output_file + '.net', cnet, mode='wb', networkid=find_in_dict(config_dict, 'networkid'), targetname=find_in_dict(config_dict, 'targetname'), description=find_in_dict(config_dict, 'description'), username=find_in_dict(config_dict, 'username'))