def _resize_worker(gfpath, new_gfpath, new_size): """ worker function for parallel generator """ import vtool as vt img = vt.imread(gfpath) new_img = vt.resize(img, new_size) vt.imwrite(new_gfpath, new_img) return new_gfpath
def test_cv2_flann(): """ Ignore: [name for name in dir(cv2) if 'create' in name.lower()] [name for name in dir(cv2) if 'stereo' in name.lower()] ut.grab_zipped_url('https://priithon.googlecode.com/archive/a6117f5e81ec00abcfb037f0f9da2937bb2ea47f.tar.gz', download_dir='.') """ import cv2 from vtool.tests import dummy import plottool as pt import vtool as vt img1 = vt.imread(ut.grab_test_imgpath('easy1.png')) img2 = vt.imread(ut.grab_test_imgpath('easy2.png')) stereo = cv2.StereoBM_create(numDisparities=16, blockSize=15) disparity = stereo.compute(img1, img2) pt.imshow(disparity) pt.show() #cv2.estima flow = cv2.createOptFlow_DualTVL1() img1, img2 = vt.convert_image_list_colorspace([img1, img2], 'gray', src_colorspace='bgr') img2 = vt.resize(img2, img1.shape[0:2][::-1]) out = img1.copy() flow.calc(img1, img2, out) orb = cv2.ORB_create() kp1, vecs1 = orb.detectAndCompute(img1, None) kp2, vecs2 = orb.detectAndCompute(img2, None) detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") skp = detector.detect(img1) skp, sd = descriptor.compute(img1, skp) tkp = detector.detect(img2) tkp, td = descriptor.compute(img2, tkp) out = img1.copy() cv2.drawKeypoints(img1, kp1, outImage=out) pt.imshow(out) vecs1 = dummy.testdata_dummy_sift(10) vecs2 = dummy.testdata_dummy_sift(10) # NOQA FLANN_INDEX_KDTREE = 0 # bug: flann enums are missing #flann_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=4) index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5) search_params = dict(checks=50) # or pass empty dictionary flann = cv2.FlannBasedMatcher(index_params, search_params) # NOQA cv2.flann.Index(vecs1, index_params) #cv2.FlannBasedMatcher(flann_params) cv2.flann.Index(vecs1, flann_params) # NOQA
def nosql_draw2(check_func, match): from matplotlib.backends.backend_agg import FigureCanvas try: from matplotlib.backends.backend_agg import Figure except ImportError: from matplotlib.figure import Figure was_interactive = mpl.is_interactive() if was_interactive: mpl.interactive(False) # fnum = 32 fig = Figure() canvas = FigureCanvas(fig) # NOQA # fig.clf() ax = fig.add_subplot(1, 1, 1) if check_func is not None and check_func(): return ax, xywh1, xywh2 = match.show(ax=ax) if check_func is not None and check_func(): return savekw = { # 'dpi' : 60, 'dpi': 80, } axes_extents = pt.extract_axes_extents(fig) # assert len(axes_extents) == 1, 'more than one axes' extent = axes_extents[0] with io.BytesIO() as stream: # This call takes 23% - 15% of the time depending on settings fig.savefig(stream, bbox_inches=extent, **savekw) stream.seek(0) data = np.fromstring(stream.getvalue(), dtype=np.uint8) if check_func is not None and check_func(): return pt.plt.close(fig) image = cv2.imdecode(data, 1) thumbsize = 221 max_dsize = (thumbsize, thumbsize) dsize, sx, sy = vt.resized_clamped_thumb_dims( vt.get_size(image), max_dsize) if check_func is not None and check_func(): return image = vt.resize(image, dsize) vt.imwrite(fpath, image) if check_func is not None and check_func(): return
def draw_thumb_helper(tup): thumbsize, gpath, orient, bbox_list, theta_list = tup # time consuming # img = vt.imread(gpath, orient=orient) img = vt.imread(gpath) (gh, gw) = img.shape[0:2] img_size = (gw, gh) if isinstance(thumbsize, int): max_dsize = (thumbsize, thumbsize) dsize, sx, sy = vt.resized_clamped_thumb_dims(img_size, max_dsize) elif isinstance(thumbsize, tuple) and len(thumbsize) == 2: th, tw = thumbsize dsize, sx, sy = thumbsize, tw / gw, th / gh else: raise ValueError('Incompatible thumbsize') new_verts_list = list(vt.scaled_verts_from_bbox_gen(bbox_list, theta_list, sx, sy)) # ----------------- # Actual computation thumb = vt.resize(img, dsize) orange_bgr = (0, 128, 255) for new_verts in new_verts_list: thumb = vt.draw_verts(thumb, new_verts, color=orange_bgr, thickness=2) width, height = dsize return thumb, width, height
def export_to_xml( ibs, species_list, species_mapping=None, offset='auto', enforce_viewpoint=False, target_size=900, purge=False, use_maximum_linear_dimension=True, use_existing_train_test=True, include_parts=False, gid_list=None, output_path=None, allow_empty_images=False, min_annot_size=5, **kwargs, ): """Create training XML for training models.""" import random from datetime import date from wbia.detecttools.pypascalmarkup import PascalVOC_Markup_Annotation logger.info('Received species_mapping = %r' % (species_mapping, )) if species_list is None: species_list = sorted(set(species_mapping.values())) logger.info('Using species_list = %r' % (species_list, )) def _add_annotation( annotation, bbox, theta, species_name, viewpoint, interest, decrease, width, height, part_type=None, ): # Transformation matrix R = vt.rotation_around_bbox_mat3x3(theta, bbox) # Get verticies of the annotation polygon verts = vt.verts_from_bbox(bbox, close=True) # Rotate and transform vertices xyz_pts = vt.add_homogenous_coordinate(np.array(verts).T) trans_pts = vt.remove_homogenous_coordinate(R.dot(xyz_pts)) new_verts = np.round(trans_pts).astype(np.int).T.tolist() x_points = [pt[0] for pt in new_verts] y_points = [pt[1] for pt in new_verts] xmin = int(min(x_points) * decrease) xmax = int(max(x_points) * decrease) ymin = int(min(y_points) * decrease) ymax = int(max(y_points) * decrease) # Bounds check xmin = max(xmin, 0) ymin = max(ymin, 0) xmax = min(xmax, width - 1) ymax = min(ymax, height - 1) # Get info info = {} w_ = xmax - xmin h_ = ymax - ymin if w_ < min_annot_size: return if h_ < min_annot_size: return if viewpoint != -1 and viewpoint is not None: info['pose'] = viewpoint if interest is not None: info['interest'] = '1' if interest else '0' if part_type is not None: species_name = '%s+%s' % ( species_name, part_type, ) area = w_ * h_ logger.info('\t\tAdding %r with area %0.04f pixels^2' % ( species_name, area, )) annotation.add_object(species_name, (xmax, xmin, ymax, ymin), **info) current_year = int(date.today().year) information = {'database_name': ibs.get_dbname()} import datetime now = datetime.datetime.now() folder = 'VOC%d' % (now.year, ) if output_path is None: output_path = ibs.get_cachedir() datadir = join(output_path, 'VOCdevkit', folder) imagedir = join(datadir, 'JPEGImages') annotdir = join(datadir, 'Annotations') setsdir = join(datadir, 'ImageSets') mainsetsdir = join(setsdir, 'Main') if purge: ut.delete(datadir) ut.ensuredir(datadir) ut.ensuredir(imagedir) ut.ensuredir(annotdir) ut.ensuredir(setsdir) ut.ensuredir(mainsetsdir) # Get all gids and process them if gid_list is None: gid_list = sorted(ibs.get_valid_gids()) sets_dict = { 'test': [], 'train': [], 'trainval': [], 'val': [], } index = 1 if offset == 'auto' else offset # Make a preliminary train / test split as imagesets or use the existing ones if not use_existing_train_test: ibs.imageset_train_test_split(**kwargs) train_gid_set = set(general_get_imageset_gids(ibs, 'TRAIN_SET', **kwargs)) test_gid_set = set(general_get_imageset_gids(ibs, 'TEST_SET', **kwargs)) logger.info('Exporting %d images' % (len(gid_list), )) for gid in gid_list: aid_list = ibs.get_image_aids(gid) image_uri = ibs.get_image_uris(gid) image_path = ibs.get_image_paths(gid) if len(aid_list) > 0 or allow_empty_images: fulldir = image_path.split('/') filename = fulldir.pop() extension = filename.split('.')[-1] # NOQA out_name = '%d_%06d' % ( current_year, index, ) out_img = '%s.jpg' % (out_name, ) _image = ibs.get_images(gid) height, width, channels = _image.shape condition = width > height if use_maximum_linear_dimension else width < height if condition: ratio = height / width decrease = target_size / width width = target_size height = int(target_size * ratio) else: ratio = width / height decrease = target_size / height height = target_size width = int(target_size * ratio) dst_img = join(imagedir, out_img) _image = vt.resize(_image, (width, height)) vt.imwrite(dst_img, _image) annotation = PascalVOC_Markup_Annotation(dst_img, folder, out_img, source=image_uri, **information) bbox_list = ibs.get_annot_bboxes(aid_list) theta_list = ibs.get_annot_thetas(aid_list) species_name_list = ibs.get_annot_species_texts(aid_list) viewpoint_list = ibs.get_annot_viewpoints(aid_list) interest_list = ibs.get_annot_interest(aid_list) part_rowids_list = ibs.get_annot_part_rowids(aid_list) zipped = zip( bbox_list, theta_list, species_name_list, viewpoint_list, interest_list, part_rowids_list, ) for ( bbox, theta, species_name, viewpoint, interest, part_rowid_list, ) in zipped: if species_mapping is not None: species_name = species_mapping.get(species_name, species_name) if species_name is not None and species_name not in species_list: continue _add_annotation( annotation, bbox, theta, species_name, viewpoint, interest, decrease, width, height, ) if include_parts and len(part_rowid_list) > 0: part_bbox_list = ibs.get_part_bboxes(part_rowid_list) part_theta_list = ibs.get_part_thetas(part_rowid_list) part_type_list = ibs.get_part_types(part_rowid_list) part_zipped = zip(part_bbox_list, part_theta_list, part_type_list) for part_bbox, part_theta, part_type in part_zipped: part_viewpoint = viewpoint part_interest = None _add_annotation( annotation, part_bbox, part_theta, species_name, part_viewpoint, part_interest, decrease, width, height, part_type=part_type, ) out_filename = '%s.xml' % (out_name, ) dst_annot = join(annotdir, out_filename) if gid in test_gid_set: sets_dict['test'].append(out_name) elif gid in train_gid_set: state = random.uniform(0.0, 1.0) if state <= 0.75: sets_dict['train'].append(out_name) sets_dict['trainval'].append(out_name) else: sets_dict['val'].append(out_name) sets_dict['trainval'].append(out_name) else: raise AssertionError( 'All gids must be either in the TRAIN_SET or TEST_SET imagesets' ) # Write XML logger.info('Copying:\n%r\n%r\n%r\n\n' % ( image_path, dst_img, (width, height), )) xml_data = open(dst_annot, 'w') xml_data.write(annotation.xml()) xml_data.close() while exists(dst_annot): index += 1 if offset != 'auto': break out_filename = '%d_%06d.xml' % ( current_year, index, ) dst_annot = join(annotdir, out_filename) else: logger.info('Skipping:\n%r\n\n' % (image_path, )) for key in sets_dict.keys(): manifest_filename = '%s.txt' % (key, ) manifest_filepath = join(mainsetsdir, manifest_filename) with open(manifest_filepath, 'w') as file_: sets_dict[key].append('') content = sets_dict[key] content = '\n'.join(content) file_.write(content) logger.info('...completed') return datadir
def export_to_coco( ibs, species_list, species_mapping={}, viewpoint_mapping={}, target_size=2400, use_maximum_linear_dimension=True, use_existing_train_test=True, include_parts=False, gid_list=None, include_reviews=True, require_image_reviewed=False, require_named=False, output_images=True, use_global_train_set=False, **kwargs, ): """Create training COCO dataset for training models.""" from datetime import date import datetime import random import json logger.info('Received species_mapping = %r' % (species_mapping, )) logger.info('Received viewpoint_mapping = %r' % (viewpoint_mapping, )) if species_list is None: species_list = sorted(set(species_mapping.values())) logger.info('Using species_list = %r' % (species_list, )) current_year = int(date.today().year) datadir = abspath(join(ibs.get_cachedir(), 'coco')) annotdir = join(datadir, 'annotations') imagedir = join(datadir, 'images') image_dir_dict = { 'train': join(imagedir, 'train%s' % (current_year, )), 'val': join(imagedir, 'val%s' % (current_year, )), 'test': join(imagedir, 'test%s' % (current_year, )), } ut.delete(datadir) ut.ensuredir(datadir) ut.ensuredir(annotdir) ut.ensuredir(imagedir) for dataset in image_dir_dict: ut.ensuredir(image_dir_dict[dataset]) info = { 'description': 'Wild Me %s Dataset' % (ibs.dbname, ), # 'url' : 'http://www.greatgrevysrally.com', 'url': 'http://www.wildme.org', 'version': '1.0', 'year': current_year, 'contributor': 'Wild Me <*****@*****.**>', 'date_created': datetime.datetime.utcnow().isoformat(' '), 'name': ibs.get_db_name(), 'uuid': str(ibs.get_db_init_uuid()), } licenses = [ { 'url': 'http://creativecommons.org/licenses/by-nc-nd/2.0/', 'id': 3, 'name': 'Attribution-NonCommercial-NoDerivs License', }, ] assert len(species_list) == len( set(species_list)), 'Cannot have duplicate species in species_list' category_dict = {} categories = [] for index, species in enumerate(sorted(species_list)): species = species_mapping.get(species, species) categories.append({ 'id': index, 'name': species, 'supercategory': 'animal' }) category_dict[species] = index def _add_annotation_or_part( image_index, annot_index, annot_uuid, bbox, theta, species_name, viewpoint, interest, annot_name, decrease, width, height, individuals, part_index=None, part_uuid=None, ): is_part = part_index is not None R = vt.rotation_around_bbox_mat3x3(theta, bbox) verts = vt.verts_from_bbox(bbox, close=True) xyz_pts = vt.add_homogenous_coordinate(np.array(verts).T) trans_pts = vt.remove_homogenous_coordinate(R.dot(xyz_pts)) new_verts = np.round(trans_pts).astype(np.int).T.tolist() x_points = [int(np.around(pt[0] * decrease)) for pt in new_verts] y_points = [int(np.around(pt[1] * decrease)) for pt in new_verts] segmentation = ut.flatten(list(zip(x_points, y_points))) xmin = max(min(x_points), 0) ymin = max(min(y_points), 0) xmax = min(max(x_points), width - 1) ymax = min(max(y_points), height - 1) w = xmax - xmin h = ymax - ymin area = w * h xtl_, ytl_, w_, h_ = bbox xtl_ *= decrease ytl_ *= decrease w_ *= decrease h_ *= decrease annot_part = { 'bbox': [xtl_, ytl_, w_, h_], 'theta': theta, 'viewpoint': viewpoint, 'segmentation': [segmentation], 'segmentation_bbox': [xmin, ymin, w, h], 'area': area, 'iscrowd': 0, 'id': part_index if is_part else annot_index, 'image_id': image_index, 'category_id': category_dict[species_name], 'uuid': str(part_uuid if is_part else annot_uuid), 'individual_ids': individuals, } if is_part: annot_part['annot_id'] = annot_index else: annot_part['isinterest'] = int(interest) annot_part['name'] = annot_name return annot_part, area output_dict = {} for dataset in ['train', 'val', 'test']: output_dict[dataset] = { 'info': info, 'licenses': licenses, 'categories': categories, 'images': [], 'annotations': [], 'parts': [], } # Get all gids and process them if gid_list is None: if require_named: aid_list = ibs.get_valid_aids() species_list_ = ibs.get_annot_species(aid_list) flag_list = [ species_mapping.get(species_, species_) in species_list for species_ in species_list_ ] aid_list = ut.compress(aid_list, flag_list) nid_list = ibs.get_annot_nids(aid_list) flag_list = [nid >= 0 for nid in nid_list] aid_list = ut.compress(aid_list, flag_list) gid_list = list(set(ibs.get_annot_gids(aid_list))) else: gid_list = ibs.get_valid_gids() if require_image_reviewed: image_reviewed_list = ibs.get_image_reviewed(gid_list) gid_list = ut.compress(gid_list, image_reviewed_list) gid_list = sorted(list(set(gid_list))) # Make a preliminary train / test split as imagesets or use the existing ones if not use_existing_train_test: ibs.imageset_train_test_split(**kwargs) train_gid_set = set(general_get_imageset_gids(ibs, 'TRAIN_SET', **kwargs)) test_gid_set = set(general_get_imageset_gids(ibs, 'TEST_SET', **kwargs)) image_index = 1 annot_index = 1 part_index = 1 aid_dict = {} logger.info('Exporting %d images' % (len(gid_list), )) for gid in gid_list: if use_global_train_set: dataset = 'train' else: if gid in test_gid_set: dataset = 'test' elif gid in train_gid_set: state = random.uniform(0.0, 1.0) if state <= 0.75: dataset = 'train' else: dataset = 'val' else: # raise AssertionError('All gids must be either in the TRAIN_SET or TEST_SET imagesets') logger.info('GID = %r was not in the TRAIN_SET or TEST_SET' % (gid, )) dataset = 'test' width, height = ibs.get_image_sizes(gid) if target_size is None: decrease = 1.0 else: condition = width > height if use_maximum_linear_dimension else width < height if condition: ratio = height / width decrease = target_size / width width = target_size height = int(target_size * ratio) else: ratio = width / height decrease = target_size / height height = target_size width = int(target_size * ratio) image_path = ibs.get_image_paths(gid) image_filename = '%012d.jpg' % (image_index, ) image_filepath = join(image_dir_dict[dataset], image_filename) if output_images: _image = ibs.get_images(gid) _image = vt.resize(_image, (width, height)) vt.imwrite(image_filepath, _image) image_gps = ibs.get_image_gps(gid) if image_gps is None or len(image_gps) != 2 or None in image_gps: image_gps_lat, image_gps_lon = None else: image_gps_lat, image_gps_lon = image_gps image_gps_lat = '%03.06f' % (image_gps_lat, ) image_gps_lon = '%03.06f' % (image_gps_lon, ) output_dict[dataset]['images'].append({ 'license': 3, 'file_name': image_filename, # 'file_name' : basename(ibs.get_image_uris_original(gid)), 'photographer': ibs.get_image_notes(gid), 'coco_url': None, 'height': height, 'width': width, 'date_captured': ibs.get_image_datetime_str(gid).replace('/', '-'), 'gps_lat_captured': image_gps_lat, 'gps_lon_captured': image_gps_lon, 'flickr_url': None, 'id': image_index, 'uuid': str(ibs.get_image_uuids(gid)), }) logger.info('Copying:\n%r\n%r\n%r\n\n' % ( image_path, image_filepath, (width, height), )) aid_list = ibs.get_image_aids(gid) bbox_list = ibs.get_annot_bboxes(aid_list) theta_list = ibs.get_annot_thetas(aid_list) species_name_list = ibs.get_annot_species_texts(aid_list) viewpoint_list = ibs.get_annot_viewpoints(aid_list) interest_list = ibs.get_annot_interest(aid_list) annot_uuid_list = ibs.get_annot_uuids(aid_list) annot_name_list = ibs.get_annot_name_texts(aid_list) part_rowids_list = ibs.get_annot_part_rowids(aid_list) nid_list = ibs.get_annot_nids(aid_list) zipped = zip( aid_list, bbox_list, theta_list, species_name_list, viewpoint_list, interest_list, annot_uuid_list, annot_name_list, part_rowids_list, nid_list, ) for ( aid, bbox, theta, species_name, viewpoint, interest, annot_uuid, annot_name, part_rowid_list, nid, ) in zipped: species_name = species_mapping.get(species_name, species_name) if species_name is None: continue if species_name not in species_list: continue if require_named and nid < 0: continue viewpoint = viewpoint_mapping.get(species_name, {}).get(viewpoint, viewpoint) # if viewpoint is None: # continue individuals = ibs.get_name_aids(ibs.get_annot_nids(aid)) # Transformation matrix annot, area = _add_annotation_or_part( image_index, annot_index, annot_uuid, bbox, theta, species_name, viewpoint, interest, annot_name, decrease, width, height, individuals, ) logger.info('\t\tAdding annot %r with area %0.04f pixels^2' % ( species_name, area, )) if include_reviews: reviews = ibs.get_review_rowids_from_single([aid])[0] user_list = ibs.get_review_identity(reviews) aid_tuple_list = ibs.get_review_aid_tuple(reviews) decision_list = ibs.get_review_decision_str(reviews) ids = [] decisions = [] zipped = zip(user_list, aid_tuple_list, decision_list) for user, aid_tuple, decision in zipped: if 'user:web' not in user: continue match = list(set(aid_tuple) - set([aid])) assert len(match) == 1 ids.append(match[0]) decisions.append(decision.lower()) annot['review_ids'] = list(zip(ids, decisions)) output_dict[dataset]['annotations'].append(annot) if include_parts and len(part_rowid_list) > 0: part_uuid_list = ibs.get_part_uuids(part_rowid_list) part_bbox_list = ibs.get_part_bboxes(part_rowid_list) part_theta_list = ibs.get_part_thetas(part_rowid_list) part_type_list = ibs.get_part_types(part_rowid_list) part_zipped = zip(part_uuid_list, part_bbox_list, part_theta_list, part_type_list) for part_uuid, part_bbox, part_theta, part_type in part_zipped: part_species_name = '%s+%s' % ( species_name, part_type, ) part_species_name = species_mapping.get( part_species_name, part_species_name) if part_species_name is None: continue if part_species_name not in species_list: continue part, area = _add_annotation_or_part( image_index, annot_index, annot_uuid, part_bbox, part_theta, part_species_name, viewpoint, interest, annot_name, decrease, width, height, individuals, part_index=part_index, part_uuid=part_uuid, ) logger.info( '\t\tAdding part %r with area %0.04f pixels^2' % ( part_species_name, area, )) output_dict[dataset]['parts'].append(part) part_index += 1 aid_dict[aid] = annot_index annot_index += 1 image_index += 1 for dataset in output_dict: annots = output_dict[dataset]['annotations'] for index in range(len(annots)): annot = annots[index] # Map internal aids to external annot index individual_ids = annot['individual_ids'] individual_ids_ = [] for individual_id in individual_ids: if individual_id not in aid_dict: continue individual_id_ = aid_dict[individual_id] individual_ids_.append(individual_id_) annot['individual_ids'] = individual_ids_ # Map reviews if include_reviews: review_ids = annot['review_ids'] review_ids_ = [] for review in review_ids: review_id, review_decision = review if review_id not in aid_dict: continue review_id_ = aid_dict[review_id] review_ = ( review_id_, review_decision, ) review_ids_.append(review_) annot['review_ids'] = review_ids_ # Store output_dict[dataset]['annotations'][index] = annot for dataset in output_dict: json_filename = 'instances_%s%s.json' % ( dataset, current_year, ) json_filepath = join(annotdir, json_filename) with open(json_filepath, 'w') as json_file: json.dump(output_dict[dataset], json_file) logger.info('...completed') return datadir
def nosql_draw(check_func, rchip1_fpath, rchip2_fpath, kpts1, kpts2): # This gets executed in the child thread and does drawing async style #from matplotlib.backends.backend_pdf import FigureCanvasPdf as FigureCanvas #from matplotlib.backends.backend_pdf import Figure #from matplotlib.backends.backend_svg import FigureCanvas #from matplotlib.backends.backend_svg import Figure from matplotlib.backends.backend_agg import FigureCanvas try: from matplotlib.backends.backend_agg import Figure except ImportError: from matplotlib.figure import Figure kpts1_ = vt.offset_kpts(kpts1, (0, 0), (resize_factor, resize_factor)) kpts2_ = vt.offset_kpts(kpts2, (0, 0), (resize_factor, resize_factor)) #from matplotlib.figure import Figure if check_func is not None and check_func(): return rchip1 = vt.imread(rchip1_fpath) rchip1 = vt.resize_image_by_scale(rchip1, resize_factor) if check_func is not None and check_func(): return rchip2 = vt.imread(rchip2_fpath) rchip2 = vt.resize_image_by_scale(rchip2, resize_factor) if check_func is not None and check_func(): return try: idx = cm.daid2_idx[daid] fm = cm.fm_list[idx] fsv = None if cm.fsv_list is None else cm.fsv_list[idx] fs = None if fsv is None else fsv.prod(axis=1) except KeyError: fm = [] fs = None fsv = None maxnum = 200 if fs is not None and len(fs) > maxnum: # HACK TO ONLY SHOW TOP MATCHES sortx = fs.argsort()[::-1] fm = fm.take(sortx[:maxnum], axis=0) fs = fs.take(sortx[:maxnum], axis=0) was_interactive = mpl.is_interactive() if was_interactive: mpl.interactive(False) #fnum = 32 fig = Figure() canvas = FigureCanvas(fig) # NOQA #fig.clf() ax = fig.add_subplot(1, 1, 1) if check_func is not None and check_func(): return #fig = pt.plt.figure(fnum) #H1 = np.eye(3) #H2 = np.eye(3) #H1[0, 0] = .5 #H1[1, 1] = .5 #H2[0, 0] = .5 #H2[1, 1] = .5 ax, xywh1, xywh2 = pt.show_chipmatch2(rchip1, rchip2, kpts1_, kpts2_, fm, fs=fs, colorbar_=False, ax=ax) if check_func is not None and check_func(): return savekw = { # 'dpi' : 60, 'dpi' : 80, } axes_extents = pt.extract_axes_extents(fig) #assert len(axes_extents) == 1, 'more than one axes' extent = axes_extents[0] with io.BytesIO() as stream: # This call takes 23% - 15% of the time depending on settings fig.savefig(stream, bbox_inches=extent, **savekw) stream.seek(0) data = np.fromstring(stream.getvalue(), dtype=np.uint8) if check_func is not None and check_func(): return pt.plt.close(fig) image = cv2.imdecode(data, 1) thumbsize = 221 max_dsize = (thumbsize, thumbsize) dsize, sx, sy = vt.resized_clamped_thumb_dims(vt.get_size(image), max_dsize) if check_func is not None and check_func(): return image = vt.resize(image, dsize) vt.imwrite(fpath, image) if check_func is not None and check_func(): return