Scopeo and Fora Soft logos

Group microscope streaming for university labs

Published: Nov 14, 2026
Scopeo live microscope view on a MacBook with measurement tools and a measurements table
Scopeo Users page: teachers with their subjects and assigned students
Observation and measurement quiz with a countdown, a specimen image and an answer field
Fora Soft designed and developed Scopeo end to end: the interface, the web app, the backend, and the camera service that connects the classroom's Wi-Fi microscope cameras to the platform. The cameras are third-party hardware.
Scopeo is a web platform that streams live microscope video to a whole class at once, built for university microscope classrooms. Each microscope gets a camera, and a class of up to 42 participants works with live video from all of them: each participant sees every microscope in use, switches between them, takes snapshots, and measures distances and areas right on the live video. Teachers give graded tests during the class with the same video and tools. Scopeo belongs to Arktiks, a developer of laboratory information systems, and LACOPA, a supplier of laboratory and microscopy equipment, sells it as a ready-to-use digital microscopy classroom. LACOPA reports that one classroom supports more than 20 cameras working at the same time.
Scopeo architecture: Wi-Fi microscope cameras, camera service, LiveKit media server and the class browsers, with a real-time channel and a backend on one university server

How the platform works

The system works like this: everything runs on one server inside the university. The camera service finds the cameras on the local network and sends each microscope's video to a media server (LiveKit), which delivers it to browsers. Annotations, raised hands and test events reach browsers through a separate real-time channel, and the backend stores accounts, classes, images, annotations and tests.

The hardest part of the platform is the gap between the hardware and the classroom. Stock camera software works for one person at one computer. Scopeo had to turn a room of Wi-Fi cameras into live streams that the whole class opens in a browser. It had to keep measurements calibrated for each objective and aligned on every screen, and recover when a camera or a student's connection drops in the middle of a class. Now the class shares one set of streams and measuring tools, and the teacher can see what each student is looking at.

Who uses the platform

  • Students work at numbered workstations, one per microscope. Up to two students share a workstation during a class, and one user works there in individual mode outside class. Students sign in with their own accounts and join a class with its session code and their workstation number.
  • Teachers start and end classes, add students one by one or as a whole group from a spreadsheet, watch each student's microscope, share their screen, and build, run and grade tests.
  • Admins create teacher accounts and manage the microscope cameras and the calibration table used for measurements.

A class is a live session that a teacher starts; work outside a class is individual mode. A workstation is a numbered place at one microscope. What a user draws on an image (lines, polygons, pen strokes, text) is an annotation, and each user's annotations form that user's own layer.

Three participants connected around one magnified specimen under a microscope
Scopeo highlights: up to 42 participants, every microscope live, measurements in µm, graded tests, TIFF with metadata, exports with annotations, on-premise server

Highlights

  • Every microscope in the room is a live stream in the browser, for classes of up to 42 participants.
  • Distances and areas are measured in micrometres on live video and stay aligned with the image at any on-screen zoom and on any screen.
  • The teacher opens any student's microscope together with that student's annotations and runs graded tests inside the live class.
  • Snapshots are saved as TIFF with the objective and class details inside the file, and exports come with annotations drawn in.
  • The whole system runs on the university's own server, cameras are set up from the browser, and a stream that drops in the middle of a class restarts on its own.

Live video from every microscope in the room

Scopeo turns each microscope's Wi-Fi camera into a live stream that the whole class can open in the browser, so students and teachers don't need the camera vendor's software on their computers.

The camera service, written in Python, works with the ToupTek cameras through the vendor SDK and pushes video into LiveKit over WebRTC. It has two ways to do this:

  • when a camera offers its own H.264 stream, the service forwards it without re-encoding, which keeps delay and server load low;
  • otherwise the service encodes the camera's frames itself with low-latency settings, 30 frames per second at 4 Mbps by default, and the bitrate can be changed while the stream is running.

The backend starts a microscope's stream when the first user takes its workstation and stops it when the last one leaves, so microscopes nobody is using don't send video or load the server. Each microscope has its own room on the media server, and users join it with watch-only access.

In the participant sidebar, each microscope in use appears as a preview image that the camera service refreshes every 5 seconds, so a browser doesn't have to receive full video from all microscopes at once. Full live video plays when a user opens a microscope.

To develop and test without hardware, the camera service replays recorded microscope video as virtual cameras. The test environment runs on them, and changes merged into the development branch are deployed there automatically.

Live microscope view with session code, Share screen and End session buttons, a quiz banner and student previews
Measurement tools and scale bar toggle next to a table of segments, polygons and circles with lengths, angles and areas

Calibrated measurements on live video

Users measure specimens directly on the live video, in micrometres or millimetres. The tools are:

  • line segment: length, start and end coordinates, angle;
  • polygon: area, perimeter, centre;
  • freehand pen;
  • text labels;
  • scale bar.

The admin uploads a table, in Excel or CSV, that maps each objective's magnification to pixels per micrometre. When a user selects another objective in Scopeo, the measurement labels and the scale bar are recalculated, and the scale bar snaps to round lengths such as 10, 20 or 50 µm. A table under the video lists the segments and polygons with their values, separately for the user's own layer and for the layer they are viewing.

The hard part was keeping annotations aligned with the video. All geometry is stored in the camera's native pixel grid (2592×1944), and the same transform is applied to the video and to the annotations drawn over it. Annotations stay in place at any on-screen zoom, window size or screen resolution and look the same on other users' screens.

Users can zoom to one camera pixel per screen pixel, fit the image to the window, or fit it to the free area next to the measurements panel. The view pans on its own while an annotation is dragged near the edge, and common actions have keyboard shortcuts.

Each change is saved and sent in real time to the users allowed to see it; a moved annotation is sent when the user releases it, so dragging stays smooth. Annotations can be styled with colour, line width from 1 to 30, arrow, tick or dot line ends, and label fonts with bold, italic and underline.

The teacher sees what each student sees

The teacher follows the work of the whole room from one screen instead of walking between microscopes.

The participant sidebar shows each student's microscope preview with the student's annotations on top; the annotations update live. One click opens that view full size with the student's measurements. The teacher can sketch on it to think something through; such a sketch stays on the teacher's screen and doesn't change the student's layer. Students who raise a hand move to the top of the student list in the order they raised it. The teacher can share their screen with the class, gets a notification when a student joins or leaves, can remove a student, and can end the class for everyone at once.

Annotation visibility follows classroom rules, and the backend enforces them: a student's annotations go only to the teacher, the annotations in the teacher's own layer go to the whole class, and students don't receive each other's annotations. A layer can be changed only by its author.

Teacher's sidebar with a running quiz and student microscope previews, one student with a raised hand
Image storage table with image names, dates, objective, session, teacher, author, layers and notes

Snapshots that keep their scientific value

Snapshots are saved at full camera resolution together with the data needed to measure on them later.

A snapshot, taken with a button or the F8 key, comes from the latest full-resolution frame the camera SDK delivers to the camera service, not from a capture of the video in the browser. The service saves it as a TIFF without compression.

The backend then prepares the file for later work:

  • if the user had brightness or colour adjustments switched on, the backend applies the same ones to the file with the standard filter formulas that browsers use, so the file matches what the user saw;
  • it makes a WebP preview, because most browsers can't display TIFF;
  • it writes the objective magnification, camera model, class type and name, teacher, notes and dates into the file's EXIF and XMP metadata.

When a TIFF snapshot saved by Scopeo is uploaded back, Scopeo reads the objective from its metadata and applies that objective's calibration, so measurements on the reloaded image stay correct. Images uploaded from a computer, JPEG or TIFF, are padded to the camera's 4:3 aspect ratio so the tools work on them the same way.

The image library keeps class work and individual work apart, filters by objective and date, can show only the user's own images, and searches by image name, notes, class and author. Students see their own images and images from the classes they attended. In the editor, several images open as tabs, and users switch between the annotation layers available to them.

Exports with annotations drawn in

Users take their work out of Scopeo as ordinary image files that look the same as on screen. An image can be exported as the original only, with the user's own layer, with all layers available to that user, or with selected layers. Several images download as one ZIP archive.

The backend draws the annotations itself. It runs the same drawing engine as the browser (Paper.js) without a screen, turns the result into SVG and renders it with resvg. Fonts are bundled with the app and system fonts are switched off, so the result doesn't depend on the fonts installed on a particular server. Text underlines are drawn as separate lines, positioned from measured glyph widths. The annotations, measurement labels and scale bar are then placed over the full-size image.

Export 3 images dialog with original, my layer, all available layers and selected layers options and a Download ZIP button
Quiz banner: Measurements quiz in progress with 14:12 left and an End button

Tests during the live class

Teachers check knowledge on the same specimens the class is looking at, without a separate testing tool.

Teachers build tests with single-choice, multiple-choice and open-answer questions, set points for each question, reorder answer options by dragging, and can add a time limit. A question image can come from the image library, from a computer, or from a snapshot of the live microscope view together with its annotations.

A test runs like this:

  • the teacher starts the test during a class, and students get a banner to begin;
  • answers are saved automatically a moment after each change;
  • the teacher and the students see the same countdown, and the test ends for all students when it reaches zero on the teacher's page;
  • when the test ends, on time or earlier by the teacher's decision, all unfinished attempts are graded and closed in one step;
  • choice questions are scored automatically, and a multiple-choice answer earns points only when it matches the correct set exactly;
  • the teacher grades open answers by hand.

Results can be filtered by date, student, teacher, course and group. Teachers can copy a colleague's test and reuse it.

Camera settings from the browser

Each user adjusts the camera of the microscope they work at in Scopeo instead of the vendor's desktop app: exposure, gain, auto exposure, auto white balance, contrast, gamma, saturation and stream bitrate.

The camera service reads each camera's real parameters with their ranges and defaults from the SDK, up to 37 of them, and drops the ones the camera doesn't support, so the controls match the connected model. A changed parameter is shown to other users watching that microscope after the camera reports the new value, and one button resets the camera to its defaults.

Some adjustments are applied in the browser instead of the camera: brightness, monochrome mode, colour temperature, hue, mirroring and 90° rotation. They are synced to everyone watching that microscope and carried over into saved snapshots: the backend applies the colour adjustments, and the camera service applies mirroring and rotation.

Camera settings panel with exposure, gain, contrast, gamma, saturation and bitrate sliders next to a specimen image
Recovery flows: camera error to stream restart, page reload with a 10-second grace period, teacher offline to class closed after 10 minutes

Recovery from dropouts during a class

Wi-Fi cameras and student laptops lose connection, and the system is built to recover without the teacher's help:

  • the camera service listens for error events from each camera and checks every 5 seconds that cameras providing their own stream are still reachable; after a failure it restarts the stream, with a pause that grows after each attempt up to 30 seconds;
  • when a user opens a microscope, the backend checks the stream on the media server and restarts it if it is broken or the camera was offline;
  • a browser connection gets a 10-second grace period, so a page reload doesn't free the student's workstation;
  • if the teacher disconnects without ending the class, the class is closed 10 minutes later and its microscopes are released; the timer is kept in RabbitMQ, so it survives a backend restart;
  • after a restart, the backend frees the workstations of users who are no longer connected.

Installation on the university's own server and network

Scopeo runs as a set of Docker containers on one server inside the university. Once it is installed, the cameras are set up from the browser, without a technician at the server console.

On the Cameras page an admin can:

  • see the cameras found on the local network and give each one a workstation number (a number belongs to one camera at a time);
  • add a camera by IP address when automatic discovery can't reach it, and hide cameras that aren't in use;
  • send Wi-Fi credentials to a camera and switch it between access-point and client mode;
  • connect the server itself to a Wi-Fi network.

Camera discovery relies on network broadcasts, which often break on servers with Docker or several network interfaces. Scopeo notices when the cameras that used to be connected over Wi-Fi have all gone offline and offers a one-click repair of the server's network routes.

The platform works over HTTPS with a Let's Encrypt certificate or with the university's own certificates for closed networks. Prometheus and Grafana track the server's CPU, memory and disk load.

University server with Docker containers: Traefik HTTPS, Prometheus and Grafana, camera discovery and one-click network route repair
Edit student form over the students list with subjects and assigned teachers

Accounts and bulk student import

Teachers and admins add a whole group of students from one Excel file instead of typing accounts in one by one.

In the import file the columns can come in any order (surname, first name, patronymic, role, email, group, course, subject), the capitalisation of names is corrected, and all rows are checked in the browser before upload and again on the backend. Importing the same users again updates their accounts by email instead of creating duplicates.

New students and imported users receive an email invitation with a generated password. Invitation and password emails go through a queue, and an email that fails to send goes back to the queue. Passwords are reset with a 6-digit email code that expires after 10 minutes and allows 5 attempts. Admins can deactivate and restore accounts, and a deactivated user can't sign in. The web app redirects students away from the user, test builder and camera pages.

Technologies

🖥 Platforms
Web (runs in the browser); on-premise Linux server connected to Wi-Fi microscope cameras
🎨 Frontend
Next.js, TypeScript, React, Zustand, Paper.js, TanStack Table, dnd-kit, SheetJS (xlsx)
⚙️ Backend
NestJS, Node.js, MongoDB, Mongoose, Socket.io, RabbitMQ, Redis, Nodemailer, sharp, resvg, opentype.js, ExifTool, archiver
🎥 Video
LiveKit, LiveKit Ingress, WebRTC, WHIP, GStreamer, H.264, x264, coturn
🔬 Camera service
Python, ToupTek camera SDK, OpenCV, NumPy, Pillow, python-socketio, NetworkManager
⚒️ Infrastructure
Docker Compose, Traefik, Let's Encrypt, Prometheus, Grafana, GitLab CI
Scopeo