def create_submit(args):
with open(args.pred_file, 'rb') as f:
print('loading: ', args.pred_file)
preds = pickle.load(f)
classes, _ = get_top_classes(args.start_index, args.end_index)
df_test = pd.read_csv(os.path.join(settings.DATA_DIR, 'VRD_sample_submission.csv'))
print('getting image sizes')
df_test['h'] = df_test.ImageId.map(lambda x: get_image_size(os.path.join(settings.TEST_IMG_DIR, '{}.jpg'.format(x)))[1])
df_test['w'] = df_test.ImageId.map(lambda x: get_image_size(os.path.join(settings.TEST_IMG_DIR, '{}.jpg'.format(x)))[0])
print(df_test.head())
final_preds = []
for p in tqdm(preds, total=len(preds)):
final_preds.append(get_preds(p, len(classes), args.th))
total_objs = 0
for p in final_preds:
total_objs += len(p['labels'])
print('total predicted objects:', total_objs)
pred_strs = []
for i, p in tqdm(enumerate(final_preds), total=len(final_preds)):
h = df_test.iloc[i].h
w = df_test.iloc[i].w
pred_strs.append(get_pred_str(p, w, h, classes))
df_test.PredictionString = pred_strs
print(df_test.head())
df_test.to_csv(args.out, index=False, columns=['ImageId', 'PredictionString'])
print('done')
def blend_images_effect(
image1: image_types,
image2: image_types,
image1_alpha=0.7,
image2_alpha=0.3,
zeta=0,
resolution=(1920, 1080),
) -> np.ndarray:
"""
Alpha blending images
:param image1: first image (one of image_type)
:param image2: second image (one of image_type)
:param image1_alpha: float value 0.0 - 1.0
:param image2_alpha: float value 0.0 - 1.0
:param zeta: additional int value
:param resolution: both images resolution should match to it
:return: OpenCV image
"""
s1, s2 = utils.get_image_size(image1), utils.get_image_size(image2)
if s1 != resolution:
image1 = cv2.resize(image1, resolution)
if s1 != resolution:
image1 = cv2.resize(image2, resolution)
return cv2.addWeighted(
utils.load_image(image1, np.ndarray),
image1_alpha,
utils.load_image(image2, np.ndarray),
image2_alpha,
zeta
)
def submit(args):
global preds, classes
classes, _ = get_top_classes(args.start_index, args.end_index,
args.class_file)
print('loading {}...'.format(args.pred_file))
with open(args.pred_file, 'rb') as f:
preds = pickle.load(f)
print('len(preds):', len(preds))
print('num classes of preds:', len(preds[0][1]))
print('specified num classes:', len(classes))
#assert len(preds[0][1]) == len(classes)
print('creating submission...')
df_test = pd.read_csv(osp.join(DATA_DIR, 'sample_empty_submission.csv'))
df_test.ImageWidth = df_test.ImageID.map(
lambda x: get_image_size(get_fn(x))[0])
df_test.ImageHeight = df_test.ImageID.map(
lambda x: get_image_size(get_fn(x))[1])
df_test['img_index'] = df_test.index
df_test = parallel_apply(df_test, set_pred_str)
df_test = df_test.drop(columns=['img_index'], axis=1)
df_test.to_csv(args.out, index=False)
print('done')
def set_image(self, image_inst):
curr_size = utils.get_image_size(self.image)
next_size = utils.get_image_size(image_inst)
if curr_size != next_size:
image_inst = cv2.resize(utils.convert_image_type(image_inst, numpy.ndarray), curr_size)
image_inst = utils.convert_image_type(image_inst, type(image_inst))
self.image = image_inst
def create_val_prediction(args):
with open(args.pred_file, 'rb') as f:
print('loading: ', args.pred_file)
preds = pickle.load(f)
df_test = pd.read_csv(os.path.join(settings.DATA_DIR, 'val_imgs.csv'))
img_dir = settings.VAL_IMG_DIR
print('getting image sizes')
df_test['h'] = df_test.ImageId.map(
lambda x: get_image_size(os.path.join(img_dir, '{}.jpg'.format(x)))[1])
df_test['w'] = df_test.ImageId.map(
lambda x: get_image_size(os.path.join(img_dir, '{}.jpg'.format(x)))[0])
print(df_test.head())
final_preds = []
for p in tqdm(preds, total=len(preds)):
final_preds.append(get_preds(p, args.th))
total_objs = 0
for p in final_preds:
total_objs += len(p['labels'])
print('total predicted objects:', total_objs)
classes, _ = get_classes()
res = []
for i, (img_id,
p) in tqdm(enumerate(zip(df_test.ImageId.values, final_preds)),
total=len(final_preds)):
h = df_test.iloc[i].h
w = df_test.iloc[i].w
#pred_strs.append(get_pred_str(p, w, h, classes))
for label, score, bbox in zip(p['labels'], p['scores'], p['bboxes']):
label1, label2 = classes[label].split(',')
det = {
'ImageID': img_id,
'LabelName1': label1,
'LabelName2': label2,
'XMin1': bbox[0] / w,
'YMin1': bbox[1] / h,
'XMax1': bbox[2] / w,
'YMax1': bbox[3] / h,
'XMin2': bbox[0] / w,
'YMin2': bbox[1] / h,
'XMax2': bbox[2] / w,
'YMax2': bbox[3] / h,
'RelationshipLabel': 'is',
'Score': score
}
res.append(det)
#df_test['PredictionString'] = pred_strs
df_val = pd.DataFrame(res)
print(df_val.head())
df_val.to_csv(args.out, index=False)
print('done')
def on_click(event):
"""Plot click event handler - zoom into set"""
global box
print event.inaxes
box_width = (box[1].real - box[0].real)
box_height = (box[1].imag - box[0].imag)
center = complex(box[0].real + (float(event.xdata)/get_image_size(img)[0])*box_width,
box[0].imag + (1.0-(float(event.ydata)/get_image_size(img)[1]))*box_height)
new_box_size = complex(box_width/1.5, box_height/1.5)
box[0] = center - new_box_size/2
box[1] = center + new_box_size/2
render_mandel_iterative(img, box[0], box[1], max_iter)
ax.imshow(img, cm.spectral, interpolation='nearest')
plt_show()
def render_avi(dir_name: str, avi_full_path: str, fps=25):
if not os.path.isdir(dir_name):
raise OSError
if not avi_full_path.lower().endswith('.avi'):
avi_full_path += '.avi'
if dir_name[-1] not in ['\\', '/']:
dir_name += os.sep
frames = list((dir_name + img for img in os.listdir(dir_name) if img.split('.')[-1].lower() in ['jpg', 'png']))
frames = sorted(frames, key=lambda x: int(x.split(os.sep)[1].split('.')[0]))
frames_len = len(frames)
frame_res = utils.get_image_size(frames[0])
writer = cv2.VideoWriter(avi_full_path, cv2.VideoWriter_fourcc('X', 'V', 'I', 'D'), fps, frame_res)
print('Frames count: ' + str(frames_len))
j = 0
for i in range(frames_len):
if i > 0 and i % fps == 0:
print(f'{i+1}/{frames_len}', end=', ')
j += 1
if j > 0 and j % 10 == 0:
print(end='\n')
writer.write(utils.load_image(frames[i], numpy.ndarray))
print('Rendering AVI Done!')
def dump_test(_X, batch_size=config.batch_size, mode='res'):
image_size = utils.get_image_size(mode)
num_batch = int(np.ceil(len(_X) / config.batch_size))
for i in range(num_batch):
if i % 30 == 0:
print("Batch %d" % (i))
x_batch, paths = [], []
for path in _X[i * config.batch_size:(i + 1) * config.batch_size]:
try:
img = image.load_img(path,
target_size=(image_size, image_size))
except:
print(path)
continue
img = image.img_to_array(img)
x_batch.append(img)
path = path.split('/')[1].split('.')[0]
paths.append(path)
x_batch = np.array(x_batch)
x_batch = get_features(x_batch, mode)
paths = np.array(paths)
pickle.dump((x_batch, paths),
open('x_test_' + mode + '/' + str(i) + '.pickle', 'wb'),
pickle.HIGHEST_PROTOCOL)
def draw_fleet(fb, x, y, rows, columns, padding, alien, mask, img_idx):
""" Draw table with same bitmap"""
w, h = get_image_size(alien[img_idx])
for i in xrange(columns):
for j in xrange(rows):
draw_bitmap_2(fb, x + i*(w+padding), y + j*(h+padding),
alien[img_idx], mask[img_idx])
def set_effects(self, kwargs: dict):
self.effects = {}
no_effects_list = create_empty_callbacks_cl(self.frames_count)
for item in ('preprocess_first', 'preprocess_second',
'postprocess_first', 'postprocess_second'):
value = kwargs.get(item, no_effects_list)
print(f'@@ set_effects!! item={item} of type={type(value)}')
if isclass(value):
# noinspection PyTypeChecker
if issubclass(value, ImageTravel):
value: ImageTravel = value(
image=self.im1,
frames_count=self.frames_count,
frame_resolution=utils.get_image_size(self.im1))
if isinstance(value, ImageTravel):
print('TRANSITION: if isinstance(value, ImageTravel):')
cb = utils.Callback(fun_ptr=value.next_frame,
needs_params=('frame_index', 'im1'))
value: utils.CircleList = utils.CircleList(
list_or_tuple=[cb], max_iterations=self.frames_count)
if isinstance(value, (list, tuple)):
value: utils.CircleList = utils.CircleList(
list_or_tuple=value, max_iterations=self.frames_count)
if not isinstance(value, utils.CircleList):
raise TypeError
value.max_iterations = self.frames_count
self.effects[item] = value
def save_to_seaweedfs(message):
host = CONFIG['seaweed_filler_host']
port = CONFIG['seaweed_filler_port']
try:
images_list = message['preview_images']
_dir = message['document_uuid']
original_document = message['original_document']
document_name = message['document_name']
result_list = save_files_filler_batch(host, port, _dir, images_list)
_splited = os.path.split(original_document)
_ex = _splited[1].split('.')[1]
document_file = '%s.%s' % (document_name, _ex)
new_original_document = os.path.join(_splited[0], document_file)
os.rename(original_document, new_original_document)
save_file_to_filler(host, port, _dir, new_original_document)
message['cover_image'] = result_list[0]
width, height = get_image_size(images_list[0])
message['preview_image_width'] = width
message['preview_image_height'] = height
message['original_document'] = document_file
# TODO: add /tmp to conf
shutil.rmtree(os.path.join('/tmp', _dir))
del message['preview_images']
return message
except Exception as e:
sentry_client(e)
def work(item):
if item.icon:
print 'thread start'
if item.icon.startswith('plugins'):
item.icon = '/{}'.format(item.icon)
else:
item.icon = CACHE.get(item.icon)
item.info['poster'] = item.icon
try:
item.width, item.height = utils.get_image_size('.{}'.format(item.icon))
if item.width > 600 or item.height > 600:
item.width = item.width / 2
item.height = item.height / 2
if item.width < 200 or item.height < 200:
item.width = item.width * 2
item.height = item.height * 2
except:
traceback.print_exc(file=sys.stdout)
item.width = 300
item.height = 300
print 'thread done'
else:
item.width = 300
item.height = 300
item.context['Item info'] = 'ItemInfo({})'.format(json.dumps(item.info))
def work(item):
if item.icon:
print 'thread start'
if item.icon.startswith('plugins'):
item.icon = '/{}'.format(item.icon)
else:
item.icon = CACHE.get(item.icon)
item.info['poster'] = item.icon
try:
item.width, item.height = utils.get_image_size('.{}'.format(
item.icon))
if item.width > 600 or item.height > 600:
item.width = item.width / 2
item.height = item.height / 2
if item.width < 200 or item.height < 200:
item.width = item.width * 2
item.height = item.height * 2
except:
traceback.print_exc(file=sys.stdout)
item.width = 300
item.height = 300
print 'thread done'
else:
item.width = 300
item.height = 300
item.context['Item info'] = 'ItemInfo({})'.format(json.dumps(
item.info))
def next_batch(_X, _Y, batch_size=128, mode='res'):
image_size = utils.get_image_size(mode)
num_batch = int(np.ceil(len(_Y) / config.batch_size))
for i in range(num_batch):
if i % 30 == 0:
print("Batch: %d" % (i))
x_batch, y_batch = [], []
for path, label in zip(
_X[i * config.batch_size:(i + 1) * config.batch_size],
_Y[i * config.batch_size:(i + 1) * config.batch_size]):
try:
img = image.load_img(path,
target_size=(image_size, image_size))
except:
continue
img = image.img_to_array(img)
x_batch.append(img)
y_tmp = np.zeros((config.num_classes, ))
y_tmp[label] = 1
y_batch.append(y_tmp)
x_batch = np.array(x_batch)
x_batch = get_features(x_batch, mode)
y_batch = np.array(y_batch)
yield x_batch, y_batch
def reload(self, **kwargs) -> True or utils.image_types:
"""
Reloads image from drive with other params than in __init__
:keyword kwargs:
:key image_type: PIL.Image.Image or numpy.ndarray, or passed in __init__
:key resolution: new resolution or passed in __init__
:key return_image: if passed and set to True, method returns reloaded image, else returns True
:return: look above
"""
self.image = utils.load_image(self.init_params['full_path'], self.init_params['image_type'])
resolution = self.init_params['kwargs']['resolution']
image_type = kwargs.get('image_type', self.init_params['image_type'])
if kwargs.get('resolution', None) is not None:
resolution = kwargs['resolution']
if resolution is not None:
print('ImageHandler reloading, resize to', resolution)
loaded_image_size = utils.get_image_size(self.image)
if loaded_image_size != resolution:
self.image = utils.convert_image_type(
source_image=cv_effects.cut_rect(
image=self.image,
src_box=(0, 0, *loaded_image_size),
size=resolution
),
dest_type=image_type
)
self.init_params['reload_params'] = kwargs
if kwargs.get('return_image', None) is not None:
return self.image
return True
def fit_images(images_list: list, resolution=(1920, 1080)) -> list:
for i in range(len(images_list)):
if resolution != utils.get_image_size(images_list[i]):
images_list[i] = cv2.resize(images_list[i], resolution)
return images_list
def _get_data(self, json_file_path):
"""
Retrun dict with list of images and list of classes and list of objects,
objects have img_path, widtha and height of image, list of dict with singel boxes,
and list of labels.
:param json_file_path: path to json file to open
:type json_file_path: str
:retruns: dict of json data
:rtype: dict
"""
output = {}
objects = []
images = []
uniq_dataset_classes = []
json_data = self._read_json_file(json_file_path)
for image_json_object in json_data:
if not bool(image_json_object["Label"]):
continue
object_data = {}
image_save_path = os.path.join(self.tmp_folder,
image_json_object["ID"] + ".jpg")
urllib.request.urlretrieve(image_json_object["Labeled Data"],
image_save_path)
self._check_images_orientation(image_save_path)
boxes = list()
labels = list()
for object_on_img in image_json_object["Label"]["objects"]:
xmin = object_on_img['bbox']['left']
ymin = object_on_img['bbox']['top']
xmax = xmin + object_on_img['bbox']['width']
ymax = ymin + object_on_img['bbox']['height']
boxes.append({
'xmin': xmin,
'ymin': ymin,
'xmax': xmax,
'ymax': ymax
})
labels.append(object_on_img["value"])
if not object_on_img["value"] in uniq_dataset_classes:
uniq_dataset_classes.append(object_on_img["value"])
width, height, depth = get_image_size(image_save_path)
object_data.update({'img_name': os.path.split(image_save_path)[1]})
object_data.update({'img_path': image_save_path})
object_data.update({'width': width})
object_data.update({'height': height})
object_data.update({'depth': depth})
object_data.update({'boxes': boxes})
object_data.update({'labels': labels})
objects.append(object_data)
images.append(image_save_path)
output.update({'images': images})
uniq_dataset_classes = self._format_dataset_classes(
uniq_dataset_classes)
output.update({'dataset_classes': uniq_dataset_classes})
output.update({'objects': objects})
return output
def render_mandel_iterative(img, ll_corner, ur_corner, max_iter=100):
""" Simplest approach, iterating over every point """
size = get_image_size(img)
x_axis = np.linspace(ll_corner.real, ur_corner.real, num=size[0])
y_axis = np.linspace(ur_corner.imag, ll_corner.imag, num=size[1])
for i in xrange(size[1]):
for j in xrange(size[0]):
val, iteration, max_reached = mandel_point(complex(x_axis[j], y_axis[i]), max_iter)
if not max_reached:
putpixel(img, j, i, iteration)
else:
putpixel(img, j, i, 0)
def get_image(html, query, current):
# extract image url
img_list = get_img_list(html)
num = 0
if img_list:
count = 0
# extract title
title_list = get_title_list(html)
title_list = remove_label(title_list)
# extract size
width_list = get_width_list(html)
height_list = get_height_list(html)
for img_url in img_list:
# extract url
img_url = get_image_url(img_url)
# crawl image on the page
try:
# detect the image(find the bigest face in the image)
result = api.detection.detect(url=img_url, mode='oneface')
if result['face']:
image_path = '%s%s.jpg' % (IMAGE_DIR, current+num)
# download image
filename, msg = urllib.urlretrieve(img_url, image_path)
# if download successfully
if msg['Content-Length']:
# append tag to image
append_tags(image_path, get_image_size(width_list[count]), get_image_size(height_list[count]),
get_image_title(title_list[count]), img_url, query, result['face'][0]['attribute'])
# output info
print "%s: %s" % (current+num, img_url)
num += 1
if num >= EACH:
break
except Exception as err:
print(err)
count += 1
else:
print "%s didn't have .jpg format picture" % query
return current+num
def ensemble(args):
global all_preds, classes, ens_dets, MAX_NUM
MAX_NUM = args.max_num
classes, _ = get_top_classes(args.start_index, args.end_index,
args.class_file)
for fn in pred_files:
print('loading {} ...'.format(fn))
with open(fn, 'rb') as f:
all_preds.append(pickle.load(f))
print('len(preds):', len(all_preds[0]))
print('num classes of preds:', len(all_preds[0][0][1]))
print('specified num classes:', len(classes))
#assert len(preds[0][1]) == len(classes)
with Pool(24) as p:
num_imgs = len(all_preds[0])
#ens_dets = list(tqdm(iterable=p.map(get_ens_det, list(range(num_imgs))), total=num_imgs))
ens_dets = p.map(get_ens_det, range(num_imgs))
#num_imgs = len(preds1)
#for idx in tqdm(range(num_imgs), total=num_imgs):
# ens_dets.append(get_ens_det(idx))
print('getting img size...')
df_test = pd.read_csv(osp.join(DATA_DIR, 'sample_empty_submission.csv'))
df_test.ImageWidth = df_test.ImageID.map(
lambda x: get_image_size(get_fn(x))[0])
df_test.ImageHeight = df_test.ImageID.map(
lambda x: get_image_size(get_fn(x))[1])
print('creating submission...')
df_test['img_index'] = df_test.index
df_test = parallel_apply(df_test, set_pred_str)
df_test = df_test.drop(columns=['img_index'], axis=1)
df_test.to_csv(args.out, index=False)
print('done')
def animate():
""" Draw alien fleet repeatedly, taking care
of descending to next row when appropriate"""
global fig
w, h = get_image_size(alien[0])
rows = 4
columns = 10
padding = 10
yend = yres - rows * (h + padding)
# last column does not need right padding
row_width = (w + padding) * columns - padding
y = 0
x = padding
xdelta = 3
ydelta = 4
flip_freq = 10
frame_num = 0
img_idx = 0
key = False
def on_key_press(event):
print "Key!"
key = True
#hid = fig.canvas.mpl_connect('key_press_event', on_key_press)
while y <= yend and not key:
frame_num += 1
fb[:] = img[:]
x += xdelta
if frame_num % flip_freq == 0:
img_idx += 1
if img_idx >= len(alien):
img_idx = 0
if x + row_width >= xres:
x -= (x + row_width) % xres
xdelta = -xdelta
y += ydelta
elif x < 0:
xdelta = -xdelta
x = x + xdelta
y += ydelta
draw_fleet(fb, x, y, rows, columns, padding, alien, mask, img_idx)
dat.set_data(fb)
fig.canvas.draw()
plt.pause(0.001)
def draw_bitmap(img, x, y, bitmap, mask=None):
""" Draws bitmap on image array, on positions x, y
optionally using mask
"""
if mask is not None:
assert bitmap.shape[0:2] == mask.shape
w, h = get_image_size(bitmap)
for yi in xrange(h):
for xi in xrange(w):
# anything that is not 0 in mask means take that pixel
m = mask is None or not getpixel(mask, xi, yi)
if m:
putpixel(img, x+xi, y+yi, getpixel(bitmap, xi, yi))
def draw_bitmap_2(img, x, y, bitmap, mask=None):
""" More numpy-ish way"""
if mask is not None:
assert bitmap.shape[0:2] == mask.shape
w, h = get_image_size(bitmap)
if mask is not None:
if img.ndim == 3:
# take care of case with RGB image & single component mask
img[y:y+h, x:x+w] &= mask[:, :, np.newaxis]
elif img.ndim == 2:
img[y:y+h, x:x+w] &= mask
img[y:y+h, x:x+w] |= bitmap
else:
img[y:y+h, x:x+w] = bitmap
def _check_images_orientation(self, image_path):
"""
Check if dowloaded images have good orientation, and if bad
orientation that will be rotated.
:param image_path: path image
:type image_path: str
:retruns: None
:rtype: None
"""
width, height, depth = get_image_size(image_path)
if height > width:
image = cv2.imread(image_path)
image = ndimage.rotate(image, 90)
cv2.imwrite(image_path, image)
return None
def mask_from_bitmap(img):
""" Derive mask for blitting image img. Mask has value 0
iff given pixel or any of its neighbours has
nonzero value, 255 otherwise"""
mask = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
w, h = get_image_size(img)
for i in xrange(h):
for j in xrange(w):
# in this case neighbours include pixel itself
neighbours = img[max(0, i-1) : min(i+1, h-1),
max(0, j-1) : min(j+1, w-1)]
mask[i][j] = 0 if np.any(neighbours) else 255
return mask
def test(model, test_loader, test_files, config):
"""Test the result"""
# TODO: use config.yml
conf_thresh = 0.005
nms_thresh = 0.45
num_classes = config['num_classes']
anchors = config['anchors']
num_anchors = len(anchors) // 2
line_id = -1
results = {}
for i in range(num_classes):
results[i] = []
start = time.time()
for batch_idx, (data, target) in enumerate(test_loader):
data = data.cuda()
data = Variable(data, volatile=True)
output = model(data).data
batch_boxes = get_region_boxes(output, conf_thresh, num_classes,
anchors, num_anchors, 0, 1)
for i in range(output.size(0)):
line_id += 1
im_id = os.path.basename(test_files[line_id]).split('.')[0]
width, height = get_image_size(test_files[line_id])
boxes = batch_boxes[i]
boxes = nms(boxes, nms_thresh)
for box in boxes:
x1 = (box[0] - box[2] / 2) * width
y1 = (box[1] - box[3] / 2) * height
x2 = (box[0] + box[2] / 2) * width
y2 = (box[1] + box[3] / 2) * height
det_conf = box[4]
for j in range((len(box) - 5) // 2):
cls_conf = box[5 + 2 * j]
cls_id = box[6 + 2 * j]
prob = det_conf * cls_conf
results[cls_id].append((im_id, prob, x1, y1, x2, y2))
end = time.time()
print('Batch {}/{}, time cost: {:.4f}s per image'.format(
batch_idx + 1, len(test_loader),
(end - start) / ((batch_idx + 1) * output.size(0))))
return results
def __init__(
self,
full_path: str,
image_type: utils.image_types = numpy.ndarray,
**kwargs):
"""
:param full_path: full path to image on drive
:param image_type: PIL.Image.Image or numpy.ndarray
:keyword kwargs:
:key load: loads image to RAM, pass True value for it
:key resolution: tuple (width, height) that tells to handle rescaled image
:key frame_indexes: list/tuple of ints describing positions on timeline where image should occur
:key uid_setter: instance of such class with method set_next_uid() -> str
"""
kwargs['frame_indexes'] = kwargs.get('frame_indexes', [0])
self.init_params = locals()
self.uid = None
if kwargs.get('uid_setter', False):
uid_setter = kwargs['uid_setter']
if hasattr(uid_setter, 'set_next_uid'):
uid_setter = getattr(uid_setter, 'set_next_uid')
if callable(uid_setter):
self.uid = uid_setter()
self.image = False if not kwargs.get('load', False) else utils.load_image(
image_or_path=full_path,
result_type=image_type
)
if 'resolution' in kwargs:
if self.image is not False:
self.image = utils.load_image(self.image, numpy.ndarray)
size = utils.get_image_size(self.image)
if size != kwargs['resolution']:
print('ImageHandler resize resolution to', kwargs['resolution'])
input('enter...')
self.image = cv2.resize(self.image, kwargs['resolution'])
self.image = utils.convert_image_type(self.image, image_type)
def __init__(self, appName):
self.timer = 0
self.window = ac.newApp(appName)
ac.setTitle(self.window, "")
ac.drawBorder(self.window, 0)
ac.setIconPosition(self.window, 0, -10000)
ac.setSize(self.window, 367, 73)
ac.setBackgroundOpacity(self.window, 0)
self.fastestLapBanner = ac.addLabel(self.window, "")
ac.setPosition(self.fastestLapBanner, 0, 0)
w, h = get_image_size(FC.FASTEST_LAP_BANNER)
ac.setSize(self.fastestLapBanner, w, h)
ac.setBackgroundTexture(self.fastestLapBanner, FC.FASTEST_LAP_BANNER)
self.fastestLapBackground = ac.addLabel(self.window, "")
ac.setPosition(self.fastestLapBackground, w, 0)
ac.setSize(self.fastestLapBackground, 400, h)
ac.setBackgroundTexture(self.fastestLapBackground,
FC.DRIVER_WIDGET_BACKGROUND)
self.nameLabel = ac.addLabel(self.window, "")
ac.setPosition(self.nameLabel, w + 10, 11)
ac.setFontSize(self.nameLabel, 22)
ac.setCustomFont(self.nameLabel, FC.FONT_NAME, 0, 0)
ac.setFontColor(self.nameLabel, 0.86, 0.86, 0.86, 1)
ac.setFontAlignment(self.nameLabel, "left")
self.lastNameLabel = ac.addLabel(self.window, "")
ac.setPosition(self.lastNameLabel, w + 10, 37)
ac.setFontSize(self.lastNameLabel, 28)
ac.setCustomFont(self.lastNameLabel, FC.FONT_NAME, 0, 1)
ac.setFontColor(self.lastNameLabel, 0.86, 0.86, 0.86, 1)
ac.setFontAlignment(self.lastNameLabel, "left")
self.timeLabel = ac.addLabel(self.window, "")
ac.setPosition(self.timeLabel, w + 385, 22)
ac.setFontSize(self.timeLabel, 35)
ac.setCustomFont(self.timeLabel, FC.FONT_NAME, 0, 1)
ac.setFontColor(self.timeLabel, 0.86, 0.86, 0.86, 1)
ac.setFontAlignment(self.timeLabel, "right")
def main(args):
# instantiate model and inputs
image_size = get_image_size(args.model_name)
input_shape = [args.bs, 3, image_size, image_size]
model = get_model(args.model_name)
dummy_input = torch.randn(*input_shape).cuda()
with closing(get_inference_wrapper(model, dummy_input,
args.mode)) as inference_wrapper:
result = evaluate(inference_wrapper)
df = eval_result_to_df(args.mode, result)
if args.out_path:
df.to_csv(args.out_path)
else:
summary = pd.DataFrame({
'mean (ms)': df.mean(),
'stdev (ms)': df.std()
})
print(summary)
def shape(self): #Standard shape setup of window print 'shaping window' w,h = self.window.get_size() if w==0: w = 100 if h==0: h = 100 self.w = w self.h = h self.pixmap = gtk.gdk.Pixmap (None, w, h, 1) ctx = self.pixmap.cairo_create() self.bgpb = gtk.gdk.pixbuf_new_from_file(Globals.ImageDirectory + Globals.StartMenuTemplate) if Globals.Settings['GtkColors'] == 1 and Globals.Has_Numpy: if not self.colorpb: bgcolor = Globals.GtkColorCode r = (bgcolor.red*255)/65535.0 g = (bgcolor.green*255)/65535.0 b = (bgcolor.blue*255)/65535.0 self.colorpb= self.bgpb.copy() for row in self.colorpb.get_pixels_array(): for pix in row: pix[0] = r pix[1] = g pix[2] = b self.bgpb.composite(self.colorpb, 0, 0, self.w, self.h, 0, 0, 1, 1, gtk.gdk.INTERP_BILINEAR, 70) self.bgpb = self.colorpb ctx.save() ctx.set_source_rgba(1, 1, 1,0) ctx.set_operator (cairo.OPERATOR_SOURCE) ctx.paint() ctx.restore() if Globals.MenuHasIcon==1: cairo_drawing.draw_image(ctx,Globals.UserIconFrameOffsetX,Globals.UserIconFrameOffsetY,Globals.UserImageFrame) w,h = utils.get_image_size(Globals.UserImageFrame) cairo_drawing.draw_scaled_image(ctx,Globals.IconInX +Globals.UserIconFrameOffsetX,Globals.UserIconFrameOffsetY+Globals.IconInY,Globals.UserImage,Globals.IconInW ,Globals.IconInH) cairo_drawing.draw_enhanced_image(ctx,0,0,Globals.ImageDirectory + Globals.StartMenuTemplate) if self.window.is_composited(): self.window.input_shape_combine_mask(self.pixmap,0,0) else: self.window.shape_combine_mask(self.pixmap, 0, 0)
def _extract_by_image_size(self, url):
self.driver.get(url)
images = self.driver.find_elements_by_tag_name('img')
for image in images[:4]:
src = image.get_property('src')
if not src:
continue
image_url = utils.image_src_to_url(url, src)
try:
width, height = utils.get_image_size(image_url)
if (50 <= width <= 100) and (50 <= height <= 100):
return image_url
except Exception as e:
pass
return None
def pick_image_for_frame(self, frame_index: int = -1) -> List[utils.image_types, int]:
if frame_index == -1:
# print(f'Wizard::pick_image() for frame {frame_index} ==> (default) = {self.global_frame_index}')
frame_index = self.global_frame_index
closest, result_handler_id = self.total_slide_duration, None
for handler_id, image_handler in enumerate(self.image_handlers):
indexes = image_handler.get_frame_indexes()
if frame_index >= indexes[0]:
dist = frame_index - indexes[0]
if dist < closest:
closest, result_handler_id = dist, handler_id
if result_handler_id is None:
raise ValueError('No such image')
result = self.image_handlers[result_handler_id].get_image()
print(f'picked image.index = {result_handler_id}, with shape:', utils.get_image_size(result))
return [
cv2.resize(utils.convert_image_type(result, numpy.ndarray), self.frame_resolution),
result_handler_id
]
def scale_images_dir(src_images_dir_path: str, dest_images_dir_path: str, dest_size=(1920, 1080)) -> int:
if not os.path.isdir(src_images_dir_path):
raise FileNotFoundError(f'src_images_dir_path="{src_images_dir_path}" is not a directory')
if os.path.isfile(dest_images_dir_path):
raise OSError(f'dest_images_dir_path="{dest_images_dir_path}" is file, not directory')
result = 0
if src_images_dir_path[-1] not in ['\\', '/']:
src_images_dir_path += os.path.sep
if dest_images_dir_path[-1] not in ['\\', '/']:
dest_images_dir_path += os.path.sep
for next_file in os.listdir(src_images_dir_path):
if next_file.split('.')[-1].lower() in ['jpg', 'png', 'bmp']:
img = utils.load_image(src_images_dir_path + next_file, np.ndarray)
if utils.get_image_size(img) == dest_size:
utils.save_image(img, dest_images_dir_path)
else:
utils.save_image(img, cv2.resize(img, dest_size))
result += 1
return result
def _cut_objects(self, image_data):
"""
Method cut labled objcet form image and save it as small image in tmp class folders.
:param image_data: dict of info about image and all object on that image
:type image_data: dict
:retruns: None
:rtype: None
"""
full_image = cv2.imread(image_data['img_path'])
for idx, i_object in enumerate(image_data['boxes']):
cut_image = full_image[i_object['ymin']:i_object['ymax'],
i_object['xmin']:i_object['xmax']]
cut_object_name = "".join([
os.path.splitext(image_data['img_name'])[0], '_',
str(idx), ".jpg"
])
cut_object_path = os.path.join(
self.dataset_classes_path_map[image_data['labels'][idx]],
cut_object_name)
width, height, depth = get_image_size(cut_image)
if height > width:
cut_image = ndimage.rotate(cut_image, -90)
cv2.imwrite(cut_object_path, cut_image)
return None
def _read_text(self, text_path, uniq_dataset_classes=[]):
"""
Method that extract information from text file and return dict,
and update uniq dataset classes list.
:param text_path: path to text file
:type text_path: str
:param uniq_dataset_classes: list of uniq class name
:type uniq_dataset_classes: list
:return: tuple with dict data from text and list of uniq class name
:rtype: tuple
"""
output_dict = {}
image_filepath, image_filename = self._get_img_name_and_img_path_from_text_filename(
text_path)
output_dict['img_name'] = image_filename
output_dict['img_path'] = image_filepath
width, height, depth = get_image_size(output_dict['img_path'])
output_dict['width'] = width
output_dict['height'] = height
output_dict['depth'] = depth
labels = []
boxes = []
for label_bbox_str in load_text_file_as_list(text_path):
bbox = {}
label_bbox_list = label_bbox_str.split()
labels.append(uniq_dataset_classes[int(label_bbox_list[0])])
bbox['xmin'] = int(width * float(label_bbox_list[1]))
bbox['ymax'] = int(height * float(label_bbox_list[2]))
bbox['xmax'] = int((float(label_bbox_list[3]) * width) +
bbox['xmin'])
bbox['ymin'] = int((float(label_bbox_list[4]) * height) +
bbox['ymax'])
boxes.append(bbox)
output_dict['boxes'] = boxes
output_dict['labels'] = labels
return output_dict, uniq_dataset_classes
def valid(weightfile, outfile, outdir):
pool = ThreadPool(1)
valid_images = args.valid
name_list = args.names
prefix = outdir
names = utils.load_class_names(name_list)
utils.set_default_context_by_args(args)
with open(valid_images) as fp:
tmp_files = fp.readlines()
valid_files = [item.rstrip() for item in tmp_files]
# Build the YOLO v2 network
def create_losses(batchsize, imheight, imwidth, test=True):
import gc
gc.collect()
nnabla_ext.cuda.clear_memory_cache()
anchors = args.num_anchors
classes = args.num_classes
yolo_x = nnabla.Variable((batchsize, 3, imheight, imwidth))
yolo_features = yolov2.yolov2(yolo_x, anchors, classes, test=test)
return yolo_x, yolo_features
yolo_x_nnabla, yolo_features_nnabla = create_losses(args.valid_batchsize,
args.height,
args.width,
test=True)
nnabla.load_parameters(weightfile)
valid_dataset = dataset.data_iterator_yolo(valid_images,
args,
train=False,
shape=(args.width, args.height),
shuffle=False,
batch_size=args.valid_batchsize)
assert (args.valid_batchsize > 1)
fps = [0] * args.num_classes
if not os.path.exists(outdir):
os.mkdir(outdir)
for i in range(args.num_classes):
buf = '%s/%s%s.txt' % (prefix, outfile, names[i])
fps[i] = open(buf, 'w')
lineId = 0
total_samples = len(valid_files)
total_batches = (total_samples + args.valid_batchsize -
1) // args.valid_batchsize
for each_batch in range(0, total_batches):
ret = valid_dataset.next()
data, target = ret
yolo_x_nnabla.d = data
yolo_features_nnabla.forward(clear_buffer=True)
batch_boxes = utils.get_region_boxes(yolo_features_nnabla.d,
args.conf_thresh,
args.num_classes, args.anchors,
args.num_anchors, 0, 1)
for i in range(yolo_features_nnabla.d.shape[0]):
if lineId >= total_samples:
print("Reached End of total_samples")
break
fileId = os.path.basename(valid_files[lineId]).split('.')[0]
width, height = utils.get_image_size(valid_files[lineId])
print(valid_files[lineId])
lineId += 1
boxes = batch_boxes[i]
boxes = utils.nms(boxes, args.nms_thresh)
for box in boxes:
x1 = (box[0] - box[2] / 2.0) * width
y1 = (box[1] - box[3] / 2.0) * height
x2 = (box[0] + box[2] / 2.0) * width
y2 = (box[1] + box[3] / 2.0) * height
det_conf = box[4]
for j in range((len(box) - 5) // 2):
cls_conf = box[5 + 2 * j]
cls_id = box[6 + 2 * j]
prob = det_conf * cls_conf
fps[cls_id].write('%s %f %f %f %f %f\n' %
(fileId, prob, x1, y1, x2, y2))
for i in range(args.num_classes):
fps[i].close()
def acMain(ac_version):
# VARIABLES
global totalDrivers
global drivers
global leaderboardWindow, driverWidget, driverComparisonWidget, fastest_lap_banner
# LABELS
global leaderboard
global lapCountTimerLabel, leaderboardBaseLabel, leaderboardInfoBackgroundLabel, leaderboardBackgroundLabel
global flagLabel
totalDrivers = ac.getCarsCount()
n_splits = ac.getTrackLength(0) / FC.TRACK_SECTION_LENGTH
drivers = [Driver(i, n_splits) for i in range(totalDrivers)] # driver positions and update times
ac.initFont(0, FC.FONT_NAME, 0, 0)
leaderboardWindow = ac.newApp(FC.APP_NAME)
ac.setTitle(leaderboardWindow, "")
ac.drawBorder(leaderboardWindow, 0)
ac.setIconPosition(leaderboardWindow, 0, -10000)
ac.setSize(leaderboardWindow, 200, 200)
ac.setBackgroundOpacity(leaderboardWindow, 0)
# ===============================
# Leaderboard Background
leaderboardBaseLabel = ac.addLabel(leaderboardWindow, "")
ac.setPosition(leaderboardBaseLabel, 0, 0)
w, h = get_image_size(FC.LEADERBOARD_BASE_RACE)
ac.setSize(leaderboardBaseLabel, w, h)
ac.setBackgroundTexture(leaderboardBaseLabel, FC.LEADERBOARD_BASE_RACE)
leaderboardBackgroundLabel = ac.addLabel(leaderboardWindow, "")
ac.setPosition(leaderboardBackgroundLabel, 0, h)
ac.setSize(leaderboardBackgroundLabel, w, totalDrivers*LeaderboardRow.ROW_HEIGHT + 2)
ac.setBackgroundTexture(leaderboardBackgroundLabel, FC.LEADERBOARD_BACKGROUND);
# ===============================
# Lap Counter / Time
lapCountTimerLabel = ac.addLabel(leaderboardWindow, "")
ac.setPosition(lapCountTimerLabel, 74, 52)
ac.setFontSize(lapCountTimerLabel, 22)
ac.setCustomFont(lapCountTimerLabel, FC.FONT_NAME, 0, 1)
ac.setFontAlignment(lapCountTimerLabel, "center")
ac.setFontColor(lapCountTimerLabel, 0.86, 0.86, 0.86, 1)
# ===============================
# Flags
flagLabel = ac.addLabel(leaderboardWindow, "")
ac.setPosition(flagLabel, w, 8)
ac.setSize(flagLabel, 110, h-8)
ac.setVisible(flagLabel, 0)
# ===============================
# Info Background
leaderboardInfoBackgroundLabel = ac.addLabel(leaderboardWindow, "")
ac.setPosition(leaderboardInfoBackgroundLabel, w, h)
ac.setSize(leaderboardInfoBackgroundLabel, 110, totalDrivers*LeaderboardRow.ROW_HEIGHT + 2)
ac.setBackgroundTexture(leaderboardInfoBackgroundLabel, FC.LEADERBOARD_INFO_BACKGROUNG)
info_button = ac.addButton(leaderboardWindow, "")
ac.setPosition(info_button, w, h)
ac.setSize(info_button, 110, totalDrivers*LeaderboardRow.ROW_HEIGHT + 2)
ac.addOnClickedListener(info_button, on_click_info)
ac.setBackgroundOpacity(info_button, 0)
ac.drawBorder(info_button, 0)
# ===============================
# Driver Widget
driverWidget = DriverWidget(FC.APP_NAME+" Driver")
# ===============================
# Driver Comparison Widget
driverComparisonWidget = DriverComparisonWidget(FC.APP_NAME+" Driver Comparison")
# ===============================
# FastestLap Banner
fastest_lap_banner = FastestLapBanner(FC.APP_NAME+" Top Banner")
fastest_lap_banner.hide()
leaderboard = [None] * totalDrivers
for i in range(totalDrivers):
leaderboard[i] = LeaderboardRow(leaderboardWindow, i)
return FC.APP_NAME
def convert_to_coco(self, input_dir, output_file, output_image_dir=None):
self._check_format(Format.COCO)
ensure_dir(os.path.dirname(output_file))
if output_image_dir is not None:
ensure_dir(output_image_dir)
images, categories, annotations = [], [], []
category_name_to_id = {}
data_key = self._data_keys[0]
for item_idx, item in enumerate(self.iter_from_dir(input_dir)):
image_path = item['input'][data_key]
if not os.path.exists(image_path):
if output_image_dir is None:
raise FileNotFoundError(
f'We can\'t find file by path {image_path}: if it is URL, please specify "output_image_dir"'
f'where downloaded images will be stored'
)
try:
image_path = download(image_path, output_image_dir)
except:
logger.error(f'Unable to download {image_path}. The item {item} will be skipped', exc_info=True)
continue
width, height = get_image_size(image_path)
image_id = len(images)
images.append({
'width': width,
'height': height,
'id': image_id,
'file_name': image_path
})
bboxes = next(iter(item['output'].values()))
for bbox in bboxes:
category_name = bbox['rectanglelabels'][0]
if category_name not in category_name_to_id:
category_id = len(categories)
category_name_to_id[category_name] = category_id
categories.append({
'id': category_id,
'name': category_name
})
category_id = category_name_to_id[category_name]
annotation_id = len(annotations)
x = int(bbox['x'] / 100 * width)
y = int(bbox['y'] / 100 * height)
w = int(bbox['width'] / 100 * width)
h = int(bbox['height'] / 100 * height)
annotations.append({
'id': annotation_id,
'image_id': image_id,
'category_id': category_id,
'segmentation': [],
'bbox': [x, y, w, h],
'ignore': 0,
'iscrowd': 0,
'area': w * h
})
with io.open(output_file, mode='w') as fout:
json.dump({
'images': images,
'categories': categories,
'annotations': annotations,
'info': {
'year': datetime.now().year,
'version': '1.0',
'contributor': 'Label Studio'
}
}, fout, indent=2)
def __init__(
self,
image1: image_types or None = None,
image2: image_types or None = None,
dest_dir: str = 'rendered',
frames_count=50,
**kwargs
): # -~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^/-_/~-~/*^-.
"""
Base class for animations between images.
:param image1: look at utils.image_types
:param image2: look at utils.image_types
:param dest_dir: there rendered frames will be saved
:param frames_count: number of frames to render
:param kwargs:
usable keys:
> parent_timeline: Timeline
> prefix: str -> prefix in file name of rendered frame
> extension: str -> extension of output file (rendered frame)
> load_as: [PillowImage, np.ndarray] -> tells how image file should be opened
> preprocess_first, preprocess_second, postprocess_first, postprocess_second:
- list of callbacks to predicates or CircleList(list of callbacks/predicates) or ImageTravel instance
- Type name of ImageTravel class (type name, not instance or its __init__ method call!
"""
'''self.fill_later = False
if kwargs.get('fill_later', False) is True:
self.fill_later = True
return'''
self.im1 = self.im2 = None
if image1 is not None and image2 is not None:
self.im1, self.im2 = utils.verify_alpha_channel(
image1), utils.verify_alpha_channel(image2)
'''if image1 is None and image2 is None:
err = 'If params image1 is None and image2 is None, pass parent_timeline argument of Timeline instance'
if 'parent_timeline' not in kwargs:
raise AttributeError(err)
if not isinstance(kwargs['parent_timeline'], RenderController.Timeline):
raise AttributeError(err)'''
if 'prefix' not in kwargs:
class_name = str(self.__class__).split("'")[1][:-2]
if '.' in class_name:
self.prefix = class_name.split('.')[-1]
else:
self.prefix = kwargs['prefix']
if 'extension' not in kwargs:
kwargs['extension'] = 'png'
else:
if kwargs['extension'] not in ['jpg', 'png']:
kwargs['extension'] = 'png'
if 'frame_resolution' not in kwargs:
if self.im1 is None:
tl: RenderControllers.TimelineModel = kwargs.get(
'parent_timeline', False)
if not tl:
raise AttributeError('Cannot obtain resolution of frame')
kwargs['frame_resolution'] = tl.get_frame_resolution()
else:
kwargs['frame_resolution'] = utils.get_image_size(self.im1)
self.dest_dir = dest_dir
self.frames_count = frames_count
self.kwargs = kwargs
self.name_counter = 0
if 'load_as' not in kwargs:
self.kwargs['load_as'] = PillowImage
if isinstance(image1, np.ndarray):
self.kwargs['load_as'] = np.ndarray
self.effects = {}
self.frame_index = -1
""" Do some animation, multiple blits, test draw_bitmap_2 """
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from bitmap import draw_bitmap_2, mask_from_bitmap
from utils import get_image_size
import numpy as np
img = mpimg.imread("../samples/rocks_red.jpg")
xres, yres = get_image_size(img)
alien = (mpimg.imread("../samples/Space_invader_dn_c.png") * 255) \
.astype(np.uint8)
mask = mask_from_bitmap(alien)
alien2 = (mpimg.imread("../samples/Space_invader_up_c.png") * 255) \
.astype(np.uint8)
mask2 = mask_from_bitmap(alien2)
alien = [alien, alien2]
mask = [mask, mask2]
# comment out to test animation without masks
# mask = [None, None]
def draw_fleet(fb, x, y, rows, columns, padding, alien, mask, img_idx):
""" Draw table with same bitmap"""
w, h = get_image_size(alien[img_idx])
def valid(weightfile, outfile, outdir):
pool = ThreadPool(1)
valid_images = args.valid
name_list = args.names
prefix = outdir
names = utils.load_class_names(name_list)
utils.set_default_context_by_args(args)
with open(valid_images) as fp:
tmp_files = fp.readlines()
valid_files = [item.rstrip() for item in tmp_files]
# Build the YOLO v2 network
def create_losses(batchsize, imheight, imwidth, test=True):
import gc
gc.collect()
nnabla_ext.cuda.clear_memory_cache()
anchors = args.num_anchors
classes = args.num_classes
yolo_x = nnabla.Variable((batchsize, 3, imheight, imwidth))
yolo_features = yolov2.yolov2(yolo_x, anchors, classes, test=test)
return yolo_x, yolo_features
yolo_x_nnabla, yolo_features_nnabla = create_losses(args.valid_batchsize,
args.height,
args.width,
test=True)
nnabla.load_parameters(weightfile)
valid_dataset = dataset.listDataset(valid_images,
args,
train=False,
shape=(args.width, args.height),
shuffle=False)
assert (args.valid_batchsize > 1)
def batch_iter(it, batch_size):
def list2np(t):
imgs, labels = zip(*t)
retimgs = np.zeros((len(imgs), ) + imgs[0].shape, dtype=np.float32)
retlabels = np.zeros((len(labels), ) + labels[0].shape,
dtype=np.float32)
for i, img in enumerate(imgs):
retimgs[i, :, :, :] = img
for i, label in enumerate(labels):
retlabels[i, :] = label
return retimgs, retlabels
retlist = []
for i, item in enumerate(it):
retlist.append(item)
if i % batch_size == batch_size - 1:
ret = list2np(retlist)
# # Don't train for batches that contain no labels
# # TODO: fix this
# if not (np.sum(ret[1].numpy()) == 0):
yield ret
retlist = []
# Excess data is discarded
if len(retlist) > 0:
ret = list2np(retlist)
# # Don't train for batches that contain no labels
# # TODO: fix this
# if not (np.sum(ret[1].numpy()) == 0):
yield ret
valid_loader = batch_iter(iter(valid_dataset),
batch_size=args.valid_batchsize)
fps = [0] * args.num_classes
if not os.path.exists(outdir):
os.mkdir(outdir)
for i in range(args.num_classes):
buf = '%s/%s%s.txt' % (prefix, outfile, names[i])
fps[i] = open(buf, 'w')
lineId = -1
future_data = pool.apply_async(utils.raise_info_thread(next),
(valid_loader, None))
for batch_idx in itertools.count():
curr_data = future_data
future_data = pool.apply_async(utils.raise_info_thread(next),
(valid_loader, None))
ret = curr_data.get()
if ret is None:
break
data, target = ret
yolo_x_nnabla.d = data
yolo_features_nnabla.forward(clear_buffer=True)
batch_boxes = utils.get_region_boxes(yolo_features_nnabla.d,
args.conf_thresh,
args.num_classes, args.anchors,
args.num_anchors, 0, 1)
for i in range(yolo_features_nnabla.d.shape[0]):
lineId = lineId + 1
fileId = os.path.basename(valid_files[lineId]).split('.')[0]
width, height = utils.get_image_size(valid_files[lineId])
print(valid_files[lineId])
boxes = batch_boxes[i]
boxes = utils.nms(boxes, args.nms_thresh)
for box in boxes:
x1 = (box[0] - box[2] / 2.0) * width
y1 = (box[1] - box[3] / 2.0) * height
x2 = (box[0] + box[2] / 2.0) * width
y2 = (box[1] + box[3] / 2.0) * height
det_conf = box[4]
for j in range((len(box) - 5) // 2):
cls_conf = box[5 + 2 * j]
cls_id = box[6 + 2 * j]
prob = det_conf * cls_conf
fps[cls_id].write('%s %f %f %f %f %f\n' %
(fileId, prob, x1, y1, x2, y2))
for i in range(args.num_classes):
fps[i].close()
