def _generateBatchFromIDs(self, imageIdxs):
imageIDs = [self.dataID[idx] for idx in imageIdxs]
for imageID in imageIDs:
imageMeta = self.imagesMeta[imageID]
imageMeta['id'] = imageID
io_start = time.time()
img, imageDims = filters_rpn.prepareInputs(imageMeta,
self.images_path,
self.cfg)
io_end = time.time()
if self.mode == 'test':
return img, None, imageMeta, imageDims, None
pp_start = time.time()
Y_tmp = filters_rpn.loadData(imageMeta, self.anchors_path,
self.cfg)
if Y_tmp is None:
Y_tmp = filters_rpn.createTargets(imageMeta, imageDims,
self.cfg)
Y = filters_rpn.reduceData(Y_tmp, self.cfg)
pp_end = time.time()
times = [io_end - io_start, pp_end - pp_start]
if self.do_meta:
return img, Y, imageMeta, imageDims, times
return img, Y
def _generateFastBatch(self, imageIDs):
for imageID in imageIDs:
imageMeta = self.imagesMeta[imageID]
imageInputs = self._getImageInputs(imageID)
imageMeta['id'] = imageID
io_start = time.time()
img, imageDims = filters_rpn.prepareInputs(imageMeta, self.images_path, self.cfg)
io_end = time.time()
pp_start = time.time()
Y_tmp = filters_hoi.loadData(imageInputs, imageDims, self.cfg)
pp_end = time.time()
if Y_tmp is None:
if self.mode == 'train':
raise Exception("ups: no detections available, path:%s" % self.rois_path)
else:
return None
if self.mode == 'val':
all_hbboxes, all_obboxes, all_target_labels, all_val_map = Y_tmp
if all_val_map.shape[1] > self.cfg.nb_hoi_rois:
idxs = np.random.choice(list(range(self.cfg.nb_hoi_rois)), self.cfg.nb_hoi_rois, replace=False)
all_hbboxes = all_hbboxes[:,idxs,:]
all_obboxes = all_obboxes[:,idxs,:]
all_target_labels = all_target_labels[:,idxs,:]
patterns = filters_hoi.createInteractionPatterns(all_hbboxes, all_obboxes, self.cfg)
all_hbboxes, all_obboxes = filters_hoi.prepareInputs(all_hbboxes, all_obboxes, imageDims)
b_pattern = np.zeros((1,self.cfg.nb_hoi_rois)+patterns[0][0].shape)
b_pattern[0,:patterns.shape[1],::] = patterns
b_hbboxes = np.zeros((1,self.cfg.nb_hoi_rois)+all_hbboxes[0][0].shape)
b_hbboxes[0,:all_hbboxes.shape[1],::] = all_hbboxes
b_obboxes = np.zeros((1,self.cfg.nb_hoi_rois)+all_obboxes[0][0].shape)
b_obboxes[0,:all_obboxes.shape[1],::] = all_obboxes
b_targets = np.zeros((1,self.cfg.nb_hoi_rois)+all_target_labels[0][0].shape)
b_targets[0,:all_target_labels.shape[1],::] = all_target_labels
if self.do_meta:
return [img, all_hbboxes, all_obboxes, patterns], all_target_labels, imageMeta, imageDims, None
return [img, b_hbboxes, b_obboxes, b_pattern], b_targets
elif self.mode == 'test':
all_hbboxes, all_obboxes, all_target_labels, all_val_map = Y_tmp
return [img, all_hbboxes, all_obboxes, all_val_map], all_target_labels, imageMeta, imageDims, None
hbboxes, obboxes, target_labels, val_map = filters_hoi.reduceTargets(Y_tmp, self.cfg)
patterns = filters_hoi.createInteractionPatterns(hbboxes, obboxes, self.cfg)
hbboxes, obboxes = filters_hoi.prepareInputs(hbboxes, obboxes, imageDims)
times = np.array([io_end-io_start, pp_end-pp_start])
if self.do_meta:
return [img, hbboxes, obboxes, patterns], target_labels, imageMeta, imageDims, times
return [img, hbboxes, obboxes, patterns], target_labels
def stagezero(self, imageMeta, data_type):
images_path = self.images_path + data_type + '/'
anchors_path = self.anchors_path + data_type + '/'
X, imageDims = filters_rpn.prepareInputs(imageMeta, images_path,
self.cfg)
y = None
if self.mode == 'train':
y_tmp = filters_rpn.loadData(imageMeta, anchors_path, self.cfg)
if y_tmp is None:
y_tmp = filters_rpn.createTargets(imageMeta, imageDims,
self.cfg)
y = filters_rpn.reduceData(y_tmp, self.cfg)
return X, y, imageDims
def saveEvalData(generator, Stages, cfg, obj_mapping):
cfg.my_output_path = cfg.results_path + 'det' + cfg.my_results_dir + '/res/' + generator.data_type + '/'
if not os.path.exists(cfg.my_output_path):
os.makedirs(cfg.my_output_path)
save_path = cfg.my_output_path
print(' save_path:', save_path)
evalData = []
imagesIDs = list(generator.imagesMeta.keys())
r.shuffle(imagesIDs)
for batchidx, imageID in enumerate(imagesIDs):
if (batchidx + 1) % (generator.nb_batches //
100) == 0 or batchidx == 1 or (
batchidx + 1) == generator.nb_batches:
utils.update_progress_new(batchidx + 1, generator.nb_batches,
imageID)
path = save_path + imageID + '.pkl'
if os.path.exists(path):
continue
imageMeta = generator.imagesMeta[imageID]
imageMeta['id'] = imageID
imageInputs = generator._getImageInputs(imageID)
X, imageDims = filters_rpn.prepareInputs(imageMeta,
generator.images_path, cfg)
Y_tmp = filters_detection.loadData(imageInputs, cfg)
proposals, target_labels, target_deltas = Y_tmp
#STAGE 1
# proposals = Stages.stageone([img], y, imageMeta, imageDims)
#STAGE 2
bboxes = Stages.stagetwo([X, proposals], imageMeta, imageDims)
if bboxes is None:
utils.save_obj(None, save_path + str(imageID))
continue
#CONVERT
evalData = filters_detection.convertResults(bboxes[0], imageMeta,
obj_mapping,
imageDims['scale'],
cfg.rpn_stride)
utils.save_obj(evalData, save_path + str(imageID))
return evalData
def saveEvalData(generator, Stages, cfg, hoi_mapping):
cfg.my_output_path = cfg.results_path + 'hoi' + cfg.my_results_dir + '/res/' + generator.data_type + generator.approach + '/'
if not os.path.exists(cfg.my_output_path):
os.makedirs(cfg.my_output_path)
save_path = cfg.my_output_path
print(' save_path:', save_path)
evalData = []
imageMeta = None
imagesIDs = list(generator.imagesMeta.keys())
r.shuffle(imagesIDs)
for batchidx, imageID in enumerate(imagesIDs):
if (batchidx+1) % (max(100,generator.nb_batches // 100)) == 0 or batchidx==1 or (batchidx+1) == generator.nb_batches:
utils.update_progress_new(batchidx+1, generator.nb_batches, imageID)
path = save_path + imageID + '.pkl'
if os.path.exists(path):
continue
imageMeta = generator.imagesMeta[imageID]
imageMeta['id'] = imageID
# [X, all_hbboxes, all_obboxes, all_val_map], all_target_labels, imageMeta, imageDims, _ = next(genIterator)
imageInputs = generator._getImageInputs(imageID)
X, imageDims = filters_rpn.prepareInputs(imageMeta, generator.images_path, cfg)
Y_tmp = filters_hoi.loadData(imageInputs, imageDims, cfg)
if Y_tmp is None:
utils.save_obj(None, save_path + imageID)
continue
all_hbboxes, all_obboxes, all_target_labels, all_val_map = Y_tmp
#STAGE 3
pred_hbboxes, pred_obboxes, pred_props = Stages.stagethree([X,all_hbboxes,all_obboxes], imageMeta, imageDims, obj_mapping=None)
if pred_hbboxes is None:
utils.save_obj(None, save_path + imageID)
continue
#CONVERT
evalData = filters_hoi.convertResults(pred_hbboxes, pred_obboxes, pred_props, imageMeta, imageDims['scale'], cfg, hoi_mapping)
utils.save_obj(evalData, save_path + imageID)
return evalData, imageMeta
def saveInputData(imagesMeta, data_type, cfg):
load_path = cfg.data_path + 'images/' + data_type + '/'
save_path = cfg.my_output_path + data_type + 'newest/'
if not os.path.exists(save_path):
os.makedirs(save_path)
print('save_path', save_path)
nb_images = len(imagesMeta)
for batchidx, (imageID, imageMeta) in enumerate(imagesMeta.items()):
imageID = imageMeta['imageName'].split('.')[0]
utils.update_progress_new(batchidx + 1, nb_images, imageID)
path = save_path + imageID + '.pkl'
if os.path.exists(path):
continue
img, imageDims = filters_rpn.prepareInputs(imageMeta, load_path, cfg)
[Y1, Y2, M] = filters_rpn.createTargets(imageMeta, imageDims, cfg)
rpnMeta = filters_rpn.convertData([Y1, Y2, M], cfg)
utils.save_obj(rpnMeta, save_path + imageID)
def _generateBatchFromIDs(self, imageIdxs):
imageIDs = [self.dataID[idx] for idx in imageIdxs]
# if imageIDs[0] < '550394':
# return None, None, None, None, None
# else:
# print(imageIDs)
# Only works for batch_size=0
# batchIdx = 0
for imageID in imageIDs:
imageMeta = self.imagesMeta[imageID]
imageInputs = self._getImageInputs(imageID)
imageMeta['id'] = imageID
io_start = time.time()
img, imageDims = filters_rpn.prepareInputs(imageMeta, self.images_path, self.cfg)
io_end = time.time()
pp_start = time.time()
# Y_tmp = filters_detection.loadData(imageMeta, self.rois_path, imageDims, self.cfg)
Y_tmp = filters_detection.loadData(imageInputs, self.cfg)
if Y_tmp is None:
raise Exception("ups: no detections available, path:%s" % self.rois_path)
pp_end = time.time()
if self.mode == 'test':
bboxes, target_labels, target_deltas = Y_tmp
return [img, bboxes], [target_labels, target_deltas], imageMeta, imageDims, None
# bboxes, target_labels, target_deltas = Y_tmp
bboxes, target_labels, target_deltas = filters_detection.reduceData(Y_tmp, self.cfg)
bboxes = filters_detection.prepareInputs(bboxes, imageDims, imageMeta)
times = np.array([io_end-io_start, pp_end-pp_start])
if self.do_meta:
return [img, bboxes], [target_labels, target_deltas], imageMeta, imageDims, times
return [img, bboxes], [target_labels, target_deltas]
# config
cfg = data.cfg
obj_mapping = data.class_mapping
# data
genTrain = DataGenerator(imagesMeta=data.trainGTMeta,
cfg=cfg,
data_type='train',
do_meta=True)
# genVal = DataGenerator(imagesMeta = data.valGTMeta, cfg=cfg, data_type='val', do_meta=True)
imageID = '487566'
imageMeta = genTrain.imagesMeta[imageID]
imageInputs = genTrain.imagesInputs[imageID]
X, imageDims = filters_rpn.prepareInputs(imageMeta, genTrain.images_path, cfg)
Y_tmp = filters_detection.loadData(imageInputs, cfg)
for i in range(1):
bboxes1, target_labels, target_deltas = filters_detection.reduceData(
Y_tmp, cfg)
bboxes2 = np.copy(bboxes1)
bboxes2 = filters_detection.prepareInputs(bboxes2, imageDims, imageMeta)
import draw
import filters_detection
img = np.copy(X[0])
img += cfg.PIXEL_MEANS
img = img.astype(np.uint8)
#CONVERT
#inputMeta = filters_hoi.convertData([hbboxes, obboxes, target_labels, val_map], cfg, mode=genTest.data_type)
#
#utils.save_obj(inputMeta, cfg.part_data_path + imageID)
iterator = genTrain
genItr = iterator.begin()
for batchidx in range(1):
[img, all_hbboxes, all_obboxes,
patterns], target_labels, imageMeta, imageDims, _ = next(genItr)
imageID = imageMeta['imageName']
utils.update_progress_new(batchidx + 1, iterator.nb_batches, imageID)
# [img, hbboxes, obboxes, patterns], target_labels, imageMeta, imageDims, _ = next(genItr)
X, _ = filters_rpn.prepareInputs(imageMeta, iterator.images_path, cfg)
imageID = imageMeta['imageName']
# continue
# draw.drawPositiveCropHoI(None, None, hcrops, ocrops, patterns, target_labels, imageMeta, imageDims, cfg, obj_mapping)
# import draw
import draw
img = np.copy(X[0])
img += cfg.PIXEL_MEANS
img = img.astype(np.uint8)
#hbboxes = np.expand_dims(hbboxes,axis=0)
#obboxes = np.expand_dims(obboxes,axis=0)
hbboxes, obboxes = filters_hoi.unprepareInputs(all_hbboxes, all_obboxes,
imageDims)
#if True:
nb_total = np.zeros(cfg.nb_hoi_classes)
nb_tp = np.zeros(cfg.nb_hoi_classes)
nb_empty = 0
nb_total_preds = 0
for j, (imageID, imageMeta) in enumerate(generator.imagesMeta.items()):
# imageID = 'HICO_train2015_00028567'
# imageMeta = generator.imagesMeta[imageID]
if (j+1) % 100 == 0:
utils.update_progress_new((j+1), generator.nb_images, imageID)
img = cv.imread(generator.images_path + imageMeta['imageName'])
X, imageDims = filters_rpn.prepareInputs(imageMeta, generator.images_path, cfg)
objs = imageMeta['objects']
gt_rels = imageMeta['rels']
gtbboxes = helper._transformGTBBox(objs, obj_mapping, None, scale=imageDims['scale'], rpn_stride=cfg.rpn_stride, dosplit=False)
checks = np.zeros(len(gt_rels))
if np.max(gtbboxes[:,2]) > 2+imageDims['output_shape'][1] or np.max(gtbboxes[:,3]) > 2+imageDims['output_shape'][0]:
print('bad bbs', imageID, np.max(gtbboxes[:,2]), np.max(gtbboxes[:,3]), imageDims['output_shape'])
imageInputs = utils.load_obj(cfg.my_input_path + 'testnew/' + imageID)
if imageInputs is None:
idxs = []
nb_empty += 1
else:
idxs = np.where(np.array(imageInputs['val_map'])==3)[0]
