def post(self, pe_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(roles.DESIGNER), 401
else:
data = json.loads(request.data)
re = sia.review_update(dbm, data, user.idx, pe_id)
dbm.close_session()
return re
def get(self, last_img_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(roles.ANNOTATOR), 401
else:
last_img_id = int(last_img_id)
re = sia.get_next(dbm, identity,last_img_id, DATA_URL)
dbm.close_session()
return re
def get(self, pe_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.DESIGNER), 401
else:
re = sia.reviewoptions(dbm, pe_id, user.idx)
dbm.close_session()
return re
def delete(self, label_leaf_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
label = dbm.get_label_leaf(label_leaf_id)
dbm.delete(label)
dbm.commit()
dbm.close_session()
return "success"
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
re = sia.get_configuration(dbm, identity)
print('Anno task config in endpoint', re)
dbm.close_session()
return re
def get(self, template_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.DESIGNER), 401
else:
re = template_service.get_template(dbm, template_id, user)
dbm.close_session()
return re
def post(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
data = json.loads(request.data)
re = mia.get_special(dbm, identity, data['miaIds'])
dbm.close_session()
return re
def post(self, img_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
re = sia.get_prev(dbm, identity, img_id)
dbm.close_session()
return re
def get(self, pipeline_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.DESIGNER), 401
else:
re = pipeline_service.get_running_pipe(dbm, identity, pipeline_id,
DATA_URL)
dbm.close_session()
return re
def post(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
data = json.loads(request.data)
img = dbm.get_image_anno(data['imageId'])
flask.current_app.logger.info('img.img_path: {}'.format(
img.img_path))
flask.current_app.logger.info('img.fs.name: {}'.format(
img.fs.name))
# fs_db = dbm.get_fs(img.fs_id)
fs = FileMan(fs_db=img.fs)
#img = PIL.Image.open('/home/lost/data/media/10_voc2012/2007_008547.jpg')
# img = PIL.Image.open(img_path)
if data['clahe']['active']:
img = fs.load_img(img.img_path, color_type='gray')
else:
img = fs.load_img(img.img_path, color_type='color')
flask.current_app.logger.info(
'Triggered filter. Received data: {}'.format(data))
# img_io = BytesIO()
# img.save(img_io, 'PNG')
# img_io.seek(0)
# return send_file(img_io, mimetype='image/png')
if data['rotate']['active']:
if data['rotate']['angle'] == 90:
img = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)
elif data['rotate']['angle'] == -90:
img = cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE)
elif data['rotate']['angle'] == 180:
img = cv2.rotate(img, cv2.ROTATE_180)
if data['clahe']['active']:
clahe = cv2.createCLAHE(data['clahe']['clipLimit'])
img = clahe.apply(img)
# img = img.rotate(data['rotate']['angle'], expand=True)
# img = ImageOps.autocontrast(img)
# data = BytesIO()
# img.save(data, "PNG")
_, data = cv2.imencode('.jpg', img)
data64 = base64.b64encode(data.tobytes())
dbm.close_session()
return u'data:img/jpg;base64,' + data64.decode('utf-8')
def post(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ADMINISTRATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
data = json.loads(request.data)
project_config = ProjectConfigMan(dbm)
for element in data:
project_config.update_entry(element['key'],
value=element['value'])
return "success"
def get(self, id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
requesteduser = dbm.get_user_by_id(id)
dbm.close_session()
if requesteduser:
return requesteduser
else:
return "User with ID '{}' not found.".format(id)
def patch(self, id):
args = update_user_parser.parse_args()
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
requesteduser = dbm.get_user_by_id(id)
if requesteduser:
requesteduser.email = args.get('email')
requesteduser.first_name = args.get('first_name')
requesteduser.last_name = args.get('last_name')
if roles.DESIGNER not in args.get('roles'):
for user_role in dbm.get_user_roles_by_user_id(id):
if user_role.role.name == roles.DESIGNER and requesteduser.user_name != 'admin':
dbm.delete(user_role)
dbm.commit()
if args.get('roles'):
for role_name in args.get('roles'):
if role_name == 'Designer':
designer_role = dbm.get_role_by_name(roles.DESIGNER)
requesteduser.roles.append(designer_role)
for user_group in dbm.get_user_groups_by_user_id(id):
if user_group.group.is_user_default:
continue
dbm.delete(user_group)
dbm.commit()
if args.get('groups'):
for group_name in args.get('groups'):
group = dbm.get_group_by_name(group_name)
if group:
requesteduser.groups.append(group)
if args.get('password'):
print(args.get('password'))
requesteduser.set_password(args.get('password'))
dbm.save_obj(requesteduser)
dbm.close_session()
return 'success', 200
else:
dbm.close_session()
return "User with ID '{}' not found.".format(id), 400
def post(self):
args = annotask_parser.parse_args(request)
logger.critical('------------ annotask post ----------------')
logger.critical(args)
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
annotask_service.choose_annotask(dbm, args.get('id'), user.idx)
dbm.close_session()
return "success"
def post(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
# get data from parser
data = create_user_parser.parse_args()
# find user in database
user = None
if 'email' in data:
user = dbm.find_user_by_email(data['email'])
if not user and 'user_name' in data:
user = dbm.find_user_by_user_name(data['user_name'])
if user:
return {'message': 'User already exists.'}, 401
else:
user = DBUser(
user_name = data['user_name'],
email = data['email'],
email_confirmed_at=datetime.datetime.utcnow(),
password= data['password'],
)
anno_role = dbm.get_role_by_name(roles.ANNOTATOR)
user.roles.append(anno_role)
user.groups.append(Group(name=user.user_name, is_user_default=True))
if data['roles']:
for role_name in data['roles']:
if role_name == 'Designer':
designer_role = dbm.get_role_by_name(roles.DESIGNER)
user.roles.append(designer_role)
if data['groups']:
for group_name in data['groups']:
group = dbm.get_group_by_name(group_name)
if group:
user.groups.append(group)
dbm.save_obj(user)
try:
email.send_new_user(user,data['password'])
except:
pass
dbm.close_session()
return {
'message': 'success'
}, 200
def main():
lostconfig = config.LOSTConfig()
# project_root = join(lostconfig.project_path, "data")
# if not os.path.exists(project_root):
# os.makedirs(project_root)
fman = file_man.FileMan(lostconfig)
fman.create_project_folders()
# Create Tables
dbm = access.DBMan(lostconfig)
dbm.create_database()
create_first_user(dbm)
create_lost_filesystem_entry(dbm, lostconfig)
create_project_config(dbm)
dbm.close_session()
def post(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
#TODO: Check if user is permitted to load this image
data = json.loads(request.data)
#flask.current_app.logger.info('mia -> getimage. Received data: {}'.format(data))
if data['type'] == 'imageBased':
db_img = dbm.get_image_anno(data['id'])
fm = FileMan(fs_db=db_img.fs)
img = load_img(db_img, fm, user)
elif data['type'] == 'annoBased':
db_anno = dbm.get_two_d_anno(two_d_anno_id=data['id'])
db_img = dbm.get_image_anno(db_anno.img_anno_id)
fm = FileMan(fs_db=db_img.fs)
# image = fm.load_img(db_img.img_path)
image = load_img(db_img, fm, user)
# get annotation_task config
config = mia.get_config(dbm, user.idx)
draw_anno = False
context = None
try:
draw_anno = config['drawAnno']
except:
pass
try:
context = float(config['addContext'])
except:
pass
crops, _ = anno_helper.crop_boxes(
[db_anno.to_vec('anno.data')],
[db_anno.to_vec('anno.dtype')],
image,
context=context,
draw_annotations=draw_anno)
img = crops[0]
else:
raise Exception('Unknown mia image type')
_, data = cv2.imencode('.jpg', img)
data64 = base64.b64encode(data.tobytes())
dbm.close_session()
return u'data:img/jpg;base64,' + data64.decode('utf-8')
def post(self):
args = group_parser.parse_args(request)
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
group_name = args.get('group_name')
if not group_name:
return "A group name is required.", 400
if dbm.get_group_by_name(group_name):
return "Group with name '{}' already exists.".format(
group_name), 409
group = model.Group(name=group_name, manager_id=identity)
dbm.save_obj(group)
dbm.commit()
dbm.close_session()
return "success"
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
root_leaves = dbm.get_all_label_trees()
trees = list()
for root_leaf in root_leaves:
trees.append(
LabelTree(dbm, root_leaf.idx).to_hierarchical_dict())
dbm.close_session()
return trees
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
working_task = annotask_service.get_current_annotask(dbm, user)
dbm.close_session()
import json
#with open('/code/backend/lost/api/annotask/test/workingOnAnnoTask.json') as f:
# data = json.load(f)
#return data
return working_task
def get(self, last_img_id):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
re = sia.get_previous(dbm, identity, last_img_id, DATA_URL)
dbm.close_session()
logger.critical('++++++++++++++++++ SIA prev ++++++++++++++++++')
logger.critical(re)
return re
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
users = dbm.get_users()
for us in users:
for g in us.groups:
if g.is_user_default:
us.groups.remove(g)
dbm.close_session()
ulist = {'users':users}
return ulist
def get(self, path):
print(path)
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
# raise Exception('data/logs/ -> Not Implemented!')
fm = FileMan(LOST_CONFIG)
with fm.fs.open(fm.get_abs_path(path), 'rb') as f:
resp = make_response(f.read())
resp.headers[
"Content-Disposition"] = "attachment; filename=log.csv"
resp.headers["Content-Type"] = "text/csv"
return resp
def patch(self):
args = update_user_parser.parse_args()
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if user:
user.email = args.get('email')
user.first_name = args.get('first_name')
user.last_name = args.get('last_name')
if args.get('password'):
user.set_password(args.get('password'))
dbm.save_obj(user)
dbm.close_session()
return 'success', 200
else:
dbm.close_session()
return "No user found.", 405
def patch(self):
args = update_label_parser.parse_args()
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
label = dbm.get_label_leaf(int(args.get('id')))
label.name = args.get('name')
label.description = args.get('description')
label.abbreviation = args.get('abbreviation')
label.external_id = args.get('external_id')
dbm.save_obj(label)
dbm.close_session()
return 'success'
def post(self):
args = create_label_parser.parse_args()
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
label = model.LabelLeaf(name=args.get('name'),abbreviation=args.get('abbreviation'), \
description=args.get('description'),external_id=args.get('external_id'),
is_root=args.get('is_root'))
if args.get('parent_leaf_id'):
label.parent_leaf_id = args.get('parent_leaf_id'),
dbm.save_obj(label)
dbm.close_session()
return "success"
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
group_ids = [g.idx for g in user.groups]
annotask_list = annotask_service.get_available_annotasks(
dbm, group_ids, identity)
dbm.close_session()
import json
#with open('/code/backend/lost/api/annotask/test/annoTasks.json') as f:
# data = json.load(f)
#return data
return annotask_list
def get(self, visibility):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
default_group = dbm.get_group_by_name(user.user_name)
if visibility == VisLevel().USER:
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
root_leaves = dbm.get_all_label_trees(
group_id=default_group.idx)
trees = list()
for root_leaf in root_leaves:
trees.append(
LabelTree(dbm, root_leaf.idx).to_hierarchical_dict())
dbm.close_session()
return trees
if visibility == VisLevel().GLOBAL:
if not user.has_role(roles.ADMINISTRATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
root_leaves = dbm.get_all_label_trees(global_only=True)
trees = list()
for root_leaf in root_leaves:
trees.append(
LabelTree(dbm, root_leaf.idx).to_hierarchical_dict())
dbm.close_session()
return trees
if visibility == VisLevel().ALL:
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
root_leaves = dbm.get_all_label_trees(
group_id=default_group.idx, add_global=True)
trees = list()
for root_leaf in root_leaves:
trees.append(
LabelTree(dbm, root_leaf.idx).to_hierarchical_dict())
dbm.close_session()
return trees
dbm.close_session()
return "You are not authorized.", 401
def post(self):
# get data from parser
data = login_parser.parse_args()
dbm = access.DBMan(LOST_CONFIG)
# find user in database
if 'user_name' in data:
user = dbm.find_user_by_user_name(data['user_name'])
# check password
if user and user.check_password(data['password']):
dbm.close_session()
expires = datetime.timedelta(days=3650)
access_token = create_access_token(identity=user.idx, fresh=True, expires_delta=expires)
return {
'token': access_token
}, 200
dbm.close_session()
return {'message': 'Invalid credentials'}, 401
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.DESIGNER), 401
else:
# for group in user.groups:
# print("--- printing group of user.groups ---")
# print(group)
group_ids = [g.idx for g in user.groups]
re = pipeline_service.get_pipelines(dbm, group_ids)
dbm.close_session()
# print("--- PipelineList result ---")
# print(re)
return re
