def run(self,
template_path=None,
data=None,
state=None,
initial_events=None):
if template_path is None:
# read config
config_path = os.path.join(self.repo_dir,
os.environ.get("CONFIG_DIR", ""),
'config.json')
if file_exists(config_path):
#we are not in debug mode
config = load_json_file(config_path)
template_path = config.get('gui_template', None)
if template_path is None:
self.logger.info(
"there is no gui_template field in config.json")
else:
template_path = os.path.join(self.repo_dir, template_path)
if template_path is None:
template_path = os.path.join(os.path.dirname(sys.argv[0]),
'gui.html')
if not file_exists(template_path):
self.logger.info("App will be running without GUI",
extra={"app_url": self.app_url})
template = ""
else:
with open(template_path, 'r') as file:
template = file.read()
self.public_api.app.initialize(self.task_id, template, data, state)
self.logger.info("Application session is initialized",
extra={"app_url": self.app_url})
try:
self.loop.create_task(self.publish(initial_events),
name="Publisher")
self.loop.create_task(self.consume(), name="Consumer")
self.loop.run_forever()
finally:
self.loop.close()
self.logger.info("Successfully shutdown the APP service.")
if self._error is not None:
raise self._error
def get_related_images(self, item_name):
results = []
path = self.get_related_images_path(item_name)
if dir_exists(path):
files = list_files(path, SUPPORTED_IMG_EXTS)
for file in files:
img_meta_path = os.path.join(path, get_file_name_with_ext(file)+".json")
img_meta = {}
if file_exists(img_meta_path):
img_meta = load_json_file(img_meta_path)
results.append((file, img_meta))
return results
def read_validate_model_class_to_idx_map(model_config_fpath, in_project_classes_set, class_to_idx_config_key):
"""Reads class id --> int index mapping from the model config; checks that the set of classes matches the input."""
if not fs.file_exists(model_config_fpath):
raise RuntimeError('Unable to continue_training, config for previous training wasn\'t found.')
with open(model_config_fpath) as fin:
model_config = json.load(fin)
model_class_mapping = model_config.get(class_to_idx_config_key, None)
if model_class_mapping is None:
raise RuntimeError('Unable to continue_training, model does not have class mapping information.')
model_classes_set = set(model_class_mapping.keys())
if model_classes_set != in_project_classes_set:
error_message_text = 'Unable to continue_training, sets of classes for model and dataset do not match.'
logger.critical(
error_message_text, extra={'model_classes': model_classes_set, 'dataset_classes': in_project_classes_set})
raise RuntimeError(error_message_text)
return model_class_mapping.copy()
def load_font(font_file_name: str,
font_size: int = 12) -> ImageFont.FreeTypeFont:
"""
Set global font true-type for drawing.
Args:
font_file_name: name of font file (example: 'DejaVuSansMono.ttf')
font_size: selected font size
Returns:
loaded from file font
"""
if get_file_ext(font_file_name) == FONT_EXTENSION:
font_path = _get_font_path_by_name(font_file_name)
if (font_path is not None) and file_exists(font_path):
return ImageFont.truetype(font_path, font_size, encoding='utf-8')
else:
raise ValueError(
'Font file "{}" not found in system paths. Try to set another font.'
.format(font_file_name))
else:
raise ValueError('Supported only TrueType fonts!')
def import_cityscapes(api: sly.Api, task_id, context, state, app_logger):
tag_metas = sly.TagMetaCollection()
obj_classes = sly.ObjClassCollection()
dataset_names = []
storage_dir = my_app.data_dir
if INPUT_DIR:
cur_files_path = INPUT_DIR
extract_dir = os.path.join(
storage_dir,
str(Path(cur_files_path).parent).lstrip("/"))
input_dir = os.path.join(extract_dir, Path(cur_files_path).name)
archive_path = os.path.join(
storage_dir,
cur_files_path + ".tar") # cur_files_path.split("/")[-2] + ".tar"
project_name = Path(cur_files_path).name
else:
cur_files_path = INPUT_FILE
extract_dir = os.path.join(storage_dir, get_file_name(cur_files_path))
archive_path = os.path.join(storage_dir,
get_file_name_with_ext(cur_files_path))
project_name = get_file_name(INPUT_FILE)
input_dir = os.path.join(storage_dir,
get_file_name(cur_files_path)) # extract_dir
api.file.download(TEAM_ID, cur_files_path, archive_path)
if tarfile.is_tarfile(archive_path):
with tarfile.open(archive_path) as archive:
archive.extractall(extract_dir)
else:
raise Exception("No such file".format(INPUT_FILE))
new_project = api.project.create(WORKSPACE_ID,
project_name,
change_name_if_conflict=True)
tags_template = os.path.join(input_dir, "gtFine", "*")
tags_paths = glob.glob(tags_template)
tags = [os.path.basename(tag_path) for tag_path in tags_paths]
if train_tag in tags and val_tag not in tags:
split_train = True
elif trainval_tag in tags and val_tag not in tags:
split_train = True
else:
split_train = False
search_fine = os.path.join(input_dir, "gtFine", "*", "*",
"*_gt*_polygons.json")
files_fine = glob.glob(search_fine)
files_fine.sort()
search_imgs = os.path.join(input_dir, "leftImg8bit", "*", "*",
"*_leftImg8bit" + IMAGE_EXT)
files_imgs = glob.glob(search_imgs)
files_imgs.sort()
if len(files_fine) == 0 or len(files_imgs) == 0:
raise Exception('Input cityscapes format not correct')
samples_count = len(files_fine)
progress = sly.Progress('Importing images', samples_count)
images_pathes_for_compare = []
images_pathes = {}
images_names = {}
anns_data = {}
ds_name_to_id = {}
if samples_count > 2:
random_train_indexes = get_split_idxs(samples_count, samplePercent)
for idx, orig_ann_path in enumerate(files_fine):
parent_dir, json_filename = os.path.split(
os.path.abspath(orig_ann_path))
dataset_name = os.path.basename(parent_dir)
if dataset_name not in dataset_names:
dataset_names.append(dataset_name)
ds = api.dataset.create(new_project.id,
dataset_name,
change_name_if_conflict=True)
ds_name_to_id[dataset_name] = ds.id
images_pathes[dataset_name] = []
images_names[dataset_name] = []
anns_data[dataset_name] = []
orig_img_path = json_path_to_image_path(orig_ann_path)
images_pathes_for_compare.append(orig_img_path)
if not file_exists(orig_img_path):
logger.warn(
'Image for annotation {} not found is dataset {}'.format(
orig_ann_path.split('/')[-1], dataset_name))
continue
images_pathes[dataset_name].append(orig_img_path)
images_names[dataset_name].append(
sly.io.fs.get_file_name_with_ext(orig_img_path))
tag_path = os.path.split(parent_dir)[0]
train_val_tag = os.path.basename(tag_path)
if split_train is True and samples_count > 2:
if (train_val_tag == train_tag) or (train_val_tag == trainval_tag):
if idx in random_train_indexes:
train_val_tag = train_tag
else:
train_val_tag = val_tag
# tag_meta = sly.TagMeta(train_val_tag, sly.TagValueType.NONE)
tag_meta = sly.TagMeta('split', sly.TagValueType.ANY_STRING)
if not tag_metas.has_key(tag_meta.name):
tag_metas = tag_metas.add(tag_meta)
# tag = sly.Tag(tag_meta)
tag = sly.Tag(meta=tag_meta, value=train_val_tag)
json_data = json.load(open(orig_ann_path))
ann = sly.Annotation.from_img_path(orig_img_path)
for obj in json_data['objects']:
class_name = obj['label']
if class_name == 'out of roi':
polygon = obj['polygon'][:5]
interiors = [obj['polygon'][5:]]
else:
polygon = obj['polygon']
if len(polygon) < 3:
logger.warn(
'Polygon must contain at least 3 points in ann {}, obj_class {}'
.format(orig_ann_path, class_name))
continue
interiors = []
interiors = [convert_points(interior) for interior in interiors]
polygon = sly.Polygon(convert_points(polygon), interiors)
if city_classes_to_colors.get(class_name, None):
obj_class = sly.ObjClass(
name=class_name,
geometry_type=sly.Polygon,
color=city_classes_to_colors[class_name])
else:
new_color = generate_rgb(city_colors)
city_colors.append(new_color)
obj_class = sly.ObjClass(name=class_name,
geometry_type=sly.Polygon,
color=new_color)
ann = ann.add_label(sly.Label(polygon, obj_class))
if not obj_classes.has_key(class_name):
obj_classes = obj_classes.add(obj_class)
ann = ann.add_tag(tag)
anns_data[dataset_name].append(ann)
progress.iter_done_report()
out_meta = sly.ProjectMeta(obj_classes=obj_classes, tag_metas=tag_metas)
api.project.update_meta(new_project.id, out_meta.to_json())
for ds_name, ds_id in ds_name_to_id.items():
dst_image_infos = api.image.upload_paths(ds_id, images_names[ds_name],
images_pathes[ds_name])
dst_image_ids = [img_info.id for img_info in dst_image_infos]
api.annotation.upload_anns(dst_image_ids, anns_data[ds_name])
stat_dct = {
'samples': samples_count,
'src_ann_cnt': len(files_fine),
'src_img_cnt': len(files_imgs)
}
logger.info('Found img/ann pairs.', extra=stat_dct)
images_without_anns = set(files_imgs) - set(images_pathes_for_compare)
if len(images_without_anns) > 0:
logger.warn('Found source images without corresponding annotations:')
for im_path in images_without_anns:
logger.warn('Annotation not found {}'.format(im_path))
logger.info('Found classes.',
extra={
'cnt':
len(obj_classes),
'classes':
sorted([obj_class.name for obj_class in obj_classes])
})
logger.info('Created tags.',
extra={
'cnt':
len(out_meta.tag_metas),
'tags':
sorted([tag_meta.name for tag_meta in out_meta.tag_metas])
})
my_app.stop()