def _copy_dir_recursively(cls, src_path, dst_path):
files = sly.list_dir(src_path)
for file_subpath in files:
src_fpath = osp.join(src_path, file_subpath)
storage_fpath = osp.join(dst_path, file_subpath)
sly.ensure_base_path(storage_fpath)
cls._copy_file_concurr(src_fpath, storage_fpath)
def run_inference(self):
out_project_fs = copy(self.in_project_fs)
out_project_fs.root_path = self.helper.paths.results_dir
out_project_fs.make_dirs()
inf_feeder = sly.InferenceFeederFactory.create(self.config, self.helper.in_project_meta, self.train_classes)
out_pr_meta = inf_feeder.out_meta
out_pr_meta.to_dir(out_project_fs.project_path)
ia_cnt = out_project_fs.pr_structure.image_cnt
progress = sly.progress_counter_inference(cnt_imgs=ia_cnt)
for sample in self.in_project_fs:
logger.info('Will process image',
extra={'dataset_name': sample.ds_name, 'image_name': sample.image_name})
ann_packed = sly.json_load(sample.ann_path)
ann = sly.Annotation.from_packed(ann_packed, self.helper.in_project_meta)
img = cv2.imread(sample.img_path)[:, :, ::-1]
res_ann = inf_feeder.feed(img, ann, self._infer_on_img)
out_ann_fpath = out_project_fs.ann_path(sample.ds_name, sample.image_name)
res_ann_packed = res_ann.pack()
sly.json_dump(res_ann_packed, out_ann_fpath)
if self.debug_copy_images:
out_img_fpath = out_project_fs.img_path(sample.ds_name, sample.image_name)
sly.ensure_base_path(out_img_fpath)
shutil.copy(sample.img_path, out_img_fpath)
progress.iter_done_report()
sly.report_inference_finished()
def _download_images_from_remote(self, pr_writer, image_id_to_ds, img_infos):
if len(img_infos) == 0:
return
infos_with_paths = [(info, pr_writer.get_img_path(image_id_to_ds[info.id], info.title, info.ext))
for info in img_infos]
hash2path = {x[0].hash: x[1] for x in infos_with_paths} # for unique hashes
unique_hashes = list(hash2path.keys())
ready_paths = []
ready_hashes = []
progress = sly.ProgressCounter('Download remote images', len(unique_hashes), ext_logger=self.logger)
def close_fh(fh):
fpath = fh.file_path
if fh.close_and_check():
ready_paths.append(fpath)
ready_hashes.append(img_hash)
progress.iter_done_report()
else:
self.logger.warning('file was skipped while downloading',
extra={'img_path': fpath, 'img_hash': img_hash})
# download by unique hashes
for batch_img_hashes in sly.batched(unique_hashes, constants.BATCH_SIZE_DOWNLOAD_IMAGES):
file_handler = None
img_hash = None
for chunk in self.api.get_stream_with_data('DownloadImages',
api_proto.ChunkImage,
api_proto.ImagesHashes(images_hashes=batch_img_hashes)):
if chunk.image.hash: # non-empty hash means beginning of new image
if file_handler is not None:
close_fh(file_handler)
img_hash = chunk.image.hash
self.logger.trace('download_images', extra={'img_hash': img_hash})
dst_fpath = hash2path[img_hash]
file_handler = ChunkedFileWriter(file_path=dst_fpath)
file_handler.write(chunk.chunk)
close_fh(file_handler) # must be not None
# process non-unique hashes
for info, dst_path in infos_with_paths:
origin_path = hash2path[info.hash]
if (origin_path != dst_path) and osp.isfile(origin_path):
sly.ensure_base_path(dst_path)
sly.copy_file(origin_path, dst_path)
self._write_images_to_agent_storage(ready_paths, ready_hashes)
def process(self, data_el):
img_desc, ann = data_el
free_name = self.net.get_free_name(img_desc.get_img_name())
new_dataset_name = img_desc.get_res_ds_name()
for out_dir, flag_name, mapping_name in self.odir_flag_mapping:
if not self.settings[flag_name]:
continue
cls_mapping = self.settings[mapping_name]
# hack to draw 'black' regions
if flag_name == 'masks_human':
cls_mapping = {
k: (1, 1, 1) if max(v) == 0 else v
for k, v in cls_mapping.items()
}
img = self.draw_colored_mask(ann, cls_mapping)
if flag_name == 'masks_human':
orig_img = img_desc.read_image()
comb_img = sly.overlay_images(orig_img, img, 0.5)
sep = np.array([[[0, 255, 0]]] * orig_img.shape[0],
dtype=np.uint8)
img = np.hstack((orig_img, sep, comb_img))
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
output_img_path = osp.join(self.output_folder, new_dataset_name,
out_dir, free_name + '.png')
sly.ensure_base_path(output_img_path)
cv2.imwrite(output_img_path, img)
# net _always_ downloads images
if self.settings['images'] is True:
if img_desc.need_write() is True:
self.pr_writer.write_image(img_desc, free_name)
else:
self.pr_writer.copy_image(img_desc, free_name)
if self.settings['annotations'] is True:
ann_to_save = deepcopy(ann)
ann_to_save.normalize_figures()
packed_ann = ann_to_save.pack()
self.pr_writer.write_ann(img_desc, packed_ann, free_name)
yield ([img_desc, ann], )
def process(self, data_el):
img_desc, ann = data_el
free_name = self.net.get_free_name(img_desc.get_img_name())
new_dataset_name = img_desc.get_res_ds_name()
if self.settings.get('visualize'):
out_meta = self.net.get_result_project_meta()
cls_mapping = {}
for cls_descr in out_meta.classes:
color_s = cls_descr.get('color')
if color_s is not None:
color = sly.hex2rgb(color_s)
else:
color = sly.get_random_color()
cls_mapping[cls_descr['title']] = color
# hack to draw 'black' regions
cls_mapping = {k: (1, 1, 1) if max(v) == 0 else v for k, v in cls_mapping.items()}
vis_img = self.draw_colored_mask(ann, cls_mapping)
orig_img = img_desc.read_image()
comb_img = sly.overlay_images(orig_img, vis_img, 0.5)
sep = np.array([[[0, 255, 0]]] * orig_img.shape[0], dtype=np.uint8)
img = np.hstack((orig_img, sep, comb_img))
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
output_img_path = osp.join(self.output_folder, new_dataset_name, 'visualize', free_name + '.png')
sly.ensure_base_path(output_img_path)
cv2.imwrite(output_img_path, img)
# net _always_ downloads images
if self.settings['images'] is True:
if img_desc.need_write() is True:
self.pr_writer.write_image(img_desc, free_name)
else:
self.pr_writer.copy_image(img_desc, free_name)
if self.settings['annotations'] is True:
ann_to_save = deepcopy(ann)
ann_to_save.normalize_figures()
packed_ann = ann_to_save.pack()
self.pr_writer.write_ann(img_desc, packed_ann, free_name)
yield ([img_desc, ann],)
def main():
# Please note that auxiliary methods from sly (supervisely_lib) use supervisely_lib.logger to format output.
# So don't replace formatters or handlers of the logger.
# One may use other loggers or simple prints for other output, but it's recommended to use supervisely_lib.logger.
logger.info('Hello ML world')
print('Glad to see u')
# TaskHelperTrain contains almost all needed to run inference as Supervisely task,
# including task settings and paths to data and model.
task_helper = sly.TaskHelperInference()
# All settings and parameters are passed to task in json file.
# Content of the file is entirely dependent on model implementation.
inference_settings = task_helper.task_settings
logger.info('Task settings are read',
extra={'task_settings': inference_settings})
# Let's imitate loading training model weights. Task acquires directory with the weights.
# And content of the directory is entirely dependent on model implementation.
model_dir = task_helper.paths.model_dir
model = load_fake_model(model_dir)
logger.info('Model weights are loaded', extra={'model_dir': model_dir})
# We are going to read input project with data for inference.
project_meta = task_helper.in_project_meta # Project meta contains list of project classes.
project_dir = task_helper.paths.project_dir
project_fs = sly.ProjectFS.from_disk_dir_project(project_dir)
# ProjectFS enlists all samples (image/annotation pairs) in input project.
# We are to write inference results as sly project with same structure into provided results dir.
# There is no need to save images, only annotations and project meta are required.
results_dir = task_helper.paths.results_dir
out_project_fs = sly.ProjectFS(results_dir, project_fs.pr_structure)
# It's necessary to write project meta (with list of classes) for output project.
out_meta = sly.ProjectMeta([{
'title': 'hat',
'shape': 'point',
'color': '#FF0000'
}]) # create meta
out_meta.to_dir(out_project_fs.project_path) # and save
# We are to report progress of task over sly.ProgressCounter if we want to observe the progress in web panel.
# In fact one task may report progress for some sequential (not nested) subtasks,
# but here we will report inference progress only.
ia_cnt = out_project_fs.pr_structure.image_cnt
progress = sly.progress_counter_inference(cnt_imgs=ia_cnt)
# Iterating over samples (image/annotation pairs) in input project.
for item_descr in project_fs:
logger.info('Processing input sample',
extra={
'dataset': item_descr.ds_name,
'image_name': item_descr.image_name
})
# Open some image...
img = cv2.imread(item_descr.img_path)
logger.info('Read image from input project',
extra={
'width': img.shape[1],
'height': img.shape[0]
})
# And read corresponding annotation...
ann_packed = sly.json_load(item_descr.ann_path)
ann = sly.Annotation.from_packed(ann_packed, project_meta)
logger.info('Read annotation from input project',
extra={'tags': ann['tags']})
logger.info('Some forward pass...')
time.sleep(1)
# Let's imitate inference output.
# We are to save results as sly Figures in annotation.
ann['objects'] = [sly.FigurePoint.from_pt('hat', (800, 800))
] # imagine that our model found the point
out_ann_path = out_project_fs.ann_path(item_descr.ds_name,
item_descr.image_name)
sly.ensure_base_path(out_ann_path) # create intermediate directories
sly.json_dump(ann.pack(), out_ann_path) # and save annotation
# Note that there is no need to save image.
progress.iter_done_report(
) # call it after every iteration to report progress
# It's necessary to report that the inference task is finished.
sly.report_inference_finished()
# Thank you for your patience.
logger.info('Applying finished.')
def main():
logger.info('Hello world.')
# It isn't necessary, but let's suppose that our data will be stored as for Supervisely task:
# input in '/sly_task_data/data` and results in '/sly_task_data/results'.
# So TaskPaths provides the paths.
task_paths = sly.TaskPaths()
project_dir = task_paths.project_dir # the paths includes project name
project_meta = sly.ProjectMeta.from_dir(project_dir)
# Now we've read meta of input project.
logger.info('Input project meta: {} class(es).'.format(len(project_meta.classes)))
project_fs = sly.ProjectFS.from_disk(*sly.ProjectFS.split_dir_project(project_dir))
# Now we've read project structure.
logger.info('Input project: "{}" contains {} dataset(s) and {} image(s).'.format(
project_fs.pr_structure.name,
len(project_fs.pr_structure.datasets),
project_fs.image_cnt
))
# prepare color mapping
color_mapping = {}
for cls_descr in project_meta.classes:
color_s = cls_descr.get('color')
if color_s is not None:
color = sly.hex2rgb(color_s) # use color from project meta if exists
else:
color = sly.get_random_color() # or use random color otherwise
color_mapping[cls_descr['title']] = color
# enumerate all input samples (image/annotation pairs)
for item_descr in project_fs:
logger.info('Processing input sample',
extra={'dataset': item_descr.ds_name, 'image_name': item_descr.image_name})
# Open image
img = cv2.imread(item_descr.img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # to work with r-g-b colors
# And read corresponding annotation.
ann_packed = sly.json_load(item_descr.ann_path)
ann = sly.Annotation.from_packed(ann_packed, project_meta)
# Draw annotations on image
for fig in ann['objects']:
color = color_mapping.get(fig.class_title)
fig.draw(img, color)
# Note that this method draws lines with width 1, and points as single pixels.
# Save image. Please note that we just save images, not new Supervisely project.
src_image_ext = item_descr.ia_data['image_ext'] # let's preserve source image format (by extension)
out_fpath = osp.join(
task_paths.results_dir, item_descr.project_name, item_descr.ds_name, item_descr.image_name + src_image_ext
)
sly.ensure_base_path(out_fpath) # create intermediate dirs if required
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # to work with r-g-b colors
cv2.imwrite(out_fpath, img) # write image
logger.info('Done.')
def _read_obj_impl(self, st_path, dst_path):
sly.ensure_base_path(dst_path)
sly.copy_file(st_path, dst_path)
def _write_obj_impl(self, src_path, st_path):
sly.ensure_base_path(st_path)
self._copy_file_concurr(src_path, st_path)
