optica-core 0.2.1 → 0.2.3

package/src/data/models/distance.ts

@@ -1,6 +1,6 @@
 import Color from "color"
 import { Landmark, type LandmarkObject } from "./landmark"
-import { distanceVector, type Coordinates, type Position } from "./coordinates"
+import { distanceVector, type Position } from "./coordinates"
 import { computeDistance, randomColorRGB, type ScaleUnit } from "../../lib/utils"
 
 export type DistanceObject = {
@@ -9,52 +9,40 @@ export type DistanceObject = {
     color: string,
 }
 
+// sum of the segments between consecutive landmarks, `point`: where a landmark is. undefined under two landmarks
+function sumOfSegments(landmarks: Landmark[], point: (landmark: Landmark) => Position) : number | undefined {
+    if(landmarks.length < 2 ){
+        return undefined
+    }
+    return computeDistance(landmarks.slice(1).map((landmark, i) => distanceVector(point(landmarks[i]!), point(landmark))))
+}
+
 export class Distance {
     label : string
     landmarks : Array<Landmark>
     color: Color
-    edit_label: boolean
-    edit_distance: boolean
     show : boolean
 
     constructor(label: string, landmarks : Array<Landmark> | null = null, color: Color | null = null){
         this.label = label
         this.landmarks = landmarks || new Array()
-        this.edit_label = false
-        this.edit_distance = false
         this.show = true
         this.color = color || Color.rgb(randomColorRGB())
     }
 
-    // Physical vector between each consecutive pair of landmarks
-    get distance() : Position[] | undefined{
-        if(this.landmarks.length < 2 ){
-            return undefined
-        }
-        let distance : Position[] = new Array()
-        for(let i = 1; i < this.landmarks.length; i++){
-            distance.push(distanceVector(this.landmarks[i-1].position, this.landmarks[i].position))
-        }
-        return distance
+    // physical length: sum of the segments between consecutive landmarks, undefined under two landmarks
+    get distance() : number | undefined {
+        return sumOfSegments(this.landmarks, (landmark) => landmark.position)
     }
 
-    // Pixel vector between each consecutive pair of landmarks
-    get distancePx() : Coordinates[] | undefined{
-        if(this.landmarks.length < 2 ){
-            return undefined
-        }
-        let distance : Coordinates[] = new Array()
-        for(let i = 1; i < this.landmarks.length; i++){
-            distance.push(distanceVector(this.landmarks[i-1].pose.marker, this.landmarks[i].pose.marker))
-        }
-        return distance
+    // pixel length: sum of the segments between consecutive markers, undefined under two landmarks
+    get distancePx() : number | undefined {
+        return sumOfSegments(this.landmarks, (landmark) => landmark.pose.marker)
     }
 
-    // length in image units: pixel length for the "px" scale, physical length otherwise.
-    // undefined while it can't be measured
+    // length in image units: pixel length for the "px" scale, physical length otherwise
     length(scale?: ScaleUnit) : number | undefined {
-        const intervals = scale == "px" ? this.distancePx : this.distance
-        return intervals === undefined ? undefined : computeDistance(intervals)
+        return scale == "px" ? this.distancePx : this.distance
     }
 
     in(landmark : Landmark | string) : boolean{

package/src/data/models/image.ts

@@ -1,7 +1,9 @@
 // Minimal image identity shared by every app (stack, rotation, spectral, ...)
 export type ImageName = {
     name: string,
-    label: string
+    label: string,
+    // sent by the backend when the thumbnail of this image exists
+    hasThumbnail?: boolean
 }
 
 // What an annotation keeps of its image: the name to find it back, the label and the

package/src/data/models/landmark.ts

@@ -23,9 +23,6 @@ export class Landmark {
     position : Position
     color: Color
     show: boolean
-    edit: boolean
-    isClicked: boolean
-    isDragged: boolean
 
     // pose.image may be the full image, only its reference is kept
     constructor(id: string, label: string, pose: Pose, position : Position, color: Color | null = null) {
@@ -33,11 +30,8 @@ export class Landmark {
         this.label = label
         this.pose = { marker: pose.marker, image: imageRef(pose.image) }
         this.position = position
-        this.edit = false
         this.color = color || Color.rgb(randomColorRGB())
         this.show = true
-        this.isClicked = false
-        this.isDragged = false
     }
 
     equals(other : Landmark | string | null | undefined){
@@ -58,16 +52,6 @@ export class Landmark {
         return { id: this.id, label: this.label, pose: this.pose, position : this.position, color: this.color.hex() }
     }
 
-    getId() : string {
-        return this.id
-    }
-    getLabel() : string {
-        return this.label
-    }
-    setLabel(label : string){
-        this.label = label
-    }
-
     getColorHEX() : string{
         return this.color.hex()
     }
@@ -87,23 +71,4 @@ export class Landmark {
             image : imageRef(image)
         }
     }
-
-    getPose() : Pose {
-        return this.pose
-    }
-
-    setPosition(position : Position) {
-        this.position = position
-    }
-
-    getPosition() : Position {
-        return this.position
-    }
-
-    getEdit() : boolean{
-        return this.edit
-    }
-    setEdit(edit : boolean){
-        this.edit = edit
-    }
 }

package/src/data/models/project.ts

@@ -11,7 +11,6 @@ export type AcquisitionObject<TImage extends ProjectImage = ProjectImage> = {
     // images on their own: the stacked results, the depth maps...
     standaloneImages?: TImage[]
     size: Size
-    thumbnails: boolean
 }
 
 // Images taken together, with the viewer state and the annotations of the acquisition.
@@ -22,7 +21,6 @@ export class Acquisition<TImage extends ProjectImage = ProjectImage, TAnnotation
     images: TImage[]
     standaloneImages: TImage[]
     size: Size
-    thumbnails: boolean
     camera: Camera
     // shared by the images of the group and the standalone ones
     annotations: TAnnotations
@@ -37,7 +35,6 @@ export class Acquisition<TImage extends ProjectImage = ProjectImage, TAnnotation
         this.images = object.images
         this.standaloneImages = object.standaloneImages ?? []
         this.size = object.size
-        this.thumbnails = object.thumbnails
         this.camera = createCamera()
         this.annotations = this.createAnnotations()
         this.index = 0
@@ -121,7 +118,6 @@ export class Acquisition<TImage extends ProjectImage = ProjectImage, TAnnotation
             images: this.images,
             standaloneImages: this.standaloneImages,
             size: this.size,
-            thumbnails: this.thumbnails,
         }
     }
 }

package/src/data/providers/backend.ts

@@ -0,0 +1,28 @@
+import type { DataProvider } from "./providers";
+import { WebProvider } from "./web_providers";
+import { OrthancProvider } from "./orthanc_providers";
+import { providerSettings } from "../../config/appSettings"
+
+// Backends an app can be served by (VITE_BACKEND_TYPE)
+export type BackendType = "WEB" | "ORTHANC"
+
+// how to build the provider of each backend from its url (VITE_BACKEND_URL)
+export type ProviderBuilders<P extends DataProvider> = Record<BackendType, (url: string) => P>
+
+// The core providers, `plugin`: the path of the app in Orthanc
+export function coreProviders(plugin: string): ProviderBuilders<DataProvider> {
+    return {
+        WEB: (url) => new WebProvider(url),
+        ORTHANC: (url) => new OrthancProvider(url, plugin),
+    }
+}
+
+// Provider of the backend set in the environment (.env: VITE_BACKEND_TYPE, VITE_BACKEND_URL).
+// Apps with their own routes pass their own providers (sphaer)
+export function createProvider<P extends DataProvider>(builders: ProviderBuilders<P>): P {
+    const type = providerSettings.type
+    if (!(type in builders)) {
+        throw new Error(`Unknown VITE_BACKEND_TYPE "${type}", expected one of ${Object.keys(builders).join(", ")}`)
+    }
+    return builders[type as BackendType](providerSettings.url)
+}

package/src/data/repositories/data_repository.ts

@@ -5,7 +5,7 @@ import type { ImageName, ProjectImage } from "../models/image";
 import type { Pose } from "../models/landmark";
 
 // Common part of every app repository, apps only have to parse their /images payload
-export abstract class DataRepository<TData> implements Repository<TData> {
+export abstract class DataRepository<TData, TPosition extends Position = Position> implements Repository<TData, TPosition> {
     provider: DataProvider;
 
     constructor(provider: DataProvider) {
@@ -14,9 +14,9 @@ export abstract class DataRepository<TData> implements Repository<TData> {
 
     abstract getImages(objectPath: string): Promise<TData>
 
-    computeLandmarkPosition(objectPath: string, pose: Pose) : Promise<Position> {
+    computeLandmarkPosition(objectPath: string, pose: Pose) : Promise<TPosition> {
         return this.provider.computeLandmarkPosition(objectPath, pose.image.name, pose.marker).then((res) => {
-            return res.data as Position
+            return res.data as TPosition
         })
     }
 
@@ -28,11 +28,12 @@ export abstract class DataRepository<TData> implements Repository<TData> {
         return this.provider.getThumbnail(objectPath, imageName)
     }
 
-    // Fill the image and thumbnail urls of images sent by /images
-    protected resolveUrls<T extends ImageName>(objectPath: string, images: T[], thumbnails: boolean): (T & ProjectImage)[] {
+    // Fill the image and thumbnail urls of images sent by /images,
+    // the thumbnail url only for the images the backend marks with `hasThumbnail`
+    protected resolveUrls<T extends ImageName>(objectPath: string, images: T[]): (T & ProjectImage)[] {
         return images.map((image) => Object.assign(image, {
             image: this.getFullImage(objectPath, image.name),
-            thumbnail: thumbnails ? this.getThumbnail(objectPath, image.name) : undefined,
+            thumbnail: image.hasThumbnail ? this.getThumbnail(objectPath, image.name) : undefined,
         }))
     }
 }

package/src/data/repositories/project_repository.ts

@@ -1,4 +1,5 @@
 import type { DataProvider } from "../providers/providers";
+import type { Position } from "../models/coordinates";
 import type { ProjectImage } from "../models/image";
 import { Acquisition, Project, type AcquisitionObject } from "../models/project";
 import type { AnnotationsSet } from "../models/annotations";
@@ -16,8 +17,9 @@ export function parseAcquisitions<TImage extends ProjectImage>(data: any): Acqui
 }
 
 // Loads /images as a Project, apps whose payload differs pass a parser
-export class ProjectRepository<TImage extends ProjectImage = ProjectImage, TAcquisition extends Acquisition<TImage, AnnotationsSet> = Acquisition<TImage>>
-    extends DataRepository<Project<TImage, TAcquisition>> {
+// TPosition: Coords3D when the backend gives 3D positions (stack, depth)
+export class ProjectRepository<TImage extends ProjectImage = ProjectImage, TAcquisition extends Acquisition<TImage, AnnotationsSet> = Acquisition<TImage>, TPosition extends Position = Position>
+    extends DataRepository<Project<TImage, TAcquisition>, TPosition> {
     parse: ProjectParser<TImage>
     createAcquisition: AcquisitionFactory<TImage, TAcquisition>
 
@@ -34,8 +36,8 @@ export class ProjectRepository<TImage extends ProjectImage = ProjectImage, TAcqu
     async getImages(objectPath: string): Promise<Project<TImage, TAcquisition>> {
         const res = await this.provider.getImages(objectPath)
         const acquisitions = this.parse(res.data).map((object) => {
-            object.images = this.resolveUrls(objectPath, object.images, object.thumbnails)
-            object.standaloneImages = this.resolveUrls(objectPath, object.standaloneImages ?? [], object.thumbnails)
+            object.images = this.resolveUrls(objectPath, object.images)
+            object.standaloneImages = this.resolveUrls(objectPath, object.standaloneImages ?? [])
             return this.createAcquisition(object)
         })
         return new Project<TImage, TAcquisition>(objectPath, acquisitions)

package/src/data/repositories/repository.ts

@@ -1,9 +1,10 @@
 import type { Position } from "../models/coordinates";
 import type { Pose } from "../models/landmark";
 
-export interface Repository<TData = unknown> {
+// TPosition: Coords3D for the apps whose backend gives 3D positions (stack, depth)
+export interface Repository<TData = unknown, TPosition extends Position = Position> {
     getImages : (objectPath:string) => Promise<TData>;
     getFullImage : (objectPath:string, imageName : string) => string;
     getThumbnail : (objectPath:string, imageName : string) => string;
-    computeLandmarkPosition : (objectPath:string, pose : Pose) => Promise<Position>;
+    computeLandmarkPosition : (objectPath:string, pose : Pose) => Promise<TPosition>;
 }

package/src/env.d.ts

@@ -3,5 +3,4 @@
 interface ImportMetaEnv {
     readonly VITE_BACKEND_TYPE: string
     readonly VITE_BACKEND_URL: string
-    readonly VITE_REPOSITORY: string
 }

package/src/index.ts

@@ -1,13 +1,13 @@
 export * from "./lib/utils"
 export * from "./lib/export"
 export * from "./lib/persistence"
+export * from "./lib/interaction"
 export * from "./config/appSettings"
 
 export * from "./data/models/coordinates"
 export * from "./data/models/image"
 export * from "./data/models/camera"
 export * from "./data/models/project"
-export * from "./data/models/marker"
 export * from "./data/models/landmark"
 export * from "./data/models/distance"
 export * from "./data/models/dequeMax2"
@@ -17,9 +17,8 @@ export * from "./data/providers/routes"
 export * from "./data/providers/providers"
 export * from "./data/providers/web_providers"
 export * from "./data/providers/orthanc_providers"
-export * from "./data/providers/provider_factory"
+export * from "./data/providers/backend"
 
 export * from "./data/repositories/repository"
 export * from "./data/repositories/data_repository"
 export * from "./data/repositories/project_repository"
-export * from "./data/repositories/repository_factory"

package/src/lib/interaction.ts

@@ -0,0 +1,10 @@
+import { reactive } from "vue"
+
+// What the user is doing with the landmarks right now, shared by the lists and the ImageViewer.
+// Not part of the models: never saved, one landmark at a time (by id).
+export const interaction = reactive({
+    // pressed in a list, until the pointer is released: the viewer draws it bigger
+    pressed: null as string | null,
+    // dragged in the viewer: its row in the lists is highlighted and scrolled to
+    dragged: null as string | null,
+})

package/src/lib/persistence.ts

@@ -34,17 +34,22 @@ export function usePersistedAnnotations(project: () => Project<any, any> | null
         }
     }, { immediate: true })
 
-    // watch the annotations only, not the images of the project.
+    // Watches what is saved, serialized: only a change of it writes the storage, not the
+    // display state of the annotations (hover, drag) nor the images of the project.
     // Registered after the restore: it saves the restored annotations, never empty ones over them.
-    watch(() => project()?.acquisitions.map((acquisition) => acquisition.annotations), () => {
+    watch(() => {
         const loaded = project()
         if (!loaded) {
-            return
+            return undefined
         }
         const saved: SavedAnnotations = {
             annotations: loaded.annotationsToJSON(),
             selection: Object.fromEntries(loaded.acquisitions.map((acquisition) => [acquisition.id, acquisition.annotations.getSelection()])),
         }
-        storage.setItem(key(loaded.objectPath), JSON.stringify(saved))
-    }, { deep: true })
+        return { objectPath: loaded.objectPath, json: JSON.stringify(saved) }
+    }, (saved, previous) => {
+        if (saved && (saved.objectPath != previous?.objectPath || saved.json != previous.json)) {
+            storage.setItem(key(saved.objectPath), saved.json)
+        }
+    })
 }

package/src/lib/utils.ts

@@ -31,9 +31,12 @@ export function randomColorRGB(): [number, number, number] {
   return [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)]
 }
 
-// short random base-36 id (landmarks)
-export function randomID(): string {
-  return (Math.random() + 1).toString(36).substring(7)
+const ID_CHARS = "0123456789abcdefghijklmnopqrstuvwxyz"
+
+// random base-36 id of `length` characters (landmarks, also their first label: kept short).
+// getRandomValues works on http too, unlike crypto.randomUUID
+export function randomID(length: number = 5): string {
+  return Array.from(crypto.getRandomValues(new Uint8Array(length)), (byte) => ID_CHARS[byte % ID_CHARS.length]).join("")
 }
 
 export enum Scale {
@@ -63,11 +66,6 @@ export const DOT_RADIUS = 4.5
 export const SPACE_TARGET = 0.2
 export const ROUNDING = 2
 
-// length in image units -> length shown in `scale`, corrected by the calibration factor
-export function toScale(length: number, adjustFactor: number): number {
-  return length * adjustFactor
-}
-
 // calibration factor so that `length` is shown as `target` in `scale`
 export function adjustFactorFor(length: number, target: number, scale: ScaleUnit): number {
   return target / length * Scale[scale]

package/tests/annotations.test.ts

@@ -2,14 +2,14 @@ import { describe, expect, it } from "vitest"
 import { effectScope, isReactive, nextTick, reactive, shallowRef } from "vue"
 import Color from "color"
 import {
-  Acquisition, Annotations, Distance, Landmark, Project, usePersistedAnnotations,
+  Acquisition, Annotations, DequeMax2, Distance, Landmark, Project, usePersistedAnnotations,
   type ProjectImage,
 } from "../src"
 
 const size = { width: 100, height: 100 }
 const image = (name: string): ProjectImage => ({ name, label: name, image: "" })
 const landmark = (id: string, img = image("i0")) => new Landmark(id, id, { marker: { x: 1, y: 2 }, image: img }, { x: 10, y: 20 }, Color("#ff0000"))
-const acquisition = (id: string, names: string[] = ["i0"]) => new Acquisition({ id, images: names.map(image), size, thumbnails: false })
+const acquisition = (id: string, names: string[] = ["i0"]) => new Acquisition({ id, images: names.map(image), size })
 
 describe("Annotations", () => {
   it("creates a selected distance and returns the reactive copy through a store", () => {
@@ -88,9 +88,9 @@ class TaggedAcquisition extends Acquisition<ProjectImage> {
 
 describe("Project annotations", () => {
   it("lets an app use its own Annotations", () => {
-    const a = new TaggedAcquisition({ id: "a", images: [image("i0")], size, thumbnails: false })
+    const a = new TaggedAcquisition({ id: "a", images: [image("i0")], size })
     expect(a.annotations.tagged).toBe(true)
-    a.annotations.restore({ distances: [{ label: "d", color: "#00ff00", landmarks: [], value: 0 }] })
+    a.annotations.restore({ distances: [{ label: "d", color: "#00ff00", landmarks: [], distance: 0 }] })
     expect(a.annotations.distances[0]).toBeInstanceOf(Distance)
   })
 
@@ -170,6 +170,28 @@ describe("usePersistedAnnotations", () => {
     scope2.stop()
   })
 
+  it("doesn't write the storage for what isn't saved", async () => {
+    const storage = new MemoryStorage()
+    const current = shallowRef<Project | null>(null)
+    const scope = effectScope()
+    scope.run(() => usePersistedAnnotations(() => current.value, storage))
+    current.value = reactive(new Project("A1", [acquisition("rotation")])) as Project
+    await nextTick()
+    const annotations = current.value.acquisition!.annotations
+    annotations.landmarks.push(landmark("kept"))
+    await nextTick()
+    let writes = 0
+    const setItem = storage.setItem.bind(storage)
+    storage.setItem = (key, value) => { writes++; setItem(key, value) }
+    annotations.landmarks[0]!.show = false
+    await nextTick()
+    expect(writes).toBe(0)
+    annotations.landmarks[0]!.label = "renamed"
+    await nextTick()
+    expect(writes).toBe(1)
+    scope.stop()
+  })
+
   it("ignores a saved selection that doesn't fit the annotations", () => {
     const annotations = new Annotations()
     annotations.newDistance()
@@ -179,3 +201,42 @@ describe("usePersistedAnnotations", () => {
     expect(annotations.selectedDistanceIndex).toBe(-1)
   })
 })
+
+describe("scale", () => {
+  const distance = () => new Distance("d", [
+    new Landmark("a", "a", { marker: { x: 0, y: 0 }, image: image("i0") }, { x: 0, y: 0 }),
+    new Landmark("b", "b", { marker: { x: 3, y: 4 }, image: image("i0") }, { x: 30, y: 40 }),
+  ])
+
+  it("applies the calibration to physical lengths, not to pixels", () => {
+    const annotations = new Annotations()
+    annotations.adjustFactor = 2
+    annotations.scale = "cm"
+    expect(annotations.scaled(distance())).toBe(10)
+    annotations.scale = "px"
+    expect(annotations.scaled(distance())).toBe(5)
+  })
+
+  it("doesn't calibrate in pixels", () => {
+    const annotations = new Annotations()
+    annotations.scale = "px"
+    annotations.calibrate(distance(), 10)
+    expect(annotations.adjustFactor).toBe(1)
+    annotations.scale = "mm"
+    annotations.calibrate(distance(), 10)
+    expect(annotations.adjustFactor).toBe(0.2)
+  })
+})
+
+describe("DequeMax2", () => {
+  it("keeps the last two items, finds them with equals", () => {
+    const deque = new DequeMax2([landmark("a"), landmark("b"), landmark("c")])
+    expect(deque.items.map((l) => l.id)).toEqual(["b", "c"])
+    deque.add(landmark("c"))
+    expect(deque.items.map((l) => l.id)).toEqual(["b", "c"])
+    expect([deque.contains("b"), deque.contains(landmark("a")), deque.contains(null)]).toEqual([true, false, false])
+    deque.remove("unknown")
+    deque.remove("b")
+    expect([deque.first?.id, deque.last?.id, deque.isFull()]).toEqual(["c", "c", false])
+  })
+})

package/tests/project.test.ts

@@ -6,7 +6,7 @@ const size = { width: 2000, height: 1000 }
 const img = (name: string, extra = {}): ProjectImage => ({ name, label: name, image: "", ...extra })
 
 function acquisition(images: string[], standalone: string[] = []): Acquisition {
-  return new Acquisition({ id: "a", images: images.map((n) => img(n)), standaloneImages: standalone.map((n) => img(n)), size, thumbnails: false })
+  return new Acquisition({ id: "a", images: images.map((n) => img(n)), standaloneImages: standalone.map((n) => img(n)), size })
 }
 
 describe("Acquisition", () => {
@@ -42,7 +42,7 @@ describe("Acquisition", () => {
   })
 
   it("uses the size of the image when it has one", () => {
-    const a = new Acquisition({ id: "a", images: [], standaloneImages: [img("d0", { size: { width: 5, height: 5 } }), img("d1")], size, thumbnails: false })
+    const a = new Acquisition({ id: "a", images: [], standaloneImages: [img("d0", { size: { width: 5, height: 5 } }), img("d1")], size })
     expect(a.sizeOf()).toEqual({ width: 5, height: 5 })
     expect(a.sizeOf(a.getImage("d1"))).toEqual(size)
   })
@@ -50,8 +50,8 @@ describe("Acquisition", () => {
 
 describe("Project", () => {
   it("selects acquisitions and finds images", () => {
-    const vis = new Acquisition({ id: "VIS", images: [img("vis0")], size, thumbnails: false })
-    const uv = new Acquisition({ id: "UV", images: [img("uv0")], standaloneImages: [img("uvRGB")], size, thumbnails: false })
+    const vis = new Acquisition({ id: "VIS", images: [img("vis0")], size })
+    const uv = new Acquisition({ id: "UV", images: [img("uv0")], standaloneImages: [img("uvRGB")], size })
     const p = new Project("A1", [vis, uv])
     expect(p.selectedImage?.name).toBe("vis0")
     p.selectAcquisition("UV")
@@ -75,21 +75,32 @@ function provider(data: unknown): DataProvider {
 
 describe("ProjectRepository", () => {
   it("reads the standard payload and resolves the urls", async () => {
-    const payload = { acquisitions: [{ id: "stack", images: [{ name: "s0", label: "s0" }], standaloneImages: [{ name: "r", label: "Result" }], size, thumbnails: true }] }
+    const payload = { acquisitions: [{ id: "stack", images: [{ name: "s0", label: "s0", hasThumbnail: true }], standaloneImages: [{ name: "r", label: "Result" }], size }] }
     const project = await new ProjectRepository(provider(payload)).getImages("A1")
     const a = project.acquisition!
     expect(a.images[0]).toMatchObject({ image: "S/A1/s0/full-image", thumbnail: "S/A1/s0/thumbnail" })
     expect(a.standaloneImages[0]).toMatchObject({ label: "Result", image: "S/A1/r/full-image" })
   })
 
+  it("resolves the thumbnail of the images marked with hasThumbnail only", async () => {
+    const payload = { acquisitions: [{
+      id: "stack", size,
+      images: [{ name: "s0", label: "s0", hasThumbnail: true }, { name: "s1", label: "s1", hasThumbnail: false }, { name: "s2", label: "s2" }],
+      standaloneImages: [{ name: "r", label: "Result", hasThumbnail: true }],
+    }] }
+    const a = (await new ProjectRepository(provider(payload)).getImages("A1")).acquisition!
+    expect(a.images.map((image) => image.thumbnail)).toEqual(["S/A1/s0/thumbnail", undefined, undefined])
+    expect(a.standaloneImages[0].thumbnail).toBe("S/A1/r/thumbnail")
+  })
+
   it("adapts a legacy payload with a parser (spectral: one acquisition per group)", async () => {
     type SpectralImage = ProjectImage & { wavelength: { value: number } }
     const legacy = {
-      VIS: { spectralImages: [{ name: "v450", label: "v450", wavelength: { value: 450 } }], individualImages: { RGB: { name: "vRGB", label: "RGB" } }, size, thumbnails: false },
-      UV: { spectralImages: [], individualImages: { RGB: { name: "uRGB", label: "RGB" } }, size, thumbnails: false },
+      VIS: { spectralImages: [{ name: "v450", label: "v450", wavelength: { value: 450 } }], individualImages: { RGB: { name: "vRGB", label: "RGB" } }, size },
+      UV: { spectralImages: [], individualImages: { RGB: { name: "uRGB", label: "RGB" } }, size },
     }
     const parse = (data: any): AcquisitionObject<SpectralImage>[] => Object.entries<any>(data).map(([id, group]) => ({
-      id, images: group.spectralImages, standaloneImages: Object.values(group.individualImages), size: group.size, thumbnails: group.thumbnails,
+      id, images: group.spectralImages, standaloneImages: Object.values(group.individualImages), size: group.size,
     }))
     const project = await new ProjectRepository<SpectralImage>(provider(legacy), parse).getImages("A1")
     expect(project.acquisitions.map((a) => a.id)).toEqual(["VIS", "UV"])
@@ -99,9 +110,9 @@ describe("ProjectRepository", () => {
   })
 
   it("adapts depth: no group, standalone images with their own size", async () => {
-    const legacy = { images: [{ id: "d0", label: "D0", size: { width: 10, height: 20 } }], thumbnails: false }
+    const legacy = { images: [{ id: "d0", label: "D0", size: { width: 10, height: 20 } }] }
     const parse = (data: any): AcquisitionObject[] => [{
-      id: "depth", images: [], size: data.images[0].size, thumbnails: data.thumbnails,
+      id: "depth", images: [], size: data.images[0].size,
       standaloneImages: data.images.map((i: any) => ({ name: i.id, label: i.label, size: i.size })),
     }]
     const project = await new ProjectRepository(provider(legacy), parse).getImages("A1")

package/src/data/models/marker.ts

@@ -1,8 +0,0 @@
-import Color from "color"
-import type { Coordinates } from "./coordinates"
-
-export type Marker = {
-    id : string,
-    pos : Coordinates,
-    color : Color
-}

package/src/data/providers/provider_factory.ts

@@ -1,32 +0,0 @@
-import type { DataProvider } from "./providers";
-import { WebProvider } from "./web_providers";
-import { providerSettings } from "../../config/appSettings"
-
-type ProviderBuilder = (url: string) => DataProvider
-
-// "ORTHANC" needs the plugin name of the app, register it with
-// ProviderFactory.register("ORTHANC", (url) => new OrthancProvider(url, "polaroptica"))
-export class ProviderFactory{
-    private static _instances = new Map<string, DataProvider>()
-    private static _builders = new Map<string, ProviderBuilder>([
-        ["WEB", (url) => new WebProvider(url)],
-    ])
-
-    static register(type : string, builder : ProviderBuilder){
-        this._builders.set(type, builder)
-        this._instances.delete(type)
-    }
-
-    static get(type : string = providerSettings.type) : DataProvider{
-        let instance = this._instances.get(type)
-        if(instance == null){
-            const builder = this._builders.get(type)
-            if(builder == null){
-                throw new Error(`Unknown provider type "${type}"`)
-            }
-            instance = builder(providerSettings.url)
-            this._instances.set(type, instance)
-        }
-        return instance
-    }
-}

package/src/data/repositories/repository_factory.ts

@@ -1,31 +0,0 @@
-import type { Repository } from "./repository";
-import type { DataProvider } from "../providers/providers";
-import { ProviderFactory } from "../providers/provider_factory";
-import { providerSettings, repositorySettings } from "../../config/appSettings"
-
-type RepositoryBuilder = (provider: DataProvider) => Repository<any>
-
-// Apps register their repository at startup:
-// RepositoryFactory.register("DATA", (provider) => new StackRepository(provider))
-export class RepositoryFactory{
-    private static _instances = new Map<string, Repository<any>>()
-    private static _builders = new Map<string, RepositoryBuilder>()
-
-    static register(type : string, builder : RepositoryBuilder){
-        this._builders.set(type, builder)
-        this._instances.delete(type)
-    }
-
-    static get<R extends Repository<any> = Repository>(type : string = repositorySettings.type) : R{
-        let instance = this._instances.get(type)
-        if(instance == null){
-            const builder = this._builders.get(type)
-            if(builder == null){
-                throw new Error(`Unknown repository type "${type}"`)
-            }
-            instance = builder(ProviderFactory.get(providerSettings.type))
-            this._instances.set(type, instance)
-        }
-        return instance as R
-    }
-}