diff --git a/.github/workflows/update-schema.yaml b/.github/workflows/update-schema.yaml
new file mode 100644
index 00000000..7110dea2
--- /dev/null
+++ b/.github/workflows/update-schema.yaml
@@ -0,0 +1,22 @@
+name: Update Schema
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - 'src/Database/migrations/**'
+
+jobs:
+  update-schema:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Trigger schema update
+      run: |
+        curl -X POST --fail \
+          -H "Authorization: token ${{ secrets.BIIGLE_SCHEMA_API_TOKEN }}" \
+          -H "Content-Type: application/json" \
+          --data '{"event_type": "build_application"}' \
+          https://api.github.com/repos/biigle/schema/dispatches
diff --git a/README.md b/README.md
index bf07fe49..0c88eba6 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@ This is the BIIGLE module to review image annotations in a regular grid.
 This module is already included in [`biigle/biigle`](https://github.com/biigle/biigle).
 
 1. Run `composer require biigle/largo`.
+2. Install the Python dependencies with `pip install -r requirements.txt`.
 2. Add `Biigle\Modules\Largo\LargoServiceProvider::class` to the `providers` array in `config/app.php`.
 3. Run `php artisan vendor:publish --tag=public` to publish the public assets of this module.
 4. Configure a storage disk for the Largo annotation patches and set the `LARGO_PATCH_STORAGE_DISK` variable to the name of this storage disk in the `.env` file. The content of the storage disk should be publicly accessible. Example for a local disk:
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..7d20fe0e
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,4 @@
+Pillow==10.2.0
+torch==2.1.*
+torchvision==0.16.*
+xformers==0.0.18
diff --git a/src/Console/Commands/GenerateMissing.php b/src/Console/Commands/GenerateMissing.php
index 30083bc7..12da1a03 100644
--- a/src/Console/Commands/GenerateMissing.php
+++ b/src/Console/Commands/GenerateMissing.php
@@ -2,13 +2,18 @@
 
 namespace Biigle\Modules\Largo\Console\Commands;
 
+use Biigle\Annotation;
+use Biigle\Image;
 use Biigle\ImageAnnotation;
-use Biigle\Modules\Largo\Jobs\GenerateImageAnnotationPatch;
-use Biigle\Modules\Largo\Jobs\GenerateVideoAnnotationPatch;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedFile;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedImage;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedVideo;
 use Biigle\VideoAnnotation;
+use Biigle\VolumeFile;
 use Carbon\Carbon;
-use File;
 use Illuminate\Console\Command;
+use Illuminate\Contracts\Filesystem\Filesystem;
+use Illuminate\Database\Eloquent\Builder;
 use Storage;
 
 class GenerateMissing extends Command
@@ -18,39 +23,38 @@ class GenerateMissing extends Command
      *
      * @var string
      */
-    protected $signature = 'largo:generate-missing {--dry-run} {--volume=} {--no-image-annotations} {--no-video-annotations} {--queue=} {--newer-than=}
-        {--older-than=}';
+    protected $signature = 'largo:generate-missing
+        {--dry-run : Do not submit processing jobs to the queue}
+        {--volume= : Check only this volume}
+        {--skip-images : Do not check image annotations}
+        {--skip-videos : Do not check video annotations}
+        {--skip-vectors : Do not check feature vectors}
+        {--skip-patches : Do not check annotation patches}
+        {--queue= : Submit processing jobs to this queue}
+        {--newer-than= : Only check annotations newer than this date}
+        {--older-than= : Only check annotations older than this date}';
 
     /**
      * The console command description.
      *
      * @var string
      */
-    protected $description = 'Generate missing patches for annotations.';
+    protected $description = 'Generate missing data for annotations.';
 
     /**
-     * Largo patch storage file format.
-     *
-     * @var string
+     * Queue to push process jobs to.
      */
-    protected $format;
+    protected string $queue;
 
     /**
-     * Number of annotations missing patches.
-     *
-     * @var int
+     * Whether to skip checking for missing patches.
      */
-    protected $count;
+    protected bool $skipPatches;
 
     /**
-     * Create a new command instance.
+     * Whether to skip checking for missing feature vectors.
      */
-    public function __construct()
-    {
-        parent::__construct();
-        $this->format = config('largo.patch_format');
-        $this->count = 0.0;
-    }
+    protected bool $skipVectors;
 
     /**
      * Execute the command.
@@ -59,31 +63,31 @@ public function __construct()
      */
     public function handle()
     {
-        $pushToQueue = !$this->option('dry-run');
-        $storage = Storage::disk(config('largo.patch_storage_disk'));
-        $queue = $this->option('queue') ?: config('largo.generate_annotation_patch_queue');
+        $this->queue = $this->option('queue') ?: config('largo.generate_annotation_patch_queue');
+        $this->skipPatches = $this->option('skip-patches');
+        $this->skipVectors = $this->option('skip-vectors');
 
-        if (!$this->option('no-image-annotations')) {
-            $this->handleImageAnnotations($storage, $pushToQueue, $queue);
+        if (!$this->option('skip-images')) {
+            $this->handleImageAnnotations();
         }
 
-        $this->count = 0;
-
-        if (!$this->option('no-video-annotations')) {
-            $this->handleVideoAnnotations($storage, $pushToQueue, $queue);
+        if (!$this->option('skip-videos')) {
+            $this->handleVideoAnnotations();
         }
     }
 
     /**
      * Check image annnotation patches
-     *
-     * @param \Illuminate\Filesystem\FilesystemAdapter $storage
-     * @param bool $pushToQueue
-     * @param string $queue
      */
-    protected function handleImageAnnotations($storage, $pushToQueue, $queue)
+    protected function handleImageAnnotations(): void
     {
         $annotations = ImageAnnotation::join('images', 'images.id', '=', 'image_annotations.image_id')
+            // Order by image ID first because we want to submit the annotations in
+            // batches for each image.
+            ->orderBy('image_annotations.image_id')
+            // Order by annotation ID second to ensure a deterministic order for lazy().
+            ->orderBy('image_annotations.id')
+            ->select('image_annotations.id', 'image_annotations.image_id')
             ->when($this->option('volume'), function ($query) {
                 $query->where('images.volume_id', $this->option('volume'));
             })
@@ -93,75 +97,97 @@ protected function handleImageAnnotations($storage, $pushToQueue, $queue)
             ->when($this->option('older-than'), function ($query) {
                 $query->where('image_annotations.created_at', '<', new Carbon($this->option('older-than')));
             })
-            ->select('image_annotations.id', 'images.uuid as uuid');
-
-        $total = $annotations->count();
-        $progress = $this->output->createProgressBar($total);
-        $this->info("Checking {$total} image annotations...");
-
-        $handleAnnotation = function ($annotation) use ($progress, $pushToQueue, $storage, $queue) {
-            $prefix = fragment_uuid_path($annotation->uuid);
-            if (!$storage->exists("{$prefix}/{$annotation->id}.{$this->format}")) {
-                $this->count++;
-                if ($pushToQueue) {
-                    GenerateImageAnnotationPatch::dispatch($annotation)
-                        ->onQueue($queue);
-                }
-            }
-            $progress->advance();
-        };
+            ->when(!$this->skipVectors, function ($query) {
+                $query->leftJoin('image_annotation_label_feature_vectors', 'image_annotation_label_feature_vectors.annotation_id', '=', 'image_annotations.id')
+                    ->addSelect('image_annotation_label_feature_vectors.id as vector_id');
+            });
 
-        $annotations->eachById($handleAnnotation, 10000, 'image_annotations.id', 'id');
-
-        $progress->finish();
-        
-        if($total === 0) {
-            $this->info("\n");
-            return;
-        }
-
-        $percent = round($this->count / $total * 100, 2);
-        $this->info("\nFound {$this->count} image annotations with missing patches ({$percent} %).");
-        if ($pushToQueue) {
-            $this->info("Pushed {$this->count} jobs to queue {$queue}.");
-        }
+        $this->line("Image annotations");
+        $this->handleAnnotations($annotations);
     }
 
     /**
      * Check video annnotation patches
-     *
-     * @param \Illuminate\Filesystem\FilesystemAdapter $storage
-     * @param bool $pushToQueue
-     * @param string $queue
      */
-    protected function handleVideoAnnotations($storage, $pushToQueue, $queue)
+    protected function handleVideoAnnotations(): void
     {
         $annotations = VideoAnnotation::join('videos', 'videos.id', '=', 'video_annotations.video_id')
+            // Order by video ID first because we want to submit the annotations in
+            // batches for each video.
+            ->orderBy('video_annotations.video_id')
+            // Order by annotation ID second to ensure a deterministic order for lazy().
+            ->orderBy('video_annotations.id')
+            ->select('video_annotations.id', 'video_annotations.video_id')
             ->when($this->option('volume'), function ($query) {
                 $query->where('videos.volume_id', $this->option('volume'));
             })
             ->when($this->option('newer-than'), function ($query) {
                 $query->where('video_annotations.created_at', '>', new Carbon($this->option('newer-than')));
             })
-            ->select('video_annotations.id', 'videos.uuid as uuid');
+            ->when($this->option('older-than'), function ($query) {
+                $query->where('video_annotations.created_at', '<', new Carbon($this->option('older-than')));
+            })
+            ->when(!$this->skipVectors, function ($query) {
+                $query->leftJoin('video_annotation_label_feature_vectors', 'video_annotation_label_feature_vectors.annotation_id', '=', 'video_annotations.id')
+                    ->addSelect('video_annotation_label_feature_vectors.id as vector_id');
+            });
+
+        $this->line("Video annotations");
+        $this->handleAnnotations($annotations);
+    }
+
+    protected function handleAnnotations(Builder $annotations): void
+    {
+        $pushToQueue = !$this->option('dry-run');
+        $storage = Storage::disk(config('largo.patch_storage_disk'));
 
+        $count = 0;
+        $jobCount = 0;
         $total = $annotations->count();
         $progress = $this->output->createProgressBar($total);
-        $this->info("Checking {$total} video annotations...");
-
-        $handleAnnotation = function ($annotation) use ($progress, $pushToQueue, $storage, $queue) {
-            $prefix = fragment_uuid_path($annotation->uuid);
-            if (!$storage->exists("{$prefix}/v-{$annotation->id}.{$this->format}")) {
-                $this->count++;
-                if ($pushToQueue) {
-                    GenerateVideoAnnotationPatch::dispatch($annotation)
-                        ->onQueue($queue);
+        $this->info("Checking {$total} annotations...");
+
+        $currentFile = null;
+        $currentAnnotationBatch = [];
+
+        // lazy() is crucial as we can't load all annotations at once!
+        foreach ($annotations->with('file')->lazy() as $annotation) {
+            $progress->advance();
+
+            if ($this->skipPatches) {
+                $needsPatch = false;
+            } else {
+                $needsPatch = !$storage->exists(
+                    ProcessAnnotatedFile::getTargetPath($annotation)
+                );
+            }
+
+            $needsVector = !$this->skipVectors && is_null($annotation->vector_id);
+
+            if (!$needsPatch && !$needsVector) {
+                continue;
+            }
+
+            $count++;
+
+            if (!$currentFile || $currentFile->id !== $annotation->file->id) {
+                if (!empty($currentAnnotationBatch) && $pushToQueue) {
+                    $jobCount++;
+                    $this->dispatcheProcessJob($currentFile, $currentAnnotationBatch);
                 }
+
+                $currentFile = $annotation->file;
+                $currentAnnotationBatch = [];
             }
-            $progress->advance();
-        };
 
-        $annotations->eachById($handleAnnotation, 10000, 'video_annotations.id', 'id');
+            $currentAnnotationBatch[] = $annotation->id;
+        }
+
+        // Push final job.
+        if (!empty($currentAnnotationBatch) && $pushToQueue) {
+            $jobCount++;
+            $this->dispatcheProcessJob($currentFile, $currentAnnotationBatch);
+        }
 
         $progress->finish();
 
@@ -170,10 +196,29 @@ protected function handleVideoAnnotations($storage, $pushToQueue, $queue)
             return;
         }
 
-        $percent = round($this->count / $total * 100, 2);
-        $this->info("\nFound {$this->count} video annotations with missing patches ({$percent} %).");
+        $percent = round($count / $total * 100, 2);
+        $this->info("\nFound {$count} annotations with missing patches ({$percent} %).");
         if ($pushToQueue) {
-            $this->info("Pushed {$this->count} jobs to queue {$queue}.");
+            $this->info("Pushed {$jobCount} jobs to queue {$this->queue}.");
+        }
+    }
+
+    protected function dispatcheProcessJob(VolumeFile $file, array $ids)
+    {
+        if ($file instanceof Image) {
+            ProcessAnnotatedImage::dispatch($file,
+                    only: $ids,
+                    skipPatches: $this->skipPatches,
+                    skipFeatureVectors: $this->skipVectors
+                )
+                ->onQueue($this->queue);
+        } else {
+            ProcessAnnotatedVideo::dispatch($file,
+                    only: $ids,
+                    skipPatches: $this->skipPatches,
+                    skipFeatureVectors: $this->skipVectors
+                )
+                ->onQueue($this->queue);
         }
     }
 }
diff --git a/src/Console/Commands/InitializeFeatureVectors.php b/src/Console/Commands/InitializeFeatureVectors.php
new file mode 100644
index 00000000..4da2c3d1
--- /dev/null
+++ b/src/Console/Commands/InitializeFeatureVectors.php
@@ -0,0 +1,100 @@
+<?php
+
+namespace Biigle\Modules\Largo\Console\Commands;
+
+use Biigle\ImageAnnotation;
+use Biigle\Modules\Largo\Jobs\InitializeFeatureVectorChunk;
+use Biigle\VideoAnnotation;
+use Biigle\Volume;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Queue;
+
+class InitializeFeatureVectors extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'largo:initialize-feature-vectors
+        {volume : ID of the volume of which the annotations should be processed}
+        {--dry-run : Do not submit jobs to generate feature vectors}
+        {--queue=default : Queue name to push jobs to generate feature vectors to}
+        {--chunk-size=1000 : Number of annotations to process in a single job}';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Generate annotation feature vectors based on their annotation thumbnails.';
+
+    /**
+     * Execute the command.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        $volume = Volume::findOrFail($this->argument('volume'));
+        if ($volume->isImageVolume()) {
+            $this->processImages($volume);
+        } else {
+            $this->processVideos($volume);
+        }
+    }
+
+    protected function processImages(Volume $volume)
+    {
+        $chunkSize = intval($this->option('chunk-size'));
+        $loopChunkSize = max($chunkSize, 10000);
+
+        $query = ImageAnnotation::join('images', 'images.id', '=', 'image_annotations.image_id')
+            ->where('images.volume_id', $volume->id);
+
+        $count = $query->count();
+        $this->info("Processing {$count} image annotations.");
+        $p = $this->output->createProgressBar($count);
+
+        $query->select('image_annotations.id')
+            ->chunkById($loopChunkSize, function ($chunk) use ($p, $chunkSize) {
+                $chunk->chunk($chunkSize)->each(function ($c) use ($p) {
+                    $job = new InitializeFeatureVectorChunk($c->pluck('id')->all(), []);
+                    if (!$this->option('dry-run')) {
+                        Queue::pushOn($this->option('queue'), $job);
+                    }
+                    $p->advance($c->count());
+                });
+            });
+
+        $p->finish();
+        $this->line('');
+    }
+
+    protected function processVideos(Volume $volume)
+    {
+        $chunkSize = intval($this->option('chunk-size'));
+        $loopChunkSize = max($chunkSize, 10000);
+
+        $query = VideoAnnotation::join('videos', 'videos.id', '=', 'video_annotations.video_id')
+            ->where('videos.volume_id', $volume->id);
+
+        $count = $query->count();
+        $this->info("Processing {$count} video annotations.");
+        $p = $this->output->createProgressBar($count);
+
+        $query->select('video_annotations.id')
+            ->chunkById($loopChunkSize, function ($chunk) use ($p, $chunkSize) {
+                $chunk->chunk($chunkSize)->each(function ($c) use ($p) {
+                    $job = new InitializeFeatureVectorChunk([], $c->pluck('id')->all());
+                    if (!$this->option('dry-run')) {
+                        Queue::pushOn($this->option('queue'), $job);
+                    }
+                    $p->advance($c->count());
+                });
+            });
+
+        $p->finish();
+        $this->line('');
+    }
+}
diff --git a/src/Database/Factories/ImageAnnotationLabelFeatureVectorFactory.php b/src/Database/Factories/ImageAnnotationLabelFeatureVectorFactory.php
new file mode 100644
index 00000000..e32ae067
--- /dev/null
+++ b/src/Database/Factories/ImageAnnotationLabelFeatureVectorFactory.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Biigle\Modules\Largo\Database\Factories;
+
+use Biigle\ImageAnnotation;
+use Biigle\ImageAnnotationLabel;
+use Biigle\Label;
+use Biigle\LabelTree;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Volume;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+class ImageAnnotationLabelFeatureVectorFactory extends Factory
+{
+    /**
+     * The name of the factory's corresponding model.
+     *
+     * @var string
+     */
+    protected $model = ImageAnnotationLabelFeatureVector::class;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array
+     */
+    public function definition()
+    {
+        return [
+            'id' => ImageAnnotationLabel::factory(),
+            'annotation_id' => ImageAnnotation::factory(),
+            'label_id' => Label::factory(),
+            'label_tree_id' => LabelTree::factory(),
+            'volume_id' => Volume::factory(),
+            'vector' => range(0, 383),
+        ];
+    }
+}
diff --git a/src/Database/Factories/VideoAnnotationLabelFeatureVectorFactory.php b/src/Database/Factories/VideoAnnotationLabelFeatureVectorFactory.php
new file mode 100644
index 00000000..4e80e588
--- /dev/null
+++ b/src/Database/Factories/VideoAnnotationLabelFeatureVectorFactory.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Biigle\Modules\Largo\Database\Factories;
+
+use Biigle\VideoAnnotation;
+use Biigle\VideoAnnotationLabel;
+use Biigle\Label;
+use Biigle\LabelTree;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\Volume;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+class VideoAnnotationLabelFeatureVectorFactory extends Factory
+{
+    /**
+     * The name of the factory's corresponding model.
+     *
+     * @var string
+     */
+    protected $model = VideoAnnotationLabelFeatureVector::class;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array
+     */
+    public function definition()
+    {
+        return [
+            'id' => VideoAnnotationLabel::factory(),
+            'annotation_id' => VideoAnnotation::factory(),
+            'label_id' => Label::factory(),
+            'label_tree_id' => LabelTree::factory(),
+            'volume_id' => Volume::factory(),
+            'vector' => range(0, 383),
+        ];
+    }
+}
diff --git a/src/Database/migrations/2023_12_15_153400_create_annotation_feature_vectors_tables.php b/src/Database/migrations/2023_12_15_153400_create_annotation_feature_vectors_tables.php
new file mode 100644
index 00000000..0740b94e
--- /dev/null
+++ b/src/Database/migrations/2023_12_15_153400_create_annotation_feature_vectors_tables.php
@@ -0,0 +1,128 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        /*
+         * Context/explanation: These tables are optimized for fast queries both by Largo
+         * and (in the future) for LabelBOT. Largo needs to filter by label_id and
+         * volume_id, followed by a vector sort. These tables include both IDs (although
+         * they could be joined to the labels and images/videos tables) because it will
+         * make the query faster. This does not benefit from a vector index because the
+         * sorting always needs to consider all rows with a certain label_id and
+         * volume_id. We use a compound index for the volume_id and label_id instead.
+         *
+         * LabelBOT will likely filter by label_tree_id and then search for most similar
+         * annotations. The current plan is to dynamically create partitions for
+         * these tables (one each for a label tree), so the label_tree_id is redundantly
+         * included here, too. Partitioned tables combined with a vector index may be the
+         * fastest way to query for "most similar" annotations that also involves
+         * filtering by label_tree_id. There is some controversy, though (see below), and
+         * we need to test the performance once we have real data in these tables.
+         *
+         * Recommends partitioning for filtered sorting:
+         * https://github.com/pgvector/pgvector#filtering
+         *
+         * Mentions impracticality of partitioning to lots (100s) of categories but also
+         * mentions possible improvements to pgvector to natively support fltering:
+         * https://github.com/pgvector/pgvector/issues/259#issuecomment-1783872804
+         */
+
+        Schema::create('image_annotation_label_feature_vectors', function (Blueprint $table) {
+                $table->unsignedBigInteger('id');
+                $table->foreign('id')
+                    ->references('id')
+                    ->on('image_annotation_labels')
+                    ->onDelete('cascade');
+
+                $table->foreignId('annotation_id')
+                    ->constrained(table: 'image_annotations')
+                    ->onDelete('cascade');
+
+                $table->foreignId('label_id')
+                    ->constrained()
+                    ->onDelete('restrict');
+
+                // This is added to be used by LabelBOT in the future.
+                // We still have to think of an efficient indexing strategy so indexes
+                // are added later.
+                $table->foreignId('label_tree_id')
+                    ->constrained()
+                    ->onDelete('restrict');
+
+                $table->foreignId('volume_id')
+                    ->constrained()
+                    ->onDelete('cascade');
+
+                $table->vector('vector', 384);
+
+                // For Largo queries.
+                $table->index(['label_id', 'volume_id']);
+
+                // For create/update queries.
+                $table->index('annotation_id');
+
+                // Ensure consistency and speed up updateOrCreate queries.
+                $table->primary('id');
+            });
+
+        Schema::create('video_annotation_label_feature_vectors', function (Blueprint $table) {
+                $table->unsignedBigInteger('id');
+                $table->foreign('id')
+                    ->references('id')
+                    ->on('video_annotation_labels')
+                    ->onDelete('cascade');
+
+                $table->foreignId('annotation_id')
+                    ->constrained(table: 'video_annotations')
+                    ->onDelete('cascade');
+
+                $table->foreignId('label_id')
+                    ->constrained()
+                    ->onDelete('restrict');
+
+                // This is added to be used by LabelBOT in the future.
+                // We still have to think of an efficient indexing strategy so indexes
+                // are added later.
+                $table->foreignId('label_tree_id')
+                    ->constrained()
+                    ->onDelete('restrict');
+
+                $table->foreignId('volume_id')
+                    ->constrained()
+                    ->onDelete('cascade');
+
+                $table->vector('vector', 384);
+
+                // For Largo queries.
+                $table->index(['label_id', 'volume_id']);
+
+                // For create/update queries.
+                $table->index('annotation_id');
+
+                // Ensure consistency and speed up updateOrCreate queries.
+                $table->primary('id');
+            });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::dropIfExists('image_annotation_label_feature_vectors');
+        Schema::dropIfExists('video_annotation_label_feature_vectors');
+    }
+};
diff --git a/src/Http/Controllers/Api/Projects/SortAnnotationsByOutliersController.php b/src/Http/Controllers/Api/Projects/SortAnnotationsByOutliersController.php
new file mode 100644
index 00000000..f748e665
--- /dev/null
+++ b/src/Http/Controllers/Api/Projects/SortAnnotationsByOutliersController.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace Biigle\Modules\Largo\Http\Controllers\Api\Projects;
+
+use DB;
+use Biigle\Http\Controllers\Api\Controller;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\Project;
+
+class SortAnnotationsByOutliersController extends Controller
+{
+    /**
+     * Sort annotations with specific label by outliers.
+     *
+     * @api {get} projects/:pid/annotations/sort/outliers/:lid Sort annotations with the same label by outliers
+     * @apiGroup Projects
+     * @apiName ShowProjectsAnnotationsSortOutliers
+     * @apiParam {Number} pid The project ID
+     * @apiParam {Number} lid The Label ID
+     * @apiPermission projectMember
+     * @apiDescription Returns a list of image/video annotation IDs with the outliers first. Image annotation IDs are prefixed with `i` (e.g. `i123`) and video annotation IDs are prefixed with `v` (e.g. `v456`).
+     *
+     * @param  int  $pid Project ID
+     * @param int $lid Label ID
+     * @return \Illuminate\Http\Response
+     */
+    public function index($pid, $lid)
+    {
+        $project = Project::findOrFail($pid);
+        $this->authorize('access', $project);
+
+        // This was too complicated with the query builder. Since there is no rist of SQL
+        // injection here, we just use raw SQL.
+        $sql = <<<SQL
+        SELECT "id" FROM (
+            (
+              SELECT CONCAT('i', "annotation_id") AS id, "vector"
+              FROM "image_annotation_label_feature_vectors"
+              WHERE "label_id" = :lid AND "volume_id" IN (
+                 SELECT "volume_id" FROM "project_volume" WHERE "project_id" = :pid
+              )
+           )
+           UNION
+           (
+              SELECT CONCAT('v', "annotation_id") AS id, "vector"
+              FROM "video_annotation_label_feature_vectors"
+              WHERE "label_id" = :lid AND "volume_id" IN (
+                 SELECT "volume_id" FROM "project_volume" WHERE "project_id" = :pid
+              )
+           )
+        ) AS "temp"
+        ORDER BY "temp"."vector" <=> (
+            SELECT AVG("temp2"."vector") FROM (
+              SELECT "vector" FROM "image_annotation_label_feature_vectors"
+              WHERE "label_id" = :lid AND "volume_id" IN (
+                 SELECT "volume_id" FROM "project_volume" WHERE "project_id" = :pid
+              )
+              UNION ALL
+              SELECT "vector" FROM "video_annotation_label_feature_vectors"
+              WHERE "label_id" = :lid AND "volume_id" IN (
+                 SELECT "volume_id" FROM "project_volume" WHERE "project_id" = :pid
+              )
+           ) AS temp2
+        ) DESC, id DESC
+        SQL;
+
+        $ids = DB::select($sql, ['pid' => $pid, 'lid' => $lid]);
+
+        // Filtering unique IDs is not required here because the UNIQUE in the query
+        // takes care of that.
+        return array_map(fn ($v) => $v->id, $ids);
+    }
+}
diff --git a/src/Http/Controllers/Api/Volumes/SortAnnotationsByOutliersController.php b/src/Http/Controllers/Api/Volumes/SortAnnotationsByOutliersController.php
new file mode 100644
index 00000000..495f1372
--- /dev/null
+++ b/src/Http/Controllers/Api/Volumes/SortAnnotationsByOutliersController.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Biigle\Modules\Largo\Http\Controllers\Api\Volumes;
+
+use Biigle\Http\Controllers\Api\Controller;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\Volume;
+
+class SortAnnotationsByOutliersController extends Controller
+{
+    /**
+     * Sort annotations with specific label by outliers.
+     *
+     * @api {get} volumes/:vid/annotations/sort/outliers/:lid Sort annotations with the same label by outliers
+     * @apiGroup Volumes
+     * @apiName ShowVolumesAnnotationsSortOutliers
+     * @apiParam {Number} vid The volume ID
+     * @apiParam {Number} lid The Label ID
+     * @apiPermission projectMember
+     * @apiDescription Returns a list of image/video annotation IDs with the outliers first.
+     *
+     * @param  int  $vid Volume ID
+     * @param int $lid Label ID
+     * @return \Illuminate\Http\Response
+     */
+    public function index($vid, $lid)
+    {
+        $volume = Volume::findOrFail($vid);
+        $this->authorize('access', $volume);
+
+        if ($volume->isVideoVolume()) {
+            $query = VideoAnnotationLabelFeatureVector::where('volume_id', $vid)
+                ->where('label_id', $lid)
+                ->orderByRaw('vector <=> (SELECT AVG(vector) FROM video_annotation_label_feature_vectors WHERE volume_id = ? AND label_id = ?) DESC, annotation_id DESC', [$vid, $lid]);
+        } else {
+            $query = ImageAnnotationLabelFeatureVector::where('volume_id', $vid)
+                ->where('label_id', $lid)
+                ->orderByRaw('vector <=> (SELECT AVG(vector) FROM image_annotation_label_feature_vectors WHERE volume_id = ? AND label_id = ?) DESC, annotation_id DESC', [$vid, $lid]);
+        }
+
+        return $query->pluck('annotation_id')
+            // Use distinct/unique *after* fetchig from the DB because otherwise the
+            // vector would need to be selected, too (order by expressions must appear in
+            // the select list). But we don't want to get the huge vectors.
+            ->unique()
+            ->values();
+    }
+}
diff --git a/src/Http/routes.php b/src/Http/routes.php
index 08b1e293..ad39aa3d 100644
--- a/src/Http/routes.php
+++ b/src/Http/routes.php
@@ -25,39 +25,47 @@
     'prefix' => 'api/v1',
     'middleware' => ['api', 'auth:web,api'],
 ], function ($router) {
-    $router->post('volumes/{id}/largo', [
-        'uses' => 'Volumes\LargoController@save',
+    $router->get('labels/{id}/image-annotations', [
+        'uses' => 'Labels\ImageAnnotationsController@index',
     ]);
 
-    $router->get('volumes/{id}/image-annotations/filter/label/{id2}', [
-        'uses' => 'Volumes\FilterImageAnnotationsByLabelController@index',
+    $router->get('labels/{id}/video-annotations', [
+        'uses' => 'Labels\VideoAnnotationsController@index',
     ]);
 
-    $router->get('volumes/{id}/video-annotations/filter/label/{id2}', [
-        'uses' => 'Volumes\FilterVideoAnnotationsByLabelController@index',
+    $router->get('projects/{id}/annotations/sort/outliers/{id2}', [
+        'uses' => 'Projects\SortAnnotationsByOutliersController@index',
     ]);
 
-    $router->get('volumes/{id}/image-annotations/examples/{id2}', [
-        'uses' => 'Volumes\ImageAnnotationExamplesController@index',
+    $router->get('projects/{id}/image-annotations/filter/label/{id2}', [
+        'uses' => 'Projects\FilterImageAnnotationsByLabelController@index',
     ]);
 
     $router->post('projects/{id}/largo', [
         'uses' => 'Projects\LargoController@save',
     ]);
 
-    $router->get('projects/{id}/image-annotations/filter/label/{id2}', [
-        'uses' => 'Projects\FilterImageAnnotationsByLabelController@index',
-    ]);
-
     $router->get('projects/{id}/video-annotations/filter/label/{id2}', [
         'uses' => 'Projects\FilterVideoAnnotationsByLabelController@index',
     ]);
 
-    $router->get('labels/{id}/image-annotations', [
-        'uses' => 'Labels\ImageAnnotationsController@index',
+    $router->get('volumes/{id}/annotations/sort/outliers/{id2}', [
+        'uses' => 'Volumes\SortAnnotationsByOutliersController@index',
     ]);
 
-    $router->get('labels/{id}/video-annotations', [
-        'uses' => 'Labels\VideoAnnotationsController@index',
+    $router->get('volumes/{id}/image-annotations/examples/{id2}', [
+        'uses' => 'Volumes\ImageAnnotationExamplesController@index',
+    ]);
+
+    $router->get('volumes/{id}/image-annotations/filter/label/{id2}', [
+        'uses' => 'Volumes\FilterImageAnnotationsByLabelController@index',
+    ]);
+
+    $router->post('volumes/{id}/largo', [
+        'uses' => 'Volumes\LargoController@save',
+    ]);
+
+    $router->get('volumes/{id}/video-annotations/filter/label/{id2}', [
+        'uses' => 'Volumes\FilterVideoAnnotationsByLabelController@index',
     ]);
 });
diff --git a/src/ImageAnnotationLabelFeatureVector.php b/src/ImageAnnotationLabelFeatureVector.php
new file mode 100644
index 00000000..a673d08a
--- /dev/null
+++ b/src/ImageAnnotationLabelFeatureVector.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace Biigle\Modules\Largo;
+
+use Biigle\Modules\Largo\Database\Factories\ImageAnnotationLabelFeatureVectorFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Pgvector\Laravel\Vector;
+
+class ImageAnnotationLabelFeatureVector extends Model
+{
+    use HasFactory;
+
+    /**
+     * Don't maintain timestamps for this model.
+     *
+     * @var bool
+     */
+    public $timestamps = false;
+
+    /**
+     * The attributes that should be casted to native types.
+     *
+     * @var array
+     */
+    protected $casts = [
+        'vector' => Vector::class,
+    ];
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var array
+     */
+    protected $fillable = [
+        'id',
+        'annotation_id',
+        'label_id',
+        'label_tree_id',
+        'volume_id',
+        'vector',
+    ];
+
+    /**
+     * Create a new factory instance for the model.
+     *
+     * @return \Illuminate\Database\Eloquent\Factories\Factory
+     */
+    protected static function newFactory()
+    {
+        return ImageAnnotationLabelFeatureVectorFactory::new();
+    }
+}
diff --git a/src/Jobs/ApplyLargoSession.php b/src/Jobs/ApplyLargoSession.php
index b404bee4..3da07a6f 100644
--- a/src/Jobs/ApplyLargoSession.php
+++ b/src/Jobs/ApplyLargoSession.php
@@ -8,6 +8,8 @@
 use Biigle\Label;
 use Biigle\Modules\Largo\Events\LargoSessionFailed;
 use Biigle\Modules\Largo\Events\LargoSessionSaved;
+use Biigle\Modules\Largo\Jobs\CopyImageAnnotationFeatureVector;
+use Biigle\Modules\Largo\Jobs\CopyVideoAnnotationFeatureVector;
 use Biigle\Modules\Largo\Jobs\RemoveImageAnnotationPatches;
 use Biigle\Modules\Largo\Jobs\RemoveVideoAnnotationPatches;
 use Biigle\User;
@@ -144,8 +146,11 @@ protected function handleImageAnnotations()
     {
         [$dismissed, $changed] = $this->ignoreDeletedLabels($this->dismissedImageAnnotations, $this->changedImageAnnotations);
 
-        $this->applyDismissedLabels($this->user, $dismissed, $this->force, ImageAnnotationLabel::class);
+        // Change labels first, then dismiss to keep the opportunity to copy feature
+        // vectors. If labels are deleted first, the feature vectors will be immediately
+        // deleted, too, and nothing can be copied any more.
         $this->applyChangedLabels($this->user, $changed, ImageAnnotation::class, ImageAnnotationLabel::class);
+        $this->applyDismissedLabels($this->user, $dismissed, $this->force, ImageAnnotationLabel::class);
         $this->deleteDanglingAnnotations($dismissed, $changed, ImageAnnotation::class);
     }
 
@@ -156,8 +161,11 @@ protected function handleVideoAnnotations()
     {
         [$dismissed, $changed] = $this->ignoreDeletedLabels($this->dismissedVideoAnnotations, $this->changedVideoAnnotations);
 
-        $this->applyDismissedLabels($this->user, $dismissed, $this->force, VideoAnnotationLabel::class);
+        // Change labels first, then dismiss to keep the opportunity to copy feature
+        // vectors. If labels are deleted first, the feature vectors will be immediately
+        // deleted, too, and nothing can be copied any more.
         $this->applyChangedLabels($this->user, $changed, VideoAnnotation::class, VideoAnnotationLabel::class);
+        $this->applyDismissedLabels($this->user, $dismissed, $this->force, VideoAnnotationLabel::class);
         $this->deleteDanglingAnnotations($dismissed, $changed, VideoAnnotation::class);
     }
 
@@ -286,6 +294,10 @@ protected function applyChangedLabels($user, $changed, $annotationModel, $labelM
             }
         }
 
+        // Store the ID so we can efficiently loop over the models later. This is only
+        // possible because all this happens inside a DB transaction (see above).
+        $startId = $labelModel::orderBy('id', 'desc')->select('id')->first()->id;
+
         collect($newAnnotationLabels)
             ->when($labelModel === ImageAnnotationLabel::class, function ($labels) {
                 return $labels->map(function ($item) {
@@ -301,6 +313,18 @@ protected function applyChangedLabels($user, $changed, $annotationModel, $labelM
             ->each(function ($chunk) use ($labelModel) {
                 $labelModel::insert($chunk->toArray());
             });
+
+        $labelModel::where('id', '>', $startId)
+            ->eachById(function ($annotationLabel) use ($labelModel) {
+                // Execute the jobs synchronously because after this method the
+                // old annotation labels may be deleted and there will be nothing
+                // to copy any more.
+                if ($labelModel === ImageAnnotationLabel::class) {
+                    (new CopyImageAnnotationFeatureVector($annotationLabel))->handle();
+                } else {
+                    (new CopyVideoAnnotationFeatureVector($annotationLabel))->handle();
+                }
+            });
     }
 
     /**
diff --git a/src/Jobs/CopyAnnotationFeatureVector.php b/src/Jobs/CopyAnnotationFeatureVector.php
new file mode 100644
index 00000000..5559a87b
--- /dev/null
+++ b/src/Jobs/CopyAnnotationFeatureVector.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Biigle\AnnotationLabel;
+use Biigle\Jobs\Job;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+
+abstract class CopyAnnotationFeatureVector extends Job
+{
+    use SerializesModels, InteractsWithQueue;
+
+    /**
+     * Ignore this job if the annotation does not exist any more.
+     *
+     * @var bool
+     */
+    protected $deleteWhenMissingModels = true;
+
+
+    /**
+     * Copy the feature vector of the annotation associated with the annotation label
+     * to create a new feature vector for the annotation label.
+     */
+    public function __construct(public AnnotationLabel $annotationLabel)
+    {
+        //
+    }
+
+    /**
+     * Execute the job.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        $vector = $this->getFeatureVectorQuery()->first();
+        if (!is_null($vector)) {
+            $this->updateOrCreateFeatureVector([
+                'id' => $this->annotationLabel->id,
+                'annotation_id' => $this->annotationLabel->annotation_id,
+                'label_id' => $this->annotationLabel->label_id,
+                'label_tree_id' => $this->annotationLabel->label->label_tree_id,
+                'volume_id' => $vector->volume_id,
+                'vector' => $vector->vector,
+            ]);
+        }
+    }
+
+    /**
+     * Get a query for the feature vectors associated with the annotation of this job.
+     */
+    abstract protected function getFeatureVectorQuery(): Builder;
+
+    /**
+     * Create a new feature vector model for the annotation of this job.
+     */
+    abstract protected function updateOrCreateFeatureVector(array $attributes): void;
+}
diff --git a/src/Jobs/CopyImageAnnotationFeatureVector.php b/src/Jobs/CopyImageAnnotationFeatureVector.php
new file mode 100644
index 00000000..2a5c0c31
--- /dev/null
+++ b/src/Jobs/CopyImageAnnotationFeatureVector.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Illuminate\Database\Eloquent\Builder;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+
+class CopyImageAnnotationFeatureVector extends CopyAnnotationFeatureVector
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function getFeatureVectorQuery(): Builder
+    {
+        return ImageAnnotationLabelFeatureVector::where('annotation_id', $this->annotationLabel->annotation_id);
+    }
+
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function updateOrCreateFeatureVector(array $attributes): void
+    {
+        $idArray = ['id' => $attributes['id']];
+        unset($attributes['id']);
+        ImageAnnotationLabelFeatureVector::updateOrCreate($idArray, $attributes);
+    }
+}
diff --git a/src/Jobs/CopyVideoAnnotationFeatureVector.php b/src/Jobs/CopyVideoAnnotationFeatureVector.php
new file mode 100644
index 00000000..21c9964b
--- /dev/null
+++ b/src/Jobs/CopyVideoAnnotationFeatureVector.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Illuminate\Database\Eloquent\Builder;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+
+class CopyVideoAnnotationFeatureVector extends CopyAnnotationFeatureVector
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function getFeatureVectorQuery(): Builder
+    {
+        return VideoAnnotationLabelFeatureVector::where('annotation_id', $this->annotationLabel->annotation_id);
+    }
+
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function updateOrCreateFeatureVector(array $attributes): void
+    {
+        $idArray = ['id' => $attributes['id']];
+        unset($attributes['id']);
+        VideoAnnotationLabelFeatureVector::updateOrCreate($idArray, $attributes);
+    }
+}
diff --git a/src/Jobs/GenerateAnnotationPatch.php b/src/Jobs/GenerateAnnotationPatch.php
deleted file mode 100644
index eac153b3..00000000
--- a/src/Jobs/GenerateAnnotationPatch.php
+++ /dev/null
@@ -1,299 +0,0 @@
-<?php
-
-namespace Biigle\Modules\Largo\Jobs;
-
-use Biigle\Contracts\Annotation;
-use Biigle\FileCache\Exceptions\FileLockedException;
-use Biigle\Jobs\Job;
-use Biigle\Shape;
-use Biigle\VideoAnnotation;
-use Biigle\VolumeFile;
-use Exception;
-use FileCache;
-use Illuminate\Contracts\Queue\ShouldQueue;
-use Illuminate\Foundation\Bus\Dispatchable;
-use Illuminate\Queue\InteractsWithQueue;
-use Illuminate\Queue\SerializesModels;
-use Jcupitt\Vips\Image;
-use Log;
-use Str;
-
-abstract class GenerateAnnotationPatch extends Job implements ShouldQueue
-{
-    use SerializesModels, InteractsWithQueue;
-
-    /**
-     * The number of times the job may be attempted.
-     *
-     * @var int
-     */
-    public $tries = 3;
-
-    /**
-     * The the annotation to generate a patch for.
-     *
-     * @var Annotation
-     */
-    protected $annotation;
-
-    /**
-     * The storage disk to store the annotation patches to.
-     *
-     * @var string
-     */
-    protected $targetDisk;
-
-    /**
-     * Ignore this job if the annotation does not exist any more.
-     *
-     * @var bool
-     */
-    protected $deleteWhenMissingModels = true;
-
-
-    /**
-     * Create a new job instance.
-     *
-     * @param Annotation $annotation The the annotation to generate a patch for.
-     * @param string|null $targetDisk The storage disk to store the annotation patches to.
-     *
-     * @return void
-     */
-    public function __construct(Annotation $annotation, $targetDisk = null)
-    {
-        $this->annotation = $annotation;
-        $this->targetDisk = $targetDisk !== null
-            ? $targetDisk
-            : config('largo.patch_storage_disk');
-    }
-
-    /**
-     * Execute the job.
-     *
-     * @return void
-     */
-    public function handle()
-    {
-        try {
-            FileCache::get($this->annotation->getFile(), [$this, 'handleFile'], true);
-        } catch (FileLockedException $e) {
-            // Retry this job without increasing the attempts if the file is currently
-            // written by another worker. This worker can process other jobs in the
-            // meantime.
-            // See: https://github.com/laravel/ideas/issues/735
-            static::dispatch($this->annotation, $this->targetDisk)
-                ->onConnection($this->connection)
-                ->onQueue($this->queue)
-                ->delay(60);
-        } catch (Exception $e) {
-            if ($this->shouldRetryAfterException($e)) {
-                // Exponential backoff for retry after 10 and then 20 minutes.
-                $this->release($this->attempts() * 600);
-            } else {
-                $class = get_class($this->annotation);
-                Log::warning("Could not generate annotation patch for {$class} {$this->annotation->id}: {$e->getMessage()}", ['exception' => $e]);
-            }
-        }
-    }
-
-    /**
-     * Handle a single file.
-     *
-     * @param VolumeFile $file
-     * @param string $path Path to the cached file.
-     */
-    abstract public function handleFile(VolumeFile $file, $path);
-
-    /**
-     * Assemble the target path for an annotation patch.
-     *
-     * @param Annotation $annotation
-     *
-     * @return string
-     */
-    protected function getTargetPath(Annotation $annotation): string
-    {
-        $prefix = fragment_uuid_path($annotation->getFile()->uuid);
-        $format = config('largo.patch_format');
-
-        if ($annotation instanceof VideoAnnotation) {
-            // Add "v-" to make absolutely sure that no collisions (same UUID, same ID)
-            // occur because patches are stored on the same disk.
-            return "{$prefix}/v-{$annotation->id}.{$format}";
-        }
-
-        // This is the old patch storage scheme, so we don't add "i-" for backwards
-        // compatibility.
-        return "{$prefix}/{$annotation->id}.{$format}";
-    }
-
-    /**
-     * Determine if this job should retry instead of fail after an exception
-     *
-     * @param Exception $e
-     *
-     * @return bool
-     */
-    protected function shouldRetryAfterException(Exception $e)
-    {
-        $message = $e->getMessage();
-        return $this->attempts() < $this->tries && (
-            // The remote source might be available again after a while.
-            Str::contains($message, 'The source resource could not be established') ||
-            // This error presumably occurs due to worker concurrency.
-            Str::contains($message, 'Impossible to create the root directory')
-        );
-    }
-
-    /**
-     * Calculate the bounding rectangle of the patch to extract.
-     *
-     * @param array $points
-     * @param Shape $Shape
-     * @param int $thumbWidth
-     * @param int $thumbHeight
-     *
-     * @return array Containing width, height, top and left
-     */
-    protected function getPatchRect(array $points, Shape $shape, $thumbWidth, $thumbHeight)
-    {
-        $padding = config('largo.patch_padding');
-
-        switch ($shape->id) {
-            case Shape::pointId():
-                $pointPadding = config('largo.point_padding');
-                $left = $points[0] - $pointPadding;
-                $right = $points[0] + $pointPadding;
-                $top = $points[1] - $pointPadding;
-                $bottom = $points[1] + $pointPadding;
-                break;
-
-            case Shape::circleId():
-                $left = $points[0] - $points[2];
-                $right = $points[0] + $points[2];
-                $top = $points[1] - $points[2];
-                $bottom = $points[1] + $points[2];
-                break;
-
-            default:
-                $left = INF;
-                $right = -INF;
-                $top = INF;
-                $bottom = -INF;
-                foreach ($points as $index => $value) {
-                    if ($index % 2 === 0) {
-                        $left = min($left, $value);
-                        $right = max($right, $value);
-                    } else {
-                        $top = min($top, $value);
-                        $bottom = max($bottom, $value);
-                    }
-                }
-        }
-
-        $left -= $padding;
-        $right += $padding;
-        $top -= $padding;
-        $bottom += $padding;
-
-        $width = $right - $left;
-        $height = $bottom - $top;
-
-        // Ensure the minimum width so the annotation patch is not "zoomed in".
-        if ($width < $thumbWidth) {
-            $delta = ($thumbWidth - $width) / 2.0;
-            $left -= $delta;
-            $right += $delta;
-            $width = $thumbWidth;
-        }
-
-        // Ensure the minimum height so the annotation patch is not "zoomed in".
-        if ($height < $thumbHeight) {
-            $delta = ($thumbHeight - $height) / 2.0;
-            $top -= $delta;
-            $bottom += $delta;
-            $height = $thumbHeight;
-        }
-
-        $widthRatio = $width / $thumbWidth;
-        $heightRatio = $height / $thumbHeight;
-
-        // increase the size of the patch so its aspect ratio is the same than the
-        // ratio of the thumbnail dimensions
-        if ($widthRatio > $heightRatio) {
-            $newHeight = round($thumbHeight * $widthRatio);
-            $top -= round(($newHeight - $height) / 2);
-            $height = $newHeight;
-        } else {
-            $newWidth = round($thumbWidth * $heightRatio);
-            $left -= round(($newWidth - $width) / 2);
-            $width = $newWidth;
-        }
-
-        return [
-            'width' => intval(round($width)),
-            'height' => intval(round($height)),
-            'left' => intval(round($left)),
-            'top' => intval(round($top)),
-        ];
-    }
-
-    /**
-     * Adjust the position and size of the patch rectangle so it is contained in the
-     * image.
-     *
-     * @param array $rect
-     * @param Image $image
-     *
-     * @return array
-     */
-    protected function makeRectContained($rect, $image)
-    {
-        // Order of min max is importans so the point gets no negative coordinates.
-        $rect['left'] = min($image->width - $rect['width'], $rect['left']);
-        $rect['left'] = max(0, $rect['left']);
-        $rect['top'] = min($image->height - $rect['height'], $rect['top']);
-        $rect['top'] = max(0, $rect['top']);
-
-        // Adjust dimensions of rect if it is larger than the image.
-        $rect['width'] = min($image->width, $rect['width']);
-        $rect['height'] = min($image->height, $rect['height']);
-
-        return $rect;
-    }
-
-    /**
-     * Get the annotation patch as buffer.
-     *
-     * @param Image $image
-     * @param array $points
-     * @param Shape $shape
-     *
-     * @return string
-     */
-    protected function getAnnotationPatch($image, $points, $shape)
-    {
-        $thumbWidth = config('thumbnails.width');
-        $thumbHeight = config('thumbnails.height');
-
-        if ($shape->id === Shape::wholeFrameId()) {
-            $image = $image->resize(floatval($thumbWidth) / $image->width);
-        } else {
-            $rect = $this->getPatchRect($points, $shape, $thumbWidth, $thumbHeight);
-            $rect = $this->makeRectContained($rect, $image);
-
-            $image = $image->crop(
-                    $rect['left'],
-                    $rect['top'],
-                    $rect['width'],
-                    $rect['height']
-                )
-                ->resize(floatval($thumbWidth) / $rect['width']);
-        }
-
-        return $image->writeToBuffer('.'.config('largo.patch_format'), [
-            'Q' => 85,
-            'strip' => true,
-        ]);
-    }
-}
diff --git a/src/Jobs/GenerateFeatureVectors.php b/src/Jobs/GenerateFeatureVectors.php
new file mode 100644
index 00000000..8b0da453
--- /dev/null
+++ b/src/Jobs/GenerateFeatureVectors.php
@@ -0,0 +1,262 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Biigle\Jobs\Job;
+use Biigle\Shape;
+use Biigle\VideoAnnotation;
+use Biigle\VolumeFile;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Process;
+use SplFileObject;
+
+
+abstract class GenerateFeatureVectors extends Job implements ShouldQueue
+{
+    /**
+     * The "radius" of the bounding box around a point annotation.
+     *
+     * This is half the patch size of 224 that is expected by DINO.
+     *
+     * @var int
+     */
+    const POINT_PADDING = 112;
+
+        /**
+     * Get the bounding box of an annotation
+     */
+    public function getAnnotationBoundingBox(
+        array $points,
+        Shape $shape,
+        int $pointPadding = self::POINT_PADDING,
+        int $boxPadding = 0
+    ): array
+    {
+        $box = match ($shape->id) {
+            Shape::pointId() => $this->getPointBoundingBox($points, $pointPadding),
+            Shape::circleId() => $this->getCircleBoundingBox($points),
+            // An ellipse will not be handled correctly by this but I didn't bother
+            // because this shape is almost never used anyway.
+            default => $this->getPolygonBoundingBox($points),
+        };
+
+        if ($boxPadding > 0) {
+            $box = [
+                $box[0] - $boxPadding,
+                $box[1] - $boxPadding,
+                $box[2] + $boxPadding,
+                $box[3] + $boxPadding,
+            ];
+        }
+
+        return $this->makeBoxIntegers([
+            $box[0], // left
+            $box[1], // top
+            $box[2] - $box[0], // width
+            $box[3] - $box[1], // height
+        ]);
+    }
+
+    /**
+     * Modify a bounding box so it adheres to the aspect ratio given by width and height.
+     */
+    public function ensureBoxAspectRatio(array $box, int $aspectWidth, int $aspectHeight): array
+    {
+        [$left, $top, $width, $height] = $box;
+
+        // Ensure the minimum width so the annotation patch is not "zoomed in".
+        if ($width < $aspectWidth) {
+            $left -= ($aspectWidth - $width) / 2.0;
+            $width = $aspectWidth;
+        }
+
+        // Ensure the minimum height so the annotation patch is not "zoomed in".
+        if ($height < $aspectHeight) {
+            $top -= ($aspectHeight - $height) / 2.0;
+            $height = $aspectHeight;
+        }
+
+        $widthRatio = $width / $aspectWidth;
+        $heightRatio = $height / $aspectHeight;
+
+        // Increase the size of the patch so its aspect ratio is the same than the
+        // ratio of the given dimensions.
+        if ($widthRatio > $heightRatio) {
+            $newHeight = round($aspectHeight * $widthRatio);
+            $top -= round(($newHeight - $height) / 2);
+            $height = $newHeight;
+        } else {
+            $newWidth = round($aspectWidth * $heightRatio);
+            $left -= round(($newWidth - $width) / 2);
+            $width = $newWidth;
+        }
+
+        return $this->makeBoxIntegers([$left, $top, $width, $height]);
+    }
+
+    /**
+     * Adjust the position and size of the box so it is contained in a box with the given
+     * dimensions.
+     */
+    public function makeBoxContained(array $box, ?int $maxWidth, ?int $maxHeight)
+    {
+        [$left, $top, $width, $height] = $box;
+
+        if (!is_null($maxWidth)) {
+            $left = min($maxWidth - $width, $left);
+            // Adjust dimensions of rect if it is larger than the image.
+            $width = min($maxWidth, $width);
+        }
+
+        if (!is_null($maxHeight)) {
+            $top = min($maxHeight - $height, $top);
+            // Adjust dimensions of rect if it is larger than the image.
+            $height = min($maxHeight, $height);
+        }
+
+        // Order of min max is importans so the point gets no negative coordinates.
+        $left = max(0, $left);
+        $top = max(0, $top);
+
+        return [$left, $top, $width, $height];
+    }
+
+    /**
+     * Get the bounding box of a point annotation.
+     */
+    protected function getPointBoundingBox(array $points, int $padding): array
+    {
+        return [
+            $points[0] - $padding,
+            $points[1] - $padding,
+            $points[0] + $padding,
+            $points[1] + $padding,
+        ];
+    }
+
+    /**
+     * Get the bounding box of a circle annotation.
+     */
+    protected function getCircleBoundingBox(array $points): array
+    {
+        return [
+            $points[0] - $points[2],
+            $points[1] - $points[2],
+            $points[0] + $points[2],
+            $points[1] + $points[2],
+        ];
+    }
+
+    /**
+     * Get the bounding box of an annotation that is no point, circle or whole frame.
+     */
+    protected function getPolygonBoundingBox(array $points): array
+    {
+        $minX = INF;
+        $minY = INF;
+        $maxX = -INF;
+        $maxY = -INF;
+
+        for ($i = 0; $i < count($points); $i += 2) {
+            $minX = min($minX, $points[$i]);
+            $minY = min($minY, $points[$i + 1]);
+            $maxX = max($maxX, $points[$i]);
+            $maxY = max($maxY, $points[$i + 1]);
+        }
+
+        return [$minX, $minY, $maxX, $maxY];
+    }
+
+    /**
+     * Round and cast box values to int.
+     */
+    protected function makeBoxIntegers(array $box): array
+    {
+        return array_map(fn ($v) => intval(round($v)), $box);
+    }
+
+    /**
+     * Generate the input for the python script.
+     *
+     * @param array $files VolumeFile instances of the files to which the annotations
+     * belong.
+     * @param array $paths Paths of locally cached files.
+     * @param \Illuminate\Support\Collection $annotations Annotations grouped by their
+     * file ID (e.g. image_id).
+     */
+    protected function generateInput(array $files, array $paths, Collection $annotations): array
+    {
+        $input = [];
+
+        foreach ($files as $index => $file) {
+            $path = $paths[$index];
+            $fileAnnotations = $annotations[$file->id];
+            $boxes = $this->generateFileInput($file, $fileAnnotations);
+
+            if (!empty($boxes)) {
+                $input[$path] = $boxes;
+            }
+        }
+
+        return $input;
+    }
+
+    protected function generateFileInput(VolumeFile $file, Collection $annotations): array
+    {
+        $boxes = [];
+        foreach ($annotations as $a) {
+            if ($a->shape_id === Shape::wholeFrameId()) {
+                $box = [0, 0, $file->width ?: 0, $file->height ?: 0];
+            } else {
+                $points = $a->getPoints();
+                if (($a instanceof VideoAnnotation) && !empty($points)) {
+                    $points = $points[0];
+                }
+                $box = $this->getAnnotationBoundingBox($points, $a->getShape(), self::POINT_PADDING);
+                $box = $this->makeBoxContained($box, $file->width, $file->height);
+            }
+
+            $zeroSize = $box[2] === 0 && $box[3] === 0;
+
+            if (!$zeroSize) {
+                // Convert width and height to "right" and "bottom" coordinates.
+                $box[2] = $box[0] + $box[2];
+                $box[3] = $box[1] + $box[3];
+
+                $boxes[$a->id] = $box;
+            }
+        }
+
+        return $boxes;
+    }
+
+    /**
+     * Run the Python command.
+     *
+     * @param string $command
+     */
+    protected function python(string $inputPath, string $outputPath)
+    {
+        $python = config('largo.python');
+        $script = config('largo.extract_features_script');
+        $result = Process::forever()
+            ->env(['TORCH_HOME' => config('largo.torch_hub_path')])
+            ->run("{$python} -u {$script} {$inputPath} {$outputPath}")
+            ->throw();
+    }
+
+    /**
+     * Generator to read the output CSV row by row.
+     */
+    protected function readOutputCsv(string $path): \Generator
+    {
+        $file = new SplFileObject($path);
+        while (!$file->eof()) {
+            $csv = $file->fgetcsv();
+            if (count($csv) === 2) {
+                yield $csv;
+            }
+        }
+    }
+}
diff --git a/src/Jobs/GenerateImageAnnotationPatch.php b/src/Jobs/GenerateImageAnnotationPatch.php
deleted file mode 100644
index 2c456330..00000000
--- a/src/Jobs/GenerateImageAnnotationPatch.php
+++ /dev/null
@@ -1,44 +0,0 @@
-<?php
-
-namespace Biigle\Modules\Largo\Jobs;
-
-use Biigle\Shape;
-use Biigle\VolumeFile;
-use Exception;
-use FileCache;
-use Storage;
-use VipsImage;
-
-class GenerateImageAnnotationPatch extends GenerateAnnotationPatch
-{
-    /**
-     * Handle a single image.
-     *
-     * @param VolumeFile $file
-     * @param string $path Path to the cached image file.
-     */
-    public function handleFile(VolumeFile $file, $path)
-    {
-        // Do not get the path in the constructor because that would require fetching all
-        // the images of the annotations. This would be really slow when lots of
-        // annotation patchs should be generated.
-        $targetPath = $this->getTargetPath($this->annotation);
-        $image = $this->getVipsImage($path);
-
-        $buffer = $this->getAnnotationPatch($image, $this->annotation->getPoints(), $this->annotation->getShape());
-
-        Storage::disk($this->targetDisk)->put($targetPath, $buffer);
-    }
-
-    /**
-     * Get the vips image instance.
-     *
-     * @param string $path
-     *
-     * @return \Jcupitt\Vips\Image
-     */
-    protected function getVipsImage($path)
-    {
-        return VipsImage::newFromFile($path, ['access' => 'sequential']);
-    }
-}
diff --git a/src/Jobs/GenerateVideoAnnotationPatch.php b/src/Jobs/GenerateVideoAnnotationPatch.php
deleted file mode 100644
index df0ec368..00000000
--- a/src/Jobs/GenerateVideoAnnotationPatch.php
+++ /dev/null
@@ -1,62 +0,0 @@
-<?php
-
-namespace Biigle\Modules\Largo\Jobs;
-
-use Biigle\VolumeFile;
-use FFMpeg\Coordinate\TimeCode;
-use FFMpeg\FFMpeg;
-use FFMpeg\Media\Video;
-use Storage;
-use VipsImage;
-
-class GenerateVideoAnnotationPatch extends GenerateAnnotationPatch
-{
-    /**
-     * Handle a single image.
-     *
-     * @param VolumeFile $file
-     * @param string $path Path to the cached image file.
-     */
-    public function handleFile(VolumeFile $file, $path)
-    {
-        if (count($this->annotation->frames) === 0) {
-            // Expect the unexpected.
-            return;
-        }
-
-        $points = $this->annotation->points[0] ?? null;
-        $targetPath = $this->getTargetPath($this->annotation);
-
-        $video = $this->getVideo($path);
-        $frame = $this->getVideoFrame($video, $this->annotation->frames[0]);
-        $buffer = $this->getAnnotationPatch($frame, $points, $this->annotation->shape);
-        Storage::disk($this->targetDisk)->put($targetPath, $buffer);
-    }
-
-    /**
-     * Get the FFMpeg video instance.
-     *
-     * @param string $path
-     *
-     * @return Video
-     */
-    protected function getVideo($path)
-    {
-        return FFMpeg::create()->open($path);
-    }
-
-    /**
-     * Get a video frame from a specific time as VipsImage object.
-     *
-     * @param Video $video
-     * @param float $time
-     *
-     * @return \Jcupitt\Vips\Image
-     */
-    protected function getVideoFrame(Video $video, $time)
-    {
-        $buffer = $video->frame(TimeCode::fromSeconds($time))->save(null, false, true);
-
-        return VipsImage::newFromBuffer($buffer);
-    }
-}
diff --git a/src/Jobs/InitializeFeatureVectorChunk.php b/src/Jobs/InitializeFeatureVectorChunk.php
new file mode 100644
index 00000000..1e749934
--- /dev/null
+++ b/src/Jobs/InitializeFeatureVectorChunk.php
@@ -0,0 +1,188 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Biigle\Annotation;
+use Biigle\ImageAnnotation;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\Shape;
+use Biigle\VideoAnnotation;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+
+class InitializeFeatureVectorChunk extends GenerateFeatureVectors
+{
+    use InteractsWithQueue;
+
+    public function __construct(
+        public array $imageAnnotationIds,
+        public array $videoAnnotationIds
+    )
+    {
+        //
+    }
+
+    public function handle()
+    {
+        $skipIds = ImageAnnotationLabelFeatureVector::whereIn('annotation_id', $this->imageAnnotationIds)
+            ->distinct()
+            ->pluck('annotation_id')
+            ->toArray();
+
+        $ids = array_diff($this->imageAnnotationIds, $skipIds);
+        $models = ImageAnnotation::whereIn('id', $ids)
+            ->with('file', 'labels.label', 'shape')
+            ->get()
+            ->keyBy('id');
+
+        // Chunk to avoid maximum insert parameter limit.
+        $this->getInsertData($models)->chunk(10000)->each(fn ($chunk) =>
+            ImageAnnotationLabelFeatureVector::insert($chunk->toArray())
+        );
+
+        $skipIds = VideoAnnotationLabelFeatureVector::whereIn('annotation_id', $this->videoAnnotationIds)
+            ->distinct()
+            ->pluck('annotation_id')
+            ->toArray();
+
+        $ids = array_diff($this->videoAnnotationIds, $skipIds);
+        $models = VideoAnnotation::whereIn('id', $ids)
+            ->with('file', 'labels.label')
+            ->get()
+            ->keyBy('id');
+
+        // Chunk to avoid maximum insert parameter limit.
+        $this->getInsertData($models)->chunk(10000)->each(fn ($chunk) =>
+            VideoAnnotationLabelFeatureVector::insert($chunk->toArray())
+        );
+    }
+
+    /**
+     * Get the array to insert new feature vector models into the DB.
+     */
+    public function getInsertData(Collection $models): Collection
+    {
+        $insert = collect([]);
+
+        $outputPath = tempnam(sys_get_temp_dir(), 'largo_feature_vector_output');
+
+        try {
+            foreach ($this->getFeatureVectors($models, $outputPath) as $row) {
+                $annotation = $models->get($row[0]);
+                $vector = $row[1];
+                $i = $annotation->labels
+                    ->map(fn ($annotationLabel) => [
+                        'id' => $annotationLabel->id,
+                        'annotation_id' => $annotation->id,
+                        'label_id' => $annotationLabel->label_id,
+                        'label_tree_id' => $annotationLabel->label->label_tree_id,
+                        'volume_id' => $annotation->file->volume_id,
+                        'vector' => $vector,
+                    ]);
+                $insert = $insert->concat($i);
+            }
+        } finally {
+            File::delete($outputPath);
+        }
+
+        return $insert;
+    }
+
+    /**
+     * Generate feature vectors from the thumbnails of many annotations.
+     *
+     * @param Collection $models Annotation models
+     * @param string $outputPath Path to stroe the CSV file with feature vectors
+     */
+    public function getFeatureVectors(Collection $models, string $outputPath): \Generator
+    {
+        if ($models->isEmpty()) {
+            return (fn () => yield from [])();
+        }
+
+        $disk = Storage::disk(config('largo.patch_storage_disk'));
+        $rect = [0, 0, config('thumbnails.width'), config('thumbnails.height')];
+        $paths = [];
+
+        try {
+            $input = [];
+            foreach ($models as $a) {
+                $srcPath = ProcessAnnotatedFile::getTargetPath($a);
+                $tmpPath = tempnam(sys_get_temp_dir(), '');
+
+                $thumbnail = $disk->get($srcPath);
+                if (is_null($thumbnail)) {
+                    continue;
+                }
+
+                File::put($tmpPath, $thumbnail);
+                $paths[] = $tmpPath;
+
+                // Compute the annotation outlines in "thumbnail space".
+                $padding = config('largo.patch_padding');
+                $pointPadding = config('largo.point_padding');
+                $thumbWidth = config('thumbnails.width');
+                $thumbHeight = config('thumbnails.height');
+
+                if ($a->shape_id === Shape::wholeFrameId()) {
+                    $input[$tmpPath] = [$a->id => [0, 0, $thumbWidth, $thumbHeight]];
+                    continue;
+                }
+
+                if ($a instanceof VideoAnnotation) {
+                    $points = $a->points[0];
+                } else {
+                    $points = $a->points;
+                }
+
+                // First determine the box of the thumbnail to get the position and scale
+                // factor.
+                $box = $this->getAnnotationBoundingBox($points, $a->shape, $pointPadding, $padding);
+                $box = $this->ensureBoxAspectRatio($box, $thumbWidth, $thumbHeight);
+                $box = $this->makeBoxContained($box, $a->file->width, $a->file->height);
+                $x = $box[0];
+                $y = $box[1];
+                $scale = floatval($thumbWidth) / $box[2];
+
+                // The get the box of the annotation.
+                $box = $this->getAnnotationBoundingBox($points, $a->shape, $pointPadding, $padding);
+                $box = $this->makeBoxContained($box, $a->file->width, $a->file->height);
+                // Make coordinates relative to thumbnail box.
+                $box[0] -= $x;
+                $box[1] -= $y;
+                // Than scale coordinates to "thumbnail space".
+                $box = array_map(fn ($v) => $v * $scale, $box);
+                $box = $this->makeBoxIntegers($box);
+
+                $zeroSize = $box[2] === 0 && $box[3] === 0;
+
+                if ($zeroSize) {
+                    continue;
+                }
+                // Convert width and height to "right" and "bottom" coordinates.
+                $box[2] = $box[0] + $box[2];
+                $box[3] = $box[1] + $box[3];
+
+                $input[$tmpPath] = [$a->id => $box];
+            }
+
+            if (empty($input)) {
+                return (fn () => yield from [])();
+            }
+
+            $inputPath = tempnam(sys_get_temp_dir(), 'largo_feature_vector_input');
+
+            File::put($inputPath, json_encode($input));
+            $paths[] = $inputPath;
+
+            $this->python($inputPath, $outputPath);
+        } finally {
+            File::delete($paths);
+        }
+
+        return $this->readOutputCsv($outputPath);
+    }
+}
diff --git a/src/Jobs/ProcessAnnotatedFile.php b/src/Jobs/ProcessAnnotatedFile.php
new file mode 100644
index 00000000..200fefd0
--- /dev/null
+++ b/src/Jobs/ProcessAnnotatedFile.php
@@ -0,0 +1,229 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Biigle\Contracts\Annotation;
+use Biigle\FileCache\Exceptions\FileLockedException;
+use Biigle\Modules\Largo\Traits\ComputesAnnotationBox;
+use Biigle\Shape;
+use Biigle\VideoAnnotation;
+use Biigle\VolumeFile;
+use Exception;
+use FileCache;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Log;
+use Jcupitt\Vips\Image;
+use Str;
+
+abstract class ProcessAnnotatedFile extends GenerateFeatureVectors
+{
+    use SerializesModels, InteractsWithQueue;
+
+    /**
+     * The number of times the job may be attempted.
+     *
+     * @var int
+     */
+    public $tries = 3;
+
+    /**
+     * Ignore this job if the annotation does not exist any more.
+     *
+     * @var bool
+     */
+    protected $deleteWhenMissingModels = true;
+
+    /**
+     * Create a new job instance.
+     *
+     * @param VolumeFile $file The file to process.
+     * @param array $only If filled with annotation IDs belonging to the
+     * file, only the annotations will be processed.
+     * @param bool|boolean $skipPatches Disable generation of annotation patches.
+     * @param bool|boolean $skipFeatureVectors Disable generation of annotation
+     * feature vectors.
+     * @param ?string $targetDisk The storage disk to store annotation patches to (
+     * default is the configured `largo.patch_storage_disk`).
+     */
+    public function __construct(
+        public VolumeFile $file,
+        public array $only = [],
+        public bool $skipPatches = false,
+        public bool $skipFeatureVectors = false,
+        public ?string $targetDisk = null
+    )
+    {
+        $this->targetDisk = $targetDisk ?: config('largo.patch_storage_disk');
+    }
+
+    /**
+     * Assemble the target path for an annotation patch.
+     *
+     * @param Annotation $annotation
+     *
+     * @return string
+     */
+    public static function getTargetPath(Annotation $annotation): string
+    {
+        $prefix = fragment_uuid_path($annotation->getFile()->uuid);
+        $format = config('largo.patch_format');
+
+        return match($annotation::class) {
+            // Add "v-" to make absolutely sure that no collisions (same UUID, same ID)
+            // occur because patches are stored on the same disk.
+            VideoAnnotation::class => "{$prefix}/v-{$annotation->id}.{$format}",
+            // This is the old patch storage scheme, so we don't add "i-" for backwards
+            // compatibility.
+            default => "{$prefix}/{$annotation->id}.{$format}",
+        };
+    }
+
+    /**
+     * Execute the job.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        try {
+            FileCache::get($this->file, [$this, 'handleFile'], true);
+        } catch (FileLockedException $e) {
+            // Retry this job without increasing the attempts if the file is currently
+            // written by another worker. This worker can process other jobs in the
+            // meantime.
+            // See: https://github.com/laravel/ideas/issues/735
+            static::dispatch(
+                    $this->file,
+                    $this->only,
+                    $this->skipPatches,
+                    $this->skipFeatureVectors,
+                    $this->targetDisk
+                )
+                ->onConnection($this->connection)
+                ->onQueue($this->queue)
+                ->delay(60);
+        } catch (Exception $e) {
+            if ($this->shouldRetryAfterException($e)) {
+                // Exponential backoff for retry after 10 and then 20 minutes.
+                $this->release($this->attempts() * 600);
+            } else {
+                $class = get_class($this->file);
+                Log::warning("Could not process annotated {$class} {$this->file->id}: {$e->getMessage()}", ['exception' => $e]);
+            }
+        }
+    }
+
+    /**
+     * Handle a single file.
+     *
+     * @param VolumeFile $file
+     * @param string $path Path to the cached file.
+     */
+    abstract public function handleFile(VolumeFile $file, $path);
+
+    /**
+     * Determine if this job should retry instead of fail after an exception
+     *
+     * @param Exception $e
+     *
+     * @return bool
+     */
+    protected function shouldRetryAfterException(Exception $e)
+    {
+        $message = $e->getMessage();
+        return $this->attempts() < $this->tries && (
+            // The remote source might be available again after a while.
+            Str::contains($message, 'The source resource could not be established') ||
+            // This error presumably occurs due to worker concurrency.
+            Str::contains($message, 'Impossible to create the root directory')
+        );
+    }
+
+    /**
+     * Get the annotation patch as buffer.
+     *
+     * @param Image $image
+     * @param array $points
+     * @param Shape $shape
+     *
+     * @return string
+     */
+    protected function getAnnotationPatch($image, $points, $shape)
+    {
+        $thumbWidth = config('thumbnails.width');
+        $thumbHeight = config('thumbnails.height');
+
+        if ($shape->id === Shape::wholeFrameId()) {
+            $image = $image->resize(floatval($thumbWidth) / $image->width);
+        } else {
+            $padding = config('largo.patch_padding');
+            $pointPadding = config('largo.point_padding');
+
+            $box = $this->getAnnotationBoundingBox($points, $shape, $pointPadding, $padding);
+            $box = $this->ensureBoxAspectRatio($box, $thumbWidth, $thumbHeight);
+            $box = $this->makeBoxContained($box, $image->width, $image->height);
+
+            $image = $image->crop(...$box)->resize(floatval($thumbWidth) / $box[2]);
+        }
+
+        return $image->writeToBuffer('.'.config('largo.patch_format'), [
+            'Q' => 85,
+            'strip' => true,
+        ]);
+    }
+
+    /**
+     * Generates feature vectors for the specified annotations belonging to the file of
+     * this job. This method either creates new feature vector models or updates the
+     * existing ones for the annotations.
+     *
+     * @param Collection $annotation
+     * @param array|string $filePath If a string, a file path to the local image to use for feature vector generation. If an array, a map of annotation IDs to a local image file path.
+     */
+    protected function generateFeatureVectors(Collection $annotations, array|string $filePath): void
+    {
+        $boxes = $this->generateFileInput($this->file, $annotations);
+
+        if (empty($boxes)) {
+            return;
+        }
+
+        $inputPath = tempnam(sys_get_temp_dir(), 'largo_feature_vector_input');
+        $outputPath = tempnam(sys_get_temp_dir(), 'largo_feature_vector_output');
+
+        try {
+            if (is_array($filePath)) {
+                $input = [];
+                foreach ($boxes as $id => $box) {
+                    $path = $filePath[$id];
+                    if (array_key_exists($path, $input)) {
+                        $input[$path][$id] = $box;
+                    } else {
+                        $input[$path] = [$id => $box];
+                    }
+                }
+            } else {
+                $input = [$filePath => $boxes];
+            }
+
+            File::put($inputPath, json_encode($input));
+            $this->python($inputPath, $outputPath);
+            $output = $this->readOutputCsv($outputPath);
+            $this->updateOrCreateFeatureVectors($annotations, $output);
+        } finally {
+            File::delete($outputPath);
+            File::delete($inputPath);
+        }
+    }
+
+    /**
+     * Create the feature vectors based on the Python script output.
+     */
+    abstract protected function updateOrCreateFeatureVectors(Collection $annotations, \Generator $output): void;
+}
diff --git a/src/Jobs/ProcessAnnotatedImage.php b/src/Jobs/ProcessAnnotatedImage.php
new file mode 100644
index 00000000..c2efc916
--- /dev/null
+++ b/src/Jobs/ProcessAnnotatedImage.php
@@ -0,0 +1,101 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Biigle\ImageAnnotation;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Shape;
+use Biigle\VolumeFile;
+use Exception;
+use FileCache;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+use VipsImage;
+
+class ProcessAnnotatedImage extends ProcessAnnotatedFile
+{
+    /**
+     * Handle a single image.
+     *
+     * @param VolumeFile $file
+     * @param string $path Path to the cached image file.
+     */
+    public function handleFile(VolumeFile $file, $path)
+    {
+        if (!$this->skipPatches) {
+            $image = $this->getVipsImage($path);
+        } else {
+            $image = null;
+        }
+
+        $this->getAnnotationQuery($file)
+            ->when(!empty($this->only), fn ($q) => $q->whereIn('id', $this->only))
+            ->chunkById(1000, function ($annotations) use ($image, $path) {
+                if (!$this->skipPatches) {
+                    $annotations->each(function ($a) use ($image) {
+                        $buffer = $this->getAnnotationPatch(
+                            $image,
+                            $a->getPoints(),
+                            $a->getShape()
+                        );
+                        $targetPath = self::getTargetPath($a);
+                        Storage::disk($this->targetDisk)->put($targetPath, $buffer);
+                    });
+                }
+
+                if (!$this->skipFeatureVectors) {
+                    $this->generateFeatureVectors($annotations, $path);
+                }
+            });
+    }
+
+    /**
+     * Create the feature vectors based on the Python script output.
+     */
+    protected function updateOrCreateFeatureVectors(Collection $annotations, \Generator $output): void
+    {
+        $annotations = $annotations->load('labels.label')->keyBy('id');
+        foreach ($output as $row) {
+            $annotation = $annotations->get($row[0]);
+
+            foreach ($annotation->labels as $al) {
+                ImageAnnotationLabelFeatureVector::updateOrCreate(
+                    ['id' => $al->id],
+                    [
+                        'annotation_id' => $annotation->id,
+                        'label_id' => $al->label_id,
+                        'label_tree_id' => $al->label->label_tree_id,
+                        'volume_id' => $this->file->volume_id,
+                        'vector' => $row[1],
+                    ]
+                );
+            }
+        }
+    }
+
+    /**
+     * Get the vips image instance.
+     *
+     * @param string $path
+     *
+     * @return \Jcupitt\Vips\Image
+     */
+    protected function getVipsImage($path)
+    {
+        // Must not use sequential access because multiple patches could be extracted.
+        return VipsImage::newFromFile($path);
+    }
+
+    /**
+     * Get the query builder for the annotations.
+     *
+     * This can be used to extend this class and process different models than image
+     * annotations.
+     */
+    protected function getAnnotationQuery(VolumeFile $file): Builder
+    {
+        return ImageAnnotation::where('image_id', $file->id);
+    }
+}
diff --git a/src/Jobs/ProcessAnnotatedVideo.php b/src/Jobs/ProcessAnnotatedVideo.php
new file mode 100644
index 00000000..837fb19b
--- /dev/null
+++ b/src/Jobs/ProcessAnnotatedVideo.php
@@ -0,0 +1,123 @@
+<?php
+
+namespace Biigle\Modules\Largo\Jobs;
+
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\VideoAnnotation;
+use Biigle\VolumeFile;
+use FFMpeg\Coordinate\TimeCode;
+use FFMpeg\FFMpeg;
+use FFMpeg\Media\Video;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+use VipsImage;
+
+class ProcessAnnotatedVideo extends ProcessAnnotatedFile
+{
+    /**
+     * Handle a single image.
+     *
+     * @param VolumeFile $file
+     * @param string $path Path to the cached image file.
+     */
+    public function handleFile(VolumeFile $file, $path)
+    {
+        $video = $this->getVideo($path);
+
+        VideoAnnotation::where('video_id', $file->id)
+            ->when(!empty($this->only), fn ($q) => $q->whereIn('id', $this->only))
+            ->chunkById(1000, fn ($a) => $this->processAnnotationChunk($a, $video));
+    }
+
+    /**
+     * Process a chunk of annotations of this job's file.
+     */
+    protected function processAnnotationChunk(Collection $annotations, Video $video): void
+    {
+        $frameFiles = [];
+
+        try {
+            foreach ($annotations as $a) {
+                $points = $a->points[0] ?? null;
+                $frame = $a->frames[0];
+                $videoFrame = $this->getVideoFrame($video, $frame);
+
+                if (!$this->skipPatches) {
+                    $buffer = $this->getAnnotationPatch($videoFrame, $points, $a->shape);
+                    $targetPath = self::getTargetPath($a);
+                    Storage::disk($this->targetDisk)->put($targetPath, $buffer);
+                }
+
+                if (!$this->skipFeatureVectors && !array_key_exists($frame, $frameFiles)) {
+                    $framePath = tempnam(sys_get_temp_dir(), 'largo_video_frame').'.png';
+                    $videoFrame->writeToFile($framePath);
+                    $frameFiles[$frame] = $framePath;
+                }
+            }
+
+            if (!$this->skipFeatureVectors) {
+                $annotationFrames = $annotations->mapWithKeys(
+                        fn ($a) => [$a->id => $frameFiles[$a->frames[0]]]
+                    )
+                    ->toArray();
+
+                $this->generateFeatureVectors($annotations, $annotationFrames);
+            }
+        } finally {
+            File::delete(array_values($frameFiles));
+        }
+    }
+
+    /**
+     * Create the feature vectors based on the Python script output.
+     */
+    protected function updateOrCreateFeatureVectors(Collection $annotations, \Generator $output): void
+    {
+        $annotations = $annotations->load('labels.label')->keyBy('id');
+        foreach ($output as $row) {
+            $annotation = $annotations->get($row[0]);
+
+            foreach ($annotation->labels as $al) {
+                VideoAnnotationLabelFeatureVector::updateOrCreate(
+                    ['id' => $al->id],
+                    [
+                        'annotation_id' => $annotation->id,
+                        'label_id' => $al->label_id,
+                        'label_tree_id' => $al->label->label_tree_id,
+                        'volume_id' => $this->file->volume_id,
+                        'vector' => $row[1],
+                    ]
+                );
+            }
+        }
+    }
+
+    /**
+     * Get the FFMpeg video instance.
+     *
+     * @param string $path
+     *
+     * @return Video
+     */
+    protected function getVideo($path)
+    {
+        return FFMpeg::create()->open($path);
+    }
+
+    /**
+     * Get a video frame from a specific time as VipsImage object.
+     *
+     * @param Video $video
+     * @param float $time
+     *
+     * @return \Jcupitt\Vips\Video
+     */
+    protected function getVideoFrame(Video $video, $time)
+    {
+        $buffer = $video->frame(TimeCode::fromSeconds($time))->save(null, false, true);
+
+        return VipsImage::newFromBuffer($buffer);
+    }
+}
diff --git a/src/LargoServiceProvider.php b/src/LargoServiceProvider.php
index 5d86ace7..99975c44 100644
--- a/src/LargoServiceProvider.php
+++ b/src/LargoServiceProvider.php
@@ -2,9 +2,11 @@
 
 namespace Biigle\Modules\Largo;
 
+use Biigle\Events\AnnotationLabelAttached;
 use Biigle\Events\ImagesDeleted;
 use Biigle\Events\VideosDeleted;
 use Biigle\ImageAnnotation;
+use Biigle\Modules\Largo\Listeners\AttachLabelListener;
 use Biigle\Modules\Largo\Listeners\ImagesCleanupListener;
 use Biigle\Modules\Largo\Listeners\VideosCleanupListener;
 use Biigle\Modules\Largo\Observers\ImageAnnotationObserver;
@@ -28,6 +30,7 @@ class LargoServiceProvider extends ServiceProvider
     public function boot(Modules $modules, Router $router)
     {
         $this->loadViewsFrom(__DIR__.'/resources/views', 'largo');
+        $this->loadMigrationsFrom(__DIR__.'/Database/migrations');
 
         $this->publishes([
             __DIR__.'/public/assets' => public_path('vendor/largo'),
@@ -48,6 +51,7 @@ public function boot(Modules $modules, Router $router)
         VideoAnnotation::observe(new VideoAnnotationObserver);
         Event::listen(ImagesDeleted::class, ImagesCleanupListener::class);
         Event::listen(VideosDeleted::class, VideosCleanupListener::class);
+        Event::listen(AnnotationLabelAttached::class, AttachLabelListener::class);
 
         $modules->register('largo', [
             'viewMixins' => [
@@ -95,6 +99,11 @@ public function register()
             return new \Biigle\Modules\Largo\Console\Commands\MigratePatchStorage;
         });
         $this->commands('command.largo.migrate-patch-storage');
+
+        $this->app->singleton('command.largo.initialize-feature-vectors', function ($app) {
+            return new \Biigle\Modules\Largo\Console\Commands\InitializeFeatureVectors;
+        });
+        $this->commands('command.largo.initialize-feature-vectors');
     }
 
     /**
@@ -109,6 +118,7 @@ public function provides()
             'command.largo.config',
             'command.largo.generate-missing',
             'command.largo.migrate-patch-storage',
+            'command.largo.initialize-feature-vectors',
         ];
     }
 }
diff --git a/src/Listeners/AttachLabelListener.php b/src/Listeners/AttachLabelListener.php
new file mode 100644
index 00000000..2128ad8b
--- /dev/null
+++ b/src/Listeners/AttachLabelListener.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Biigle\Modules\Largo\Listeners;
+
+use Biigle\Events\AnnotationLabelAttached;
+use Biigle\ImageAnnotationLabel;
+use Biigle\Modules\Largo\Jobs\CopyImageAnnotationFeatureVector;
+use Biigle\Modules\Largo\Jobs\CopyVideoAnnotationFeatureVector;
+
+class AttachLabelListener
+{
+    public function handle(AnnotationLabelAttached $event)
+    {
+        if ($event->annotationLabel instanceof ImageAnnotationLabel) {
+            CopyImageAnnotationFeatureVector::dispatch($event->annotationLabel);
+        } else {
+            CopyVideoAnnotationFeatureVector::dispatch($event->annotationLabel);
+        }
+    }
+}
diff --git a/src/Observers/ImageAnnotationObserver.php b/src/Observers/ImageAnnotationObserver.php
index c61d4687..7e0ccc4a 100644
--- a/src/Observers/ImageAnnotationObserver.php
+++ b/src/Observers/ImageAnnotationObserver.php
@@ -3,7 +3,7 @@
 namespace Biigle\Modules\Largo\Observers;
 
 use Biigle\Annotation;
-use Biigle\Modules\Largo\Jobs\GenerateImageAnnotationPatch;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedImage;
 use Biigle\Modules\Largo\Jobs\RemoveImageAnnotationPatches;
 
 class ImageAnnotationObserver extends AnnotationObserver
@@ -11,9 +11,9 @@ class ImageAnnotationObserver extends AnnotationObserver
     /**
      * {@inheritdoc}
      */
-    protected function getSavedDispatch(Annotation $annotation)
+    protected function getSavedDispatch(Annotation $a)
     {
-        return GenerateImageAnnotationPatch::dispatch($annotation);
+        return ProcessAnnotatedImage::dispatch($a->image, only: [$a->id]);
     }
 
     /**
diff --git a/src/Observers/VideoAnnotationObserver.php b/src/Observers/VideoAnnotationObserver.php
index 8e37faae..d26d053a 100644
--- a/src/Observers/VideoAnnotationObserver.php
+++ b/src/Observers/VideoAnnotationObserver.php
@@ -3,7 +3,7 @@
 namespace Biigle\Modules\Largo\Observers;
 
 use Biigle\Annotation;
-use Biigle\Modules\Largo\Jobs\GenerateVideoAnnotationPatch;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedVideo;
 use Biigle\Modules\Largo\Jobs\RemoveVideoAnnotationPatches;
 
 class VideoAnnotationObserver extends AnnotationObserver
@@ -11,9 +11,9 @@ class VideoAnnotationObserver extends AnnotationObserver
     /**
      * {@inheritdoc}
      */
-    protected function getSavedDispatch(Annotation $annotation)
+    protected function getSavedDispatch(Annotation $a)
     {
-        return GenerateVideoAnnotationPatch::dispatch($annotation);
+        return ProcessAnnotatedVideo::dispatch($a->video, only: [$a->id]);
     }
 
     /**
diff --git a/src/VideoAnnotationLabelFeatureVector.php b/src/VideoAnnotationLabelFeatureVector.php
new file mode 100644
index 00000000..4509501d
--- /dev/null
+++ b/src/VideoAnnotationLabelFeatureVector.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace Biigle\Modules\Largo;
+
+use Biigle\Modules\Largo\Database\Factories\VideoAnnotationLabelFeatureVectorFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Pgvector\Laravel\Vector;
+
+class VideoAnnotationLabelFeatureVector extends Model
+{
+    use HasFactory;
+
+    /**
+     * Don't maintain timestamps for this model.
+     *
+     * @var bool
+     */
+    public $timestamps = false;
+
+    /**
+     * The attributes that should be casted to native types.
+     *
+     * @var array
+     */
+    protected $casts = [
+        'vector' => Vector::class,
+    ];
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var array
+     */
+    protected $fillable = [
+        'id',
+        'annotation_id',
+        'label_id',
+        'label_tree_id',
+        'volume_id',
+        'vector',
+    ];
+
+    /**
+     * Create a new factory instance for the model.
+     *
+     * @return \Illuminate\Database\Eloquent\Factories\Factory
+     */
+    protected static function newFactory()
+    {
+        return VideoAnnotationLabelFeatureVectorFactory::new();
+    }
+}
diff --git a/src/config/largo.php b/src/config/largo.php
index 35caed40..fea01eed 100644
--- a/src/config/largo.php
+++ b/src/config/largo.php
@@ -39,4 +39,19 @@
      | Specifies which queue should be used for the job to save a Largo session.
      */
     'apply_session_queue' => env('LARGO_APPLY_SESSION_QUEUE', 'default'),
+
+    /*
+    | Path to the extract features script.
+    */
+    'extract_features_script' => __DIR__.'/../resources/scripts/ExtractFeatures.py',
+
+    /*
+    | Path to the directory to use as Torch Hub cache.
+    */
+    'torch_hub_path' => storage_path('largo_cache'),
+
+    /*
+    | Path to the Python executable.
+    */
+    'python' => env('LARGO_PYTHON', '/usr/bin/python3'),
 ];
diff --git a/src/public/assets/scripts/main.js b/src/public/assets/scripts/main.js
index b3209b3d..4a7c7e63 100644
--- a/src/public/assets/scripts/main.js
+++ b/src/public/assets/scripts/main.js
@@ -1 +1 @@
-(()=>{"use strict";var e,t={732:()=>{var e="imageAnnotation",t="videoAnnotation";function n(e,t,n,i,s,o,a,l){var r,u="function"==typeof e?e.options:e;if(t&&(u.render=t,u.staticRenderFns=n,u._compiled=!0),i&&(u.functional=!0),o&&(u._scopeId="data-v-"+o),a?(r=function(e){(e=e||this.$vnode&&this.$vnode.ssrContext||this.parent&&this.parent.$vnode&&this.parent.$vnode.ssrContext)||"undefined"==typeof __VUE_SSR_CONTEXT__||(e=__VUE_SSR_CONTEXT__),s&&s.call(this,e),e&&e._registeredComponents&&e._registeredComponents.add(a)},u._ssrRegister=r):s&&(r=l?function(){s.call(this,(u.functional?this.parent:this).$root.$options.shadowRoot)}:s),r)if(u.functional){u._injectStyles=r;var d=u.render;u.render=function(e,t){return r.call(t),d(e,t)}}else{var h=u.beforeCreate;u.beforeCreate=h?[].concat(h,r):[r]}return{exports:e,options:u}}const i=n({computed:{id:function(){return this.image.id},uuid:function(){return this.image.uuid},type:function(){return this.image.type},patchPrefix:function(){return this.uuid[0]+this.uuid[1]+"/"+this.uuid[2]+this.uuid[3]+"/"+this.uuid},urlTemplate:function(){return biigle.$require("largo.patchUrlTemplate")}},methods:{getThumbnailUrl:function(){return this.type===t?this.urlTemplate.replace(":prefix",this.patchPrefix).replace(":id","v-".concat(this.id)):this.urlTemplate.replace(":prefix",this.patchPrefix).replace(":id",this.id)}},created:function(){this.type===e?this.showAnnotationRoute=biigle.$require("largo.showImageAnnotationRoute"):this.showAnnotationRoute=biigle.$require("largo.showVideoAnnotationRoute")}},undefined,undefined,!1,null,null,null).exports;const s=n({mixins:[i],props:{_id:{type:String,required:!0},_uuid:{type:String,required:!0},label:{type:Object,required:!0},emptySrc:{type:String,required:!0},_urlTemplate:{type:String,required:!0}},data:function(){return{url:""}},computed:{title:function(){return"Example annotation for label "+this.label.name},src:function(){return this.url||this.emptySrc},image:function(){return{id:this._id,uuid:this._uuid,type:e}},urlTemplate:function(){return this._urlTemplate}},methods:{showEmptyImage:function(){this.url=""}},created:function(){this.url=this.getThumbnailUrl()}},undefined,undefined,!1,null,null,null).exports,o=Vue.resource("api/v1/volumes{/id}/largo",{},{queryImageAnnotations:{method:"GET",url:"api/v1/volumes{/id}/image-annotations/filter/label{/label_id}"},queryVideoAnnotations:{method:"GET",url:"api/v1/volumes{/id}/video-annotations/filter/label{/label_id}"},queryExampleAnnotations:{method:"GET",url:"api/v1/volumes{/id}/image-annotations/examples{/label_id}"}});var a=biigle.$require("echo"),l=biigle.$require("events"),r=biigle.$require("messages").handleErrorResponse,u=biigle.$require("volumes.components.imageGrid"),d=biigle.$require("volumes.components.imageGridImage"),h=biigle.$require("annotations.components.labelsTabPlugins"),c=biigle.$require("labelTrees.components.labelTrees"),m=biigle.$require("core.mixins.loader"),f=biigle.$require("messages"),g=biigle.$require("core.components.powerToggle"),p=biigle.$require("annotations.components.settingsTabPlugins"),b=biigle.$require("core.components.sidebar"),v=biigle.$require("core.components.sidebarTab");const w=n({mixins:[m],components:{annotationPatch:s},props:{label:{default:null},volumeId:{type:Number,required:!0},count:{type:Number,default:3}},data:function(){return{exampleLabel:null,exampleAnnotations:[],cache:{},shown:!0}},computed:{isShown:function(){return this.shown&&null!==this.label},hasExamples:function(){return this.exampleLabel&&this.exampleAnnotations&&Object.keys(this.exampleAnnotations).length>0}},methods:{parseResponse:function(e){return e.data},setExampleAnnotations:function(e){(!e[0].hasOwnProperty("annotations")||Object.keys(e[0].annotations).length<this.count)&&delete this.cache[e[1]],e[0].hasOwnProperty("label")&&e[0].label.id===e[1]||delete this.cache[e[1]],this.label&&this.label.id===e[1]&&(this.exampleAnnotations=e[0].annotations,this.exampleLabel=e[0].label)},updateShown:function(e){this.shown=e},updateExampleAnnotations:function(){this.exampleAnnotations=[],this.isShown&&(this.startLoading(),this.cache.hasOwnProperty(this.label.id)||(this.cache[this.label.id]=o.queryExampleAnnotations({id:this.volumeId,label_id:this.label.id,take:this.count}).then(this.parseResponse)),Vue.Promise.all([this.cache[this.label.id],this.label.id]).then(this.setExampleAnnotations).finally(this.finishLoading))}},watch:{label:function(){this.updateExampleAnnotations()},shown:function(){this.updateExampleAnnotations()}},created:function(){l.$on("settings.exampleAnnotations",this.updateShown)}},undefined,undefined,!1,null,null,null).exports;h&&(h.exampleAnnotations=w);const A=n({components:{powerButton:g},props:{settings:{type:Object,required:!0}},data:function(){return{isShown:!0}},methods:{hide:function(){this.isShown=!1,this.settings.set("exampleAnnotations",!1)},show:function(){this.isShown=!0,this.settings.delete("exampleAnnotations")}},watch:{isShown:function(e){l.$emit("settings.exampleAnnotations",e)}},created:function(){this.settings.has("exampleAnnotations")&&(this.isShown=this.settings.get("exampleAnnotations"))}},undefined,undefined,!1,null,null,null).exports;p&&(p.exampleAnnotations=A),biigle.$declare("largo.mixins.annotationPatch",i);var _=n({mixins:[d,i],data:function(){return{showAnnotationRoute:null}},computed:{showAnnotationLink:function(){return this.showAnnotationRoute?this.showAnnotationRoute+this.image.id:""}},created:function(){this.type===e?this.showAnnotationRoute=biigle.$require("annotationCatalog.showImageAnnotationRoute"):this.showAnnotationRoute=biigle.$require("annotationCatalog.showVideoAnnotationRoute")}},(function(){var e=this,t=e.$createElement,n=e._self._c||t;return n("figure",{staticClass:"image-grid__image image-grid__image--catalog",class:e.classObject},[e.showAnnotationLink?n("a",{attrs:{href:e.showAnnotationLink,target:"_blank",title:"Show the annotation in the annotation tool"}},[n("img",{attrs:{src:e.srcUrl},on:{error:e.showEmptyImage}})]):n("img",{attrs:{src:e.srcUrl},on:{error:e.showEmptyImage}})])}),[],!1,null,null,null);const y=n({mixins:[u],components:{imageGridImage:_.exports}},undefined,undefined,!1,null,null,null).exports,S=Vue.resource("api/v1/labels{/id}",{},{queryImageAnnotations:{method:"GET",url:"api/v1/labels{/id}/image-annotations"},queryVideoAnnotations:{method:"GET",url:"api/v1/labels{/id}/video-annotations"}});var x=n({mixins:[d,i],data:function(){return{showAnnotationRoute:null}},computed:{showAnnotationLink:function(){return this.showAnnotationRoute?this.showAnnotationRoute+this.image.id:""},selected:function(){return this.image.dismissed},title:function(){return this.selected?"Undo dismissing this annotation":"Dismiss this annotation"}}},(function(){var e=this,t=e.$createElement,n=e._self._c||t;return n("figure",{staticClass:"image-grid__image",class:e.classObject,attrs:{title:e.title}},[e.selectable?n("div",{staticClass:"image-icon"},[n("i",{staticClass:"fas",class:e.iconClass})]):e._e(),e._v(" "),n("img",{attrs:{src:e.srcUrl},on:{click:e.toggleSelect,error:e.showEmptyImage}}),e._v(" "),e.showAnnotationLink?n("div",{staticClass:"image-buttons"},[n("a",{staticClass:"image-button",attrs:{href:e.showAnnotationLink,target:"_blank",title:"Show the annotation in the annotation tool"}},[n("span",{staticClass:"fa fa-external-link-square-alt fa-fw",attrs:{"aria-hidden":"true"}})])]):e._e()])}),[],!1,null,null,null);const I=n({mixins:[u],components:{imageGridImage:x.exports}},undefined,undefined,!1,null,null,null).exports;var C=n({mixins:[d,i],data:function(){return{showAnnotationRoute:null}},computed:{showAnnotationLink:function(){return this.showAnnotationRoute?this.showAnnotationRoute+this.image.id:""},selected:function(){return this.image.newLabel},title:function(){return this.selected?"Revert changing the label of this annotation":"Change the label of this annotation"},newLabelStyle:function(){return{"background-color":"#"+this.image.newLabel.color}}}},(function(){var e=this,t=e.$createElement,n=e._self._c||t;return n("figure",{staticClass:"image-grid__image image-grid__image--relabel",class:e.classObject,attrs:{title:e.title}},[e.selectable?n("div",{staticClass:"image-icon"},[n("i",{staticClass:"fas",class:e.iconClass})]):e._e(),e._v(" "),n("img",{attrs:{src:e.srcUrl},on:{click:e.toggleSelect,error:e.showEmptyImage}}),e._v(" "),e.showAnnotationLink?n("div",{staticClass:"image-buttons"},[n("a",{staticClass:"image-button",attrs:{href:e.showAnnotationLink,target:"_blank",title:"Show the annotation in the annotation tool"}},[n("span",{staticClass:"fa fa-external-link-square-alt",attrs:{"aria-hidden":"true"}})])]):e._e(),e._v(" "),e.selected?n("div",{staticClass:"new-label"},[n("span",{staticClass:"new-label__color",style:e.newLabelStyle}),e._v(" "),n("span",{staticClass:"new-label__name",domProps:{textContent:e._s(e.image.newLabel.name)}})]):e._e()])}),[],!1,null,null,null);var L=n({mixins:[u],components:{imageGridImage:C.exports}},undefined,undefined,!1,null,null,null);const T=n({mixins:[m],components:{labelTrees:c,sidebar:b,sidebarTab:v,powerToggle:g,dismissImageGrid:I,relabelImageGrid:L.exports},data:function(){return{user:null,labelTrees:[],step:0,selectedLabel:null,annotationsCache:{},lastSelectedImage:null,forceChange:!1,waitForSessionId:null}},computed:{isInDismissStep:function(){return 0===this.step},isInRelabelStep:function(){return 1===this.step},annotations:function(){return this.selectedLabel&&this.annotationsCache.hasOwnProperty(this.selectedLabel.id)?this.annotationsCache[this.selectedLabel.id]:[]},allAnnotations:function(){var e=[];for(var t in this.annotationsCache)this.annotationsCache.hasOwnProperty(t)&&Array.prototype.push.apply(e,this.annotationsCache[t]);return e},hasNoAnnotations:function(){return this.selectedLabel&&!this.loading&&0===this.annotations.length},dismissedAnnotations:function(){return this.allAnnotations.filter((function(e){return e.dismissed}))},annotationsWithNewLabel:function(){return this.dismissedAnnotations.filter((function(e){return!!e.newLabel}))},hasDismissedAnnotations:function(){return this.dismissedAnnotations.length>0},dismissedImageAnnotationsToSave:function(){return this.packDismissedToSave(this.dismissedAnnotations.filter((function(t){return t.type===e})))},dismissedVideoAnnotationsToSave:function(){return this.packDismissedToSave(this.dismissedAnnotations.filter((function(e){return e.type===t})))},changedImageAnnotationsToSave:function(){return this.packChangedToSave(this.annotationsWithNewLabel.filter((function(t){return t.type===e})))},changedVideoAnnotationsToSave:function(){return this.packChangedToSave(this.annotationsWithNewLabel.filter((function(e){return e.type===t})))},toDeleteCount:function(){return this.dismissedAnnotations.length-this.annotationsWithNewLabel.length},saveButtonClass:function(){return this.forceChange?"btn-danger":"btn-success"}},methods:{getAnnotations:function(e){var t=this;this.annotationsCache.hasOwnProperty(e.id)||(Vue.set(this.annotationsCache,e.id,[]),this.startLoading(),this.queryAnnotations(e).then((function(n){return t.gotAnnotations(e,n)}),r).finally(this.finishLoading))},gotAnnotations:function(n,i){var s=i[0].data,o=i[1].data,a=[];s&&(a=a.concat(this.initAnnotations(n,s,e))),o&&(a=a.concat(this.initAnnotations(n,o,t))),a=a.sort((function(e,t){return t.id-e.id})),Vue.set(this.annotationsCache,n.id,a)},initAnnotations:function(e,t,n){return Object.keys(t).map((function(i){return{id:i,uuid:t[i],label_id:e.id,dismissed:!1,newLabel:null,type:n}}))},handleSelectedLabel:function(e){this.selectedLabel=e,this.isInDismissStep&&this.getAnnotations(e)},handleDeselectedLabel:function(){this.selectedLabel=null},handleSelectedImageDismiss:function(e,t){e.dismissed?(e.dismissed=!1,e.newLabel=null):(e.dismissed=!0,t.shiftKey&&this.lastSelectedImage?this.dismissAllImagesBetween(e,this.lastSelectedImage):this.lastSelectedImage=e)},goToRelabel:function(){this.step=1,this.lastSelectedImage=null},goToDismiss:function(){this.step=0,this.lastSelectedImage=null,this.selectedLabel&&this.getAnnotations(this.selectedLabel)},handleSelectedImageRelabel:function(e,t){e.newLabel?this.selectedLabel&&e.newLabel.id!==this.selectedLabel.id?e.newLabel=this.selectedLabel:e.newLabel=null:this.selectedLabel&&(e.newLabel=this.selectedLabel,t.shiftKey&&this.lastSelectedImage?this.relabelAllImagesBetween(e,this.lastSelectedImage):this.lastSelectedImage=e)},save:function(){var e=this;if(!this.loading){if(this.toDeleteCount>0){for(var t;null!==t&&parseInt(t,10)!==this.toDeleteCount;)t=prompt("This might delete ".concat(this.toDeleteCount," annotation(s). Please enter the number to continue."));if(null===t)return}this.startLoading(),this.performSave({dismissed_image_annotations:this.dismissedImageAnnotationsToSave,changed_image_annotations:this.changedImageAnnotationsToSave,dismissed_video_annotations:this.dismissedVideoAnnotationsToSave,changed_video_annotations:this.changedVideoAnnotationsToSave,force:this.forceChange}).then((function(t){return e.waitForSessionId=t.body.id}),(function(t){e.finishLoading(),r(t)}))}},handleSessionSaved:function(e){if(e.id==this.waitForSessionId){for(var t in this.finishLoading(),f.success("Saved. You can now start a new re-evaluation session."),this.step=0,this.annotationsCache)this.annotationsCache.hasOwnProperty(t)&&delete this.annotationsCache[t];this.handleSelectedLabel(this.selectedLabel)}},handleSessionFailed:function(e){e.id==this.waitForSessionId&&(this.finishLoading(),f.danger("There was an unexpected error."))},performOnAllImagesBetween:function(e,t,n){var i=this.allAnnotations.indexOf(e),s=this.allAnnotations.indexOf(t);if(s<i){var o=s;s=i,i=o}for(var a=i+1;a<s;a++)n(this.allAnnotations[a])},dismissAllImagesBetween:function(e,t){this.performOnAllImagesBetween(e,t,(function(e){e.dismissed=!0}))},relabelAllImagesBetween:function(e,t){var n=this.selectedLabel;this.performOnAllImagesBetween(e,t,(function(e){e.dismissed&&(e.newLabel=n)}))},enableForceChange:function(){this.forceChange=!0},disableForceChange:function(){this.forceChange=!1},packDismissedToSave:function(e){for(var t={},n=e.length-1;n>=0;n--)t.hasOwnProperty(e[n].label_id)?t[e[n].label_id].push(e[n].id):t[e[n].label_id]=[e[n].id];return t},packChangedToSave:function(e){for(var t={},n=e.length-1;n>=0;n--)t.hasOwnProperty(e[n].newLabel.id)?t[e[n].newLabel.id].push(e[n].id):t[e[n].newLabel.id]=[e[n].id];return t},initializeEcho:function(){a.getInstance().private("user-".concat(this.user.id)).listen(".Biigle\\Modules\\Largo\\Events\\LargoSessionSaved",this.handleSessionSaved).listen(".Biigle\\Modules\\Largo\\Events\\LargoSessionFailed",this.handleSessionFailed)}},watch:{annotations:function(e){l.$emit("annotations-count",e.length)},dismissedAnnotations:function(e){l.$emit("dismissed-annotations-count",e.length)},step:function(e){l.$emit("step",e)},selectedLabel:function(){this.isInDismissStep&&this.$refs.dismissGrid.setOffset(0)}},created:function(){var e=this;this.user=biigle.$require("largo.user"),window.addEventListener("beforeunload",(function(t){if(e.hasDismissedAnnotations)return t.preventDefault(),t.returnValue="","This page is asking you to confirm that you want to leave - data you have entered may not be saved."})),this.initializeEcho()}},undefined,undefined,!1,null,null,null).exports;const q=n({mixins:[T],components:{catalogImageGrid:y},data:function(){return{labelTrees:[]}},methods:{queryAnnotations:function(e){var t=S.queryImageAnnotations({id:e.id}),n=S.queryVideoAnnotations({id:e.id});return Vue.Promise.all([t,n])}},created:function(){var e=biigle.$require("annotationCatalog.labelTree");this.labelTrees=[e]}},undefined,undefined,!1,null,null,null).exports;const $=n({mixins:[T],data:function(){return{volumeId:null,labelTrees:[],mediaType:""}},methods:{queryAnnotations:function(e){var t,n;return"image"===this.mediaType?(t=o.queryImageAnnotations({id:this.volumeId,label_id:e.id}),n=Vue.Promise.resolve([])):(t=Vue.Promise.resolve([]),n=o.queryVideoAnnotations({id:this.volumeId,label_id:e.id})),Vue.Promise.all([t,n])},performSave:function(e){return o.save({id:this.volumeId},e)}},created:function(){this.volumeId=biigle.$require("largo.volumeId"),this.labelTrees=biigle.$require("largo.labelTrees"),this.mediaType=biigle.$require("largo.mediaType")}},undefined,undefined,!1,null,null,null).exports;const O=n({data:function(){return{step:0,count:0,dismissedCount:0}},computed:{shownCount:function(){return this.isInDismissStep?this.count:this.dismissedCount},isInDismissStep:function(){return 0===this.step},isInRelabelStep:function(){return 1===this.step}},methods:{updateStep:function(e){this.step=e},updateCount:function(e){this.count=e},updateDismissedCount:function(e){this.dismissedCount=e}},created:function(){l.$on("annotations-count",this.updateCount),l.$on("dismissed-annotations-count",this.updateDismissedCount),l.$on("step",this.updateStep)}},undefined,undefined,!1,null,null,null).exports,E=Vue.resource("api/v1/projects{/id}/largo",{},{queryImageAnnotations:{method:"GET",url:"api/v1/projects{/id}/image-annotations/filter/label{/label_id}"},queryVideoAnnotations:{method:"GET",url:"api/v1/projects{/id}/video-annotations/filter/label{/label_id}"}});const k=n({mixins:[T],data:function(){return{projectId:null,labelTrees:[]}},methods:{queryAnnotations:function(e){var t=E.queryImageAnnotations({id:this.projectId,label_id:e.id}),n=E.queryVideoAnnotations({id:this.projectId,label_id:e.id});return Vue.Promise.all([t,n])},performSave:function(e){return E.save({id:this.projectId},e)}},created:function(){this.projectId=biigle.$require("largo.projectId"),this.labelTrees=biigle.$require("largo.labelTrees")}},undefined,undefined,!1,null,null,null).exports;biigle.$mount("annotation-catalog-container",q),biigle.$mount("largo-container",$),biigle.$mount("largo-title",O),biigle.$mount("project-largo-container",k)},401:()=>{}},n={};function i(e){var s=n[e];if(void 0!==s)return s.exports;var o=n[e]={exports:{}};return t[e](o,o.exports,i),o.exports}i.m=t,e=[],i.O=(t,n,s,o)=>{if(!n){var a=1/0;for(d=0;d<e.length;d++){for(var[n,s,o]=e[d],l=!0,r=0;r<n.length;r++)(!1&o||a>=o)&&Object.keys(i.O).every((e=>i.O[e](n[r])))?n.splice(r--,1):(l=!1,o<a&&(a=o));if(l){e.splice(d--,1);var u=s();void 0!==u&&(t=u)}}return t}o=o||0;for(var d=e.length;d>0&&e[d-1][2]>o;d--)e[d]=e[d-1];e[d]=[n,s,o]},i.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),(()=>{var e={355:0,392:0};i.O.j=t=>0===e[t];var t=(t,n)=>{var s,o,[a,l,r]=n,u=0;if(a.some((t=>0!==e[t]))){for(s in l)i.o(l,s)&&(i.m[s]=l[s]);if(r)var d=r(i)}for(t&&t(n);u<a.length;u++)o=a[u],i.o(e,o)&&e[o]&&e[o][0](),e[o]=0;return i.O(d)},n=self.webpackChunkbiigle_largo=self.webpackChunkbiigle_largo||[];n.forEach(t.bind(null,0)),n.push=t.bind(null,n.push.bind(n))})(),i.O(void 0,[392],(()=>i(732)));var s=i.O(void 0,[392],(()=>i(401)));s=i.O(s)})();
\ No newline at end of file
+(()=>{"use strict";var t,e={486:()=>{var t="imageAnnotation",e="videoAnnotation";function n(t,e,n,i,s,o,a,r){var l,u="function"==typeof t?t.options:t;if(e&&(u.render=e,u.staticRenderFns=n,u._compiled=!0),i&&(u.functional=!0),o&&(u._scopeId="data-v-"+o),a?(l=function(t){(t=t||this.$vnode&&this.$vnode.ssrContext||this.parent&&this.parent.$vnode&&this.parent.$vnode.ssrContext)||"undefined"==typeof __VUE_SSR_CONTEXT__||(t=__VUE_SSR_CONTEXT__),s&&s.call(this,t),t&&t._registeredComponents&&t._registeredComponents.add(a)},u._ssrRegister=l):s&&(l=r?function(){s.call(this,(u.functional?this.parent:this).$root.$options.shadowRoot)}:s),l)if(u.functional){u._injectStyles=l;var d=u.render;u.render=function(t,e){return l.call(e),d(t,e)}}else{var c=u.beforeCreate;u.beforeCreate=c?[].concat(c,l):[l]}return{exports:t,options:u}}const i=n({computed:{id:function(){return this.image.id},uuid:function(){return this.image.uuid},type:function(){return this.image.type},patchPrefix:function(){return this.uuid[0]+this.uuid[1]+"/"+this.uuid[2]+this.uuid[3]+"/"+this.uuid},urlTemplate:function(){return biigle.$require("largo.patchUrlTemplate")}},methods:{getThumbnailUrl:function(){return this.type===e?this.urlTemplate.replace(":prefix",this.patchPrefix).replace(":id","v-".concat(this.id)):this.urlTemplate.replace(":prefix",this.patchPrefix).replace(":id",this.id)}},created:function(){this.type===t?this.showAnnotationRoute=biigle.$require("largo.showImageAnnotationRoute"):this.showAnnotationRoute=biigle.$require("largo.showVideoAnnotationRoute")}},undefined,undefined,!1,null,null,null).exports;const s=n({mixins:[i],props:{_id:{type:String,required:!0},_uuid:{type:String,required:!0},label:{type:Object,required:!0},emptySrc:{type:String,required:!0},_urlTemplate:{type:String,required:!0}},data:function(){return{url:""}},computed:{title:function(){return"Example annotation for label "+this.label.name},src:function(){return this.url||this.emptySrc},image:function(){return{id:this._id,uuid:this._uuid,type:t}},urlTemplate:function(){return this._urlTemplate}},methods:{showEmptyImage:function(){this.url=""}},created:function(){this.url=this.getThumbnailUrl()}},undefined,undefined,!1,null,null,null).exports,o=Vue.resource("api/v1/volumes{/id}/largo",{},{queryImageAnnotations:{method:"GET",url:"api/v1/volumes{/id}/image-annotations/filter/label{/label_id}"},queryVideoAnnotations:{method:"GET",url:"api/v1/volumes{/id}/video-annotations/filter/label{/label_id}"},queryExampleAnnotations:{method:"GET",url:"api/v1/volumes{/id}/image-annotations/examples{/label_id}"},sortAnnotationsByOutlier:{method:"GET",url:"api/v1/volumes{/id}/annotations/sort/outliers{/label_id}"}});var a=biigle.$require("echo"),r=biigle.$require("events"),l=biigle.$require("messages").handleErrorResponse,u=biigle.$require("volumes.components.imageGrid"),d=biigle.$require("volumes.components.imageGridImage"),c=biigle.$require("annotations.components.labelsTabPlugins"),h=biigle.$require("labelTrees.components.labelTrees"),m=biigle.$require("core.mixins.loader"),g=biigle.$require("messages"),f=biigle.$require("core.components.powerToggle"),p=biigle.$require("annotations.components.settingsTabPlugins"),b=biigle.$require("core.components.sidebar"),v=biigle.$require("core.components.sidebarTab");const y=n({mixins:[m],components:{annotationPatch:s},props:{label:{default:null},volumeId:{type:Number,required:!0},count:{type:Number,default:3}},data:function(){return{exampleLabel:null,exampleAnnotations:[],cache:{},shown:!0}},computed:{isShown:function(){return this.shown&&null!==this.label},hasExamples:function(){return this.exampleLabel&&this.exampleAnnotations&&Object.keys(this.exampleAnnotations).length>0}},methods:{parseResponse:function(t){return t.data},setExampleAnnotations:function(t){(!t[0].hasOwnProperty("annotations")||Object.keys(t[0].annotations).length<this.count)&&delete this.cache[t[1]],t[0].hasOwnProperty("label")&&t[0].label.id===t[1]||delete this.cache[t[1]],this.label&&this.label.id===t[1]&&(this.exampleAnnotations=t[0].annotations,this.exampleLabel=t[0].label)},updateShown:function(t){this.shown=t},updateExampleAnnotations:function(){this.exampleAnnotations=[],this.isShown&&(this.startLoading(),this.cache.hasOwnProperty(this.label.id)||(this.cache[this.label.id]=o.queryExampleAnnotations({id:this.volumeId,label_id:this.label.id,take:this.count}).then(this.parseResponse)),Vue.Promise.all([this.cache[this.label.id],this.label.id]).then(this.setExampleAnnotations).finally(this.finishLoading))}},watch:{label:function(){this.updateExampleAnnotations()},shown:function(){this.updateExampleAnnotations()}},created:function(){r.$on("settings.exampleAnnotations",this.updateShown)}},undefined,undefined,!1,null,null,null).exports;c&&(c.exampleAnnotations=y);const A=n({components:{powerButton:f},props:{settings:{type:Object,required:!0}},data:function(){return{isShown:!0}},methods:{hide:function(){this.isShown=!1,this.settings.set("exampleAnnotations",!1)},show:function(){this.isShown=!0,this.settings.delete("exampleAnnotations")}},watch:{isShown:function(t){r.$emit("settings.exampleAnnotations",t)}},created:function(){this.settings.has("exampleAnnotations")&&(this.isShown=this.settings.get("exampleAnnotations"))}},undefined,undefined,!1,null,null,null).exports;p&&(p.exampleAnnotations=A),biigle.$declare("largo.mixins.annotationPatch",i);var w=n({mixins:[d,i],data:function(){return{showAnnotationRoute:null}},computed:{showAnnotationLink:function(){return this.showAnnotationRoute?this.showAnnotationRoute+this.image.id:""}},created:function(){this.type===t?this.showAnnotationRoute=biigle.$require("annotationCatalog.showImageAnnotationRoute"):this.showAnnotationRoute=biigle.$require("annotationCatalog.showVideoAnnotationRoute")}},(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("figure",{staticClass:"image-grid__image image-grid__image--catalog",class:t.classObject},[t.showAnnotationLink?n("a",{attrs:{href:t.showAnnotationLink,target:"_blank",title:"Show the annotation in the annotation tool"}},[n("img",{attrs:{src:t.srcUrl},on:{error:t.showEmptyImage}})]):n("img",{attrs:{src:t.srcUrl},on:{error:t.showEmptyImage}})])}),[],!1,null,null,null);const S=n({mixins:[u],components:{imageGridImage:w.exports}},undefined,undefined,!1,null,null,null).exports,_=Vue.resource("api/v1/labels{/id}",{},{queryImageAnnotations:{method:"GET",url:"api/v1/labels{/id}/image-annotations"},queryVideoAnnotations:{method:"GET",url:"api/v1/labels{/id}/video-annotations"}});var C=n({mixins:[d,i],data:function(){return{showAnnotationRoute:null}},computed:{showAnnotationLink:function(){return this.showAnnotationRoute?this.showAnnotationRoute+this.image.id:""},selected:function(){return this.image.dismissed},title:function(){return this.selected?"Undo dismissing this annotation":"Dismiss this annotation"}}},(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("figure",{staticClass:"image-grid__image",class:t.classObject,attrs:{title:t.title}},[t.selectable?n("div",{staticClass:"image-icon"},[n("i",{staticClass:"fas",class:t.iconClass})]):t._e(),t._v(" "),n("img",{attrs:{src:t.srcUrl},on:{click:t.toggleSelect,error:t.showEmptyImage}}),t._v(" "),t.showAnnotationLink?n("div",{staticClass:"image-buttons"},[n("a",{staticClass:"image-button",attrs:{href:t.showAnnotationLink,target:"_blank",title:"Show the annotation in the annotation tool"}},[n("span",{staticClass:"fa fa-external-link-square-alt fa-fw",attrs:{"aria-hidden":"true"}})])]):t._e()])}),[],!1,null,null,null);const I=n({mixins:[u],components:{imageGridImage:C.exports}},undefined,undefined,!1,null,null,null).exports;var x=n({mixins:[d,i],data:function(){return{showAnnotationRoute:null}},computed:{showAnnotationLink:function(){return this.showAnnotationRoute?this.showAnnotationRoute+this.image.id:""},selected:function(){return this.image.newLabel},title:function(){return this.selected?"Revert changing the label of this annotation":"Change the label of this annotation"},newLabelStyle:function(){return{"background-color":"#"+this.image.newLabel.color}}}},(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("figure",{staticClass:"image-grid__image image-grid__image--relabel",class:t.classObject,attrs:{title:t.title}},[t.selectable?n("div",{staticClass:"image-icon"},[n("i",{staticClass:"fas",class:t.iconClass})]):t._e(),t._v(" "),n("img",{attrs:{src:t.srcUrl},on:{click:t.toggleSelect,error:t.showEmptyImage}}),t._v(" "),t.showAnnotationLink?n("div",{staticClass:"image-buttons"},[n("a",{staticClass:"image-button",attrs:{href:t.showAnnotationLink,target:"_blank",title:"Show the annotation in the annotation tool"}},[n("span",{staticClass:"fa fa-external-link-square-alt",attrs:{"aria-hidden":"true"}})])]):t._e(),t._v(" "),t.selected?n("div",{staticClass:"new-label"},[n("span",{staticClass:"new-label__color",style:t.newLabelStyle}),t._v(" "),n("span",{staticClass:"new-label__name",domProps:{textContent:t._s(t.image.newLabel.name)}})]):t._e()])}),[],!1,null,null,null);const L=n({mixins:[u],components:{imageGridImage:x.exports}},undefined,undefined,!1,null,null,null).exports;var q=0,T=1,$=0,O=1;var k=n({data:function(){return{sortDirection:T,sortKey:$}},computed:{sortedAscending:function(){return this.sortDirection===q},sortedDescending:function(){return this.sortDirection===T},sortingByAnnotationId:function(){return this.sortKey===$},sortingByOutlier:function(){return this.sortKey===O}},methods:{sortAscending:function(){this.sortDirection=q},sortDescending:function(){this.sortDirection=T},reset:function(){this.sortDescending(),this.sortByAnnotationId()},sortByAnnotationId:function(){this.sortKey=$},sortByOutlier:function(){this.sortKey=O}},watch:{sortDirection:function(t){this.$emit("change-direction",t)},sortKey:function(t){this.$emit("change-key",t)}}},(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"sorting-tab"},[n("div",{staticClass:"sorting-tab__buttons"},[n("div",{staticClass:"btn-group",attrs:{role:"group"}},[n("button",{staticClass:"btn btn-default",class:{active:t.sortedDescending},attrs:{type:"button",title:"Sort descending"},on:{click:t.sortDescending}},[n("span",{staticClass:"fa fa-sort-amount-down"})]),t._v(" "),n("button",{staticClass:"btn btn-default",class:{active:t.sortedAscending},attrs:{type:"button",title:"Sort ascending"},on:{click:t.sortAscending}},[n("span",{staticClass:"fa fa-sort-amount-up"})])]),t._v(" "),n("div",{staticClass:"btn-group pull-right",attrs:{role:"group"}},[n("button",{staticClass:"btn btn-default",attrs:{type:"button",title:"Reset sorting"},on:{click:t.reset}},[n("span",{staticClass:"fa fa-times"})])])]),t._v(" "),n("div",{staticClass:"list-group sorter-list-group"},[n("button",{staticClass:"list-group-item",class:{active:t.sortingByAnnotationId},attrs:{title:"Sort by annotation timestamp (higher is newer)"},on:{click:t.sortByAnnotationId}},[t._v("\n            Created\n        ")]),t._v(" "),n("button",{staticClass:"list-group-item",class:{active:t.sortingByOutlier},attrs:{title:"Sort by outliers (higher is more dissimilar)"},on:{click:t.sortByOutlier}},[t._v("\n            Outliers\n        ")])])])}),[],!1,null,null,null);const E=n({mixins:[m],components:{labelTrees:h,sidebar:b,sidebarTab:v,powerToggle:f,dismissImageGrid:I,relabelImageGrid:L,sortingTab:k.exports},data:function(){return{user:null,labelTrees:[],step:0,selectedLabel:null,annotationsCache:{},lastSelectedImage:null,forceChange:!1,waitForSessionId:null,sortingSequenceCache:{},sortingDirection:T,sortingKey:$}},computed:{isInDismissStep:function(){return 0===this.step},isInRelabelStep:function(){return 1===this.step},annotations:function(){return this.selectedLabel&&this.annotationsCache.hasOwnProperty(this.selectedLabel.id)?this.annotationsCache[this.selectedLabel.id]:[]},sortedAnnotations:function(){var t,n,i,s=this.annotations.slice(),o=null===(t=this.sortingSequenceCache)||void 0===t||null===(n=t[null===(i=this.selectedLabel)||void 0===i?void 0:i.id])||void 0===n?void 0:n[this.sortingKey];if(o){var a={};o.forEach((function(t,e){return a[t]=e})),s.sort((function(t,n){return a[t.type===e?"v"+t.id:"i"+t.id]-a[n.type===e?"v"+n.id:"i"+n.id]}))}return this.sortingDirection===q?s.reverse():s},allAnnotations:function(){var t=[];for(var e in this.annotationsCache)this.annotationsCache.hasOwnProperty(e)&&Array.prototype.push.apply(t,this.annotationsCache[e]);return t},hasNoAnnotations:function(){return this.selectedLabel&&!this.loading&&0===this.annotations.length},dismissedAnnotations:function(){return this.allAnnotations.filter((function(t){return t.dismissed}))},annotationsWithNewLabel:function(){return this.dismissedAnnotations.filter((function(t){return!!t.newLabel}))},hasDismissedAnnotations:function(){return this.dismissedAnnotations.length>0},dismissedImageAnnotationsToSave:function(){return this.packDismissedToSave(this.dismissedAnnotations.filter((function(e){return e.type===t})))},dismissedVideoAnnotationsToSave:function(){return this.packDismissedToSave(this.dismissedAnnotations.filter((function(t){return t.type===e})))},changedImageAnnotationsToSave:function(){return this.packChangedToSave(this.annotationsWithNewLabel.filter((function(e){return e.type===t})))},changedVideoAnnotationsToSave:function(){return this.packChangedToSave(this.annotationsWithNewLabel.filter((function(t){return t.type===e})))},toDeleteCount:function(){return this.dismissedAnnotations.length-this.annotationsWithNewLabel.length},saveButtonClass:function(){return this.forceChange?"btn-danger":"btn-success"},sortingIsActive:function(){return this.isInDismissStep&&(this.sortingKey!==$||this.sortingDirection!==T)}},methods:{getAnnotations:function(t){var e,n,i,s,o=this;this.annotationsCache.hasOwnProperty(t.id)?i=Vue.Promise.resolve():(Vue.set(this.annotationsCache,t.id,[]),this.startLoading(),i=this.queryAnnotations(t).then((function(e){return o.gotAnnotations(t,e)}),l));var a=null===(e=this.sortingSequenceCache)||void 0===e||null===(n=e[t.id])||void 0===n?void 0:n[this.sortingKey];this.sortingIsActive&&!a?(this.loading||this.startLoading(),s=this.fetchSortingSequence(this.sortingKey,t.id).catch(l)):s=Vue.Promise.resolve(),Vue.Promise.all([i,s]).finally(this.finishLoading)},gotAnnotations:function(n,i){var s=i[0].data,o=i[1].data,a=[];s&&(a=a.concat(this.initAnnotations(n,s,t))),o&&(a=a.concat(this.initAnnotations(n,o,e))),a=a.sort((function(t,e){return e.id-t.id})),Vue.set(this.annotationsCache,n.id,a)},initAnnotations:function(t,e,n){return Object.keys(e).map((function(i){return{id:i,uuid:e[i],label_id:t.id,dismissed:!1,newLabel:null,type:n}}))},handleSelectedLabel:function(t){this.selectedLabel=t,this.isInDismissStep&&this.getAnnotations(t)},handleDeselectedLabel:function(){this.selectedLabel=null},handleSelectedImageDismiss:function(t,e){t.dismissed?(t.dismissed=!1,t.newLabel=null):(t.dismissed=!0,e.shiftKey&&this.lastSelectedImage?this.dismissAllImagesBetween(t,this.lastSelectedImage):this.lastSelectedImage=t)},goToRelabel:function(){this.step=1,this.lastSelectedImage=null},goToDismiss:function(){this.step=0,this.lastSelectedImage=null,this.selectedLabel&&this.getAnnotations(this.selectedLabel)},handleSelectedImageRelabel:function(t,e){t.newLabel?this.selectedLabel&&t.newLabel.id!==this.selectedLabel.id?t.newLabel=this.selectedLabel:t.newLabel=null:this.selectedLabel&&(t.newLabel=this.selectedLabel,e.shiftKey&&this.lastSelectedImage?this.relabelAllImagesBetween(t,this.lastSelectedImage):this.lastSelectedImage=t)},save:function(){var t=this;if(!this.loading){if(this.toDeleteCount>0){for(var e;null!==e&&parseInt(e,10)!==this.toDeleteCount;)e=prompt("This might delete ".concat(this.toDeleteCount," annotation(s). Please enter the number to continue."));if(null===e)return}this.startLoading(),this.performSave({dismissed_image_annotations:this.dismissedImageAnnotationsToSave,changed_image_annotations:this.changedImageAnnotationsToSave,dismissed_video_annotations:this.dismissedVideoAnnotationsToSave,changed_video_annotations:this.changedVideoAnnotationsToSave,force:this.forceChange}).then((function(e){return t.waitForSessionId=e.body.id}),(function(e){t.finishLoading(),l(e)}))}},handleSessionSaved:function(t){if(t.id==this.waitForSessionId){for(var e in this.finishLoading(),g.success("Saved. You can now start a new re-evaluation session."),this.step=0,this.annotationsCache)this.annotationsCache.hasOwnProperty(e)&&delete this.annotationsCache[e];for(var n in this.sortingSequenceCache)this.sortingSequenceCache.hasOwnProperty(n)&&delete this.sortingSequenceCache[n];this.handleSelectedLabel(this.selectedLabel)}},handleSessionFailed:function(t){t.id==this.waitForSessionId&&(this.finishLoading(),g.danger("There was an unexpected error."))},performOnAllImagesBetween:function(t,e,n){var i=this.allAnnotations.indexOf(t),s=this.allAnnotations.indexOf(e);if(s<i){var o=s;s=i,i=o}for(var a=i+1;a<s;a++)n(this.allAnnotations[a])},dismissAllImagesBetween:function(t,e){this.performOnAllImagesBetween(t,e,(function(t){t.dismissed=!0}))},relabelAllImagesBetween:function(t,e){var n=this.selectedLabel;this.performOnAllImagesBetween(t,e,(function(t){t.dismissed&&(t.newLabel=n)}))},enableForceChange:function(){this.forceChange=!0},disableForceChange:function(){this.forceChange=!1},packDismissedToSave:function(t){for(var e={},n=t.length-1;n>=0;n--)e.hasOwnProperty(t[n].label_id)?e[t[n].label_id].push(t[n].id):e[t[n].label_id]=[t[n].id];return e},packChangedToSave:function(t){for(var e={},n=t.length-1;n>=0;n--)e.hasOwnProperty(t[n].newLabel.id)?e[t[n].newLabel.id].push(t[n].id):e[t[n].newLabel.id]=[t[n].id];return e},initializeEcho:function(){a.getInstance().private("user-".concat(this.user.id)).listen(".Biigle\\Modules\\Largo\\Events\\LargoSessionSaved",this.handleSessionSaved).listen(".Biigle\\Modules\\Largo\\Events\\LargoSessionFailed",this.handleSessionFailed)},updateSortDirection:function(t){this.sortingDirection=t},fetchSortingSequence:function(t,e){var n=this;return(t===O?this.querySortByOutlier(e).then((function(t){return t.body})):Vue.Promise.resolve([])).then((function(i){return n.putSortingSequenceToCache(t,e,i)}))},putSortingSequenceToCache:function(t,e,n){this.sortingSequenceCache[e]||Vue.set(this.sortingSequenceCache,e,{}),this.sortingSequenceCache[e][t]=n},updateSortKey:function(t){var e,n,i,s=this,o=null===(e=this.selectedLabel)||void 0===e?void 0:e.id,a=null===(n=this.sortingSequenceCache)||void 0===n||null===(i=n[o])||void 0===i?void 0:i[t];o&&!a?(this.startLoading(),this.fetchSortingSequence(t,o).then((function(){return s.sortingKey=t})).catch(l).finally(this.finishLoading)):this.sortingKey=t}},watch:{annotations:function(t){r.$emit("annotations-count",t.length)},dismissedAnnotations:function(t){r.$emit("dismissed-annotations-count",t.length)},step:function(t){r.$emit("step",t)},selectedLabel:function(){this.isInDismissStep&&this.$refs.dismissGrid.setOffset(0)}},created:function(){var t=this;this.user=biigle.$require("largo.user"),window.addEventListener("beforeunload",(function(e){if(t.hasDismissedAnnotations)return e.preventDefault(),e.returnValue="","This page is asking you to confirm that you want to leave - data you have entered may not be saved."})),this.initializeEcho()}},undefined,undefined,!1,null,null,null).exports;const D=n({mixins:[E],components:{catalogImageGrid:S},data:function(){return{labelTrees:[]}},methods:{queryAnnotations:function(t){var e=_.queryImageAnnotations({id:t.id}),n=_.queryVideoAnnotations({id:t.id});return Vue.Promise.all([e,n])}},created:function(){var t=biigle.$require("annotationCatalog.labelTree");this.labelTrees=[t]}},undefined,undefined,!1,null,null,null).exports;const R=n({mixins:[E],data:function(){return{volumeId:null,labelTrees:[],mediaType:""}},methods:{queryAnnotations:function(t){var e,n;return"image"===this.mediaType?(e=o.queryImageAnnotations({id:this.volumeId,label_id:t.id}),n=Vue.Promise.resolve([])):(e=Vue.Promise.resolve([]),n=o.queryVideoAnnotations({id:this.volumeId,label_id:t.id})),Vue.Promise.all([e,n])},performSave:function(t){return o.save({id:this.volumeId},t)},querySortByOutlier:function(t){var e=this;return o.sortAnnotationsByOutlier({id:this.volumeId,label_id:t}).then((function(t){return"image"===e.mediaType?t.body=t.body.map((function(t){return"i"+t})):t.body=t.body.map((function(t){return"v"+t})),t}))}},created:function(){this.volumeId=biigle.$require("largo.volumeId"),this.labelTrees=biigle.$require("largo.labelTrees"),this.mediaType=biigle.$require("largo.mediaType")}},undefined,undefined,!1,null,null,null).exports;const V=n({data:function(){return{step:0,count:0,dismissedCount:0}},computed:{shownCount:function(){return this.isInDismissStep?this.count:this.dismissedCount},isInDismissStep:function(){return 0===this.step},isInRelabelStep:function(){return 1===this.step}},methods:{updateStep:function(t){this.step=t},updateCount:function(t){this.count=t},updateDismissedCount:function(t){this.dismissedCount=t}},created:function(){r.$on("annotations-count",this.updateCount),r.$on("dismissed-annotations-count",this.updateDismissedCount),r.$on("step",this.updateStep)}},undefined,undefined,!1,null,null,null).exports,P=Vue.resource("api/v1/projects{/id}/largo",{},{queryImageAnnotations:{method:"GET",url:"api/v1/projects{/id}/image-annotations/filter/label{/label_id}"},queryVideoAnnotations:{method:"GET",url:"api/v1/projects{/id}/video-annotations/filter/label{/label_id}"},sortAnnotationsByOutlier:{method:"GET",url:"api/v1/projects{/id}/annotations/sort/outliers{/label_id}"}});const B=n({mixins:[E],data:function(){return{projectId:null,labelTrees:[]}},methods:{queryAnnotations:function(t){var e=P.queryImageAnnotations({id:this.projectId,label_id:t.id}),n=P.queryVideoAnnotations({id:this.projectId,label_id:t.id});return Vue.Promise.all([e,n])},performSave:function(t){return P.save({id:this.projectId},t)},querySortByOutlier:function(t){return P.sortAnnotationsByOutlier({id:this.projectId,label_id:t})}},created:function(){this.projectId=biigle.$require("largo.projectId"),this.labelTrees=biigle.$require("largo.labelTrees")}},undefined,undefined,!1,null,null,null).exports;biigle.$mount("annotation-catalog-container",D),biigle.$mount("largo-container",R),biigle.$mount("largo-title",V),biigle.$mount("project-largo-container",B)},401:()=>{}},n={};function i(t){var s=n[t];if(void 0!==s)return s.exports;var o=n[t]={exports:{}};return e[t](o,o.exports,i),o.exports}i.m=e,t=[],i.O=(e,n,s,o)=>{if(!n){var a=1/0;for(d=0;d<t.length;d++){for(var[n,s,o]=t[d],r=!0,l=0;l<n.length;l++)(!1&o||a>=o)&&Object.keys(i.O).every((t=>i.O[t](n[l])))?n.splice(l--,1):(r=!1,o<a&&(a=o));if(r){t.splice(d--,1);var u=s();void 0!==u&&(e=u)}}return e}o=o||0;for(var d=t.length;d>0&&t[d-1][2]>o;d--)t[d]=t[d-1];t[d]=[n,s,o]},i.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),(()=>{var t={355:0,392:0};i.O.j=e=>0===t[e];var e=(e,n)=>{var s,o,[a,r,l]=n,u=0;if(a.some((e=>0!==t[e]))){for(s in r)i.o(r,s)&&(i.m[s]=r[s]);if(l)var d=l(i)}for(e&&e(n);u<a.length;u++)o=a[u],i.o(t,o)&&t[o]&&t[o][0](),t[o]=0;return i.O(d)},n=self.webpackChunkbiigle_largo=self.webpackChunkbiigle_largo||[];n.forEach(e.bind(null,0)),n.push=e.bind(null,n.push.bind(n))})(),i.O(void 0,[392],(()=>i(486)));var s=i.O(void 0,[392],(()=>i(401)));s=i.O(s)})();
\ No newline at end of file
diff --git a/src/public/assets/styles/main.css b/src/public/assets/styles/main.css
index 232cfe9b..d6499f1c 100644
--- a/src/public/assets/styles/main.css
+++ b/src/public/assets/styles/main.css
@@ -1 +1 @@
-.navbar-text.navbar-largo-breadcrumbs,.navbar-text.navbar-largo-breadcrumbs a{color:#ccc}.largo-images__alerts{align-items:center;display:flex;height:100%;justify-content:center;left:0;pointer-events:none;position:absolute;top:0;transition:background-color .25s ease;width:100%;z-index:2}.largo-images__alerts.block{background-color:rgba(0,0,0,.5);pointer-events:auto}.largo-tab{display:flex!important;flex-direction:column}.largo-tab .largo-tab__button{padding-bottom:10px}.largo-tab .largo-tab__label-trees{flex:1;overflow:auto}.image-grid__image--catalog>a{width:100%}.image-grid__image--relabel .new-label{bottom:0;left:0;overflow-x:hidden;padding:.5em;pointer-events:none;position:absolute;text-align:center;text-overflow:ellipsis;white-space:nowrap;width:100%}.image-grid__image--relabel .new-label__name{padding-right:16px}.image-grid__image--relabel .new-label__color{border:2px solid #eee;border-radius:50%;display:inline-block;height:1em;vertical-align:middle;width:1em}.largo-example-annotations .largo-example-annotations__images{margin-right:-1em;overflow-x:auto;white-space:nowrap}.largo-example-annotations .largo-example-annotation{image-orientation:none;height:125px;width:auto}.largo-example-annotations .largo-example-annotation:not(:last-child){margin-right:.5em}.largo-example-annotations .alert{margin-bottom:0}
+.navbar-text.navbar-largo-breadcrumbs,.navbar-text.navbar-largo-breadcrumbs a{color:#ccc}.largo-images__alerts{align-items:center;display:flex;height:100%;justify-content:center;left:0;pointer-events:none;position:absolute;top:0;transition:background-color .25s ease;width:100%;z-index:2}.largo-images__alerts.block{background-color:rgba(0,0,0,.5);pointer-events:auto}.sidebar__tab--open.largo-tab{display:flex!important;flex-direction:column}.sidebar__tab--open.largo-tab .largo-tab__button{padding-bottom:10px}.sidebar__tab--open.largo-tab .largo-tab__label-trees{flex:1;overflow:auto}.image-grid__image--catalog>a{width:100%}.image-grid__image--relabel .new-label{bottom:0;left:0;overflow-x:hidden;padding:.5em;pointer-events:none;position:absolute;text-align:center;text-overflow:ellipsis;white-space:nowrap;width:100%}.image-grid__image--relabel .new-label__name{padding-right:16px}.image-grid__image--relabel .new-label__color{border:2px solid #eee;border-radius:50%;display:inline-block;height:1em;vertical-align:middle;width:1em}.largo-example-annotations .largo-example-annotations__images{margin-right:-1em;overflow-x:auto;white-space:nowrap}.largo-example-annotations .largo-example-annotation{image-orientation:none;height:125px;width:auto}.largo-example-annotations .largo-example-annotation:not(:last-child){margin-right:.5em}.largo-example-annotations .alert{margin-bottom:0}
diff --git a/src/public/mix-manifest.json b/src/public/mix-manifest.json
index 1b90a3e9..10af68e1 100644
--- a/src/public/mix-manifest.json
+++ b/src/public/mix-manifest.json
@@ -1,4 +1,4 @@
 {
-    "/assets/scripts/main.js": "/assets/scripts/main.js?id=7dc83b19fd9d27eb012fa7ccdf3ffa24",
-    "/assets/styles/main.css": "/assets/styles/main.css?id=4be2d80b899c739e0bed700e0ca8362c"
+    "/assets/scripts/main.js": "/assets/scripts/main.js?id=40a936c2f7f3e8aa294df21e41289d94",
+    "/assets/styles/main.css": "/assets/styles/main.css?id=4bcd521568b8ea929efd8e3f72f7d338"
 }
diff --git a/src/resources/assets/js/api/projects.js b/src/resources/assets/js/api/projects.js
index adee0478..5cbb196e 100644
--- a/src/resources/assets/js/api/projects.js
+++ b/src/resources/assets/js/api/projects.js
@@ -23,4 +23,8 @@ export default Vue.resource('api/v1/projects{/id}/largo', {}, {
         method: 'GET',
         url: 'api/v1/projects{/id}/video-annotations/filter/label{/label_id}',
     },
+    sortAnnotationsByOutlier: {
+        method: 'GET',
+        url: 'api/v1/projects{/id}/annotations/sort/outliers{/label_id}',
+    },
 });
diff --git a/src/resources/assets/js/api/volumes.js b/src/resources/assets/js/api/volumes.js
index f95fb4da..62542e72 100644
--- a/src/resources/assets/js/api/volumes.js
+++ b/src/resources/assets/js/api/volumes.js
@@ -31,4 +31,8 @@ export default Vue.resource('api/v1/volumes{/id}/largo', {}, {
         method: 'GET',
         url: 'api/v1/volumes{/id}/image-annotations/examples{/label_id}',
     },
+    sortAnnotationsByOutlier: {
+        method: 'GET',
+        url: 'api/v1/volumes{/id}/annotations/sort/outliers{/label_id}',
+    },
 });
diff --git a/src/resources/assets/js/components/sortingTab.vue b/src/resources/assets/js/components/sortingTab.vue
new file mode 100644
index 00000000..c28c3013
--- /dev/null
+++ b/src/resources/assets/js/components/sortingTab.vue
@@ -0,0 +1,118 @@
+<template>
+    <div class="sorting-tab">
+        <div class="sorting-tab__buttons">
+            <div class="btn-group" role="group">
+                <button
+                    type="button"
+                    class="btn btn-default"
+                    title="Sort descending"
+                    :class="{active: sortedDescending}"
+                    @click="sortDescending"
+                        >
+                        <span class="fa fa-sort-amount-down"></span>
+                    </button>
+                <button
+                    type="button"
+                    class="btn btn-default"
+                    title="Sort ascending"
+                    :class="{active: sortedAscending}"
+                    @click="sortAscending"
+                        >
+                        <span class="fa fa-sort-amount-up"></span>
+                    </button>
+            </div>
+            <div class="btn-group pull-right" role="group">
+                <button
+                    type="button"
+                    class="btn btn-default"
+                    title="Reset sorting"
+                    @click="reset"
+                    >
+                        <span class="fa fa-times"></span>
+                    </button>
+            </div>
+        </div>
+
+        <div class="list-group sorter-list-group">
+            <button
+                class="list-group-item"
+                title="Sort by annotation timestamp (higher is newer)"
+                :class="{active: sortingByAnnotationId}"
+                @click="sortByAnnotationId"
+                >
+                Created
+            </button>
+            <button
+                class="list-group-item"
+                title="Sort by outliers (higher is more dissimilar)"
+                :class="{active: sortingByOutlier}"
+                @click="sortByOutlier"
+                >
+                Outliers
+            </button>
+        </div>
+    </div>
+</template>
+
+<script>
+
+export const SORT_DIRECTION = {
+    ASCENDING: 0,
+    DESCENDING: 1,
+};
+
+export const SORT_KEY = {
+    ANNOTATION_ID: 0,
+    OUTLIER: 1,
+};
+
+export default {
+    data() {
+        return {
+            sortDirection: SORT_DIRECTION.DESCENDING,
+            sortKey: SORT_KEY.ANNOTATION_ID,
+        };
+    },
+    computed: {
+        sortedAscending() {
+            return this.sortDirection === SORT_DIRECTION.ASCENDING;
+        },
+        sortedDescending() {
+            return this.sortDirection === SORT_DIRECTION.DESCENDING;
+        },
+        sortingByAnnotationId() {
+            return this.sortKey === SORT_KEY.ANNOTATION_ID;
+        },
+        sortingByOutlier() {
+            return this.sortKey === SORT_KEY.OUTLIER;
+        },
+    },
+    methods: {
+        sortAscending() {
+            this.sortDirection = SORT_DIRECTION.ASCENDING;
+        },
+        sortDescending() {
+            this.sortDirection = SORT_DIRECTION.DESCENDING;
+        },
+        reset() {
+            this.sortDescending();
+            this.sortByAnnotationId();
+        },
+        sortByAnnotationId() {
+            this.sortKey = SORT_KEY.ANNOTATION_ID;
+        },
+        sortByOutlier() {
+            this.sortKey = SORT_KEY.OUTLIER;
+        },
+    },
+    watch: {
+        sortDirection(direction) {
+            this.$emit('change-direction', direction);
+        },
+        sortKey(key) {
+            this.$emit('change-key', key);
+        },
+    },
+};
+</script>
+
diff --git a/src/resources/assets/js/largoContainer.vue b/src/resources/assets/js/largoContainer.vue
index d972ea2c..c5e8b3c0 100644
--- a/src/resources/assets/js/largoContainer.vue
+++ b/src/resources/assets/js/largoContainer.vue
@@ -31,6 +31,20 @@ export default {
         performSave(payload) {
             return VolumesApi.save({id: this.volumeId}, payload);
         },
+        querySortByOutlier(labelId) {
+            return VolumesApi.sortAnnotationsByOutlier({id: this.volumeId, label_id: labelId})
+                .then((response) => {
+                    // The sorting expects annotation IDs prefixed with 'i' or 'v' so it
+                    // can work with mixed image and video annotations.
+                    if (this.mediaType === 'image') {
+                        response.body = response.body.map(id => 'i' + id);
+                    } else {
+                        response.body = response.body.map(id => 'v' + id);
+                    }
+
+                    return response;
+                });
+        },
     },
     created() {
         this.volumeId = biigle.$require('largo.volumeId');
diff --git a/src/resources/assets/js/mixins/largoContainer.vue b/src/resources/assets/js/mixins/largoContainer.vue
index 62b820be..6f418768 100644
--- a/src/resources/assets/js/mixins/largoContainer.vue
+++ b/src/resources/assets/js/mixins/largoContainer.vue
@@ -1,6 +1,7 @@
 <script>
 import DismissImageGrid from '../components/dismissImageGrid';
 import RelabelImageGrid from '../components/relabelImageGrid';
+import SortingTab from '../components/sortingTab';
 import {Echo} from '../import';
 import {Events} from '../import';
 import {handleErrorResponse} from '../import';
@@ -11,6 +12,7 @@ import {Messages} from '../import';
 import {PowerToggle} from '../import';
 import {SidebarTab} from '../import';
 import {Sidebar} from '../import';
+import {SORT_DIRECTION, SORT_KEY} from '../components/sortingTab';
 
 /**
  * Mixin for largo view models
@@ -24,6 +26,7 @@ export default {
         powerToggle: PowerToggle,
         dismissImageGrid: DismissImageGrid,
         relabelImageGrid: RelabelImageGrid,
+        sortingTab: SortingTab,
     },
     data() {
         return {
@@ -35,6 +38,12 @@ export default {
             lastSelectedImage: null,
             forceChange: false,
             waitForSessionId: null,
+            // The cache is nested in two levels. The first level key is the label ID.
+            // The second level key is the sorting key. The cached value is an array
+            // of annotation IDs sorted in ascending order.
+            sortingSequenceCache: {},
+            sortingDirection: SORT_DIRECTION.DESCENDING,
+            sortingKey: SORT_KEY.ANNOTATION_ID,
         };
     },
     computed: {
@@ -51,6 +60,30 @@ export default {
 
             return [];
         },
+        sortedAnnotations() {
+            let annotations = this.annotations.slice();
+
+            // This will always be missing for the default sorting.
+            const sequence = this.sortingSequenceCache?.[this.selectedLabel?.id]?.[this.sortingKey];
+
+            if (sequence) {
+                const map = {};
+                sequence.forEach((id, idx) => map[id] = idx);
+
+                // Image annotation IDs are prefixed with 'i', video annotations with
+                // 'v' to avoid duplicate IDs whe sorting both types of annotations.
+                annotations.sort((a, b) =>
+                    map[a.type === VIDEO_ANNOTATION ? ('v' + a.id) : ('i' + a.id)] -
+                    map[b.type === VIDEO_ANNOTATION ? ('v' + b.id) : ('i' + b.id)]
+                );
+            }
+
+            if (this.sortingDirection === SORT_DIRECTION.ASCENDING) {
+                return annotations.reverse();
+            }
+
+            return annotations;
+        },
         allAnnotations() {
             let annotations = [];
             for (let id in this.annotationsCache) {
@@ -98,17 +131,36 @@ export default {
         saveButtonClass() {
             return this.forceChange ? 'btn-danger' : 'btn-success';
         },
+        sortingIsActive() {
+            return this.isInDismissStep && (this.sortingKey !== SORT_KEY.ANNOTATION_ID || this.sortingDirection !== SORT_DIRECTION.DESCENDING);
+        },
     },
     methods: {
         getAnnotations(label) {
+            let promise1;
+            let promise2;
+
             if (!this.annotationsCache.hasOwnProperty(label.id)) {
-                // Load only once
                 Vue.set(this.annotationsCache, label.id, []);
                 this.startLoading();
-                this.queryAnnotations(label)
+                promise1 = this.queryAnnotations(label)
                     .then((response) => this.gotAnnotations(label, response), handleErrorResponse)
-                    .finally(this.finishLoading);
+            } else {
+                promise1 = Vue.Promise.resolve();
             }
+
+            const sequence = this.sortingSequenceCache?.[label.id]?.[this.sortingKey];
+            if (this.sortingIsActive && !sequence) {
+                if (!this.loading) {
+                    this.startLoading();
+                }
+                promise2 = this.fetchSortingSequence(this.sortingKey, label.id)
+                    .catch(handleErrorResponse);
+            } else {
+                promise2 = Vue.Promise.resolve();
+            }
+
+            Vue.Promise.all([promise1, promise2]).finally(this.finishLoading);
         },
         gotAnnotations(label, response) {
             let imageAnnotations = response[0].data;
@@ -235,6 +287,10 @@ export default {
                     if (!this.annotationsCache.hasOwnProperty(key)) continue;
                     delete this.annotationsCache[key];
                 }
+                for (let key in this.sortingSequenceCache) {
+                    if (!this.sortingSequenceCache.hasOwnProperty(key)) continue;
+                    delete this.sortingSequenceCache[key];
+                }
                 this.handleSelectedLabel(this.selectedLabel);
             }
         },
@@ -308,6 +364,40 @@ export default {
                 .listen('.Biigle\\Modules\\Largo\\Events\\LargoSessionSaved', this.handleSessionSaved)
                 .listen('.Biigle\\Modules\\Largo\\Events\\LargoSessionFailed', this.handleSessionFailed);
         },
+        updateSortDirection(direction) {
+            this.sortingDirection = direction;
+        },
+        fetchSortingSequence(key, labelId) {
+            let promise;
+            if (key === SORT_KEY.OUTLIER) {
+                promise = this.querySortByOutlier(labelId)
+                    .then(response => response.body);
+            } else {
+                promise = Vue.Promise.resolve([]);
+            }
+
+            return promise.then(ids => this.putSortingSequenceToCache(key, labelId, ids));
+        },
+        putSortingSequenceToCache(key, labelId, sequence) {
+            if (!this.sortingSequenceCache[labelId]) {
+                Vue.set(this.sortingSequenceCache, labelId, {});
+            }
+
+            this.sortingSequenceCache[labelId][key] = sequence;
+        },
+        updateSortKey(key) {
+            const labelId = this.selectedLabel?.id;
+            const sequence = this.sortingSequenceCache?.[labelId]?.[key];
+            if (labelId && !sequence) {
+                this.startLoading();
+                this.fetchSortingSequence(key, labelId)
+                    .then(() => this.sortingKey = key)
+                    .catch(handleErrorResponse)
+                    .finally(this.finishLoading);
+            } else {
+                this.sortingKey = key;
+            }
+        },
     },
     watch: {
         annotations(annotations) {
diff --git a/src/resources/assets/js/projectLargoContainer.vue b/src/resources/assets/js/projectLargoContainer.vue
index fba6f2a1..ba221c5b 100644
--- a/src/resources/assets/js/projectLargoContainer.vue
+++ b/src/resources/assets/js/projectLargoContainer.vue
@@ -23,6 +23,9 @@ export default {
         performSave(payload) {
             return ProjectsApi.save({id: this.projectId}, payload);
         },
+        querySortByOutlier(labelId) {
+            return ProjectsApi.sortAnnotationsByOutlier({id: this.projectId, label_id: labelId});
+        },
     },
     created() {
         this.projectId = biigle.$require('largo.projectId');
diff --git a/src/resources/assets/sass/main.scss b/src/resources/assets/sass/main.scss
index 6161cc47..d276a6da 100644
--- a/src/resources/assets/sass/main.scss
+++ b/src/resources/assets/sass/main.scss
@@ -25,7 +25,7 @@
     }
 }
 
-.largo-tab {
+.sidebar__tab--open.largo-tab {
     display: flex !important;
     flex-direction: column;
 
diff --git a/src/resources/scripts/ExtractFeatures.py b/src/resources/scripts/ExtractFeatures.py
new file mode 100644
index 00000000..7a55540e
--- /dev/null
+++ b/src/resources/scripts/ExtractFeatures.py
@@ -0,0 +1,53 @@
+from PIL import Image
+import csv
+import json
+import numpy as np
+import sys
+import torch
+import torchvision.transforms as T
+
+# input_json = {
+#     cached_filename: {
+#         annotation_model_id: [left, top, right, bottom],
+#     },
+# }
+
+with open(sys.argv[1], 'r') as f:
+    input_json = json.load(f)
+
+if torch.cuda.is_available():
+    device = torch.device('cuda')
+    dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14').cuda()
+else:
+    device = torch.device('cpu')
+    dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14')
+
+dinov2_vits14.to(device)
+
+transform = T.Compose([
+    T.Resize((224, 224), interpolation=T.InterpolationMode.BICUBIC),
+    T.ToTensor(),
+    T.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
+])
+
+def normalize_image_mode(image):
+    if image.mode == 'RGBA' or image.mode == 'L' or image.mode == 'P':
+        image = image.convert('RGB')
+
+    if image.mode =='I':
+        # I images (32 bit signed integer) need to be rescaled manually before converting.
+        image = Image.fromarray(((np.array(image)/(2**16))*2**8).astype(np.uint8)).convert('RGB')
+
+    return image
+
+with open(sys.argv[2], 'w') as f:
+    writer = csv.writer(f)
+    with torch.no_grad():
+        for image_path, annotations in input_json.items():
+            image = Image.open(image_path)
+            image = normalize_image_mode(image)
+            for model_id, box in annotations.items():
+                image_crop = image.crop(box)
+                image_crop_t = transform(image_crop).unsqueeze(0).to(device)
+                features = dinov2_vits14(image_crop_t)
+                writer.writerow([model_id, json.dumps(features[0].tolist())])
diff --git a/src/resources/views/manual/tutorials/largo.blade.php b/src/resources/views/manual/tutorials/largo.blade.php
index d5df0d55..71110f54 100644
--- a/src/resources/views/manual/tutorials/largo.blade.php
+++ b/src/resources/views/manual/tutorials/largo.blade.php
@@ -16,7 +16,17 @@
             Largo allows you to view annotations with the same label in a regular grid. The annotations can belong to a single volume or an entire project. You can quickly select annotations to change their labels, attach new labels or delete them.
         </p>
 
-        <h3>How to use Largo</h3>
+        <p>
+            Contents:
+        </p>
+
+        <ol>
+            <li><a href="#how-to-use-largo">How to use Largo</a></li>
+            <li><a href="#advanced-usage">Advanced usage</a></li>
+            <li><a href="#example-use-cases">Example use cases</a></li>
+        </ol>
+
+        <h3><a name="how-to-use-largo"></a>How to use Largo</h3>
 
         <p>
             There are two ways to run Largo. To review annotations of an entire project, click on the <button class="btn btn-xs btn-default"><span class="fa fa-check-square" aria-hidden="true"></span> Largo re-evaluation</button> button in the project overview. To review annotations of a volume, click on the <button class="btn btn-xs btn-default"><span class="fa fa-check-square" aria-hidden="true"></span></button> button in the sidebar of the volume overview. Project guests are not allowed to use Largo.
@@ -44,7 +54,7 @@
         </p>
 
         <p>
-            Also displayed on hover is the big <span class="fa fa-times" aria-hidden="true"></span> symbol. This symbol indicates the "dismissal" of an annotation. Click on an annotation in the grid to mark it as dismissed. You can dismiss annotations belonging to differen labels, too. Once there are dismissed annotations, the <button class="btn btn-success btn-xs">Continue</button> button in the sidebar becomes clickable. Click this button when you are finished marking annotations as dismissed to continue to the next step.
+            Also displayed on hover is the big <span class="fa fa-times" aria-hidden="true"></span> symbol. This symbol indicates the "dismissal" of an annotation. Click on an annotation in the grid to mark it as dismissed. You can dismiss annotations belonging to different labels, too. Once there are dismissed annotations, the <button class="btn btn-success btn-xs">Continue</button> button in the sidebar becomes clickable. Click this button when you are finished marking annotations as dismissed to continue to the next step.
         </p>
 
         <p>
@@ -86,7 +96,36 @@
         </p>
 
 
-        <h3>Example use cases</h3>
+        <h3><a name="advanced-usage"></a>Advanced usage</h3>
+
+        <p>
+            Largo offers some features that go beyond the basic usage. Depending on the use case (see <a href="#example-use-cases">below</a>), these features can help to accelerate the annotation review process.
+        </p>
+
+        <h4>Sorting</h4>
+
+        <p>
+            By default, the annotation patches displayed by Largo are displayed with the newest annotations at the top and the oldest at the bottom. You can change the sorting with a click on the sorting tab (<i class="fa fa-exchange-alt fa-rotate-90"></i>) of the sidebar. Each sorting can be shown in descending (<i class="fa fa-sort-amount-down"></i>) or ascending (<i class="fa fa-sort-amount-up"></i>) order. The following sorting options are available:
+        </p>
+
+        <ul>
+            <li>
+                <p>
+                    <strong>Created</strong>: Sorts the annotation patches by timestamp. In descending order, the newest annotations are shown first. In ascending order, the oldest annotations are shown first.
+                </p>
+            </li>
+            <li>
+                <p>
+                    <strong>Outliers</strong>: Sort the annotation patches by unusual objects. In descending order, the annotation patches are shown first that look most "unusual" compared to all the other patches that are currently shown. In ascending order, the most "common" patches are shown first.
+                </p>
+                <p>
+                    Sorting by unusual annotation patches can help you to quickly identify errors. If most of the patches show objects with a similar visual appearance, those patches that show different objects will be shown at the top and you can quickly select them.
+                </p>
+            </li>
+        </ul>
+
+
+        <h3><a name="example-use-cases"></a>Example use cases</h3>
 
         <p>
             Now that you know how to use Largo, here are some use cases for what you can do.
diff --git a/src/resources/views/show/content.blade.php b/src/resources/views/show/content.blade.php
index 094f8ce8..12a6dc71 100644
--- a/src/resources/views/show/content.blade.php
+++ b/src/resources/views/show/content.blade.php
@@ -1,5 +1,5 @@
 <div class="sidebar-container__content">
-    <dismiss-image-grid v-if="isInDismissStep" ref="dismissGrid" :images="annotations" empty-url="{{ asset(config('thumbnails.empty_url')) }}" :width="{{config('thumbnails.width')}}" :height="{{config('thumbnails.height')}}" v-on:select="handleSelectedImageDismiss" :selectable="true" selected-icon="times"></dismiss-image-grid>
+    <dismiss-image-grid v-if="isInDismissStep" ref="dismissGrid" :images="sortedAnnotations" empty-url="{{ asset(config('thumbnails.empty_url')) }}" :width="{{config('thumbnails.width')}}" :height="{{config('thumbnails.height')}}" v-on:select="handleSelectedImageDismiss" :selectable="true" selected-icon="times"></dismiss-image-grid>
     <relabel-image-grid v-cloak v-else :images="dismissedAnnotations" empty-url="{{ asset(config('thumbnails.empty_url')) }}" :width="{{config('thumbnails.width')}}" :height="{{config('thumbnails.height')}}" v-on:select="handleSelectedImageRelabel" :selectable="true"></relabel-image-grid>
     <div class="largo-images__alerts" :class="{block: loading}">
         <div v-cloak v-if="loading">
@@ -13,11 +13,11 @@
         </div>
     </div>
 </div>
-<sidebar :show-buttons="false" open-tab="labels">
+<sidebar v-cloak open-tab="labels">
     <sidebar-tab class="largo-tab" name="labels" icon="tags" title="Label trees">
-        <div v-cloak class="largo-tab__button">
+        <div class="largo-tab__button">
             <button v-if="isInDismissStep" class="btn btn-success btn-block" :disabled="!hasDismissedAnnotations" title="Go to the re-labelling step" v-on:click="goToRelabel">Continue</button>
-            <div v-cloak v-else class="btn-group btn-group-justified">
+            <div v-else class="btn-group btn-group-justified">
                 <div class="btn-group">
                     <button class="btn btn-default col-xs-6" title="Go back to dismissing annotations" :disabled="loading" v-on:click="goToDismiss">Back</button>
                 </div>
@@ -28,10 +28,16 @@
             </div>
         </div>
         @can('force-edit-in', $target)
-            <div v-cloak v-if="isInRelabelStep" class="largo-tab__button">
+            <div v-if="isInRelabelStep" class="largo-tab__button">
                 <power-toggle :active="forceChange" type="danger" title="Delete or replace annotation labels created by other users" v-on:on="enableForceChange" :disabled="loading" v-on:off="disableForceChange">Force delete/re-label</power-toggle>
             </div>
         @endcan
         <label-trees class="largo-tab__label-trees" :trees="labelTrees" :show-favourites="true" v-on:select="handleSelectedLabel" v-on:deselect="handleDeselectedLabel" v-on:clear="handleDeselectedLabel"></label-trees>
     </sidebar-tab>
+    <sidebar-tab :disabled="isInRelabelStep" name="sorting" icon="exchange-alt fa-rotate-90" title="Sort patches" :highlight="sortingIsActive">
+        <sorting-tab
+            v-on:change-direction="updateSortDirection"
+            v-on:change-key="updateSortKey"
+            ></sorting-tab>
+    </sidebar-tab>
 </sidebar>
diff --git a/tests/Console/Commands/GenerateMissingTest.php b/tests/Console/Commands/GenerateMissingTest.php
new file mode 100644
index 00000000..b4b1473a
--- /dev/null
+++ b/tests/Console/Commands/GenerateMissingTest.php
@@ -0,0 +1,269 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Console\Commands;
+
+use Biigle\ImageAnnotation;
+use Biigle\ImageAnnotationLabel;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedImage;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedVideo;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\VideoAnnotation;
+use Biigle\VideoAnnotationLabel;
+use Biigle\Volume;
+use Bus;
+use Storage;
+use TestCase;
+
+class GenerateMissingTest extends TestCase
+{
+    public function testHandleImageAnnotations()
+    {
+        $a = ImageAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a) {
+            $this->assertEquals($a->image_id, $job->file->id);
+            $this->assertEquals([$a->id], $job->only);
+
+            return true;
+        });
+    }
+
+    public function testHandleImageAnnotationsSkipExisting()
+    {
+        $a = ImageAnnotation::factory()->create();
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $disk->put(ProcessAnnotatedImage::getTargetPath($a), 'abc');
+        $al = ImageAnnotationLabel::factory()->create(['annotation_id' => $a->id]);
+        ImageAnnotationLabelFeatureVector::factory()->create([
+            'id' => $al->id,
+            'annotation_id' => $a,
+        ]);
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing');
+        Bus::assertNotDispatched(ProcessAnnotatedImage::class);
+    }
+
+    public function testHandleVideoAnnotations()
+    {
+        $a = VideoAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing');
+        Bus::assertDispatched(ProcessAnnotatedVideo::class, function ($job) use ($a) {
+            $this->assertEquals($a->video_id, $job->file->id);
+            $this->assertEquals([$a->id], $job->only);
+
+            return true;
+        });
+    }
+
+    public function testHandleVideoAnnotationsSkipExisting()
+    {
+        $a = VideoAnnotation::factory()->create();
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $disk->put(ProcessAnnotatedVideo::getTargetPath($a), 'abc');
+        $al = VideoAnnotationLabel::factory()->create(['annotation_id' => $a->id]);
+        VideoAnnotationLabelFeatureVector::factory()->create([
+            'id' => $al->id,
+            'annotation_id' => $a,
+        ]);
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing');
+        Bus::assertNotDispatched(ProcessAnnotatedVideo::class);
+    }
+
+    public function testHandleBatching()
+    {
+        $a1 = ImageAnnotation::factory()->create();
+        $a2 = ImageAnnotation::factory()->create(['image_id' => $a1->image_id]);
+        $a3 = ImageAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a1, $a2) {
+            return $a1->image_id === $job->file->id && [$a1->id, $a2->id] === $job->only;
+        });
+
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a3) {
+            return $a3->image_id === $job->file->id && [$a3->id] === $job->only;
+        });
+    }
+
+    public function testHandleDryRun()
+    {
+        $a = ImageAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --dry-run');
+        Bus::assertNotDispatched(ProcessAnnotatedImage::class);
+    }
+
+    public function testHandleVolume()
+    {
+        $a1 = ImageAnnotation::factory()->create();
+        $a2 = ImageAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan("largo:generate-missing --volume={$a1->image->volume_id}");
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a1) {
+            $this->assertEquals($a1->image_id, $job->file->id);
+
+            return true;
+        });
+    }
+
+    public function testHandleSkipImages()
+    {
+        $a1 = ImageAnnotation::factory()->create();
+        $a2 = VideoAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --skip-images');
+        Bus::assertDispatched(ProcessAnnotatedVideo::class, function ($job) use ($a2) {
+            $this->assertEquals($a2->video, $job->file);
+
+            return true;
+        });
+
+        Bus::assertNotDispatched(ProcessAnnotatedImage::class);
+    }
+
+    public function testHandleSkipVideos()
+    {
+        $a1 = ImageAnnotation::factory()->create();
+        $a2 = VideoAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --skip-videos');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a1) {
+            $this->assertEquals($a1->image, $job->file);
+
+            return true;
+        });
+
+        Bus::assertNotDispatched(ProcessAnnotatedVideo::class);
+    }
+
+    public function testHandleQueue()
+    {
+        $a = ImageAnnotation::factory()->create();
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --queue=special');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) {
+            $this->assertEquals('special', $job->queue);
+
+            return true;
+        });
+    }
+
+    public function testHandleNewerThan()
+    {
+        $a1 = ImageAnnotation::factory()->create([
+            'created_at' => '2024-01-24',
+        ]);
+
+        $a2 = ImageAnnotation::factory()->create([
+            'created_at' => '2024-01-20',
+            'image_id' => $a1->image_id,
+        ]);
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --newer-than=2024-01-23');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a1) {
+            $this->assertEquals($a1->image_id, $job->file->id);
+            $this->assertEquals([$a1->id], $job->only);
+
+            return true;
+        });
+    }
+
+    public function testHandleOlderThan()
+    {
+        $a1 = ImageAnnotation::factory()->create([
+            'created_at' => '2024-01-24',
+        ]);
+
+        $a2 = ImageAnnotation::factory()->create([
+            'created_at' => '2024-01-20',
+            'image_id' => $a1->image_id,
+        ]);
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --older-than=2024-01-23');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a2) {
+            $this->assertEquals($a2->image_id, $job->file->id);
+            $this->assertEquals([$a2->id], $job->only);
+
+            return true;
+        });
+    }
+
+    public function testHandleSkipVectors()
+    {
+        $a1 = ImageAnnotation::factory()->create();
+        $a2 = ImageAnnotation::factory()->create(['image_id' => $a1->image_id]);
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $disk->put(ProcessAnnotatedImage::getTargetPath($a1), 'abc');
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --skip-vectors');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a2) {
+            $this->assertEquals($a2->image_id, $job->file->id);
+            $this->assertEquals([$a2->id], $job->only);
+            $this->assertTrue($job->skipFeatureVectors);
+            $this->assertFalse($job->skipPatches);
+
+            return true;
+        });
+    }
+
+    public function testHandleSkipPatches()
+    {
+        $a1 = ImageAnnotation::factory()->create();
+        $al = ImageAnnotationLabel::factory()->create(['annotation_id' => $a1->id]);
+        $a2 = ImageAnnotation::factory()->create(['image_id' => $a1->image_id]);
+        ImageAnnotationLabelFeatureVector::factory()->create([
+            'id' => $al->id,
+            'annotation_id' => $a1,
+        ]);
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing --skip-patches');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a2) {
+            $this->assertEquals($a2->image_id, $job->file->id);
+            $this->assertEquals([$a2->id], $job->only);
+            $this->assertFalse($job->skipFeatureVectors);
+            $this->assertTrue($job->skipPatches);
+
+            return true;
+        });
+    }
+
+    public function testHandleMixedPatchesVectors()
+    {
+        $a1 = ImageAnnotation::factory()->create();
+        $al = ImageAnnotationLabel::factory()->create(['annotation_id' => $a1->id]);
+        $a2 = ImageAnnotation::factory()->create(['image_id' => $a1->image_id]);
+        ImageAnnotationLabelFeatureVector::factory()->create([
+            'id' => $al->id,
+            'annotation_id' => $a1,
+        ]);
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $disk->put(ProcessAnnotatedImage::getTargetPath($a2), 'abc');
+
+        Bus::fake();
+        $this->artisan('largo:generate-missing');
+        Bus::assertDispatched(ProcessAnnotatedImage::class, function ($job) use ($a1, $a2) {
+            $this->assertEquals($a1->image_id, $job->file->id);
+            $this->assertEquals([$a1->id, $a2->id], $job->only);
+
+            return true;
+        });
+    }
+}
diff --git a/tests/Http/Controllers/Api/Projects/SortAnnotationsByOutliersControllerTest.php b/tests/Http/Controllers/Api/Projects/SortAnnotationsByOutliersControllerTest.php
new file mode 100644
index 00000000..536bc410
--- /dev/null
+++ b/tests/Http/Controllers/Api/Projects/SortAnnotationsByOutliersControllerTest.php
@@ -0,0 +1,95 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Http\Controllers\Api\Projects;
+
+use ApiTestCase;
+use Biigle\MediaType;
+use Biigle\Volume;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+
+class SortAnnotationsByOutliersControllerTest extends ApiTestCase
+{
+    public function testIndex()
+    {
+        $id = $this->project()->id;
+
+        $v1 = Volume::factory()->create();
+        $this->project()->addVolumeId($v1->id);
+
+        $l1 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $v1->id,
+        ]);
+        $l2 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $v1->id,
+            'label_id' => $l1->label_id,
+        ]);
+        $l3 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $v1->id,
+            'label_id' => $l1->label_id,
+            // The other feature vectors are identical so this one will be an outlier.
+            'vector' => range(1, 384),
+        ]);
+        $l4 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $v1->id,
+        ]);
+
+        $v2 = Volume::factory()->create(['media_type_id' => MediaType::videoId()]);
+        $this->project()->addVolumeId($v2->id);
+
+        $l5 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $v2->id,
+            'label_id' => $l1->label_id,
+        ]);
+        $l6 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $v2->id,
+            'label_id' => $l1->label_id,
+            'vector' => range(1, 384),
+        ]);
+
+        // Annotations from other volume should not appear.
+        ImageAnnotationLabelFeatureVector::factory()->create();
+        VideoAnnotationLabelFeatureVector::factory()->create();
+
+        $this->doTestApiRoute('GET', "/api/v1/projects/{$id}/annotations/sort/outliers/{$l1->label_id}");
+
+        $this->beUser();
+        $this->get("/api/v1/projects/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(403);
+
+        $this->beGuest();
+
+        $this->get("/api/v1/projects/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson([
+                'v'.$l6->annotation_id,
+                'i'.$l3->annotation_id,
+                'v'.$l5->annotation_id,
+                'i'.$l2->annotation_id,
+                'i'.$l1->annotation_id,
+            ]);
+
+        $this->get("/api/v1/projects/{$id}/annotations/sort/outliers/{$l4->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson(['i'.$l4->annotation_id]);
+    }
+
+    public function testIndexDuplicate()
+    {
+        $id = $this->project()->id;
+        $vid = $this->volume()->id;
+        $l1 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $vid,
+        ]);
+        $l2 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $vid,
+            'label_id' => $l1->label_id,
+            'annotation_id' => $l1->annotation_id,
+        ]);
+
+        $this->beEditor();
+        $this->get("/api/v1/projects/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson(['i'.$l1->annotation_id]);
+    }
+}
diff --git a/tests/Http/Controllers/Api/Volumes/SortAnnotationsByOutliersControllerTest.php b/tests/Http/Controllers/Api/Volumes/SortAnnotationsByOutliersControllerTest.php
new file mode 100644
index 00000000..81200f62
--- /dev/null
+++ b/tests/Http/Controllers/Api/Volumes/SortAnnotationsByOutliersControllerTest.php
@@ -0,0 +1,135 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Http\Controllers\Api\Volumes;
+
+use ApiTestCase;
+use Biigle\MediaType;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+
+class SortAnnotationsByOutliersControllerTest extends ApiTestCase
+{
+    public function testIndexImage()
+    {
+        $id = $this->volume()->id;
+        $l1 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+        ]);
+        $l2 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+            'label_id' => $l1->label_id,
+        ]);
+        $l3 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+            'label_id' => $l1->label_id,
+            // The other feature vectors are identical so this one will be an outlier.
+            'vector' => range(1, 384),
+        ]);
+        $l4 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+        ]);
+
+        // Annotations from other volume should not appear.
+        ImageAnnotationLabelFeatureVector::factory()->create();
+
+        $this->doTestApiRoute('GET', "/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}");
+
+        $this->beUser();
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(403);
+
+        $this->beGuest();
+
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson([
+                $l3->annotation_id,
+                $l2->annotation_id,
+                $l1->annotation_id,
+            ]);
+
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l4->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson([$l4->annotation_id]);
+    }
+
+    public function testIndexDuplicateImage()
+    {
+        $id = $this->volume()->id;
+        $l1 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+        ]);
+        $l2 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+            'label_id' => $l1->label_id,
+            'annotation_id' => $l1->annotation_id,
+        ]);
+
+        $this->beEditor();
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson([$l1->annotation_id]);
+    }
+
+    public function testIndexVideo()
+    {
+        $id = $this->volume(['media_type_id' => MediaType::videoId()])->id;
+        $l1 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+        ]);
+        $l2 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+            'label_id' => $l1->label_id,
+        ]);
+        $l3 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+            'label_id' => $l1->label_id,
+            // The other feature vectors are identical so this one will be an outlier.
+            'vector' => range(1, 384),
+        ]);
+        $l4 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+        ]);
+
+        // Annotations from other volume should not appear.
+        VideoAnnotationLabelFeatureVector::factory()->create();
+
+        $this->doTestApiRoute('GET', "/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}");
+
+        $this->beUser();
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(403);
+
+        $this->beGuest();
+
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson([
+                $l3->annotation_id,
+                $l2->annotation_id,
+                $l1->annotation_id,
+            ]);
+
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l4->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson([$l4->annotation_id]);
+    }
+
+    public function testIndexDuplicateVideo()
+    {
+        $id = $this->volume(['media_type_id' => MediaType::videoId()])->id;
+        $l1 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+        ]);
+        $l2 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'volume_id' => $id,
+            'label_id' => $l1->label_id,
+            'annotation_id' => $l1->annotation_id,
+        ]);
+
+        $this->beEditor();
+        $this->get("/api/v1/volumes/{$id}/annotations/sort/outliers/{$l1->label_id}")
+            ->assertStatus(200)
+            ->assertExactJson([$l1->annotation_id]);
+    }
+}
diff --git a/tests/ImageAnnotationLabelFeatureVectorTest.php b/tests/ImageAnnotationLabelFeatureVectorTest.php
new file mode 100644
index 00000000..37f256fd
--- /dev/null
+++ b/tests/ImageAnnotationLabelFeatureVectorTest.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo;
+
+use Biigle\ImageAnnotationLabel;
+use Biigle\ImageAnnotation;
+use Biigle\Label;
+use Biigle\LabelTree;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Volume;
+use Illuminate\Database\QueryException;
+use TestCase;
+
+class ImageAnnotationLabelFeatureVectorTest extends TestCase
+{
+    public function testAttributes()
+    {
+        $v = ImageAnnotationLabelFeatureVector::factory()->create();
+        $this->assertNotNull($v->id);
+        $this->assertNotNull($v->annotation_id);
+        $this->assertNotNull($v->label_id);
+        $this->assertNotNull($v->label_tree_id);
+        $this->assertNotNull($v->volume_id);
+        $this->assertNotNull($v->vector);
+    }
+
+    public function testDeleteAnnotationLabelCascade()
+    {
+        $v = ImageAnnotationLabelFeatureVector::factory()->create();
+        ImageAnnotationLabel::where('id', $v->id)->delete();
+        $this->assertNull($v->fresh());
+    }
+
+    public function testDeleteAnnotationCascade()
+    {
+        $v = ImageAnnotationLabelFeatureVector::factory()->create();
+        ImageAnnotation::where('id', $v->annotation_id)->delete();
+        $this->assertNull($v->fresh());
+    }
+
+    public function testDeleteLabelRestrict()
+    {
+        $v = ImageAnnotationLabelFeatureVector::factory()->create();
+        $this->expectException(QueryException::class);
+        Label::where('id', $v->label_id)->delete();
+    }
+
+    public function testDeleteLabelTreeRestrict()
+    {
+        $v = ImageAnnotationLabelFeatureVector::factory()->create();
+        $this->expectException(QueryException::class);
+        LabelTree::where('id', $v->label_tree_id)->delete();
+    }
+
+    public function testDeleteVolumeCascade()
+    {
+        $v = ImageAnnotationLabelFeatureVector::factory()->create();
+        Volume::where('id', $v->volume_id)->delete();
+        $this->assertNull($v->fresh());
+    }
+}
diff --git a/tests/Jobs/ApplyLargoSessionTest.php b/tests/Jobs/ApplyLargoSessionTest.php
index 7e855b34..1041e5f3 100644
--- a/tests/Jobs/ApplyLargoSessionTest.php
+++ b/tests/Jobs/ApplyLargoSessionTest.php
@@ -4,9 +4,11 @@
 
 use Biigle\Modules\Largo\Events\LargoSessionFailed;
 use Biigle\Modules\Largo\Events\LargoSessionSaved;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
 use Biigle\Modules\Largo\Jobs\ApplyLargoSession;
 use Biigle\Modules\Largo\Jobs\RemoveImageAnnotationPatches;
 use Biigle\Modules\Largo\Jobs\RemoveVideoAnnotationPatches;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
 use Biigle\Tests\ImageAnnotationLabelTest;
 use Biigle\Tests\ImageAnnotationTest;
 use Biigle\Tests\ImageTest;
@@ -626,6 +628,50 @@ public function testDispatchEventOnError()
             return true;
         });
     }
+
+    public function testChangeImageAnnotationCopyFeatureVector()
+    {
+        $user = UserTest::create();
+        $al1 = ImageAnnotationLabelTest::create(['user_id' => $user->id]);
+        $vector1 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'id' => $al1->id,
+            'annotation_id' => $al1->annotation_id,
+        ]);
+        $l1 = LabelTest::create();
+
+        $dismissed = [$al1->label_id => [$al1->annotation_id]];
+        $changed = [$l1->id => [$al1->annotation_id]];
+        $job = new ApplyLargoSession('job_id', $user, $dismissed, $changed, [], [], false);
+        $job->handle();
+
+        $vectors = ImageAnnotationLabelFeatureVector::where('annotation_id', $al1->annotation_id)->get();
+        $this->assertCount(1, $vectors);
+        $this->assertNotEquals($al1->id, $vectors[0]->id);
+        $this->assertEquals($l1->id, $vectors[0]->label_id);
+        $this->assertEquals($vector1->vector, $vectors[0]->vector);
+    }
+
+    public function testChangeVideoAnnotationCopyFeatureVector()
+    {
+        $user = UserTest::create();
+        $al1 = VideoAnnotationLabelTest::create(['user_id' => $user->id]);
+        $vector1 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'id' => $al1->id,
+            'annotation_id' => $al1->annotation_id,
+        ]);
+        $l1 = LabelTest::create();
+
+        $dismissed = [$al1->label_id => [$al1->annotation_id]];
+        $changed = [$l1->id => [$al1->annotation_id]];
+        $job = new ApplyLargoSession('job_id', $user, [], [], $dismissed, $changed, false);
+        $job->handle();
+
+        $vectors = VideoAnnotationLabelFeatureVector::where('annotation_id', $al1->annotation_id)->get();
+        $this->assertCount(1, $vectors);
+        $this->assertNotEquals($al1->id, $vectors[0]->id);
+        $this->assertEquals($l1->id, $vectors[0]->label_id);
+        $this->assertEquals($vector1->vector, $vectors[0]->vector);
+    }
 }
 
 class ApplyLargoSessionStub extends ApplyLargoSession
diff --git a/tests/Jobs/CopyImageAnnotationFeatureVectorTest.php b/tests/Jobs/CopyImageAnnotationFeatureVectorTest.php
new file mode 100644
index 00000000..cad04dfc
--- /dev/null
+++ b/tests/Jobs/CopyImageAnnotationFeatureVectorTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Jobs;
+
+use Biigle\Modules\Largo\Jobs\CopyImageAnnotationFeatureVector;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\ImageAnnotationLabel;
+use TestCase;
+
+class CopyImageAnnotationFeatureVectorTest extends TestCase
+{
+    public function testHandle()
+    {
+        $vector = ImageAnnotationLabelFeatureVector::factory()->create();
+        $annotationLabel = ImageAnnotationLabel::factory()->create([
+            'annotation_id' => $vector->annotation_id,
+        ]);
+
+        (new CopyImageAnnotationFeatureVector($annotationLabel))->handle();
+
+        $vectors = ImageAnnotationLabelFeatureVector::where('annotation_id', $vector->annotation_id)
+            ->orderBy('id', 'asc')->get();
+        $this->assertCount(2, $vectors);
+        $this->assertEquals($annotationLabel->id, $vectors[1]->id);
+        $this->assertEquals($annotationLabel->annotation_id, $vectors[1]->annotation_id);
+        $this->assertEquals($annotationLabel->label_id, $vectors[1]->label_id);
+        $this->assertEquals($annotationLabel->label->label_tree_id, $vectors[1]->label_tree_id);
+        $this->assertEquals($vector->volume_id, $vectors[1]->volume_id);
+        $this->assertEquals($vector->vector, $vectors[1]->vector);
+    }
+}
diff --git a/tests/Jobs/CopyVideoAnnotationFeatureVectorTest.php b/tests/Jobs/CopyVideoAnnotationFeatureVectorTest.php
new file mode 100644
index 00000000..bc35a521
--- /dev/null
+++ b/tests/Jobs/CopyVideoAnnotationFeatureVectorTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Jobs;
+
+use Biigle\Modules\Largo\Jobs\CopyVideoAnnotationFeatureVector;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\VideoAnnotationLabel;
+use TestCase;
+
+class CopyVideoAnnotationFeatureVectorTest extends TestCase
+{
+    public function testHandle()
+    {
+        $vector = VideoAnnotationLabelFeatureVector::factory()->create();
+        $annotationLabel = VideoAnnotationLabel::factory()->create([
+            'annotation_id' => $vector->annotation_id,
+        ]);
+
+        (new CopyVideoAnnotationFeatureVector($annotationLabel))->handle();
+
+        $vectors = VideoAnnotationLabelFeatureVector::where('annotation_id', $vector->annotation_id)
+            ->orderBy('id', 'asc')->get();
+        $this->assertCount(2, $vectors);
+        $this->assertEquals($annotationLabel->id, $vectors[1]->id);
+        $this->assertEquals($annotationLabel->annotation_id, $vectors[1]->annotation_id);
+        $this->assertEquals($annotationLabel->label_id, $vectors[1]->label_id);
+        $this->assertEquals($annotationLabel->label->label_tree_id, $vectors[1]->label_tree_id);
+        $this->assertEquals($vector->volume_id, $vectors[1]->volume_id);
+        $this->assertEquals($vector->vector, $vectors[1]->vector);
+    }
+}
diff --git a/tests/Jobs/GenerateImageAnnotationPatchTest.php b/tests/Jobs/GenerateImageAnnotationPatchTest.php
deleted file mode 100644
index aae70e43..00000000
--- a/tests/Jobs/GenerateImageAnnotationPatchTest.php
+++ /dev/null
@@ -1,266 +0,0 @@
-<?php
-
-namespace Biigle\Tests\Modules\Largo\Jobs;
-
-use Biigle\FileCache\Exceptions\FileLockedException;
-use Biigle\Modules\Largo\Jobs\GenerateImageAnnotationPatch;
-use Biigle\Shape;
-use Biigle\Tests\ImageAnnotationTest;
-use Bus;
-use Exception;
-use File;
-use FileCache;
-use Jcupitt\Vips\Image;
-use Log;
-use Mockery;
-use Storage;
-use TestCase;
-
-class GenerateImageAnnotationPatchTest extends TestCase
-{
-    public function setUp(): void
-    {
-        parent::setUp();
-        config(['largo.patch_storage_disk' => 'test']);
-    }
-
-    public function testHandleStorage()
-    {
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create();
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->once()
-            ->andReturn($image);
-        $image->shouldReceive('writeToBuffer')
-            ->with('.jpg', ['Q' => 85, 'strip' => true])
-            ->once()
-            ->andReturn('abc123');
-
-        $job->handleFile($annotation->image, 'abc');
-        $prefix = fragment_uuid_path($annotation->image->uuid);
-        $content = Storage::disk('test')->get("{$prefix}/{$annotation->id}.jpg");
-        $this->assertEquals('abc123', $content);
-    }
-
-    public function testHandleStorageConfigurableDisk()
-    {
-        Storage::fake('test2');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create();
-        $job = new GenerateImageAnnotationPatchStub($annotation, 'test2');
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->once()
-            ->andReturn($image);
-        $image->shouldReceive('writeToBuffer')
-            ->with('.jpg', ['Q' => 85, 'strip' => true])
-            ->once()
-            ->andReturn('abc123');
-
-        $job->handleFile($annotation->image, 'abc');
-        $prefix = fragment_uuid_path($annotation->image->uuid);
-        $content = Storage::disk('test2')->get("{$prefix}/{$annotation->id}.jpg");
-        $this->assertEquals('abc123', $content);
-    }
-
-    public function testHandlePoint()
-    {
-        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create([
-            'points' => [100, 100],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->with(26, 26, 148, 148)
-            ->once()
-            ->andReturn($image);
-
-        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->image, 'abc');
-    }
-
-    public function testHandleCircle()
-    {
-        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create([
-            // Should handle floats correctly.
-            // Make the circle large enough so the crop is not affected by the minimum
-            // dimension.
-            'points' => [300.4, 300.4, 200],
-            'shape_id' => Shape::circleId(),
-        ]);
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->with(90, 90, 420, 420)
-            ->once()
-            ->andReturn($image);
-
-        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->image, 'abc');
-    }
-
-    public function testHandleOther()
-    {
-        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create([
-            // Make the polygon large enough so the crop is not affected by the minimum
-            // dimension.
-            'points' => [100, 100, 100, 300, 300, 300, 300, 100],
-            'shape_id' => Shape::rectangleId(),
-        ]);
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->with(90, 90, 220, 220)
-            ->once()
-            ->andReturn($image);
-
-        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->image, 'abc');
-    }
-
-    public function testHandleContainedNegative()
-    {
-        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create([
-            'points' => [0, 0],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->once()
-            ->with(0, 0, 148, 148)
-            ->andReturn($image);
-
-        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->image, 'abc');
-    }
-
-    public function testHandleContainedPositive()
-    {
-        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create([
-            'points' => [1000, 750],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->once()
-            ->with(852, 602, 148, 148)
-            ->andReturn($image);
-
-        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->image, 'abc');
-    }
-
-    public function testHandleContainedTooLarge()
-    {
-        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $image->width = 100;
-        $image->height = 100;
-
-        $annotation = ImageAnnotationTest::create([
-            'points' => [50, 50],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->once()
-            ->with(0, 0, 100, 100)
-            ->andReturn($image);
-
-        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->image, 'abc');
-    }
-
-    public function testHandleMinDimension()
-    {
-        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
-        Storage::fake('test');
-        $image = $this->getImageMock();
-        $annotation = ImageAnnotationTest::create([
-            'points' => [60, 60, 10],
-            'shape_id' => Shape::circleId(),
-        ]);
-        $job = new GenerateImageAnnotationPatchStub($annotation);
-        $job->mock = $image;
-
-        $image->shouldReceive('crop')
-            ->with(10, 10, 100, 100)
-            ->once()
-            ->andReturn($image);
-
-        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->image, 'abc');
-    }
-
-    public function testHandleError()
-    {
-        FileCache::shouldReceive('get')->andThrow(new Exception('error'));
-        Log::shouldReceive('warning')->once();
-
-        $annotation = ImageAnnotationTest::create();
-        $job = new GenerateImageAnnotationPatch($annotation);
-        $job->handle();
-    }
-
-    public function testFileLockedError()
-    {
-        Bus::fake();
-        FileCache::shouldReceive('get')->andThrow(FileLockedException::class);
-
-        $annotation = ImageAnnotationTest::create();
-        $job = new GenerateImageAnnotationPatch($annotation);
-        $job->handle();
-        Bus::assertDispatched(GenerateImageAnnotationPatch::class);
-    }
-
-    protected function getImageMock($times = 1)
-    {
-        $image = Mockery::mock();
-        $image->width = 1000;
-        $image->height = 750;
-        $image->shouldReceive('resize')
-            ->times($times)
-            ->andReturn($image);
-
-        return $image;
-    }
-}
-
-class GenerateImageAnnotationPatchStub extends GenerateImageAnnotationPatch
-{
-    public function getVipsImage($path)
-    {
-        return $this->mock;
-    }
-}
diff --git a/tests/Jobs/GenerateVideoAnnotationPatchesTest.php b/tests/Jobs/GenerateVideoAnnotationPatchesTest.php
deleted file mode 100644
index 3dd1c9cd..00000000
--- a/tests/Jobs/GenerateVideoAnnotationPatchesTest.php
+++ /dev/null
@@ -1,342 +0,0 @@
-<?php
-
-namespace Biigle\Tests\Modules\Largo\Jobs;
-
-use Biigle\FileCache\Exceptions\FileLockedException;
-use Biigle\Modules\Largo\Jobs\GenerateVideoAnnotationPatch;
-use Biigle\Shape;
-use Biigle\Tests\VideoAnnotationTest;
-use Biigle\VideoAnnotation;
-use Bus;
-use Exception;
-use FFMpeg\Media\Video;
-use File;
-use FileCache;
-use Log;
-use Mockery;
-use Storage;
-use TestCase;
-
-class GenerateVideoAnnotationPatchesTest extends TestCase
-{
-    public function setUp(): void
-    {
-        parent::setUp();
-        config(['largo.patch_storage_disk' => 'test']);
-    }
-
-    public function testHandleStorage()
-    {
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            'points' => [],
-            'frames' => [0, 10],
-            'shape_id' => Shape::wholeFrameId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('writeToBuffer')
-            ->with('.jpg', ['Q' => 85, 'strip' => true])
-            ->once()
-            ->andReturn('abc123');
-
-        $job->handleFile($annotation->video, 'abc');
-        $prefix = fragment_uuid_path($annotation->video->uuid);
-
-        $content = Storage::disk('test')->get("{$prefix}/v-{$annotation->id}.jpg");
-        $this->assertEquals('abc123', $content);
-    }
-
-    public function testHandleStorageConfigurableDisk()
-    {
-        Storage::fake('test2');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            'points' => [],
-            'frames' => [0, 10],
-            'shape_id' => Shape::wholeFrameId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation, 'test2');
-        $job->mock = $video;
-
-        $video->shouldReceive('writeToBuffer')
-            ->with('.jpg', ['Q' => 85, 'strip' => true])
-            ->once()
-            ->andReturn('abc123');
-
-        $job->handleFile($annotation->video, 'abc');
-        $prefix = fragment_uuid_path($annotation->video->uuid);
-
-        $content = Storage::disk('test2')->get("{$prefix}/v-{$annotation->id}.jpg");
-        $this->assertEquals('abc123', $content);
-    }
-
-    public function testHandlePoint()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            // Should handle floats correctly.
-            'points' => [[100.4, 100.4], [200, 200]],
-            'frames' => [1, 2],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->with(26, 26, 148, 148)
-            ->once()
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-        $this->assertEquals([1], $job->times);
-    }
-
-    public function testHandleCircle()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            // Make the circle large enough so the crop is not affected by the minimum
-            // dimension.
-            'points' => [[300, 300, 200], [400, 400, 200]],
-            'frames' => [1, 2],
-            'shape_id' => Shape::circleId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->with(90, 90, 420, 420)
-            ->once()
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-        $this->assertEquals([1], $job->times);
-    }
-
-    public function testHandleOther()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            // Make the polygon large enough so the crop is not affected by the minimum
-            // dimension.
-            'points' => [
-                [100, 100, 150, 200, 200, 100, 100, 100],
-                [200, 200, 250, 300, 300, 200, 200, 200],
-            ],
-            'frames' => [1, 2],
-            'shape_id' => Shape::polygonId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->with(90, 90, 120, 120)
-            ->once()
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-    }
-
-    public function testHandleSingleFrame()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            'points' => [[100, 100]],
-            'frames' => [1],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->with(26, 26, 148, 148)
-            ->once()
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-        $this->assertEquals([1], $job->times);
-    }
-
-    public function testHandleContainedNegative()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            'points' => [[0, 0]],
-            'frames' => [1],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->with(0, 0, 148, 148)
-            ->once()
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-        $this->assertEquals([1], $job->times);
-    }
-
-    public function testHandleContainedPositive()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            'points' => [[1000, 750]],
-            'frames' => [1],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->with(852, 602, 148, 148)
-            ->once()
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-        $this->assertEquals([1], $job->times);
-    }
-
-    public function testHandleContainedTooLarge()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $video->width = 100;
-        $video->height = 100;
-
-        $annotation = VideoAnnotationTest::create([
-            'points' => [[50, 50]],
-            'frames' => [1],
-            'shape_id' => Shape::pointId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->once()
-            ->with(0, 0, 100, 100)
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-        $this->assertEquals([1], $job->times);
-    }
-
-    public function testHandleMinDimension()
-    {
-        config([
-            'thumbnails.height' => 100,
-            'thumbnails.width' => 100,
-        ]);
-        Storage::fake('test');
-        $video = $this->getFrameMock();
-        $annotation = VideoAnnotationTest::create([
-            'points' => [[60, 60, 10]],
-            'frames' => [1],
-            'shape_id' => Shape::circleId(),
-        ]);
-        $job = new GenerateVideoAnnotationPatchStub($annotation);
-        $job->mock = $video;
-
-        $video->shouldReceive('crop')
-            ->with(10, 10, 100, 100)
-            ->once()
-            ->andReturn($video);
-
-        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
-        $job->handleFile($annotation->video, 'abc');
-    }
-
-    public function testHandleError()
-    {
-        FileCache::shouldReceive('get')->andThrow(new Exception('error'));
-        Log::shouldReceive('warning')->once();
-
-        $annotation = VideoAnnotationTest::create();
-        $job = new GenerateVideoAnnotationPatch($annotation);
-        $job->handle();
-    }
-
-    public function testFileLockedError()
-    {
-        Bus::fake();
-        FileCache::shouldReceive('get')->andThrow(FileLockedException::class);
-
-        $annotation = VideoAnnotationTest::create();
-        $job = new GenerateVideoAnnotationPatch($annotation);
-        $job->handle();
-        Bus::assertDispatched(GenerateVideoAnnotationPatch::class);
-    }
-
-    protected function getFrameMock($times = 1)
-    {
-        $video = Mockery::mock();
-        $video->width = 1000;
-        $video->height = 750;
-        $video->shouldReceive('resize')
-            ->times($times)
-            ->andReturn($video);
-
-        return $video;
-    }
-}
-
-class GenerateVideoAnnotationPatchStub extends GenerateVideoAnnotationPatch
-{
-    public $times = [];
-
-    public function getVideo($path)
-    {
-        return Mockery::mock(Video::class);
-    }
-
-    public function getVideoFrame(Video $video, $time)
-    {
-        $this->times[] = $time;
-
-        return $this->mock;
-    }
-}
diff --git a/tests/Jobs/InitializeFeatureVectorChunkTest.php b/tests/Jobs/InitializeFeatureVectorChunkTest.php
new file mode 100644
index 00000000..969402a2
--- /dev/null
+++ b/tests/Jobs/InitializeFeatureVectorChunkTest.php
@@ -0,0 +1,238 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Jobs;
+
+use Biigle\Image;
+use Biigle\ImageAnnotation;
+use Biigle\ImageAnnotationLabel;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\Jobs\InitializeFeatureVectorChunk;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedFile;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\Shape;
+use Biigle\VideoAnnotation;
+use Biigle\VideoAnnotationLabel;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+use TestCase;
+
+class InitializeFeatureVectorChunkTest extends TestCase
+{
+    public function testHandleImages()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $al = ImageAnnotationLabel::factory()->create();
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+
+        $input = $job->input;
+        $this->assertCount(1, $input);
+        $path = array_keys($input)[0];
+        $this->assertFalse(File::exists($path));
+        $item = $input[$path];
+        $this->assertArrayHasKey($al->annotation_id, $item);
+
+        $model = ImageAnnotationLabelFeatureVector::find($al->id);
+        $this->assertNotNull($model);
+        $this->assertEquals($al->annotation_id, $model->annotation_id);
+        $this->assertEquals($al->annotation_id, $model->annotation_id);
+        $this->assertEquals($al->label_id, $model->label_id);
+        $this->assertEquals($al->label->label_tree_id, $model->label_tree_id);
+        $this->assertEquals($al->annotation->image->volume_id, $model->volume_id);
+        $this->assertEquals(range(0, 383), $model->vector->toArray());
+    }
+
+    public function testHandleVideos()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $a = VideoAnnotation::factory()->create(['points' => [[10, 10]]]);
+        $al = VideoAnnotationLabel::factory()->create(['annotation_id' => $a->id]);
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([], [$al->annotation_id]);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+
+        $model = VideoAnnotationLabelFeatureVector::find($al->id);
+        $this->assertNotNull($model);
+        $this->assertEquals($al->annotation_id, $model->annotation_id);
+        $this->assertEquals($al->annotation_id, $model->annotation_id);
+        $this->assertEquals($al->label_id, $model->label_id);
+        $this->assertEquals($al->label->label_tree_id, $model->label_tree_id);
+        $this->assertEquals($al->annotation->video->volume_id, $model->volume_id);
+        $this->assertEquals(range(0, 383), $model->vector->toArray());
+    }
+
+    public function testHandleSkipMissingAnnotations()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $al = ImageAnnotationLabel::factory()->create();
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $al->delete();
+        $job->handle();
+        $this->assertNull(ImageAnnotationLabelFeatureVector::find($al->id));
+    }
+
+    public function testHandleSkipExistingVectors()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $al = ImageAnnotationLabel::factory()->create();
+        $v = ImageAnnotationLabelFeatureVector::factory()->create([
+            'id' => $al->id,
+            'annotation_id' => $al->annotation_id,
+            'vector' => range(0, 383),
+        ]);
+        $job = new InitializeFeatureVectorChunkStub([$v->annotation_id], []);
+        $job->output = $v->annotation_id.',"'.json_encode(range(1, 384)).'"';
+        $job->handle();
+
+        $this->assertEquals(range(0, 383), $v->fresh()->vector->toArray());
+    }
+
+    public function testHandleSkipMissingThumbnails()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $al = ImageAnnotationLabel::factory()->create();
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+        $this->assertNull(ImageAnnotationLabelFeatureVector::find($al->id));
+    }
+
+    public function testHandleMultipleLabels()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $al = ImageAnnotationLabel::factory()->create();
+        $al2 = ImageAnnotationLabel::factory()->create([
+            'annotation_id' => $al->annotation_id,
+        ]);
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+
+        $model = ImageAnnotationLabelFeatureVector::find($al->id);
+        $this->assertNotNull($model);
+        $this->assertEquals($al->annotation_id, $model->annotation_id);
+        $this->assertEquals($al->annotation_id, $model->annotation_id);
+        $this->assertEquals($al->label_id, $model->label_id);
+        $this->assertEquals($al->label->label_tree_id, $model->label_tree_id);
+        $this->assertEquals($al->annotation->image->volume_id, $model->volume_id);
+        $this->assertEquals(range(0, 383), $model->vector->toArray());
+
+        $model = ImageAnnotationLabelFeatureVector::find($al2->id);
+        $this->assertNotNull($model);
+        $this->assertEquals($al2->annotation_id, $model->annotation_id);
+        $this->assertEquals($al2->annotation_id, $model->annotation_id);
+        $this->assertEquals($al2->label_id, $model->label_id);
+        $this->assertEquals($al2->label->label_tree_id, $model->label_tree_id);
+        $this->assertEquals($al2->annotation->image->volume_id, $model->volume_id);
+        $this->assertEquals(range(0, 383), $model->vector->toArray());
+    }
+
+    public function testHandlePoint()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $image = Image::factory()->create([
+            'attrs' => ['width' => 200, 'height' => 200],
+        ]);
+        $a = ImageAnnotation::factory()->create([
+            'shape_id' => Shape::pointId(),
+            'points' => [100, 100],
+            'image_id' => $image->id,
+        ]);
+        $al = ImageAnnotationLabel::factory()->create(['annotation_id' => $a->id]);
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+
+        $input = $job->input;
+        $path = array_keys($input)[0];
+        $item = $input[$path];
+        $this->assertEquals([23, 0, 158, 135], $item[$a->id]);
+    }
+
+    public function testHandleCircle()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $image = Image::factory()->create([
+            'attrs' => ['width' => 200, 'height' => 200],
+        ]);
+        $a = ImageAnnotation::factory()->create([
+            'shape_id' => Shape::circleId(),
+            'points' => [100, 100, 10],
+            'image_id' => $image->id,
+        ]);
+        $al = ImageAnnotationLabel::factory()->create(['annotation_id' => $a->id]);
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+
+        $input = $job->input;
+        $path = array_keys($input)[0];
+        $item = $input[$path];
+        $this->assertEquals([70, 47, 110, 87], $item[$a->id]);
+    }
+
+    public function testHandlePolygon()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $image = Image::factory()->create([
+            'attrs' => ['width' => 200, 'height' => 200],
+        ]);
+        $a = ImageAnnotation::factory()->create([
+            'shape_id' => Shape::polygonId(),
+            'points' => [100, 90, 110, 100, 100, 110, 90, 100],
+            'image_id' => $image->id,
+        ]);
+        $al = ImageAnnotationLabel::factory()->create(['annotation_id' => $a->id]);
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+
+        $input = $job->input;
+        $path = array_keys($input)[0];
+        $item = $input[$path];
+        $this->assertEquals([70, 47, 110, 87], $item[$a->id]);
+    }
+
+    public function testHandleWholeFrame()
+    {
+        $disk = Storage::fake(config('largo.patch_storage_disk'));
+        $image = Image::factory()->create([
+            'attrs' => ['width' => 200, 'height' => 200],
+        ]);
+        $a = ImageAnnotation::factory()->create([
+            'shape_id' => Shape::wholeFrameId(),
+            'image_id' => $image->id,
+        ]);
+        $al = ImageAnnotationLabel::factory()->create(['annotation_id' => $a->id]);
+        $disk->put(ProcessAnnotatedFile::getTargetPath($al->annotation), 'abc');
+        $job = new InitializeFeatureVectorChunkStub([$al->annotation_id], []);
+        $job->output = $al->annotation_id.',"'.json_encode(range(0, 383)).'"';
+        $job->handle();
+
+        $input = $job->input;
+        $path = array_keys($input)[0];
+        $item = $input[$path];
+        $this->assertEquals([0, 0, 180, 135], $item[$a->id]);
+    }
+}
+
+class InitializeFeatureVectorChunkStub extends InitializeFeatureVectorChunk
+{
+    public array $input = [];
+    public string $output = '';
+
+    protected function python(string $inputPath, string $outputPath)
+    {
+        $this->input = json_decode(File::get($inputPath), true);
+        File::put($outputPath, $this->output);
+    }
+}
diff --git a/tests/Jobs/ProcessAnnotatedImageTest.php b/tests/Jobs/ProcessAnnotatedImageTest.php
new file mode 100644
index 00000000..bf88ae1a
--- /dev/null
+++ b/tests/Jobs/ProcessAnnotatedImageTest.php
@@ -0,0 +1,537 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Jobs;
+
+use Biigle\FileCache\Exceptions\FileLockedException;
+use Biigle\Modules\Largo\ImageAnnotationLabelFeatureVector;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedImage;
+use Biigle\Shape;
+use Biigle\Tests\ImageAnnotationLabelTest;
+use Biigle\Tests\ImageAnnotationTest;
+use Bus;
+use Exception;
+use File;
+use FileCache;
+use Jcupitt\Vips\Image;
+use Log;
+use Mockery;
+use Storage;
+use TestCase;
+
+class ProcessAnnotatedImageTest extends TestCase
+{
+    public function setUp(): void
+    {
+        parent::setUp();
+        config(['largo.patch_storage_disk' => 'test']);
+    }
+
+    public function testHandleStorage()
+    {
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create();
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->once()
+            ->andReturn($image);
+        $image->shouldReceive('writeToBuffer')
+            ->with('.jpg', ['Q' => 85, 'strip' => true])
+            ->once()
+            ->andReturn('abc123');
+
+        $job->handleFile($annotation->image, 'abc');
+        $prefix = fragment_uuid_path($annotation->image->uuid);
+        $content = Storage::disk('test')->get("{$prefix}/{$annotation->id}.jpg");
+        $this->assertEquals('abc123', $content);
+    }
+
+    public function testHandleStorageConfigurableDisk()
+    {
+        Storage::fake('test2');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create();
+        $job = new ProcessAnnotatedImageStub($annotation->image, targetDisk: 'test2');
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->once()
+            ->andReturn($image);
+        $image->shouldReceive('writeToBuffer')
+            ->with('.jpg', ['Q' => 85, 'strip' => true])
+            ->once()
+            ->andReturn('abc123');
+
+        $job->handleFile($annotation->image, 'abc');
+        $prefix = fragment_uuid_path($annotation->image->uuid);
+        $content = Storage::disk('test2')->get("{$prefix}/{$annotation->id}.jpg");
+        $this->assertEquals('abc123', $content);
+    }
+
+    public function testHandlePoint()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create([
+            'points' => [100, 100],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->with(26, 26, 148, 148)
+            ->once()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleCircle()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create([
+            // Should handle floats correctly.
+            // Make the circle large enough so the crop is not affected by the minimum
+            // dimension.
+            'points' => [300.4, 300.4, 200],
+            'shape_id' => Shape::circleId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->with(90, 90, 420, 420)
+            ->once()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleOther()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create([
+            // Make the polygon large enough so the crop is not affected by the minimum
+            // dimension.
+            'points' => [100, 100, 100, 300, 300, 300, 300, 100],
+            'shape_id' => Shape::rectangleId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->with(90, 90, 220, 220)
+            ->once()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleContainedNegative()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create([
+            'points' => [0, 0],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->once()
+            ->with(0, 0, 148, 148)
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleContainedPositive()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create([
+            'points' => [1000, 750],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->once()
+            ->with(852, 602, 148, 148)
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleContainedTooLarge()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $image->width = 100;
+        $image->height = 100;
+
+        $annotation = ImageAnnotationTest::create([
+            'points' => [50, 50],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->once()
+            ->with(0, 0, 100, 100)
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleMinDimension()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $annotation = ImageAnnotationTest::create([
+            'points' => [60, 60, 10],
+            'shape_id' => Shape::circleId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->with(10, 10, 100, 100)
+            ->once()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleContainedNegativeProblematic()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $image->width = 25;
+        $image->height = 25;
+        $annotation = ImageAnnotationTest::create([
+            'points' => [10, 10, 15],
+            'shape_id' => Shape::circleId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->with(0, 0, 25, 25)
+            ->once()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleContainedPositiveProblematic()
+    {
+        config(['thumbnails.height' => 100, 'thumbnails.width' => 100]);
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $image->width = 25;
+        $image->height = 25;
+        $annotation = ImageAnnotationTest::create([
+            'points' => [15, 15, 15],
+            'shape_id' => Shape::circleId(),
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->with(0, 0, 25, 25)
+            ->once()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->image, 'abc');
+    }
+
+    public function testHandleError()
+    {
+        FileCache::shouldReceive('get')->andThrow(new Exception('error'));
+        Log::shouldReceive('warning')->once();
+
+        $annotation = ImageAnnotationTest::create();
+        $job = new ProcessAnnotatedImage($annotation->image);
+        $job->handle();
+    }
+
+    public function testFileLockedError()
+    {
+        Bus::fake();
+        FileCache::shouldReceive('get')->andThrow(FileLockedException::class);
+
+        $annotation = ImageAnnotationTest::create();
+        $job = new ProcessAnnotatedImage($annotation->image);
+        $job->handle();
+        Bus::assertDispatched(ProcessAnnotatedImage::class);
+    }
+
+    public function testGenerateFeatureVectorNew()
+    {
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $image->shouldReceive('crop')->andReturn($image);
+        $image->shouldReceive('writeToBuffer')->andReturn('abc123');
+        $annotation = ImageAnnotationTest::create([
+            'points' => [200, 200],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $annotationLabel = ImageAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+        $job->output = [[$annotation->id, '"'.json_encode(range(0, 383)).'"']];
+        $job->handleFile($annotation->image, 'abc');
+
+        $input = $job->input;
+        $this->assertCount(1, $input);
+        $filename = array_keys($input)[0];
+        $this->assertArrayHasKey($annotation->id, $input[$filename]);
+        $box = $input[$filename][$annotation->id];
+        $this->assertEquals([88, 88, 312, 312], $box);
+
+        $vectors = ImageAnnotationLabelFeatureVector::where('annotation_id', $annotation->id)->get();
+        $this->assertCount(1, $vectors);
+        $this->assertEquals($annotationLabel->id, $vectors[0]->id);
+        $this->assertEquals($annotationLabel->label_id, $vectors[0]->label_id);
+        $this->assertEquals($annotationLabel->label->label_tree_id, $vectors[0]->label_tree_id);
+        $this->assertEquals($annotation->image->volume_id, $vectors[0]->volume_id);
+        $this->assertEquals(range(0, 383), $vectors[0]->vector->toArray());
+    }
+
+    public function testGenerateFeatureVectorManyLabels()
+    {
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $image->shouldReceive('crop')->andReturn($image);
+        $image->shouldReceive('writeToBuffer')->andReturn('abc123');
+        $annotation = ImageAnnotationTest::create([
+            'points' => [200, 200],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $annotationLabel1 = ImageAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $annotationLabel2 = ImageAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+        $job->output = [[$annotation->id, '"'.json_encode(range(0, 383)).'"']];
+        $job->handleFile($annotation->image, 'abc');
+
+        $vectors = ImageAnnotationLabelFeatureVector::where('annotation_id', $annotation->id)->get();
+        $this->assertCount(2, $vectors);
+        $this->assertEquals($annotationLabel1->id, $vectors[0]->id);
+        $this->assertEquals($annotationLabel1->label_id, $vectors[0]->label_id);
+        $this->assertEquals(range(0, 383), $vectors[0]->vector->toArray());
+
+        $this->assertEquals($annotationLabel2->id, $vectors[1]->id);
+        $this->assertEquals($annotationLabel2->label_id, $vectors[1]->label_id);
+        $this->assertEquals(range(0, 383), $vectors[1]->vector->toArray());
+    }
+
+    public function testGenerateFeatureVectorUpdate()
+    {
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $image->shouldReceive('crop')->andReturn($image);
+        $image->shouldReceive('writeToBuffer')->andReturn('abc123');
+        $annotation = ImageAnnotationTest::create([
+            'points' => [200, 200],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $annotationLabel = ImageAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $iafv = ImageAnnotationLabelFeatureVector::factory()->create([
+            'id' => $annotationLabel->id,
+            'annotation_id' => $annotation->id,
+            'vector' => range(0, 383),
+        ]);
+
+        $annotationLabel2 = ImageAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $iafv2 = ImageAnnotationLabelFeatureVector::factory()->create([
+            'id' => $annotationLabel2->id,
+            'annotation_id' => $annotation->id,
+            'vector' => range(0, 383),
+        ]);
+
+        $job = new ProcessAnnotatedImageStub($annotation->image);
+        $job->mock = $image;
+        $job->output = [[$annotation->id, '"'.json_encode(range(1, 384)).'"']];
+        $job->handleFile($annotation->image, 'abc');
+
+        $count = ImageAnnotationLabelFeatureVector::count();
+        $this->assertEquals(2, $count);
+        $this->assertEquals(range(1, 384), $iafv->fresh()->vector->toArray());
+        $this->assertEquals(range(1, 384), $iafv2->fresh()->vector->toArray());
+    }
+
+    public function testHandlePatchOnly()
+    {
+        Storage::fake('test');
+        $image = $this->getImageMock();
+        $image->shouldReceive('crop')->andReturn($image);
+        $image->shouldReceive('writeToBuffer')->andReturn('abc123');
+
+        $annotation = ImageAnnotationTest::create([
+            'points' => [200, 200],
+            'shape_id' => Shape::pointId(),
+        ]);
+        ImageAnnotationLabelTest::create(['annotation_id' => $annotation->id]);
+        $job = new ProcessAnnotatedImageStub($annotation->image, skipFeatureVectors: true);
+        $job->mock = $image;
+        $job->output = [[$annotation->id, '"'.json_encode(range(1, 384)).'"']];
+
+        $job->handleFile($annotation->image, 'abc');
+        $prefix = fragment_uuid_path($annotation->image->uuid);
+        Storage::disk('test')->assertExists("{$prefix}/{$annotation->id}.jpg");
+        $this->assertEquals(0, ImageAnnotationLabelFeatureVector::count());
+    }
+
+    public function testHandleFeatureVectorOnly()
+    {
+        Storage::fake('test');
+        $annotation = ImageAnnotationTest::create([
+            'points' => [200, 200],
+            'shape_id' => Shape::pointId(),
+        ]);
+        ImageAnnotationLabelTest::create(['annotation_id' => $annotation->id]);
+        $job = new ProcessAnnotatedImageStub($annotation->image, skipPatches: true);
+        $job->output = [[$annotation->id, '"'.json_encode(range(1, 384)).'"']];
+
+        $job->handleFile($annotation->image, 'abc');
+        $prefix = fragment_uuid_path($annotation->image->uuid);
+        Storage::disk('test')->assertMissing("{$prefix}/{$annotation->id}.jpg");
+        $this->assertEquals(1, ImageAnnotationLabelFeatureVector::count());
+    }
+
+    public function testHandleMultipleAnnotations()
+    {
+        Storage::fake('test');
+        $image = $this->getImageMock(2);
+        $annotation1 = ImageAnnotationTest::create([
+            'points' => [100, 100],
+            'shape_id' => Shape::pointId(),
+        ]);
+        ImageAnnotationLabelTest::create(['annotation_id' => $annotation1->id]);
+        $annotation2 = ImageAnnotationTest::create([
+            'points' => [120, 120],
+            'shape_id' => Shape::pointId(),
+            'image_id' => $annotation1->image_id,
+        ]);
+        ImageAnnotationLabelTest::create(['annotation_id' => $annotation2->id]);
+
+        $job = new ProcessAnnotatedImageStub($annotation1->image);
+        $job->output = [
+            [$annotation1->id, '"'.json_encode(range(1, 384)).'"'],
+            [$annotation2->id, '"'.json_encode(range(1, 384)).'"'],
+        ];
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->twice()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->twice()->andReturn('abc123');
+        $job->handleFile($annotation1->image, 'abc');
+        $prefix = fragment_uuid_path($annotation1->image->uuid);
+        Storage::disk('test')->assertExists("{$prefix}/{$annotation1->id}.jpg");
+        Storage::disk('test')->assertExists("{$prefix}/{$annotation2->id}.jpg");
+        $this->assertEquals(2, ImageAnnotationLabelFeatureVector::count());
+    }
+
+    public function testHandleOnlyAnnotations()
+    {
+        Storage::fake('test');
+        $image = $this->getImageMock(1);
+        $annotation1 = ImageAnnotationTest::create([
+            'points' => [100, 100],
+            'shape_id' => Shape::pointId(),
+        ]);
+        ImageAnnotationLabelTest::create(['annotation_id' => $annotation1->id]);
+        $annotation2 = ImageAnnotationTest::create([
+            'points' => [120, 120],
+            'shape_id' => Shape::pointId(),
+            'image_id' => $annotation1->image_id,
+        ]);
+        ImageAnnotationLabelTest::create(['annotation_id' => $annotation2->id]);
+
+        $job = new ProcessAnnotatedImageStub($annotation1->image, only: [$annotation1->id]);
+        $job->output = [[$annotation1->id, '"'.json_encode(range(1, 384)).'"']];
+        $job->mock = $image;
+
+        $image->shouldReceive('crop')
+            ->once()
+            ->andReturn($image);
+
+        $image->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation1->image, 'abc');
+        $prefix = fragment_uuid_path($annotation1->image->uuid);
+        Storage::disk('test')->assertExists("{$prefix}/{$annotation1->id}.jpg");
+        Storage::disk('test')->assertMissing("{$prefix}/{$annotation2->id}.jpg");
+        $this->assertEquals(1, ImageAnnotationLabelFeatureVector::count());
+    }
+
+    protected function getImageMock($times = 1)
+    {
+        $image = Mockery::mock();
+        $image->width = 1000;
+        $image->height = 750;
+        $image->shouldReceive('resize')
+            ->times($times)
+            ->andReturn($image);
+
+        return $image;
+    }
+}
+
+class ProcessAnnotatedImageStub extends ProcessAnnotatedImage
+{
+    public $input;
+    public $outputPath;
+    public $output = [];
+
+    public function getVipsImage($path)
+    {
+        return $this->mock;
+    }
+
+    protected function python(string $inputPath, string $outputPath)
+    {
+        $this->input = json_decode(File::get($inputPath), true);
+        $this->outputPath = $outputPath;
+        $csv = implode("\n", array_map(fn ($row) => implode(',', $row), $this->output));
+        File::put($outputPath, $csv);
+    }
+}
diff --git a/tests/Jobs/ProcessAnnotatedVideoTest.php b/tests/Jobs/ProcessAnnotatedVideoTest.php
new file mode 100644
index 00000000..e38c9be9
--- /dev/null
+++ b/tests/Jobs/ProcessAnnotatedVideoTest.php
@@ -0,0 +1,611 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Jobs;
+
+use Biigle\FileCache\Exceptions\FileLockedException;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedVideo;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\Shape;
+use Biigle\Tests\VideoAnnotationLabelTest;
+use Biigle\Tests\VideoAnnotationTest;
+use Biigle\Video as VideoModel;
+use Biigle\VideoAnnotation;
+use Bus;
+use Exception;
+use FFMpeg\Media\Video;
+use File;
+use FileCache;
+use Log;
+use Mockery;
+use Storage;
+use TestCase;
+
+class ProcessAnnotatedVideoTest extends TestCase
+{
+    public function setUp(): void
+    {
+        parent::setUp();
+        config(['largo.patch_storage_disk' => 'test']);
+    }
+
+    public function testHandleStorage()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            'points' => [],
+            'frames' => [0, 10],
+            'shape_id' => Shape::wholeFrameId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('writeToBuffer')
+            ->with('.jpg', ['Q' => 85, 'strip' => true])
+            ->once()
+            ->andReturn('abc123');
+
+        $job->handleFile($annotation->video, 'abc');
+        $prefix = fragment_uuid_path($annotation->video->uuid);
+
+        $content = Storage::disk('test')->get("{$prefix}/v-{$annotation->id}.jpg");
+        $this->assertEquals('abc123', $content);
+    }
+
+    public function testHandleStorageConfigurableDisk()
+    {
+        Storage::fake('test2');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            'points' => [],
+            'frames' => [0, 10],
+            'shape_id' => Shape::wholeFrameId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video, targetDisk: 'test2');
+        $job->mock = $video;
+
+        $video->shouldReceive('writeToBuffer')
+            ->with('.jpg', ['Q' => 85, 'strip' => true])
+            ->once()
+            ->andReturn('abc123');
+
+        $job->handleFile($annotation->video, 'abc');
+        $prefix = fragment_uuid_path($annotation->video->uuid);
+
+        $content = Storage::disk('test2')->get("{$prefix}/v-{$annotation->id}.jpg");
+        $this->assertEquals('abc123', $content);
+    }
+
+    public function testHandlePoint()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            // Should handle floats correctly.
+            'points' => [[100.4, 100.4], [200, 200]],
+            'frames' => [1, 2],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->with(26, 26, 148, 148)
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+        $this->assertEquals([1], $job->times);
+    }
+
+    public function testHandleCircle()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            // Make the circle large enough so the crop is not affected by the minimum
+            // dimension.
+            'points' => [[300, 300, 200], [400, 400, 200]],
+            'frames' => [1, 2],
+            'shape_id' => Shape::circleId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->with(90, 90, 420, 420)
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+        $this->assertEquals([1], $job->times);
+    }
+
+    public function testHandleOther()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            // Make the polygon large enough so the crop is not affected by the minimum
+            // dimension.
+            'points' => [
+                [100, 100, 150, 200, 200, 100, 100, 100],
+                [200, 200, 250, 300, 300, 200, 200, 200],
+            ],
+            'frames' => [1, 2],
+            'shape_id' => Shape::polygonId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->with(90, 90, 120, 120)
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+    }
+
+    public function testHandleSingleFrame()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[100, 100]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->with(26, 26, 148, 148)
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+        $this->assertEquals([1], $job->times);
+    }
+
+    public function testHandleContainedNegative()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[0, 0]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->with(0, 0, 148, 148)
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+        $this->assertEquals([1], $job->times);
+    }
+
+    public function testHandleContainedPositive()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[1000, 750]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->with(852, 602, 148, 148)
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+        $this->assertEquals([1], $job->times);
+    }
+
+    public function testHandleContainedTooLarge()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $video->width = 100;
+        $video->height = 100;
+
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[50, 50]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->once()
+            ->with(0, 0, 100, 100)
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+        $this->assertEquals([1], $job->times);
+    }
+
+    public function testHandleMinDimension()
+    {
+        config([
+            'thumbnails.height' => 100,
+            'thumbnails.width' => 100,
+        ]);
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[60, 60, 10]],
+            'frames' => [1],
+            'shape_id' => Shape::circleId(),
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->with(10, 10, 100, 100)
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation->video, 'abc');
+    }
+
+    public function testHandleError()
+    {
+        FileCache::shouldReceive('get')->andThrow(new Exception('error'));
+        Log::shouldReceive('warning')->once();
+
+        $annotation = VideoAnnotationTest::create();
+        $job = new ProcessAnnotatedVideo($annotation->video);
+        $job->handle();
+    }
+
+    public function testFileLockedError()
+    {
+        Bus::fake();
+        FileCache::shouldReceive('get')->andThrow(FileLockedException::class);
+
+        $annotation = VideoAnnotationTest::create();
+        $job = new ProcessAnnotatedVideo($annotation->video);
+        $job->handle();
+        Bus::assertDispatched(ProcessAnnotatedVideo::class);
+    }
+
+    public function testGenerateFeatureVectorNew()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $video->shouldReceive('crop')->andReturn($video);
+        $video->shouldReceive('writeToBuffer')->andReturn('abc123');
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $annotationLabel = VideoAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+        $job->output = [[$annotation->id, '"'.json_encode(range(0, 383)).'"']];
+        $job->handleFile($annotation->video, 'abc');
+
+        $input = $job->input;
+        $this->assertCount(1, $input);
+        $filename = array_keys($input)[0];
+        $this->assertArrayHasKey($annotation->id, $input[$filename]);
+        $box = $input[$filename][$annotation->id];
+        $this->assertEquals([88, 88, 312, 312], $box);
+
+        $vectors = VideoAnnotationLabelFeatureVector::where('annotation_id', $annotation->id)->get();
+        $this->assertCount(1, $vectors);
+        $this->assertEquals($annotationLabel->id, $vectors[0]->id);
+        $this->assertEquals($annotationLabel->label_id, $vectors[0]->label_id);
+        $this->assertEquals($annotationLabel->label->label_tree_id, $vectors[0]->label_tree_id);
+        $this->assertEquals($annotation->video->volume_id, $vectors[0]->volume_id);
+        $this->assertEquals(range(0, 383), $vectors[0]->vector->toArray());
+    }
+
+    public function testGenerateFeatureVectorManyLabels()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $video->shouldReceive('crop')->andReturn($video);
+        $video->shouldReceive('writeToBuffer')->andReturn('abc123');
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $annotationLabel1 = VideoAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $annotationLabel2 = VideoAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+        $job->output = [[$annotation->id, '"'.json_encode(range(0, 383)).'"']];
+        $job->handleFile($annotation->video, 'abc');
+
+        $vectors = VideoAnnotationLabelFeatureVector::where('annotation_id', $annotation->id)->get();
+        $this->assertCount(2, $vectors);
+        $this->assertEquals($annotationLabel1->id, $vectors[0]->id);
+        $this->assertEquals($annotationLabel1->label_id, $vectors[0]->label_id);
+        $this->assertEquals(range(0, 383), $vectors[0]->vector->toArray());
+
+        $this->assertEquals($annotationLabel2->id, $vectors[1]->id);
+        $this->assertEquals($annotationLabel2->label_id, $vectors[1]->label_id);
+        $this->assertEquals(range(0, 383), $vectors[1]->vector->toArray());
+    }
+
+    public function testGenerateFeatureVectorUpdate()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $video->shouldReceive('crop')->andReturn($video);
+        $video->shouldReceive('writeToBuffer')->andReturn('abc123');
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        $annotationLabel = VideoAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $iafv = VideoAnnotationLabelFeatureVector::factory()->create([
+            'id' => $annotationLabel->id,
+            'annotation_id' => $annotation->id,
+            'vector' => range(0, 383),
+        ]);
+
+        $annotationLabel2 = VideoAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $iafv2 = VideoAnnotationLabelFeatureVector::factory()->create([
+            'id' => $annotationLabel2->id,
+            'annotation_id' => $annotation->id,
+            'vector' => range(0, 383),
+        ]);
+
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $video;
+        $job->output = [[$annotation->id, '"'.json_encode(range(1, 384)).'"']];
+        $job->handleFile($annotation->video, 'abc');
+
+        $count = VideoAnnotationLabelFeatureVector::count();
+        $this->assertEquals(2, $count);
+        $this->assertEquals(range(1, 384), $iafv->fresh()->vector->toArray());
+        $this->assertEquals(range(1, 384), $iafv2->fresh()->vector->toArray());
+    }
+
+    public function testGenerateFeatureVectorWholeFrame()
+    {
+        Storage::fake('test');
+        $videoMock = $this->getFrameMock();
+        $videoMock->shouldReceive('crop')->andReturn($videoMock);
+        $videoMock->shouldReceive('writeToBuffer')->andReturn('abc123');
+
+        $video = VideoModel::factory()->create([
+            'attrs' => ['width' => 1000, 'height' => 750],
+        ]);
+        $annotation = VideoAnnotationTest::create([
+            'points' => [],
+            'frames' => [1],
+            'shape_id' => Shape::wholeFrameId(),
+            'video_id' => $video->id,
+        ]);
+        $annotationLabel = VideoAnnotationLabelTest::create([
+            'annotation_id' => $annotation->id,
+        ]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video);
+        $job->mock = $videoMock;
+        $job->output = [[$annotation->id, '"'.json_encode(range(0, 383)).'"']];
+        $job->handleFile($video, 'abc');
+
+        $input = $job->input;
+        $this->assertCount(1, $input);
+        $filename = array_keys($input)[0];
+        $this->assertArrayHasKey($annotation->id, $input[$filename]);
+        $box = $input[$filename][$annotation->id];
+        $this->assertEquals([0, 0, 1000, 750], $box);
+    }
+
+    public function testHandlePatchOnly()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock();
+        $video->shouldReceive('crop')->andReturn($video);
+        $video->shouldReceive('writeToBuffer')->andReturn('abc123');
+
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        VideoAnnotationLabelTest::create(['annotation_id' => $annotation->id]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video, skipFeatureVectors: true);
+        $job->mock = $video;
+        $job->output = [[$annotation->id, '"'.json_encode(range(1, 384)).'"']];
+
+        $job->handleFile($annotation->video, 'abc');
+        $prefix = fragment_uuid_path($annotation->video->uuid);
+        Storage::disk('test')->assertExists("{$prefix}/v-{$annotation->id}.jpg");
+        $this->assertEquals(0, VideoAnnotationLabelFeatureVector::count());
+    }
+
+    public function testHandleFeatureVectorOnly()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock(0);
+        $annotation = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        VideoAnnotationLabelTest::create(['annotation_id' => $annotation->id]);
+        $job = new ProcessAnnotatedVideoStub($annotation->video, skipPatches: true);
+        $job->mock = $video;
+        $job->output = [[$annotation->id, '"'.json_encode(range(1, 384)).'"']];
+
+        $job->handleFile($annotation->video, 'abc');
+        $prefix = fragment_uuid_path($annotation->video->uuid);
+        Storage::disk('test')->assertMissing("{$prefix}/v-{$annotation->id}.jpg");
+        $this->assertEquals(1, VideoAnnotationLabelFeatureVector::count());
+    }
+
+    public function testHandleMultipleAnnotations()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock(2);
+        $annotation1 = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        VideoAnnotationLabelTest::create(['annotation_id' => $annotation1->id]);
+        $annotation2 = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+            'video_id' => $annotation1->video_id,
+        ]);
+        VideoAnnotationLabelTest::create(['annotation_id' => $annotation2->id]);
+
+        $job = new ProcessAnnotatedVideoStub($annotation1->video);
+        $job->output = [
+            [$annotation1->id, '"'.json_encode(range(1, 384)).'"'],
+            [$annotation2->id, '"'.json_encode(range(1, 384)).'"'],
+        ];
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->twice()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->twice()->andReturn('abc123');
+        $job->handleFile($annotation1->video, 'abc');
+        $prefix = fragment_uuid_path($annotation1->video->uuid);
+        Storage::disk('test')->assertExists("{$prefix}/v-{$annotation1->id}.jpg");
+        Storage::disk('test')->assertExists("{$prefix}/v-{$annotation2->id}.jpg");
+        $this->assertEquals(2, VideoAnnotationLabelFeatureVector::count());
+    }
+
+    public function testHandleOnlyAnnotations()
+    {
+        Storage::fake('test');
+        $video = $this->getFrameMock(1);
+        $annotation1 = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+        ]);
+        VideoAnnotationLabelTest::create(['annotation_id' => $annotation1->id]);
+        $annotation2 = VideoAnnotationTest::create([
+            'points' => [[200, 200]],
+            'frames' => [1],
+            'shape_id' => Shape::pointId(),
+            'video_id' => $annotation1->video_id,
+        ]);
+        VideoAnnotationLabelTest::create(['annotation_id' => $annotation2->id]);
+
+        $job = new ProcessAnnotatedVideoStub($annotation1->video, only: [$annotation1->id]);
+        $job->output = [[$annotation1->id, '"'.json_encode(range(1, 384)).'"']];
+        $job->mock = $video;
+
+        $video->shouldReceive('crop')
+            ->once()
+            ->andReturn($video);
+
+        $video->shouldReceive('writeToBuffer')->once()->andReturn('abc123');
+        $job->handleFile($annotation1->video, 'abc');
+        $prefix = fragment_uuid_path($annotation1->video->uuid);
+        Storage::disk('test')->assertExists("{$prefix}/v-{$annotation1->id}.jpg");
+        Storage::disk('test')->assertMissing("{$prefix}/v-{$annotation2->id}.jpg");
+        $this->assertEquals(1, VideoAnnotationLabelFeatureVector::count());
+    }
+
+    protected function getFrameMock($times = 1)
+    {
+        $video = Mockery::mock();
+        $video->width = 1000;
+        $video->height = 750;
+        $video->shouldReceive('resize')
+            ->times($times)
+            ->andReturn($video);
+        $video->shouldReceive('writeToFile');
+
+        return $video;
+    }
+}
+
+class ProcessAnnotatedVideoStub extends ProcessAnnotatedVideo
+{
+    public $times = [];
+    public $input;
+    public $outputPath;
+    public $output = [];
+
+    public function getVideo($path)
+    {
+        return Mockery::mock(Video::class);
+    }
+
+    public function getVideoFrame(Video $video, $time)
+    {
+        $this->times[] = $time;
+
+        return $this->mock;
+    }
+
+    protected function python(string $inputPath, string $outputPath)
+    {
+        $this->input = json_decode(File::get($inputPath), true);
+        $this->outputPath = $outputPath;
+        $csv = implode("\n", array_map(fn ($row) => implode(',', $row), $this->output));
+        File::put($outputPath, $csv);
+    }
+}
diff --git a/tests/Listeners/AttachLabelListenerTest.php b/tests/Listeners/AttachLabelListenerTest.php
new file mode 100644
index 00000000..6fab02b7
--- /dev/null
+++ b/tests/Listeners/AttachLabelListenerTest.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo\Listeners;
+
+use Biigle\Events\AnnotationLabelAttached;
+use Biigle\ImageAnnotationLabel;
+use Biigle\Modules\Largo\Jobs\CopyImageAnnotationFeatureVector;
+use Biigle\Modules\Largo\Jobs\CopyVideoAnnotationFeatureVector;
+use Biigle\Modules\Largo\Listeners\AttachLabelListener;
+use Biigle\VideoAnnotationLabel;
+use Queue;
+use TestCase;
+
+class AttachLabelListenerTest extends TestCase
+{
+    public function testHandleImageAnnotationLabel()
+    {
+        $al = ImageAnnotationLabel::factory()->create();
+
+        with(new AttachLabelListener)->handle(new AnnotationLabelAttached($al));
+
+        Queue::assertPushed(function (CopyImageAnnotationFeatureVector $job) use ($al) {
+            $this->assertEquals($al, $job->annotationLabel);
+
+            return true;
+        });
+    }
+
+    public function testHandleVideoAnnotationLabel()
+    {
+        $al = VideoAnnotationLabel::factory()->create();
+
+        with(new AttachLabelListener)->handle(new AnnotationLabelAttached($al));
+
+        Queue::assertPushed(function (CopyVideoAnnotationFeatureVector $job) use ($al) {
+            $this->assertEquals($al, $job->annotationLabel);
+
+            return true;
+        });
+    }
+}
diff --git a/tests/Observers/ImageAnnotationObserverTest.php b/tests/Observers/ImageAnnotationObserverTest.php
index b0dea7e1..65b2e499 100644
--- a/tests/Observers/ImageAnnotationObserverTest.php
+++ b/tests/Observers/ImageAnnotationObserverTest.php
@@ -2,7 +2,7 @@
 
 namespace Biigle\Tests\Modules\Largo\Observers;
 
-use Biigle\Modules\Largo\Jobs\GenerateImageAnnotationPatch;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedImage;
 use Biigle\Modules\Largo\Jobs\RemoveImageAnnotationPatches;
 use Biigle\Tests\ImageAnnotationTest;
 use TestCase;
@@ -20,13 +20,13 @@ public function testDeleting()
     public function testCreated()
     {
         $annotation = ImageAnnotationTest::create();
-        Queue::assertPushed(GenerateImageAnnotationPatch::class);
+        Queue::assertPushed(ProcessAnnotatedImage::class);
     }
 
     public function testSaved()
     {
         $annotation = ImageAnnotationTest::create();
         $annotation->save();
-        Queue::assertPushed(GenerateImageAnnotationPatch::class);
+        Queue::assertPushed(ProcessAnnotatedImage::class);
     }
 }
diff --git a/tests/Observers/VideoAnnotationObserverTest.php b/tests/Observers/VideoAnnotationObserverTest.php
index e0b059b1..4f862c2f 100644
--- a/tests/Observers/VideoAnnotationObserverTest.php
+++ b/tests/Observers/VideoAnnotationObserverTest.php
@@ -2,7 +2,7 @@
 
 namespace Biigle\Tests\Modules\Largo\Observers;
 
-use Biigle\Modules\Largo\Jobs\GenerateVideoAnnotationPatch;
+use Biigle\Modules\Largo\Jobs\ProcessAnnotatedVideo;
 use Biigle\Modules\Largo\Jobs\RemoveVideoAnnotationPatches;
 use Biigle\Tests\VideoAnnotationTest;
 use TestCase;
@@ -20,13 +20,13 @@ public function testDeleting()
     public function testCreated()
     {
         $annotation = VideoAnnotationTest::create();
-        Queue::assertPushed(GenerateVideoAnnotationPatch::class);
+        Queue::assertPushed(ProcessAnnotatedVideo::class);
     }
 
     public function testSaved()
     {
         $annotation = VideoAnnotationTest::create();
         $annotation->save();
-        Queue::assertPushed(GenerateVideoAnnotationPatch::class);
+        Queue::assertPushed(ProcessAnnotatedVideo::class);
     }
 }
diff --git a/tests/VideoAnnotationLabelFeatureVectorTest.php b/tests/VideoAnnotationLabelFeatureVectorTest.php
new file mode 100644
index 00000000..450a877a
--- /dev/null
+++ b/tests/VideoAnnotationLabelFeatureVectorTest.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Biigle\Tests\Modules\Largo;
+
+use Biigle\VideoAnnotationLabel;
+use Biigle\VideoAnnotation;
+use Biigle\Label;
+use Biigle\LabelTree;
+use Biigle\Modules\Largo\VideoAnnotationLabelFeatureVector;
+use Biigle\Volume;
+use Illuminate\Database\QueryException;
+use TestCase;
+
+class VideoAnnotationLabelFeatureVectorTest extends TestCase
+{
+    public function testAttributes()
+    {
+        $v = VideoAnnotationLabelFeatureVector::factory()->create();
+        $this->assertNotNull($v->id);
+        $this->assertNotNull($v->annotation_id);
+        $this->assertNotNull($v->label_id);
+        $this->assertNotNull($v->label_tree_id);
+        $this->assertNotNull($v->volume_id);
+        $this->assertNotNull($v->vector);
+    }
+
+    public function testDeleteAnnotationLabelCascade()
+    {
+        $v = VideoAnnotationLabelFeatureVector::factory()->create();
+        VideoAnnotationLabel::where('id', $v->id)->delete();
+        $this->assertNull($v->fresh());
+    }
+
+    public function testDeleteAnnotationCascade()
+    {
+        $v = VideoAnnotationLabelFeatureVector::factory()->create();
+        VideoAnnotation::where('id', $v->annotation_id)->delete();
+        $this->assertNull($v->fresh());
+    }
+
+    public function testDeleteLabelRestrict()
+    {
+        $v = VideoAnnotationLabelFeatureVector::factory()->create();
+        $this->expectException(QueryException::class);
+        Label::where('id', $v->label_id)->delete();
+    }
+
+    public function testDeleteLabelTreeRestrict()
+    {
+        $v = VideoAnnotationLabelFeatureVector::factory()->create();
+        $this->expectException(QueryException::class);
+        LabelTree::where('id', $v->label_tree_id)->delete();
+    }
+
+    public function testDeleteVolumeCascade()
+    {
+        $v = VideoAnnotationLabelFeatureVector::factory()->create();
+        Volume::where('id', $v->volume_id)->delete();
+        $this->assertNull($v->fresh());
+    }
+}