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'
