added new models, migrations

cvat-ai · nmanovic · Mar 28, 2020 · Oct 18, 2019 · Oct 18, 2019 · Oct 21, 2019
commit e81053806a1c9f84e562fdd8a77a450d6aa18121
@@ -31,18 +31,25 @@ RUN apt-get update && \
     DEBIAN_FRONTEND=noninteractive apt-get install -yq \
         apache2 \
         apache2-dev \
-        libapache2-mod-xsendfile \
-        supervisor \
         ffmpeg \
         gstreamer0.10-ffmpeg \
+        libapache2-mod-xsendfile \
+        libavcodec-dev \
+        libavdevice-dev \
+        libavfilter-dev \
+        libavformat-dev \
+        libavutil-dev \
         libldap2-dev \
         libsasl2-dev \
+        libswresample-dev \
+        libswscale-dev \
+        p7zip-full \
         python3-dev \
         python3-pip \
+        supervisor \
         tzdata \
-        unzip \
         unrar \
-        p7zip-full \
+        unzip \
         vim && \
     pip3 install -U setuptools && \
     ln -fs /usr/share/zoneinfo/${TZ} /etc/localtime && \

@@ -223,7 +223,7 @@
                 }
             }
 
-            async function createTask(taskData, files, onUpdate) {
+            async function createTask(taskSpec, taskDataSpec, onUpdate) {
                 const { backendAPI } = config;
 
                 async function wait(id) {
@@ -263,11 +263,15 @@
                     });
                 }
 
-                const batchOfFiles = new FormData();
-                for (const key in files) {
-                    if (Object.prototype.hasOwnProperty.call(files, key)) {
-                        for (let i = 0; i < files[key].length; i++) {
-                            batchOfFiles.append(`${key}[${i}]`, files[key][i]);
+                const taskData = new FormData();
+                for (const key in taskDataSpec) {
+                    if (Object.prototype.hasOwnProperty.call(taskDataSpec, key)) {
+                        if (Array.isArray(taskDataSpec[key])) {
+                            for (let i = 0; i < taskDataSpec[key].length; i++) {
+                                taskData.append(`${key}[${i}]`, taskDataSpec[key][i]);
+                            }
+                        } else {
+                            taskData.set(key, taskDataSpec[key]);
                         }
                     }
                 }
@@ -276,7 +280,7 @@
 
                 onUpdate('The task is being created on the server..');
                 try {
-                    response = await Axios.post(`${backendAPI}/tasks`, JSON.stringify(taskData), {
+                    response = await Axios.post(`${backendAPI}/tasks`, JSON.stringify(taskSpec), {
                         proxy: config.proxy,
                         headers: {
                             'Content-Type': 'application/json',
@@ -288,7 +292,7 @@
 
                 onUpdate('The data is being uploaded to the server..');
                 try {
-                    await Axios.post(`${backendAPI}/tasks/${response.data.id}/data`, batchOfFiles, {
+                    await Axios.post(`${backendAPI}/tasks/${response.data.id}/data`, taskData, {
                         proxy: config.proxy,
                     });
                 } catch (errorData) {

@@ -710,7 +710,7 @@
                 start_frame: undefined,
                 stop_frame: undefined,
                 frame_filter: undefined,
-                data_chunk_size: undefined,                
+                data_chunk_size: undefined,
             };
 
             for (const property in data) {
@@ -1360,39 +1360,40 @@
             return this;
         }
 
-        const taskData = {
+        const taskSpec = {
             name: this.name,
             labels: this.labels.map((el) => el.toJSON()),
-            image_quality: this.imageQuality,
             z_order: Boolean(this.zOrder),
         };
 
         if (typeof (this.bugTracker) !== 'undefined') {
-            taskData.bug_tracker = this.bugTracker;
+            taskSpec.bug_tracker = this.bugTracker;
         }
         if (typeof (this.segmentSize) !== 'undefined') {
-            taskData.segment_size = this.segmentSize;
+            taskSpec.segment_size = this.segmentSize;
         }
         if (typeof (this.overlap) !== 'undefined') {
-            taskData.overlap = this.overlap;
+            taskSpec.overlap = this.overlap;
         }
+
+        const taskDataSpec = {
+            client_files: this.clientFiles,
+            server_files: this.serverFiles,
+            remote_files: this.remoteFiles,
+            image_quality: this.imageQuality,
+        };
+
         if (typeof (this.startFrame) !== 'undefined') {
-            taskData.start_frame = this.startFrame;
+            taskDataSpec.start_frame = this.startFrame;
         }
         if (typeof (this.stopFrame) !== 'undefined') {
-            taskData.stop_frame = this.stopFrame;
+            taskDataSpec.stop_frame = this.stopFrame;
         }
         if (typeof (this.frameFilter) !== 'undefined') {
-            taskData.frame_filter = this.frameFilter;
+            taskDataSpec.frame_filter = this.frameFilter;
         }
 
-        const taskFiles = {
-            client_files: this.clientFiles,
-            server_files: this.serverFiles,
-            remote_files: this.remoteFiles,
-        };
-
-        const task = await serverProxy.tasks.createTask(taskData, taskFiles, onUpdate);
+        const task = await serverProxy.tasks.createTask(taskSpec, taskDataSpec, onUpdate);
         return new Task(task);
     };
 

@@ -3,12 +3,10 @@
 # SPDX-License-Identifier: MIT
 
 from cvat.apps.annotation import models
-from django.conf import settings
 from django.core.exceptions import ObjectDoesNotExist
 from cvat.apps.annotation.serializers import AnnotationFormatSerializer
 from django.core.files import File
 
-import os
 from copy import deepcopy
 
 def register_format(format_file):

@@ -6,18 +6,15 @@
 import cv2
 
 class ImageLoader():
-    def __init__(self, image_list):
-        self.image_list = image_list
-
-    def __getitem__(self, i):
-        return self.image_list[i]
+    def __init__(self, frame_provider):
+        self._frame_provider = frame_provider
 
     def __iter__(self):
-        for imagename in self.image_list:
+        for imagename in self._frame_provider:
             yield self._load_image(imagename)
 
     def __len__(self):
-        return len(self.image_list)
+        return len(self._frame_provider)
 
     @staticmethod
     def _load_image(path_to_image):

@@ -20,6 +20,7 @@
 from cvat.apps.authentication.auth import has_admin_role
 from cvat.apps.engine.serializers import LabeledDataSerializer
 from cvat.apps.engine.annotation import put_task_data, patch_task_data
+from cvat.apps.engine.frame_provider import FrameProvider
 
 from .models import AnnotationModel, FrameworkChoice
 from .model_loader import ModelLoader, load_labelmap
@@ -210,19 +211,6 @@ def delete(dl_model_id):
     else:
         raise Exception("Requested DL model {} doesn't exist".format(dl_model_id))
 
-def get_image_data(path_to_data):
-    def get_image_key(item):
-        return int(os.path.splitext(os.path.basename(item))[0])
-
-    image_list = []
-    for root, _, filenames in os.walk(path_to_data):
-        for filename in fnmatch.filter(filenames, "*.jpg"):
-            image_list.append(os.path.join(root, filename))
-
-    image_list.sort(key=get_image_key)
-    return ImageLoader(image_list)
-
-
 def run_inference_thread(tid, model_file, weights_file, labels_mapping, attributes, convertation_file, reset, user, restricted=True):
     def update_progress(job, progress):
         job.refresh()
@@ -243,7 +231,7 @@ def update_progress(job, progress):
         result = None
         slogger.glob.info("auto annotation with openvino toolkit for task {}".format(tid))
         result = run_inference_engine_annotation(
-            data=get_image_data(db_task.get_data_dirname()),
+            data=ImageLoader(FrameProvider(db_task)),
             model_file=model_file,
             weights_file=weights_file,
             labels_mapping=labels_mapping,

@@ -56,7 +56,7 @@ def has_module_permission(self, request):
 
 class TaskAdmin(admin.ModelAdmin):
     date_hierarchy = 'updated_date'
-    readonly_fields = ('size', 'created_date', 'updated_date', 'overlap')
+    readonly_fields = ('created_date', 'updated_date', 'overlap')
     list_display = ('name', 'mode', 'owner', 'assignee', 'created_date', 'updated_date')
     search_fields = ('name', 'mode', 'owner__username', 'owner__first_name',
         'owner__last_name', 'owner__email', 'assignee__username', 'assignee__first_name',

@@ -1,40 +1,57 @@
 import os
-from enum import Enum
+import zipfile
+
 from cvat.apps.engine.media_extractors import ArchiveExtractor, VideoExtractor
+from cvat.apps.engine.models import DataChoice
+
 
 class FrameProvider():
-    class ChunkType(Enum):
-        IMAGE = 0
-        VIDEO = 1
-
-    def __init__(self, db_task):
-        self._db_task = db_task
-        self._chunk_type = self.ChunkType.VIDEO if db_task.mode == 'interpolation' else self.ChunkType.IMAGE
-        self._chunk_extractor_class = ArchiveExtractor if self._chunk_type == self.ChunkType.IMAGE else VideoExtractor
+    def __init__(self, db_data):
+        self._db_data = db_data
+        # self._chunk_type = db_data.type
+        if db_data.type == DataChoice.IMAGESET:
+            self._chunk_extractor_class = ArchiveExtractor
+        elif db_data.type == DataChoice.VIDEO:
+            self._chunk_extractor_class = VideoExtractor
+        else:
+            pass # TODO
         self._extracted_chunk = None
         self._chunk_extractor = None
 
     def __iter__(self):
-        for i in range(self._db_task.size):
+        for i in range(self._db_data.size):
             yield self.get_frame(i)
 
     def __len__(self):
-        return self._db_task.size
+        return self._db_data.size
 
     def get_frame(self, frame_number):
-        if frame_number < 0 or frame_number >= self._db_task.size:
+        if frame_number < 0 or frame_number >= self._db_data.size:
             raise Exception('Incorrect requested frame number: {}'.format(frame_number))
-        chunk_number = frame_number // self._db_task.data_chunk_size
-        frame_offset = frame_number % self._db_task.data_chunk_size
+        chunk_number = frame_number // self._db_data.chunk_size
+        frame_offset = frame_number % self._db_data.chunk_size
         chunk_path = self.get_chunk(chunk_number)
         if chunk_number != self._extracted_chunk:
             self._extracted_chunk = chunk_number
             self._chunk_extractor = self._chunk_extractor_class([chunk_path], 95)
 
         return self._chunk_extractor[frame_offset]
 
-    def get_chunk(self, chunk_number):
-        return self._db_task.get_chunk_path(chunk_number)
+    def get_compressed_chunk(self, chunk_number):
+        path = self._db_data.get_compressed_chunk_path(chunk_number)
+        if self._db_data.type == DataChoice.LIST:
+            zip_chunk_path = '{}.list'.format(os.path.splitext(path)[0])
+            if not os.path.exists(zip_chunk_path):
+                with zipfile.ZipFile(zip_chunk_path, 'x') as zip_chunk:
+                    with open(path, 'r') as images:
+                        for im_path, idx in enumerate(images):
+                            zip_chunk.write(
+                                filename=im_path.strip(),
+                                arcname='{:06d}.jpeg'.format(idx),
+                            )
+            path = zip_chunk_path
+
+        return path
 
     def get_preview(self):
-        return os.path.join(self._db_task.get_data_dirname(), 'preview.jpg')
+        return self._db_data.get_preview_path()
@@ -42,12 +42,6 @@ def delete_tmp_dir(tmp_dir):
         if tmp_dir:
             shutil.rmtree(tmp_dir)
 
-    @staticmethod
-    def prepare_dirs(file_path):
-        dirname = os.path.dirname(file_path)
-        if not os.path.exists(dirname):
-            os.makedirs(dirname)
-
 #Note step, start, stop have no affect
 class ImageListExtractor(MediaExtractor):
     def __init__(self, source_path, image_quality, step=1, start=0, stop=0):
@@ -91,14 +85,13 @@ def save_image(self, k, dest_path):
             f.write(compressed_image.getvalue())
         return w, h
 
-    def save_as_chunks(self, chunk_size, task, progress_callback=None):
+    def save_as_chunks(self, chunk_size, data, progress_callback=None):
         counter = 0
         media_meta = []
         total_length = len(self._source_path)
         for i in range(0, total_length, chunk_size):
             chunk_data = self._source_path[i:i + chunk_size]
-            archive_name = task.get_chunk_path(counter)
-            self.prepare_dirs(archive_name)
+            archive_name = data.get_compressed_chunk_path(counter)
             with zipfile.ZipFile(archive_name, 'x') as zip_chunk:
                 for idx, image_file in enumerate(chunk_data):
                     w, h, image_buf = self.compress_image(image_file)
@@ -230,16 +223,15 @@ def __del__(self):
     def save_image(self, k, dest_path):
         shutil.copyfile(self[k], dest_path)
 
-    def save_as_chunks(self, chunk_size, task, progress_callback=None):
+    def save_as_chunks(self, chunk_size, data, progress_callback=None):
         if not self._source_path:
             raise Exception('No data to compress')
 
         for i in range(math.ceil(len(self._source_path) / chunk_size)):
             start_frame = i * chunk_size
             input_images = os.path.join(self._tmp_dir, self._imagename_pattern)
             input_options = '-f image2 -framerate 25 -start_number {}'.format(start_frame)
-            output_chunk = task.get_chunk_path(i)
-            self.prepare_dirs(output_chunk)
+            output_chunk = data.get_compressed_chunk_path(i)
             output_options = '-vframes {} -codec:v mpeg1video -q:v 0'.format(chunk_size)
 
             ff = FFmpeg(