Query API

.idea/vcs.xml

@@ -2,5 +2,6 @@

                                
                                
                                
                            
                                
                                    
                                        
                                            2  
                                            <project version="4">
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            3  
                                              <component name="VcsDirectoryMappings">
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            4  
                                                <mapping directory="$PROJECT_DIR$" vcs="Git" />
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        5 +
                                            <mapping directory="$PROJECT_DIR$/static/efficient-ui" vcs="Git" />
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            6  
                                              </component>
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            7  
                                            </project>
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                            
                                

app.py

@@ -13,6 +13,7 @@ from sqlalchemy.orm import backref

                                
                                
                                
                            
                                
                                    
                                        
                                            13  
                                            import sqlalchemy.dialects.postgresql
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            14  
                                            from os import path
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            15  
                                            import mimetypes
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        16 +
                                        import ruamel.yaml as yaml
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            17  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            18  
                                            from PIL import Image
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            19  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -374,6 +375,8 @@ def upload_post():

                                
                                
                                
                            
                                
                                    
                                        
                                            375  
                                                db.session.add(resource)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            376  
                                                db.session.commit()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            377  
                                                file.save(path.join(config.DATA_PATH, "pictures", str(resource.id)))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        378 +
                                            pil_image = Image.open(path.join(config.DATA_PATH, "pictures", str(resource.id)))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        379 +
                                            resource.width, resource.height = pil_image.size
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            380  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            381  
                                                if flask.request.form.get("annotations"):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            382  
                                                    try:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -493,6 +496,113 @@ def get_annotations(id):

                                
                                
                                
                            
                                
                                    
                                        
                                            496  
                                                return flask.jsonify(regions_json)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            497  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            498  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        499 +
                                        @app.route("/query-pictures", methods=["POST"])      # sadly GET can't have a body
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        500 +
                                        def query_pictures():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        501 +
                                            offset = int(flask.request.args.get("offset", 0))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        502 +
                                            limit = int(flask.request.args.get("limit", 16))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        503 +
                                            ordering = flask.request.args.get("ordering", "date-desc")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        504 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        505 +
                                            yaml_parser = yaml.YAML()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        506 +
                                            query_data = yaml_parser.load(flask.request.data) or {}
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        507 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        508 +
                                            query = db.session.query(PictureResource)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        509 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        510 +
                                            requirement_conditions = {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        511 +
                                                "has_object": lambda value: PictureResource.regions.any(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        512 +
                                                    PictureRegion.object_id.in_(value)),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        513 +
                                                "nature": lambda value: PictureResource.nature_id.in_(value),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        514 +
                                                "licence": lambda value: PictureResource.licences.any(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        515 +
                                                    PictureLicence.licence_id.in_(value)),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        516 +
                                                "author": lambda value: PictureResource.author_name.in_(value),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        517 +
                                                "title": lambda value: PictureResource.title.ilike(value),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        518 +
                                                "description": lambda value: PictureResource.description.ilike(value),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        519 +
                                                "origin_url": lambda value: db.func.lower(db.func.substr(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        520 +
                                                        PictureResource.origin_url,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        521 +
                                                        db.func.length(db.func.split_part(PictureResource.origin_url, "://", 1)) + 4
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        522 +
                                                )).in_(value),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        523 +
                                                "above_width": lambda value: PictureResource.width >= value,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        524 +
                                                "below_width": lambda value: PictureResource.width <= value,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        525 +
                                                "above_height": lambda value: PictureResource.height >= value,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        526 +
                                                "below_height": lambda value: PictureResource.height <= value,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        527 +
                                                "before_date": lambda value: PictureResource.timestamp <= datetime.utcfromtimestamp(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        528 +
                                                    value),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        529 +
                                                "after_date": lambda value: PictureResource.timestamp >= datetime.utcfromtimestamp(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        530 +
                                                    value)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        531 +
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        532 +
                                            if "want" in query_data:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        533 +
                                                for i in query_data["want"]:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        534 +
                                                    requirement, value = list(i.items())[0]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        535 +
                                                    condition = requirement_conditions.get(requirement)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        536 +
                                                    if condition:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        537 +
                                                        query = query.filter(condition(value))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        538 +
                                            if "exclude" in query_data:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        539 +
                                                for i in query_data["exclude"]:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        540 +
                                                    requirement, value = list(i.items())[0]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        541 +
                                                    condition = requirement_conditions.get(requirement)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        542 +
                                                    if condition:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        543 +
                                                        query = query.filter(~condition(value))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        544 +
                                            if not query_data.get("include_obsolete", False):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        545 +
                                                query = query.filter(PictureResource.replaced_by_id.is_(None))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        546 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        547 +
                                            match ordering:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        548 +
                                                case "date-desc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        549 +
                                                    query = query.order_by(PictureResource.timestamp.desc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        550 +
                                                case "date-asc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        551 +
                                                    query = query.order_by(PictureResource.timestamp.asc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        552 +
                                                case "title-asc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        553 +
                                                    query = query.order_by(PictureResource.title.asc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        554 +
                                                case "title-desc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        555 +
                                                    query = query.order_by(PictureResource.title.desc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        556 +
                                                case "random":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        557 +
                                                    query = query.order_by(db.func.random())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        558 +
                                                case "number-regions-desc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        559 +
                                                    query = query.order_by(db.func.count(PictureResource.regions).desc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        560 +
                                                case "number-regions-asc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        561 +
                                                    query = query.order_by(db.func.count(PictureResource.regions).asc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        562 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        563 +
                                            query = query.offset(offset).limit(limit)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        564 +
                                            resources = query.all()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        565 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        566 +
                                            json_response = {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        567 +
                                                "date_generated": datetime.utcnow().timestamp(),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        568 +
                                                "resources": [],
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        569 +
                                                "offset": offset,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        570 +
                                                "limit": limit,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        571 +
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        572 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        573 +
                                            json_resources = json_response["resources"]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        574 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        575 +
                                            for resource in resources:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        576 +
                                                json_resource = {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        577 +
                                                    "id": resource.id,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        578 +
                                                    "title": resource.title,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        579 +
                                                    "description": resource.description,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        580 +
                                                    "timestamp": resource.timestamp.timestamp(),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        581 +
                                                    "origin_url": resource.origin_url,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        582 +
                                                    "author": resource.author_name,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        583 +
                                                    "file_format": resource.file_format,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        584 +
                                                    "width": resource.width,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        585 +
                                                    "height": resource.height,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        586 +
                                                    "nature": resource.nature_id,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        587 +
                                                    "licences": [licence.licence_id for licence in resource.licences],
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        588 +
                                                    "replaces": resource.replaces_id,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        589 +
                                                    "replaced_by": resource.replaced_by_id,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        590 +
                                                    "regions": [],
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        591 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        592 +
                                                for region in resource.regions:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        593 +
                                                    json_resource["regions"].append({
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        594 +
                                                        "object": region.object_id,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        595 +
                                                        "type": region.json["type"],
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        596 +
                                                        "shape": region.json["shape"],
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        597 +
                                                    })
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        598 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        599 +
                                                json_resources.append(json_resource)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        600 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        601 +
                                            response = flask.jsonify(json_response)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        602 +
                                            response.headers["Content-Type"] = "application/json"
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        603 +
                                            return response
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        604 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        605 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            606  
                                            @app.route("/raw/picture/<int:id>")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            607  
                                            def raw_picture(id):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            608  
                                                resource = db.session.get(PictureResource, id)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                            
                                

formats.md

@@ -71,7 +71,7 @@ The query format is based on YAML and used to query for pictures in the system.

                                
                                
                                
                            
                                
                                    
                                        
                                            71  
                                            ### Example
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            72  
                                            ~~~yaml
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            73  
                                            # Restrictions for queried images
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        74 -
                                        - want:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        74 +
                                        want:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            75  
                                                # This means that the image must contain both rules, so both a cat and a dog
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            76  
                                                - has_object: ["Cat (Felis catus)"]
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            77  
                                                - has_object: ["Dog (Canis lupus familiaris)"]
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -90,28 +90,16 @@ The query format is based on YAML and used to query for pictures in the system.

                                
                                
                                
                            
                                
                                    
                                        
                                            90  
                                                            "Apache-2.0", "Informal-attribution", "Informal-do-anything",
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            91  
                                                            "Public-domain-old", "Public-domain"]
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            92  
                                            # Prohibitions for queried images
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        93 -
                                        - exclude:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        93 +
                                        exclude:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            94  
                                                # This means that the image must not contain any of the objects in the list
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            95  
                                                - has_object: ["Human"]
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        96 -
                                            # This excludes images taken before the given date
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        97 -
                                            - before_date: 2019-01-01
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        96 +
                                            # This excludes images uploaded before the given date
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        97 +
                                            - before_date: 1546300800
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            98  
                                                # This requires images to have a minimum resolution
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            99  
                                                - below_width: 800
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            100  
                                                - below_height: 600
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        101 -
                                        # The object types to get - if omitted, all object types mentioned in the
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        102 -
                                        # `want` section are returned
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        103 -
                                        - object_types: ["Cat (Felis catus)", "Dog (Canis lupus familiaris)"]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        104 -
                                        # Pagination
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        105 -
                                        - limit: 32
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        106 -
                                        - offset: 0
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        107 -
                                        # Sorting
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        108 -
                                        - sort_by: "date-uploaded-recent"
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        109 -
                                        # Format
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        110 -
                                        - format: "jpg"
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        111 -
                                        - max_resolution: [800, 800]  # resizes
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        112 -
                                        # In summary, we want the 32 most recent images that contain both a cat and
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        113 -
                                        # a dog, either a grass or a flower, but not a human, taken after 2019-01-01,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        114 -
                                        # must be a photo or a drawing, must carry one of certain permissive licences
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        115 -
                                        # and have a resolution of at least 800x600 pixels. We don't need the object
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        116 -
                                        # data for the plants, only for the pets.
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        101 +
                                        # In summary, we want images that contain both a cat and a dog, either a grass
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        102 +
                                        # or a flower, but not a human, taken after 2019-01-01, must be a photo or a
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        103 +
                                        # drawing, must carry one of certain permissive licences and have a resolution
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        104 +
                                        # of at least 800x600 pixels.
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            105  
                                            ~~~
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                            
                                

templates/picture.html

@@ -18,7 +18,8 @@

                                
                                
                                
                            
                                
                                    
                                        
                                            18  
                                                        <a href="/raw/picture/{{ resource.id }}">View</a> |
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            19  
                                                        <a href="/raw/picture/{{ resource.id }}" download="GigadataPicture_{{ resource.id }}{{ file_extension }}">Download</a> |
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            20  
                                                        <a href="/picture/{{ resource.id }}/annotate">Annotate</a> |
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        21 -
                                                    <a href="/picture/{{ resource.id }}/put-annotations-form">Submit JSON annotations</a>
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        21 +
                                                    <a href="/picture/{{ resource.id }}/put-annotations-form">Submit JSON annotations</a> |
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        22 +
                                                    <a href="/picture/{{ resource.id }}/get-annotations">Download annotations</a>
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            23  
                                                    </p>
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            24  
                                                    <div id="annotation-zone">
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            25  
                                                        <img id="annotation-image" src="/raw/picture/{{ resource.id }}" alt="{{ resource.title }}">