def get_ability_icons_ref(): """Read in all ability icons. Author: Appcell Args: None Returns: A dict of all ability icons, with chara names as keys and list of all abilities of this chara as values. """ res_owl = {} res_custom = {} for (chara, ability_list) in ABILITY_LIST.iteritems(): icons_list_owl = [] icons_list_custom = [] for i in ability_list: icon = ImageUtils.rgb_to_gray( ImageUtils.read("./images/abilities/" + chara + "/" + str(i) + ".png")) icons_list_owl.append( ImageUtils.resize(icon, ABILITY_ICON_WIDTH[GAMETYPE_OWL], ABILITY_ICON_HEIGHT[GAMETYPE_OWL])) icons_list_custom.append( ImageUtils.resize(icon, ABILITY_ICON_WIDTH[GAMETYPE_CUSTOM], ABILITY_ICON_HEIGHT[GAMETYPE_CUSTOM])) res_owl[chara] = icons_list_owl res_custom[chara] = icons_list_custom return {GAMETYPE_OWL: res_owl, GAMETYPE_CUSTOM: res_custom}
def generate_content(self): self.img_path = self.parameters.get('image_path') or choice( DATABASE[DRAWING_RESRC_NAME]) img = Image.open(self.img_path).convert('L') self.contrast_factor = uniform(*DRAWING_CONTRAST_FACTOR_RANGE) self.as_negative = self.parameters.get('as_negative', False) self.blur_radius = uniform( *NEG_ELEMENT_BLUR_RADIUS_RANGE) if self.as_negative else None self.opacity = randint( *NEG_ELEMENT_OPACITY_RANGE[self.name] if self. as_negative else POS_ELEMENT_OPACITY_RANGE[self.name]) self.colored = choice( [True, False], p=[DRAWING_WITH_COLOR_FREQ, 1 - DRAWING_WITH_COLOR_FREQ]) if self.colored: self.color_channels = choice(range(3), randint(1, 2), replace=False) self.other_channel_intensity = [randint(0, 100) for _ in range(3)] self.hue_color = randint(0, 360) else: self.color_channels, self.color_intensity = None, None self.with_background = choice( [True, False], p=[DRAWING_WITH_BACKGROUND_FREQ, 1 - DRAWING_WITH_BACKGROUND_FREQ]) if self.with_background: self.color, self.label = IMAGE_COLOR, IMAGE_LABEL blured_border_width = randint(*BLURED_BORDER_WIDTH_RANGE) max_size = [s - 2 * blured_border_width for s in self.size] img = resize(img, max_size) bg = Image.open(choice( DATABASE[DRAWING_BACKGROUND_RESRC_NAME])).resize(img.size) new_img = cv2.cvtColor(np.array(bg), cv2.COLOR_RGB2HSV) new_img[:, :, 0] = randint(0, 360) background = Image.fromarray( cv2.cvtColor(new_img, cv2.COLOR_HSV2RGB)) if not self.colored: background = background.convert('L').convert('RGB') self.background = background self.blured_border_width = blured_border_width else: img = resize(img, self.size) self.background, self.blured_border_width = None, 0 self.img = img self.content_width, self.content_height = self.img.size self.pos_x = randint(0, self.width - self.content_width) self.pos_y = randint(0, self.height - self.content_height) label_path = Path(self.img_path).parent / SEG_GROUND_TRUTH_FMT.format( Path(self.img_path).stem, 'png') self.mask_label = np.array( resize(Image.open(label_path), self.img.size, False, resample=Image.NEAREST))
def download(url: str, gen_pdf=True, save_img=True, quality=96, concurrent=6, resume=False) -> None: print('Preparing...') url = get_base_url(url) sep = url[:-11].rfind('/') book_id = url[sep + 1:sep + 9] img_dir = 'clawed_' + book_id need_cookie = ('/books/' in url) # magic cookie = get_cookie() if need_cookie else {} session = requests.session() session.cookies = requests.utils.cookiejar_from_dict(cookie) session.headers.update({ 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36' }) if resume: print('Resuming...') imgs = resume_file(img_dir) elif '/book4/' in url: url = url[:-11] imgs = claw_book4(url, concurrent, session) else: print('Unable to download concurrently due to limitations.') imgs = claw(url, session) if quality < 96: print('Optimizing images...') for img_list in imgs.values(): resize(img_list, quality) if save_img: print('Saving images...') os.makedirs(img_dir, exist_ok=True) for chapter_id, img_list in imgs.items(): for i, img in enumerate(img_list): with open(img_dir + f'/{chapter_id}_{i:04d}.jpg', 'wb') as file: file.write(img) print(f'Image folder path: {img_dir}') if gen_pdf: print('Generating PDF...') pdf_path = book_id + '.pdf' generate_pdf(pdf_path, imgs) print(f'PDF path: {pdf_path}') print('Done.')
def get_random_noise_pattern(width, height): pattern_path = choice(DATABASE[NOISE_PATTERN_RESRC_NAME]) pattern_type = Path(pattern_path).parent.name img = Image.open(pattern_path).convert('L') size_min, size_max = NOISE_PATTERN_SIZE_RANGE[pattern_type] size_max = min(min(width, height), size_max) size = (randint(size_min, size_max), randint(size_min, size_max)) if pattern_type in ['border_hole', 'corner_hole']: img = resize(img, size, keep_aspect_ratio=True, resample=Image.ANTIALIAS) rotation = choice( [None, Image.ROTATE_90, Image.ROTATE_180, Image.ROTATE_270]) if rotation is not None: img = img.transpose(rotation) if pattern_type == 'border_hole': if rotation is None: position = ((randint(0, width - img.size[0]), 0)) elif rotation == Image.ROTATE_90: position = (0, randint(0, height - img.size[1])) elif rotation == Image.ROTATE_180: position = ((randint(0, width - img.size[0]), height - img.size[1])) else: position = (width - img.size[0], randint(0, height - img.size[1])) else: if rotation is None: position = (0, 0) elif rotation == Image.ROTATE_90: position = (0, height - img.size[1]) elif rotation == Image.ROTATE_180: position = (width - img.size[0], height - img.size[1]) else: position = (width - img.size[0], 0) else: img = resize(img, size, keep_aspect_ratio=False, resample=Image.ANTIALIAS) rotation = randint(0, 360) img = img.rotate(rotation, fillcolor=255) pad = max(img.width, img.height) position = (randint(0, max(0, width - pad)), randint(0, max(0, height - pad))) alpha = uniform(*NOISE_PATTERN_OPACITY_RANGE) arr = np.array(img.convert('RGBA')) arr[:, :, 3] = (255 - arr[:, :, 2]) * alpha hue_color = randint(0, 360) value_ratio = uniform(0.95, 1) return Image.fromarray(arr), hue_color, value_ratio, position
def _get_avatars_before_validation(self): """Get fused avatar icons for this frame. Used when Game info is not set. First pick team colors from current frame, then overlay transparent icons on them and form new avatars. Color of background image corresponds to team color of current player. Author: Appcell Args: None Returns: A dict of all avatar icons fused """ team_colors = self.get_team_colors() avatars_left_ref = {} avatars_small_left_ref = {} avatars_right_ref = {} avatars_small_right_ref = {} # Create background image with team color bg_image_left = ImageUtils.create_bg_image(team_colors["left"], OW.AVATAR_WIDTH_REF, OW.AVATAR_HEIGHT_REF) bg_image_right = ImageUtils.create_bg_image(team_colors["right"], OW.AVATAR_WIDTH_REF, OW.AVATAR_HEIGHT_REF) avatars_ref = OW.get_avatars_ref() # Overlay transparent reference avatar on background for (name, avatar_ref) in avatars_ref.iteritems(): avatars_left_ref[name] = ImageUtils.overlay( bg_image_left, avatar_ref) avatars_small_left_ref[name] = ImageUtils.resize( ImageUtils.overlay(bg_image_left, avatar_ref), 33, 26) avatars_right_ref[name] = ImageUtils.overlay( bg_image_right, avatar_ref) avatars_small_right_ref[name] = ImageUtils.resize( ImageUtils.overlay(bg_image_right, avatar_ref), 33, 26) return { "left": avatars_left_ref, "left_small": avatars_small_left_ref, "right": avatars_right_ref, "right_small": avatars_small_right_ref }
def loadImageAndTarget(sample, augmentation): # Load image img = image.openImage(sample[0], cfg.IM_DIM) # Resize Image img = image.resize(img, cfg.IM_SIZE[0], cfg.IM_SIZE[1], mode=cfg.RESIZE_MODE) # Do image Augmentation if augmentation: img = image.augment(img, cfg.IM_AUGMENTATION, cfg.AUGMENTATION_COUNT, cfg.AUGMENTATION_PROBABILITY) # Prepare image for net input img = image.normalize(img, cfg.ZERO_CENTERED_NORMALIZATION) img = image.prepare(img) # Get target label = sample[1] index = cfg.CLASSES.index(label) target = np.zeros((len(cfg.CLASSES)), dtype='float32') target[index] = 1.0 return img, target
def __init__(self, frame_image, frame_time, game): """Initialize a Frame object. Author: Appcell Args: frame_image: the image cropped from video for this frame frame_time: time of frame in video, in seconds game: the Game object which controls all frames Returns: None """ self.is_valid = True self.players = [] self.killfeeds = [] self.image = ImageUtils.resize(frame_image, 1280, 720) self.time = frame_time self.game = game print self.time self.get_players() self.get_killfeeds() self.validate() # if self.time == 8.5: self.free()
def get_data_tensor_info(self, im): im_, im_scale = resize(im, self.target_size, self.max_size, stride=self.image_stride) im_tensor = transform(im_, self.pixel_means) im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data_tensor_info = [mx.nd.array(im_tensor), mx.nd.array(im_info)] return data_tensor_info
def __init__(self, frame_image, frame_time, game): """Initialize a Frame object. Author: Appcell Args: frame_image: the image cropped from video for this frame frame_time: time of frame in video, in seconds game: the Game object which controls all frames Returns: None """ self.is_valid = False self.players = [] self.killfeeds = [] self.image = ImageUtils.resize(frame_image, 1280, 720) self.time = frame_time self.game = game if self.game.ult_colors is None: self.game.set_ult_colors(self) # Gui.gui_instance.show_progress(self.time) print self.time self.get_players() self.get_killfeeds() self.validate() self.free()
def multi_detect_input(im): #print(im.shape) target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array( [[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data_idx = [{"data": im_tensor, "im_info": im_info}] data_idx = [[ mx.nd.array(data_idx[i][name]) for name in data_names ] for i in xrange(len(data_idx))] data_batch = mx.io.DataBatch( data=[data_idx[0]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(data_names, data_idx[0])]], provide_label=[None]) scales = [ data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data)) ] return data_batch, scales
def transform(self, img, is_gt=False, **augm_kwargs): if self.img_size is not None: resample = Image.NEAREST if is_gt else Image.ANTIALIAS if self.data_augmentation: size = tuple(map(lambda s: round(augm_kwargs['sampling_ratio'] * s), self.img_size)) if self.sampling_max_nb_pixels is not None and self.keep_aspect_ratio: ratio = float(min([s1 / s2 for s1, s2 in zip(size, img.size)])) real_size = round(ratio * img.size[0]), round(ratio * img.size[1]) nb_pixels = np.product(real_size) if nb_pixels > self.sampling_max_nb_pixels: ratio = float(np.sqrt(self.sampling_max_nb_pixels / nb_pixels)) size = round(ratio * real_size[0]), round(ratio * real_size[1]) else: size = self.img_size img = resize(img, size=size, keep_aspect_ratio=self.keep_aspect_ratio, resample=resample) if self.data_augmentation: if not is_gt: img = img.filter(ImageFilter.GaussianBlur(radius=augm_kwargs['blur_radius'])) img = ImageEnhance.Brightness(img).enhance(augm_kwargs['brightness']) img = ImageEnhance.Contrast(img).enhance(augm_kwargs['contrast']) resample = Image.NEAREST if is_gt else Image.BICUBIC img = img.rotate(augm_kwargs['rotation'], resample=resample, fillcolor=CONTEXT_BACKGROUND_COLOR) if augm_kwargs['transpose'] is not None: img = img.transpose(augm_kwargs['transpose']) return img
def generate_batch(im): """ preprocess image, return batch :param im: cv2.imread returns [height, width, channel] in BGR :return: data_batch: MXNet input batch data_names: names in data_batch im_scale: float number """ SHORT_SIDE = config.SCALES[0][0] LONG_SIDE = config.SCALES[0][1] PIXEL_MEANS = config.network.PIXEL_MEANS DATA_NAMES = ['data', 'im_info'] im_array, im_scale = resize(im, SHORT_SIDE, LONG_SIDE) im_array = transform(im_array, PIXEL_MEANS) im_info = np.array([[im_array.shape[2], im_array.shape[3], im_scale]], dtype=np.float32) data = [[mx.nd.array(im_array), mx.nd.array(im_info)]] data_shapes = [[('data', im_array.shape), ('im_info', im_info.shape)]] data_batch = mx.io.DataBatch(data=data, label=[None], provide_data=data_shapes, provide_label=[None]) return data_batch, DATA_NAMES, [im_scale]
def CFIm(cfs, coords, coord, shape): ''' Extracts single CF as a PIL image (normalized) ''' assert coord in coords normalize = lambda arr: (arr - arr.min()) / (arr.max() - arr.min()) ind = np.argmax(np.all(coords==coord,1)) return image.resize(image.greyscale_image(normalize(cfs[:,:,ind])), shape)
def main(im_name, frame, score): data = [] # only resize input image to target size and return scale im, im_scale = resize(frame, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data.append({'data': im_tensor, 'im_info': im_info}) data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] data_batch = mx.io.DataBatch(data=[data[0]], label=[], pad=0, index=0, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[0])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] tic() scores, boxes, masks, data_dict = im_detect(predictor, data_batch, data_names, scales, config) im_shapes = [data_batch.data[i][0].shape[2:4] for i in xrange(len(data_batch.data))] masks = masks[0][:, 1:, :, :] im_height = np.round(im_shapes[0][0] / scales[0]).astype('int') im_width = np.round(im_shapes[0][1] / scales[0]).astype('int') # print (im_height, im_width) boxes = clip_boxes(boxes[0], (im_height, im_width)) result_masks, result_dets = cpu_mask_voting(masks, boxes, scores[0], num_classes, 100, im_width, im_height, config.TEST.NMS, config.TEST.MASK_MERGE_THRESH, config.BINARY_THRESH) dets = [result_dets[j] for j in range(1, num_classes)] masks = [result_masks[j][:, 0, :, :] for j in range(1, num_classes)] print 'testing {} {:.4f}s'.format(im_name, toc()) min_confidence = score # visualize for i in xrange(len(dets)): keep = np.where(dets[i][:,-1] > min_confidence) dets[i] = dets[i][keep] masks[i] = masks[i][keep] ''' dets: [ numpy.ndarray([[x1 y1 x2 y2 score]]) for j in classes ] [x1 y1] - upper left corner of object [x2 y2] - lower right corner of object masks: [ numpy.ndarray([21, 21]) for j in classes ] confidence that pixel belongs to object ''' for i in range(len(dets)): if len(dets[i]) > 0: for j in range(len(dets[i])): print('{name}: {score} ({loc})'.format(name = classes[i], score = dets[i][j][-1], loc = dets[i][j][:-1].tolist()))
def fcis_seg(image, classes, predictor, args): num_classes = len(classes) + 1 data = [] target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(image, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) start = time.time() im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data.append({'data': im_tensor, 'im_info': im_info}) data_names = ['data', 'im_info'] data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] data_batch = mx.io.DataBatch(data=[data[0]], label=[], pad=0, index=0, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[0])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] scores, boxes, masks, data_dict = im_detect(predictor, data_batch, data_names, scales, config) im_shapes = [data_batch.data[i][0].shape[2:4] for i in xrange(len(data_batch.data))] if not config.TEST.USE_MASK_MERGE: all_boxes = [[] for _ in xrange(num_classes)] all_masks = [[] for _ in xrange(num_classes)] nms = py_nms_wrapper(config.TEST.NMS) for j in range(1, num_classes): indexes = np.where(scores[0][:, j] > 0.7)[0] cls_scores = scores[0][indexes, j, np.newaxis] cls_masks = masks[0][indexes, 1, :, :] try: if config.CLASS_AGNOSTIC: cls_boxes = boxes[0][indexes, :] else: raise Exception() except: cls_boxes = boxes[0][indexes, j * 4:(j + 1) * 4] cls_dets = np.hstack((cls_boxes, cls_scores)) keep = nms(cls_dets) all_boxes[j] = cls_dets[keep, :] all_masks[j] = cls_masks[keep, :] dets = [all_boxes[j] for j in range(1, num_classes)] masks = [all_masks[j] for j in range(1, num_classes)] else: masks = masks[0][:, 1:, :, :] im_height = np.round(im_shapes[0][0] / scales[0]).astype('int') im_width = np.round(im_shapes[0][1] / scales[0]).astype('int') # print (im_height, im_width) boxes = clip_boxes(boxes[0], (im_height, im_width)) result_masks, result_dets = gpu_mask_voting(masks, boxes, scores[0], num_classes, 100, im_width, im_height, config.TEST.NMS, config.TEST.MASK_MERGE_THRESH, config.BINARY_THRESH, 0) dets = [result_dets[j] for j in range(1, num_classes)] masks = [result_masks[j][:, 0, :, :] for j in range(1, num_classes)] cods, bimsks, names = decode_mask(im, dets, masks, classes, config, args) return cods, bimsks, names
def getSpecBatches(split): # Random Seed random = cfg.getRandomState() # Make predictions for every testfile for t in split: # Spec batch spec_batch = [] # Get specs for file for spec in audio.specsFromFile(t[0], cfg.SAMPLE_RATE, cfg.SPEC_LENGTH, cfg.SPEC_OVERLAP, cfg.SPEC_MINLEN, shape=(cfg.IM_SIZE[1], cfg.IM_SIZE[0]), fmin=cfg.SPEC_FMIN, fmax=cfg.SPEC_FMAX, spec_type=cfg.SPEC_TYPE): # Resize spec spec = image.resize(spec, cfg.IM_SIZE[0], cfg.IM_SIZE[1], mode=cfg.RESIZE_MODE) # Normalize spec spec = image.normalize(spec, cfg.ZERO_CENTERED_NORMALIZATION) # Prepare as input spec = image.prepare(spec) # Add to batch if len(spec_batch) > 0: spec_batch = np.vstack((spec_batch, spec)) else: spec_batch = spec # Batch too large? if spec_batch.shape[0] >= cfg.MAX_SPECS_PER_FILE: break # No specs? if len(spec_batch) == 0: spec = random.normal(0.0, 1.0, (cfg.IM_SIZE[1], cfg.IM_SIZE[0])) spec_batch = image.prepare(spec) # Shuffle spec batch spec_batch = shuffle(spec_batch, random_state=random) # yield batch, labels and filename yield spec_batch[:cfg.MAX_SPECS_PER_FILE], t[1], t[0].split(os.sep)[-1]
def main(): # get symbol pprint.pprint(config) sym_instance = eval(config.symbol + '.' + config.symbol)() sym = sym_instance.get_symbol_rfcn(config, is_train=False) # load demo data image_names = ['000057.jpg', '000149.jpg', '000351.jpg', '002535.jpg'] image_all = [] # ground truth boxes gt_boxes_all = [np.array([[132, 52, 384, 357]]), np.array([[113, 1, 350, 360]]), np.array([[0, 27, 329, 155]]), np.array([[8, 40, 499, 289]])] gt_classes_all = [np.array([3]), np.array([16]), np.array([7]), np.array([12])] data = [] for idx, im_name in enumerate(image_names): assert os.path.exists(cur_path + '/../demo/deform_psroi/' + im_name), \ ('%s does not exist'.format('../demo/deform_psroi/' + im_name)) im = cv2.imread(cur_path + '/../demo/deform_psroi/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION) image_all.append(im) target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) gt_boxes = gt_boxes_all[idx] gt_boxes = np.round(gt_boxes * im_scale) data.append({'data': im_tensor, 'rois': np.hstack((np.zeros((gt_boxes.shape[0], 1)), gt_boxes))}) # get predictor data_names = ['data', 'rois'] label_names = [] data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]] provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))] provide_label = [None for i in xrange(len(data))] arg_params, aux_params = load_param(cur_path + '/../model/deform_psroi', 0, process=True) predictor = Predictor(sym, data_names, label_names, context=[mx.gpu(0)], max_data_shapes=max_data_shape, provide_data=provide_data, provide_label=provide_label, arg_params=arg_params, aux_params=aux_params) # test for idx, _ in enumerate(image_names): data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]], provide_label=[None]) output = predictor.predict(data_batch) cls_offset = output[0]['rfcn_cls_offset_output'].asnumpy() im = image_all[idx] im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) boxes = gt_boxes_all[idx] show_dpsroi_offset(im, boxes, cls_offset, gt_classes_all[idx])
def run(self): for filename in self.files: self.print_and_log_info('Processing {}'.format( filename.relative_to(self.input_dir))) label_file = filename.parent / self.seg_fmt.format( filename.stem, 'png') dir_path = filename.parent.relative_to(self.input_dir) img = Image.open(filename).convert('RGB') pred = self.predict(img) if not label_file.exists(): self.print_and_log_warning('Ground truth not found') gt = None else: if Image.open(label_file).size == img.size: gt = self.encode_segmap(Image.open(label_file)) self.metrics[str(dir_path)].update(gt, pred) else: self.print_and_log_error( filename.relative_to(self.input_dir)) if self.save_annotations: output_path = self.output_dir / dir_path output_path.mkdir(exist_ok=True) pred_img = LabeledArray2Image.convert( pred, self.label_idx_color_mapping) mask = Image.fromarray((np.array(pred_img) == (0, 0, 0)).all( axis=-1).astype(np.uint8) * 127 + 128) blend_img = Image.composite(img, pred_img, mask) empty_pred, empty_gt = np.all(pred == 0), True lw = int(min([0.01 * img.size[0], 0.01 * img.size[1]])) if gt is not None: for label in self.labels_to_eval: if label in gt: mask_gt = (gt == label).astype(np.uint8) contours = cv2.findContours( mask_gt, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[1] for cnt in contours: empty_gt = False draw = ImageDraw.Draw(blend_img) draw.line(list( map(tuple, cnt.reshape(-1, 2).tolist())) + cnt[0][0].tolist(), fill=GT_COLOR, width=lw) if not empty_pred or not empty_gt: blend_img = resize(blend_img.convert('RGB'), (1000, 1000)) blend_img.save(output_path / '{}.jpg'.format(filename.stem)) self.save_metrics() self.print_and_log_info('Evaluator run is over')
def predict(self, image): red_img = resize(image, size=self.img_size, keep_aspect_ratio=True) inp = np.array(red_img, dtype=np.float32) / 255 if self.normalize: inp = ((inp - inp.mean(axis=(0, 1))) / (inp.std(axis=(0, 1)) + 10**-7)) inp = torch.from_numpy(inp.transpose(2, 0, 1)).float().to( self.device) # HWC -> CHW tensor with torch.no_grad(): pred = self.model(inp.reshape( 1, *inp.shape))[0].max(0)[1].cpu().numpy() return pred
def generate_content(self): self.blured_border_width = randint(*BLURED_BORDER_WIDTH_RANGE) self.as_negative = self.parameters.get('as_negative', False) self.blur_radius = uniform(*NEG_ELEMENT_BLUR_RADIUS_RANGE) if self.as_negative else None self.opacity = randint(*NEG_ELEMENT_OPACITY_RANGE[self.name] if self.as_negative else POS_ELEMENT_OPACITY_RANGE[self.name]) img = Image.open(self.parameters.get('image_path') or choice(DATABASE[IMAGE_RESRC_NAME])) img.putalpha(self.opacity) max_size = [s - 2 * self.blured_border_width for s in self.size] self.img = resize(img, max_size) self.content_width, self.content_height = self.img.size self.pos_x = randint(0, self.width - self.content_width) self.pos_y = randint(0, self.height - self.content_height)
def get_assist_icons_ref(): """Read all reference killfeed assist avatars, then write into dict Author: Appcell Args: None Returns: A dict of all reference killfeed assist avatars """ return { GAMETYPE_OWL: {chara: ImageUtils.resize( ImageUtils.read("./images/assists/" + chara + ".png"), ASSIST_ICON_WIDTH[GAMETYPE_OWL], ASSIST_ICON_HEIGHT[GAMETYPE_OWL]) \ for chara in ASSIST_CHARACTER_LIST}, GAMETYPE_CUSTOM: {chara: ImageUtils.resize( ImageUtils.read("./images/assists/" + chara + ".png"), ASSIST_ICON_WIDTH[GAMETYPE_CUSTOM], ASSIST_ICON_HEIGHT[GAMETYPE_CUSTOM]) \ for chara in ASSIST_CHARACTER_LIST}, }
def main(): # get symbol pprint.pprint(config) sym_instance = eval(config.symbol + '.' + config.symbol)() sym = sym_instance.get_symbol(config, is_train=False) # load demo data image_names = ['000240.jpg', '000437.jpg', '004072.jpg', '007912.jpg'] image_all = [] data = [] for im_name in image_names: assert os.path.exists(cur_path + '/../demo/deform_conv/' + im_name), \ ('%s does not exist'.format('../demo/deform_conv/' + im_name)) im = cv2.imread(cur_path + '/../demo/deform_conv/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION) image_all.append(im) target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data.append({'data': im_tensor, 'im_info': im_info}) # get predictor data_names = ['data', 'im_info'] label_names = [] data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]] provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))] provide_label = [None for i in xrange(len(data))] arg_params, aux_params = load_param(cur_path + '/../model/deform_conv', 0, process=True) predictor = Predictor(sym, data_names, label_names, context=[mx.gpu(0)], max_data_shapes=max_data_shape, provide_data=provide_data, provide_label=provide_label, arg_params=arg_params, aux_params=aux_params) # test for idx, _ in enumerate(image_names): data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]], provide_label=[None]) output = predictor.predict(data_batch) res5a_offset = output[0]['res5a_branch2b_offset_output'].asnumpy() res5b_offset = output[0]['res5b_branch2b_offset_output'].asnumpy() res5c_offset = output[0]['res5c_branch2b_offset_output'].asnumpy() im = image_all[idx] im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) show_dconv_offset(im, [res5c_offset, res5b_offset, res5a_offset])
def main(): # get symbol pprint.pprint(config) sym_instance = eval(config.symbol + '.' + config.symbol)() sym = sym_instance.get_symbol(config, is_train=False) # load demo data image_names = ['000240.jpg', '000437.jpg', '004072.jpg', '007912.jpg'] image_all = [] data = [] for im_name in image_names: assert os.path.exists(cur_path + '/../demo/deform_conv/' + im_name), \ ('%s does not exist'.format('../demo/deform_conv/' + im_name)) im = cv2.imread(cur_path + '/../demo/deform_conv/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION) image_all.append(im) target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data.append({'data': im_tensor, 'im_info': im_info}) # get predictor data_names = ['data', 'im_info'] label_names = [] data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]] provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))] provide_label = [None for i in xrange(len(data))] arg_params, aux_params = load_param(cur_path + '/../model/deform_conv', 0, process=True) predictor = Predictor(sym, data_names, label_names, context=[mx.gpu(0)], max_data_shapes=max_data_shape, provide_data=provide_data, provide_label=provide_label, arg_params=arg_params, aux_params=aux_params) # test for idx, _ in enumerate(image_names): data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]], provide_label=[None]) output = predictor.predict(data_batch) res5a_offset = output[0]['res5a_branch2b_offset_output'].asnumpy() res5b_offset = output[0]['res5b_branch2b_offset_output'].asnumpy() res5c_offset = output[0]['res5c_branch2b_offset_output'].asnumpy() im = image_all[idx] im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) show_dconv_offset(im, [res5c_offset, res5b_offset, res5a_offset])
def get_killfeed_icons_ref(): """Read all reference killfeed avatars, then write into dict Author: Appcell Args: None Returns: A dict of all reference killfeed icons """ return { GAMETYPE_OWL: {chara: ImageUtils.resize( ImageUtils.read("./images/icons/" + chara + ".png"), KILLFEED_ICON_WIDTH[GAMETYPE_OWL], KILLFEED_ICON_HEIGHT[GAMETYPE_OWL]) \ for chara in KILLFEED_OBJECT_LIST}, GAMETYPE_CUSTOM: {chara: ImageUtils.resize( ImageUtils.read("./images/icons/" + chara + ".png"), KILLFEED_ICON_WIDTH[GAMETYPE_CUSTOM], KILLFEED_ICON_HEIGHT[GAMETYPE_CUSTOM]) \ for chara in KILLFEED_OBJECT_LIST}, }
def _load_frame(self, idx): im = self.images[idx] target_size = cfg.SCALES[0][0] max_size = cfg.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=cfg.network.IMAGE_STRIDE) im_tensor = transform(im, cfg.network.PIXEL_MEANS) im_info = np.array( [[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) feat_stride = float(cfg.network.RCNN_FEAT_STRIDE) return mx.nd.array(im_tensor), mx.nd.array(im_info)
def predict(self, im): im, im_scale = resize(im, self.scales[0], self.scales[1], stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array( [[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data = {'data': im_tensor, 'im_info': im_info} data = [[ mx.nd.array(data[self.data_names[0]]), mx.nd.array(data[self.data_names[1]]) ]] data_batch = mx.io.DataBatch( data=data, label=[], pad=0, index=0, provide_data=[[(k, v.shape) for k, v in zip(self.data_names, data[0])]], provide_label=[None]) scores, boxes, data_dict = im_detect(self.predictor, data_batch, self.data_names, [im_scale], config) boxes = boxes[0].astype('f') scores = scores[0].astype('f') dets_nms = [] for j in range(1, scores.shape[1]): cls_scores = scores[:, j, np.newaxis] cls_boxes = boxes[:, 4:8] if config.CLASS_AGNOSTIC else boxes[:, j * 4:(j + 1) * 4] cls_dets = np.hstack((cls_boxes, cls_scores)) keep = self.nms(cls_dets) cls_dets = cls_dets[keep, :] cls_dets = cls_dets[cls_dets[:, -1] > 0.7, :] dets_nms.append(cls_dets) res = {} for idx, cls in enumerate(self.classes): res['{}'.format(cls)] = dets_nms[idx].tolist() logging.debug("Predictions: {}".format(res)) return res
def load_test(filename, short, max_size, mean, std): # read and transform image im_orig = imdecode(filename) im, im_scale = resize(im_orig, short, max_size) height, width = im.shape[:2] im_info = mx.nd.array([height, width, im_scale]) # transform into tensor and normalize im_tensor = transform(im, mean, std) # for 1-batch inference purpose, cannot use batchify (or nd.stack) to expand dims im_tensor = mx.nd.array(im_tensor).expand_dims(0) im_info = mx.nd.array(im_info).expand_dims(0) # transform cv2 BRG image to RGB for matplotlib im_orig = im_orig[:, :, (2, 1, 0)] return im_tensor, im_info, im_orig
def loadImage(self, im, bg): self.im = im self.fg = im self.bg = bg target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] self.im, im_scale = resize(self.im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(self.im, config.network.PIXEL_MEANS) im_info = np.array( [[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) self.data = {'data': im_tensor, 'im_info': im_info} self.data = [mx.nd.array(self.data[name]) for name in self.data_names]
def preprocess(self, image, image_meta, boxes=None): if boxes is not None: boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0., image_meta['orig_size'][1] - 1.) boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0., image_meta['orig_size'][0] - 1.) drift_prob = self.cfg.drift_prob if self.phase == 'train' else 0. flip_prob = self.cfg.flip_prob if self.phase == 'train' else 0. image, image_meta = whiten(image, image_meta, mean=self.rgb_mean, std=self.rgb_std) image, image_meta, boxes = drift(image, image_meta, prob=drift_prob, boxes=boxes) image, image_meta, boxes = flip(image, image_meta, prob=flip_prob, boxes=boxes) if self.cfg.forbid_resize: image, image_meta, boxes = crop_or_pad(image, image_meta, self.input_size, boxes=boxes) else: image, image_meta, boxes = resize(image, image_meta, self.input_size, boxes=boxes) return image, image_meta, boxes
def analyze(self, images): sgm = ResUnet() sgm.get_model() images = [iu.resize(img, (256, 256)) for img in images] # img1 = iu.resize(img1, (256, 256)) # img2 = iu.resize(img2, (256, 256)) masks = [sgm.predict(img) for img in images] for i, mask in enumerate(masks): cv.imshow(f"mask{i}", mask) # mask1 = sgm.predict(img1) # mask2 = sgm.predict(img2) # cv.imshow('mask1', mask1) # cv.imshow('mask2', mask2) for i, (img, mask) in enumerate(zip(images, masks)): if i == (len(images) - 1): break transform, transform_mask = self.image_work( img, images[i + 1], mask, masks[i + 1]) cv.imshow(f"transform{i}->{i+1}", transform) cv.imshow(f"transform_mask{i}->{i+1}", transform_mask) area1 = iu.get_mask_area(transform_mask) area2 = iu.get_mask_area(masks[i + 1]) print(f"area transform {i} -> {i+1}: {area2 / area1}") # transform, transform_mask = self.image_work(img1, img2, mask1, mask2) # cv.imshow('transform', transform) # cv.imshow('transform_mask', transform_mask) # # area1 = iu.get_mask_area(transform_mask) # area2 = iu.get_mask_area(mask2) # # print(area2 / area1) # # img1 = iu.add_mask(img1, mask1) # img2 = iu.add_mask(img2, mask2) # # # cv.imshow('s1', img1) # cv.imshow('s2', img2) cv.waitKey()
def save_prob_and_seg_maps(self): for k in range(len(self.dataset)): name = self.dataset.input_files[k].stem # saving probability maps takes a lot of space, remove comment if needed # np.save(self.prob_dir / "{}.npy".format(name), self.prob_maps[k]) pred = self.seg_maps[k] pred_img = LabeledArray2Image.convert( pred, label_color_mapping=self.dataset.label_idx_color_mapping) pred_img.save(self.seg_dir / "{}.png".format(name)) img = resize(Image.open(self.dataset.input_files[k]), pred_img.size, keep_aspect_ratio=False) blend_img = Image.blend(img, pred_img, alpha=0.4) blend_img.convert("RGB").save(self.blend_dir / "{}.jpg".format(name)) print_info("Probabilities and segmentation maps saved")
def get_avatars_ref(): """Read all reference avatar images and write into a dict Author: Appcell Args: None Returns: A dict of all reference avatar images """ return { chara: ImageUtils.resize( ImageUtils.read_with_transparency("./images/charas/" + chara + ".png"), AVATAR_WIDTH_REF, AVATAR_HEIGHT_REF) for chara in CHARACTER_LIST }
def main(): # get symbol pprint.pprint(config) config.symbol = 'resnet_v1_101_deeplab_dcn' if not args.deeplab_only else 'resnet_v1_101_deeplab' sym_instance = eval(config.symbol + '.' + config.symbol)() sym = sym_instance.get_symbol(config, is_train=False) # set up class names num_classes = 19 # load demo data image_names = ['frankfurt_000001_073088_leftImg8bit.png', 'lindau_000024_000019_leftImg8bit.png'] data = [] for im_name in image_names: assert os.path.exists(cur_path + '/../demo/' + im_name), ('%s does not exist'.format('../demo/' + im_name)) im = cv2.imread(cur_path + '/../demo/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION) target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data.append({'data': im_tensor, 'im_info': im_info}) # get predictor data_names = ['data'] label_names = ['softmax_label'] data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]] provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))] provide_label = [None for i in xrange(len(data))] arg_params, aux_params = load_param(cur_path + '/../model/' + ('deeplab_dcn_cityscapes' if not args.deeplab_only else 'deeplab_cityscapes'), 0, process=True) predictor = Predictor(sym, data_names, label_names, context=[mx.gpu(0)], max_data_shapes=max_data_shape, provide_data=provide_data, provide_label=provide_label, arg_params=arg_params, aux_params=aux_params) # warm up for j in xrange(2): data_batch = mx.io.DataBatch(data=[data[0]], label=[], pad=0, index=0, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[0])]], provide_label=[None]) output_all = predictor.predict(data_batch) output_all = [mx.ndarray.argmax(output['softmax_output'], axis=1).asnumpy() for output in output_all] # test for idx, im_name in enumerate(image_names): data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]], provide_label=[None]) tic() output_all = predictor.predict(data_batch) output_all = [mx.ndarray.argmax(output['softmax_output'], axis=1).asnumpy() for output in output_all] pallete = getpallete(256) segmentation_result = np.uint8(np.squeeze(output_all)) segmentation_result = Image.fromarray(segmentation_result) segmentation_result.putpalette(pallete) print 'testing {} {:.4f}s'.format(im_name, toc()) pure_im_name, ext_im_name = os.path.splitext(im_name) segmentation_result.save(cur_path + '/../demo/seg_' + pure_im_name + '.png') # visualize im_raw = cv2.imread(cur_path + '/../demo/' + im_name) seg_res = cv2.imread(cur_path + '/../demo/seg_' + pure_im_name + '.png') cv2.imshow('Raw Image', im_raw) cv2.imshow('segmentation_result', seg_res) cv2.waitKey(0) print 'done'
def main(): # get symbol pprint.pprint(config) config.symbol = 'resnet_v1_101_rfcn_dcn' if not args.rfcn_only else 'resnet_v1_101_rfcn' sym_instance = eval(config.symbol + '.' + config.symbol)() sym = sym_instance.get_symbol(config, is_train=False) # set up class names num_classes = 81 classes = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'] # load demo data image_names = ['COCO_test2015_000000000891.jpg', 'COCO_test2015_000000001669.jpg'] data = [] for im_name in image_names: assert os.path.exists(cur_path + '/../demo/' + im_name), ('%s does not exist'.format('../demo/' + im_name)) im = cv2.imread(cur_path + '/../demo/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION) target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data.append({'data': im_tensor, 'im_info': im_info}) # get predictor data_names = ['data', 'im_info'] label_names = [] data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]] provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))] provide_label = [None for i in xrange(len(data))] arg_params, aux_params = load_param(cur_path + '/../model/' + ('rfcn_dcn_coco' if not args.rfcn_only else 'rfcn_coco'), 0, process=True) predictor = Predictor(sym, data_names, label_names, context=[mx.gpu(0)], max_data_shapes=max_data_shape, provide_data=provide_data, provide_label=provide_label, arg_params=arg_params, aux_params=aux_params) nms = gpu_nms_wrapper(config.TEST.NMS, 0) # warm up for j in xrange(2): data_batch = mx.io.DataBatch(data=[data[0]], label=[], pad=0, index=0, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[0])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, scales, config) # test for idx, im_name in enumerate(image_names): data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] tic() scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, scales, config) boxes = boxes[0].astype('f') scores = scores[0].astype('f') dets_nms = [] for j in range(1, scores.shape[1]): cls_scores = scores[:, j, np.newaxis] cls_boxes = boxes[:, 4:8] if config.CLASS_AGNOSTIC else boxes[:, j * 4:(j + 1) * 4] cls_dets = np.hstack((cls_boxes, cls_scores)) keep = nms(cls_dets) cls_dets = cls_dets[keep, :] cls_dets = cls_dets[cls_dets[:, -1] > 0.7, :] dets_nms.append(cls_dets) print 'testing {} {:.4f}s'.format(im_name, toc()) # visualize im = cv2.imread(cur_path + '/../demo/' + im_name) im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) show_boxes(im, dets_nms, classes, 1) print 'done'
def main(): # get symbol pprint.pprint(config) config.symbol = 'resnet_v1_101_rfcn' model = '/../model/rfcn_vid' sym_instance = eval(config.symbol + '.' + config.symbol)() sym = sym_instance.get_test_symbol(config) # set up class names num_classes = 31 classes = ['airplane', 'antelope', 'bear', 'bicycle', 'bird', 'bus', 'car', 'cattle', 'dog', 'domestic_cat', 'elephant', 'fox', 'giant_panda', 'hamster', 'horse', 'lion', 'lizard', 'monkey', 'motorcycle', 'rabbit', 'red_panda', 'sheep', 'snake', 'squirrel', 'tiger', 'train', 'turtle', 'watercraft', 'whale', 'zebra'] # load demo data image_names = glob.glob(cur_path + '/../demo/ILSVRC2015_val_00007010/*.JPEG') output_dir = cur_path + '/../demo/rfcn/' if not os.path.exists(output_dir): os.makedirs(output_dir) # data = [] for im_name in image_names: assert os.path.exists(im_name), ('%s does not exist'.format(im_name)) im = cv2.imread(im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION) target_size = config.SCALES[0][0] max_size = config.SCALES[0][1] im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE) im_tensor = transform(im, config.network.PIXEL_MEANS) im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32) data.append({'data': im_tensor, 'im_info': im_info}) # get predictor data_names = ['data', 'im_info'] label_names = [] data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))] max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]] provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))] provide_label = [None for i in xrange(len(data))] arg_params, aux_params = load_param(cur_path + model, 0, process=True) predictor = Predictor(sym, data_names, label_names, context=[mx.gpu(0)], max_data_shapes=max_data_shape, provide_data=provide_data, provide_label=provide_label, arg_params=arg_params, aux_params=aux_params) nms = gpu_nms_wrapper(config.TEST.NMS, 0) # warm up for j in xrange(2): data_batch = mx.io.DataBatch(data=[data[0]], label=[], pad=0, index=0, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[0])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, scales, config) # test time = 0 count = 0 for idx, im_name in enumerate(image_names): data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] tic() scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, scales, config) time += toc() count += 1 print 'testing {} {:.4f}s'.format(im_name, time/count) boxes = boxes[0].astype('f') scores = scores[0].astype('f') dets_nms = [] for j in range(1, scores.shape[1]): cls_scores = scores[:, j, np.newaxis] cls_boxes = boxes[:, 4:8] if config.CLASS_AGNOSTIC else boxes[:, j * 4:(j + 1) * 4] cls_dets = np.hstack((cls_boxes, cls_scores)) keep = nms(cls_dets) cls_dets = cls_dets[keep, :] cls_dets = cls_dets[cls_dets[:, -1] > 0.7, :] dets_nms.append(cls_dets) # visualize im = cv2.imread(im_name) im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) # show_boxes(im, dets_nms, classes, 1) out_im = draw_boxes(im, dets_nms, classes, 1) _, filename = os.path.split(im_name) cv2.imwrite(output_dir + filename,out_im) print 'done'