def demo_net(detector, image_name):
"""
wrapper for detector
:param detector: Detector
:param image_name: image name
:return: None
"""
# load demo data
im = cv2.imread(image_name + '.jpg')
im_array, im_scale = resize(im, config.TEST.SCALES[0], config.TRAIN.MAX_SIZE)
im_array = transform(im_array, config.PIXEL_MEANS)
roi_array = sio.loadmat(image_name + '_boxes.mat')['boxes']
batch_index_array = np.zeros((roi_array.shape[0], 1))
projected_rois = roi_array * im_scale
roi_array = np.hstack((batch_index_array, projected_rois))
scores, boxes = detector.im_detect(im_array, roi_array)
all_boxes = [[] for _ in CLASSES]
CONF_THRESH = 0.8
NMS_THRESH = 0.3
for cls in CLASSES:
cls_ind = CLASSES.index(cls)
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
keep = np.where(cls_scores >= CONF_THRESH)[0]
cls_boxes = cls_boxes[keep, :]
cls_scores = cls_scores[keep]
dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = nms(dets, NMS_THRESH)
all_boxes[cls_ind] = dets[keep, :]
boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))]
vis_all_detection(im_array, boxes_this_image, CLASSES, 0)
def demo_net(detector, image_name):
"""
wrapper for detector
:param detector: Detector
:param image_name: image name
:return: None
"""
config.TEST.HAS_RPN = True
assert os.path.exists(image_name), image_name + ' not found'
im = cv2.imread(image_name)
im_array, im_scale = resize(im, config.SCALES[0], config.MAX_SIZE)
im_array = transform(im_array, config.PIXEL_MEANS)
im_info = np.array([[im_array.shape[2], im_array.shape[3], im_scale]], dtype=np.float32)
scores, boxes = detector.im_detect(im_array, im_info)
all_boxes = [[] for _ in CLASSES]
CONF_THRESH = 0.8
NMS_THRESH = 0.3
for cls in CLASSES:
cls_ind = CLASSES.index(cls)
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
keep = np.where(cls_scores >= CONF_THRESH)[0]
cls_boxes = cls_boxes[keep, :]
cls_scores = cls_scores[keep]
dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = nms(dets.astype(np.float32), NMS_THRESH)
all_boxes[cls_ind] = dets[keep, :]
boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))]
vis_all_detection(im_array, boxes_this_image, CLASSES, 0)
def demo_net(detector, image_name):
"""
wrapper for detector
:param detector: Detector
:param image_name: image name
:return: None
"""
config.TEST.HAS_RPN = True
assert os.path.exists(image_name), image_name + ' not found'
im = cv2.imread(image_name)
im_array, im_scale = resize(im, config.SCALES[0], config.MAX_SIZE)
im_array = transform(im_array, config.PIXEL_MEANS)
im_info = np.array([[im_array.shape[2], im_array.shape[3], im_scale]],
dtype=np.float32)
scores, boxes = detector.im_detect(im_array, im_info)
all_boxes = [[] for _ in CLASSES]
CONF_THRESH = 0.8
NMS_THRESH = 0.3
for cls in CLASSES:
cls_ind = CLASSES.index(cls)
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
keep = np.where(cls_scores >= CONF_THRESH)[0]
cls_boxes = cls_boxes[keep, :]
cls_scores = cls_scores[keep]
dets = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = nms(dets.astype(np.float32), NMS_THRESH)
all_boxes[cls_ind] = dets[keep, :]
boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))]
vis_all_detection(im_array, boxes_this_image, CLASSES, 0)
def get_image_array(roidb, scales, scale_indexes, need_mean=True):
"""
build image array from specific roidb
:param roidb: images to be processed
:param scales: scale list
:param scale_indexes: indexes
:return: array [b, c, h, w], list of scales
"""
num_images = len(roidb)
processed_ims = []
im_scales = []
for i in range(num_images):
im = cv2.imread(roidb[i]['image'])
if roidb[i]['flipped']:
im = im[:, ::-1, :]
target_size = scales[scale_indexes[i]]
im, im_scale = image_processing.resize(im, target_size,
config.MAX_SIZE)
im_tensor = image_processing.transform(im,
config.PIXEL_MEANS,
need_mean=need_mean)
processed_ims.append(im_tensor)
im_scales.append(im_scale)
array = image_processing.tensor_vstack(processed_ims)
return array, im_scales
def get_image_array(roidb, scales, scale_indexes):
"""
build image array from specific roidb
:param roidb: images to be processed
:param scales: scale list
:param scale_indexes: indexes
:return: array [b, c, h, w], list of scales
"""
num_images = len(roidb)
processed_ims = []
im_scales = []
for i in range(num_images):
im = cv2.imread(roidb[i]['image'])
if roidb[i]['flipped']:
im = im[:, ::-1, :]
target_size = scales[scale_indexes[i]]
im, im_scale = image_processing.resize(im, target_size, config.MAX_SIZE)
im_tensor = image_processing.transform(im, config.PIXEL_MEANS)
processed_ims.append(im_tensor)
im_scales.append(im_scale)
array = image_processing.tensor_vstack(processed_ims)
return array, im_scales
def demo_net(detector, image_name):
"""
wrapper for detector
:param detector: Detector
:param image_name: image name
:return: None
"""
# load demo data
im = cv2.imread(image_name + '.jpg')
im_array, im_scale = resize(im, config.TEST.SCALES[0],
config.TRAIN.MAX_SIZE)
im_array = transform(im_array, config.PIXEL_MEANS)
roi_array = sio.loadmat(image_name + '_boxes.mat')['boxes']
batch_index_array = np.zeros((roi_array.shape[0], 1))
projected_rois = roi_array * im_scale
roi_array = np.hstack((batch_index_array, projected_rois))
scores, boxes = detector.im_detect(im_array, roi_array)
all_boxes = [[] for _ in CLASSES]
CONF_THRESH = 0.8
NMS_THRESH = 0.3
for cls in CLASSES:
cls_ind = CLASSES.index(cls)
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
keep = np.where(cls_scores >= CONF_THRESH)[0]
cls_boxes = cls_boxes[keep, :]
cls_scores = cls_scores[keep]
dets = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = nms(dets, NMS_THRESH)
all_boxes[cls_ind] = dets[keep, :]
boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))]
vis_all_detection(im_array, boxes_this_image, CLASSES, 0)
def pred_eval(detector, test_data, imdb, vis=False):
"""
wrapper for calculating offline validation for faster data analysis
in this example, all threshold are set by hand
:param detector: Detector
:param test_data: data iterator, must be non-shuffle
:param imdb: image database
:param vis: controls visualization
:return:
"""
assert not test_data.shuffle
thresh = 0.1
# limit detections to max_per_image over all classes
max_per_image = 100
num_images = imdb.num_images
# all detections are collected into:
# all_boxes[cls][image] = N x 5 array of detections in
# (x1, y1, x2, y2, score)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
i = 0
for databatch in test_data:
if i % 10 == 0:
print 'testing {}/{}'.format(i, imdb.num_images)
scores, boxes = detector.im_detect(databatch.data['data'], databatch.data['rois'])
# we used scaled image & roi to train, so it is necessary to transform them back
# visualization should also be from the original size
im_path = imdb.image_path_from_index(imdb.image_set_index[i])
im = cv2.imread(im_path)
im_height = im.shape[0]
scale = float(databatch.data['data'].shape[2]) / float(im_height)
im = image_processing.transform(im, config.PIXEL_MEANS)
for j in range(1, imdb.num_classes):
indexes = np.where(scores[:, j] > thresh)[0]
cls_scores = scores[indexes, j]
cls_boxes = boxes[indexes, j * 4:(j + 1) * 4] / scale
cls_dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis]))
keep = nms(cls_dets, config.TEST.NMS)
all_boxes[j][i] = cls_dets[keep, :]
if max_per_image > 0:
image_scores = np.hstack([all_boxes[j][i][:, -1]
for j in range(1, imdb.num_classes)])
if len(image_scores) > max_per_image:
image_thresh = np.sort(image_scores)[-max_per_image]
for j in range(1, imdb.num_classes):
keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]
all_boxes[j][i] = all_boxes[j][i][keep, :]
boxes_this_image = [[]] + [all_boxes[j][i] for j in range(1, imdb.num_classes)]
if vis:
vis_all_detection(im, boxes_this_image,
imdb_classes=imdb.classes)
i += 1
cache_folder = os.path.join(imdb.cache_path, imdb.name)
if not os.path.exists(cache_folder):
os.mkdir(cache_folder)
det_file = os.path.join(cache_folder, 'detections.pkl')
with open(det_file, 'wb') as f:
cPickle.dump(all_boxes, f)
imdb.evaluate_detections(all_boxes)
def pred_eval(detector, test_data, imdb, vis=False):
"""
wrapper for calculating offline validation for faster data analysis
in this example, all threshold are set by hand
:param detector: Detector
:param test_data: data iterator, must be non-shuffle
:param imdb: image database
:param vis: controls visualization
:return:
"""
assert not test_data.shuffle
thresh = 0.1
# limit detections to max_per_image over all classes
max_per_image = 100
num_images = imdb.num_images
# all detections are collected into:
# all_boxes[cls][image] = N x 5 array of detections in
# (x1, y1, x2, y2, score)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
i = 0
for databatch in test_data:
if i % 10 == 0:
print 'testing {}/{}'.format(i, imdb.num_images)
scores, boxes = detector.im_detect(databatch.data['data'],
databatch.data['rois'])
# we used scaled image & roi to train, so it is necessary to transform them back
# visualization should also be from the original size
im_path = imdb.image_path_from_index(imdb.image_set_index[i])
im = cv2.imread(im_path)
im_height = im.shape[0]
scale = float(databatch.data['data'].shape[2]) / float(im_height)
im = image_processing.transform(im, config.PIXEL_MEANS)
for j in range(1, imdb.num_classes):
indexes = np.where(scores[:, j] > thresh)[0]
cls_scores = scores[indexes, j]
cls_boxes = boxes[indexes, j * 4:(j + 1) * 4] / scale
cls_dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis]))
keep = nms(cls_dets, config.TEST.NMS)
all_boxes[j][i] = cls_dets[keep, :]
if max_per_image > 0:
image_scores = np.hstack(
[all_boxes[j][i][:, -1] for j in range(1, imdb.num_classes)])
if len(image_scores) > max_per_image:
image_thresh = np.sort(image_scores)[-max_per_image]
for j in range(1, imdb.num_classes):
keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]
all_boxes[j][i] = all_boxes[j][i][keep, :]
boxes_this_image = [[]] + [
all_boxes[j][i] for j in range(1, imdb.num_classes)
]
if vis:
vis_all_detection(im, boxes_this_image, imdb_classes=imdb.classes)
i += 1
cache_folder = os.path.join(imdb.cache_path, imdb.name)
if not os.path.exists(cache_folder):
os.mkdir(cache_folder)
det_file = os.path.join(cache_folder, 'detections.pkl')
with open(det_file, 'wb') as f:
cPickle.dump(all_boxes, f)
imdb.evaluate_detections(all_boxes)
