def post(self, dataset_id):
""" Updates dataset by ID """
dataset = current_user.find_exist_dataset_by_id(dataset_id)
if dataset is None:
return {"message": "Invalid dataset id"}, 400
args = Parser.update_dataset_parser().parse_args()
categories = args.get('categories')
default_annotation_metadata = args.get('default_annotation_metadata')
set_default_annotation_metadata = args.get(
'set_default_annotation_metadata')
if categories is not None:
from usecase.changeDatasetCategoriesUseCase import ChangeDatasetCategoriesUseCase
ChangeDatasetCategoriesUseCase().execute(dataset_id, categories)
if default_annotation_metadata is not None:
update = {}
for key, value in default_annotation_metadata.items():
if key not in dataset.default_annotation_metadata:
update[f'set__metadata__{key}'] = value
dataset.default_annotation_metadata = default_annotation_metadata
if len(update.keys()) > 0:
AnnotationModel.objects(dataset_id=dataset.id, deleted=False)\
.update(**update)
dataset.update(
#categories=dataset.categories,
default_annotation_metadata=dataset.default_annotation_metadata)
return {"success": True}
def get(self, dataset_id):
""" All users in the dataset """
args = dataset_generate.parse_args()
dataset = current_user.find_exist_dataset_by_id(dataset_id)
if dataset is None:
return {"message": "Invalid dataset id"}, 400
images = ImageModel.objects(dataset_id=dataset.id, deleted=False)
annotated_images = images.filter(annotated=True)
annotations = AnnotationModel.objects(dataset_id=dataset_id,
deleted=False)
# Calculate annotation counts by category in this dataset
category_count = dict()
image_category_count = dict()
for category in dataset.categories:
# Calculate the annotation count in the current category in this dataset
cat_name = CategoryModel.objects(id=category).first()['name']
cat_count = AnnotationModel.objects(dataset_id=dataset_id,
category_id=category,
deleted=False).count()
category_count.update({str(cat_name): cat_count})
# Calculate the annotated images count in the current category in this dataset
image_count = len(
AnnotationModel.objects(dataset_id=dataset_id,
category_id=category,
deleted=False).distinct('image_id'))
image_category_count.update({str(cat_name): image_count})
stats = {
'total': {
'Users': dataset.get_users().count(),
'Images': images.count(),
'Annotated Images': annotated_images.count(),
'Annotations': annotations.count(),
'Categories': len(dataset.categories),
'Time Annotating (s)': (images.sum('milliseconds') or 0) / 1000
},
'average': {
'Image Size (px)':
images.average('width'),
'Image Height (px)':
images.average('height'),
'Annotation Area (px)':
annotations.average('area'),
'Time (ms) per Image':
images.average('milliseconds') or 0,
'Time (ms) per Annotation':
annotations.average('milliseconds') or 0
},
'categories': category_count,
'images_per_category': image_category_count
}
return stats
def get(self, dataset_id):
""" All users in the dataset """
args = dataset_generate.parse_args()
dataset = current_user.find_exist_dataset_by_id(dataset_id)
if dataset is None:
return {"message": "Invalid dataset id"}, 400
users = dataset.get_users()
return query_util.fix_ids(users)
def get(self, dataset_id):
""" All users in the dataset """
args = dataset_generate.parse_args()
dataset = current_user.find_exist_dataset_by_id(dataset_id)
if dataset is None:
return {"message": "Invalid dataset id"}, 400
AnnotationModel.objects(dataset_id=dataset.id)\
.update(metadata=dataset.default_annotation_metadata)
ImageModel.objects(dataset_id=dataset.id)\
.update(metadata={})
return {'success': True}
def post(self, dataset_id):
args = share.parse_args()
dataset = current_user.find_exist_dataset_by_id(dataset_id)
if dataset is None:
return {"message": "Invalid dataset id"}, 400
if not dataset.is_owner(current_user):
return {
"message": "You do not have permission to share this dataset"
}, 403
dataset.update(users=args.get('users'))
return {"success": True}
def post(self, dataset_id):
""" Adds images found on google to the dataset """
args = dataset_generate.parse_args()
dataset = current_user.find_exist_dataset_by_id(dataset_id)
if dataset is None:
return {"message": "Invalid dataset id"}, 400
if not dataset.is_owner(current_user):
return {
"message":
"You do not have permission to download the dataset's annotations"
}, 403
thread = Thread(target=download_images, args=(dataset.directory, args))
thread.start()
return {"success": True}
def get(self, dataset_id):
""" Endpoint called by image viewer client """
parsed_args = page_data.parse_args()
per_page = parsed_args.get('limit')
page = parsed_args.get('page') - 1
folder = parsed_args.get('folder')
order = parsed_args.get('order')
args = dict(request.args)
# Check if dataset exists
dataset = current_user.find_exist_dataset_by_id(dataset_id)
if dataset is None:
return {'message', 'Invalid dataset id'}, 400
# Make sure folder starts with is in proper format
if len(folder) > 0:
folder = folder[0].strip('/') + folder[1:]
if folder[-1] != '/':
folder = folder + '/'
# Get directory
directory = os.path.join(dataset.directory, folder)
if not os.path.exists(directory):
return {'message': 'Directory does not exist.'}, 400
# Remove parsed arguments
for key in parsed_args:
args.pop(key, None)
# Generate query from remaining arugments
query = {}
for key, value in args.items():
lower = value.lower()
if lower in ["true", "false"]:
value = json.loads(lower)
if len(lower) != 0:
query[key] = value
# Change category_ids__in to list
if 'category_ids__in' in query.keys():
query['category_ids__in'] = [
int(x) for x in query['category_ids__in'].split(',')
]
# Initialize mongo query with required elements:
query_build = Q(dataset_id=dataset_id)
query_build &= Q(path__startswith=directory)
query_build &= Q(deleted=False)
# Define query names that should use complex logic:
complex_query = ['annotated', 'category_ids__in']
# Add additional 'and' arguments to mongo query that do not require complex_query logic
for key in query.keys():
if key not in complex_query:
query_dict = {}
query_dict[key] = query[key]
query_build &= Q(**query_dict)
# Add additional arguments to mongo query that require more complex logic to construct
if 'annotated' in query.keys():
if 'category_ids__in' in query.keys() and query['annotated']:
# Only show annotated images with selected category_ids
query_dict = {}
query_dict['category_ids__in'] = query['category_ids__in']
query_build &= Q(**query_dict)
else:
# Only show non-annotated images
query_dict = {}
query_dict['annotated'] = query['annotated']
query_build &= Q(**query_dict)
elif 'category_ids__in' in query.keys():
# Ahow annotated images with selected category_ids or non-annotated images
query_dict_1 = {}
query_dict_1['category_ids__in'] = query['category_ids__in']
query_dict_2 = {}
query_dict_2['annotated'] = False
query_build &= (Q(**query_dict_1) | Q(**query_dict_2))
images = current_user.find_images_by_query(query_build, order)
total = images.count()
pages = int(total / per_page) + 1
images = images.skip(page * per_page).limit(per_page)
images_json = query_util.fix_ids(images)
# for image in images:
# image_json = query_util.fix_ids(image)
# query = AnnotationModel.objects(image_id=image.id, deleted=False)
# category_ids = query.distinct('category_id')
# categories = CategoryModel.objects(id__in=category_ids).only('name', 'color')
# image_json['annotations'] = query.count()
# image_json['categories'] = query_util.fix_ids(categories)
# images_json.append(image_json)
subdirectories = [
f for f in sorted(os.listdir(directory))
if os.path.isdir(directory + f) and not f.startswith('.')
]
categories = CategoryModel.objects(id__in=dataset.categories).only(
'id', 'name')
return {
"total": total,
"per_page": per_page,
"pages": pages,
"page": page,
"images": images_json,
"folder": folder,
"directory": directory,
"dataset": query_util.fix_ids(dataset),
"categories": query_util.fix_ids(categories),
"subdirectories": subdirectories
}