Webcam

Stream video from webcams attached to the Lager Box for visual inspection, automated vision testing, and remote monitoring.

Import

from lager import Net, NetType

Methods

Method	Description
`start(box_ip)`	Start a webcam stream
`stop()`	Stop the webcam stream
`get_info(box_ip)`	Get info about the stream
`get_url(box_ip)`	Get just the URL for the stream
`is_active()`	Check if stream is currently active

Method Reference

`Net.get(name, type=NetType.Webcam)`

Get a webcam net by name.

from lager import Net, NetType

webcam = Net.get('camera1', type=NetType.Webcam)

Parameters:

Parameter	Type	Description
`name`	`str`	Name of the webcam net
`type`	`NetType`	Must be `NetType.Webcam`

Returns: Webcam Net instance

`start(box_ip)`

Start a webcam video stream.

from lager import Net, NetType

webcam = Net.get('camera1', type=NetType.Webcam)
result = webcam.start(box_ip='<BOX_IP>')

print(f"Stream URL: {result['url']}")
print(f"Port: {result['port']}")

Parameters:

Parameter	Type	Description
`box_ip`	`str`	Lager Box IP address for URL generation

Returns: dict with keys:

url - Full stream URL (e.g., http://<BOX_IP>:8086/)
port - Port number for the stream
already_running - Boolean indicating if stream was already active

Raises: RuntimeError if device is already in use or not found

`stop()`

Stop the webcam stream.

from lager import Net, NetType

webcam = Net.get('camera1', type=NetType.Webcam)
stopped = webcam.stop()

if stopped:
    print("Stream stopped")
else:
    print("Stream was not running")

Returns: bool - True if stopped successfully, False if not running

`get_info(box_ip)`

Get information about the stream.

from lager import Net, NetType

webcam = Net.get('camera1', type=NetType.Webcam)
info = webcam.get_info(box_ip='<BOX_IP>')

if info:
    print(f"URL: {info['url']}")
    print(f"Port: {info['port']}")
    print(f"Device: {info['video_device']}")
else:
    print("Stream not active")

Parameters:

Parameter	Type	Description
`box_ip`	`str`	Lager Box IP address

Returns: dict or None - Stream info dict or None if not running. The dict has these keys:

url - Full stream URL
port - Port number for the stream
video_device - Video device path, such as /dev/video0
source - The tool that started the stream: 'api' for this Python API, 'cli' for lager webcam. None for a stream with no recorded origin.
started_by - The user that the starting tool named. None for a stream started from this Python API.

`get_url(box_ip)`

Get just the URL for the stream.

from lager import Net, NetType

webcam = Net.get('camera1', type=NetType.Webcam)
url = webcam.get_url(box_ip='<BOX_IP>')

if url:
    print(f"Stream at: {url}")

Parameters:

Parameter	Type	Description
`box_ip`	`str`	Lager Box IP address

Returns: str or None - Stream URL or None if not running

`is_active()`

Check if the stream is currently active.

from lager import Net, NetType

webcam = Net.get('camera1', type=NetType.Webcam)
if webcam.is_active():
    print("Stream is running")
else:
    print("Stream is stopped")

Returns: bool - True if the stream is active, False otherwise

The Python API has no snapshot method. To save one frame from a running stream, use lager webcam NET snapshot from your computer.

Examples

Start Multiple Cameras

from lager import Net, NetType

# Lager Box IP
BOX_IP = '<BOX_IP>'

# Start multiple camera streams
cameras = ['overview', 'microscope', 'solder_station']

for name in cameras:
    try:
        webcam = Net.get(name, type=NetType.Webcam)
        result = webcam.start(BOX_IP)
        print(f"{name}: {result['url']}")
    except RuntimeError as e:
        print(f"{name}: Failed - {e}")

Stream Management

from lager import Net, NetType

BOX_IP = '<BOX_IP>'

def start_camera(name):
    """Start a camera stream."""
    try:
        webcam = Net.get(name, type=NetType.Webcam)
        result = webcam.start(BOX_IP)
        if result['already_running']:
            print(f"Stream '{name}' was already running at {result['url']}")
        else:
            print(f"Started '{name}' at {result['url']}")
    except RuntimeError as e:
        print(f"Failed to start '{name}': {e}")

def stop_camera(name):
    """Stop a camera stream."""
    webcam = Net.get(name, type=NetType.Webcam)
    if webcam.stop():
        print(f"Stopped '{name}'")
    else:
        print(f"Stream '{name}' was not running")

def check_camera(name):
    """Check camera status."""
    webcam = Net.get(name, type=NetType.Webcam)
    if webcam.is_active():
        info = webcam.get_info(BOX_IP)
        print(f"{name}: Running at {info['url']}")
    else:
        print(f"{name}: Stopped")

# Usage
start_camera('main')
check_camera('main')
stop_camera('main')

Visual Inspection Test

from lager import Net, NetType
import time

BOX_IP = '<BOX_IP>'

def visual_inspection_test(camera_name, inspection_callback):
    """
    Start camera stream and wait for operator inspection.

    Args:
        camera_name: Webcam net name
        inspection_callback: Function to handle the stream URL

    Returns:
        bool: True if inspection passed
    """
    # Start stream
    webcam = Net.get(camera_name, type=NetType.Webcam)
    result = webcam.start(BOX_IP)
    stream_url = result['url']

    print(f"Visual inspection stream: {stream_url}")

    # Notify external system (could open browser, send to UI, etc.)
    inspection_callback(stream_url)

    # Wait for inspection (in real usage, this would wait for operator input)
    print("Waiting for visual inspection...")
    time.sleep(10)  # Placeholder

    # Stop stream
    webcam.stop()

    # Return result (would come from operator in real usage)
    return True

# Usage
def handle_url(url):
    print(f"Open in browser: {url}")

result = visual_inspection_test('inspection_cam', handle_url)
print(f"Inspection result: {'PASS' if result else 'FAIL'}")

Camera Discovery and Testing

from lager import Net, NetType
import os

BOX_IP = '<BOX_IP>'

def discover_cameras():
    """Find all available video devices."""
    cameras = []
    for i in range(10):  # Check video0 through video9
        device = f'/dev/video{i}'
        if os.path.exists(device):
            cameras.append(device)
    return cameras

def test_camera(net_name):
    """Test if a camera net works."""
    try:
        webcam = Net.get(net_name, type=NetType.Webcam)
        result = webcam.start(BOX_IP)
        print(f"{net_name}: OK - {result['url']}")
        webcam.stop()
        return True
    except RuntimeError as e:
        print(f"{net_name}: FAIL - {e}")
        return False

# Discover and test all cameras
print("Discovering cameras...")
devices = discover_cameras()
print(f"Found {len(devices)} video devices")

# Test configured nets (assumes you have webcam nets configured)
test_camera('camera1')
test_camera('camera2')

Already Running Detection

from lager import Net, NetType

BOX_IP = '<BOX_IP>'

webcam = Net.get('camera1', type=NetType.Webcam)

# Start stream first time
result1 = webcam.start(BOX_IP)
print(f"First start: already_running = {result1['already_running']}")

# Try to start again - should detect it's already running
result2 = webcam.start(BOX_IP)
print(f"Second start: already_running = {result2['already_running']}")

# Check if active
print(f"Is active: {webcam.is_active()}")

# Cleanup
webcam.stop()

Web Interface

Each stream serves a viewer page at its URL. It uses the same layout and colors as the oscilloscope page (lager scope NET stream web):

A header. Its Net picker moves to another stream on the box. It shows the camera’s model and device, and the frame rate, size and zoom. Its status is LIVE, STALLED (no frame for 3 seconds), WAITING (no frame yet) or OFFLINE (the stream does not answer)
The live picture, with a clock and the zoom level over it. When zoomed in, drag the picture or use the arrow keys to pan. Double-click a point to zoom in on it, or once zoomed, to centre on it
A sidebar with:
- Resolution: the size and frame rate, from the modes the camera offers. If the camera cannot stream the size you pick, it keeps the old one, and the page says why. Too little USB bandwidth is one cause
- View: zoom (slider, Out, Reset, In), Centre for the pan, Rotate (0, 90, 180 or 270 degrees) and Flip (left-right, top-bottom)
- Focus: Auto or Manual with a distance slider
- Image: exposure (Auto exposure or Manual with a slider), gain and brightness. Exposure and gain show only on a camera that has them. While auto exposure is on, the camera sets the gain itself
Hide sidebar hides it, and the page remembers the choice
Full screen shows the picture alone
Snapshot, which saves one frame as <net>-<timestamp>.jpg
At the foot of the sidebar, who started the stream, its device and its port

Every setting is kept with the stream on the box. Everyone who views the stream sees the same picture, and the settings come back when the stream restarts. Larger sizes cost the box more CPU to encode: the frame rate in the header shows what the box keeps up with. On an access-gated box, when the browser’s session ends the page says SIGNED OUT and tells you to run lager webcam url for a new link.

API Endpoints

Endpoint	Method	Description
`/`	GET	The viewer page
`/static/webcam.css`, `/static/webcam.js`	GET	The viewer page’s style and script
`/stream`	GET	Raw MJPEG video stream
`/api/info`	GET	The stream’s net, device, camera model, port, origin, fps, zoom, frame size, and seconds since the last frame (`frame_age`, `null` before the first)
`/snapshot`	GET	One JPEG frame. Returns 503 if no frame arrives within 5 seconds
`/api/zoom`	GET	Get current zoom level
`/api/zoom/in`	POST	Increase zoom
`/api/zoom/out`	POST	Decrease zoom
`/api/zoom/reset`	POST	Reset zoom to 1.0x
`/api/zoom/set`	POST	Set zoom: `{"zoom": 2.0}` (1.0 to 4.0)
`/api/focus`	GET	Focus mode and value
`/api/focus/auto`	POST	Turn on autofocus
`/api/focus/manual`	POST	Manual focus: `{"value": 128}` (0 to 255)
`/api/brightness`	GET	Brightness value
`/api/brightness/set`	POST	Set brightness: `{"value": 128}` (0 to 255)
`/api/pan/set`	POST	Pan a zoomed picture: `{"x": 0.3, "y": 0.7}`, the centre of the view as fractions of the picture
`/api/orientation/set`	POST	Any of `{"rotate": 90, "flip_h": true, "flip_v": false}`. Rotation is clockwise: 0, 90, 180 or 270
`/api/modes`	GET	The sizes and frame rates the camera offers (MJPEG), the current mode, and why the last change failed, if it did
`/api/mode/set`	POST	Change the mode: `{"width": 1920, "height": 1080, "fps": 30}`. Answers 400 for a mode the camera does not list
`/api/controls`	GET	Exposure (`auto`, `value`, `min`, `max`) and gain, for a camera that has them
`/api/controls/set`	POST	`{"control": "exposure_auto", "value": false}`, or `exposure` or `gain` with a number
`/api/fps`	GET	Get current FPS
`/api/streams`	GET	List all active streams
`/test`	GET	Health check endpoint

Hardware Requirements

Requirement	Description
USB Webcams	UVC-compatible cameras
Video Devices	`/dev/video*` device files
OpenCV	Required for video capture

Notes

Webcam nets must be configured on the Lager Box with video device path
Streams run on ports starting from 8086
Each stream uses a separate port, automatically allocated
Streams persist until explicitly stopped or the process dies
Dead stream processes are automatically cleaned up
Only one stream can use a video device at a time
Default resolution is 640x480 at 30 FPS
JPEG quality is set to 80 for bandwidth/quality balance
Streams are reachable over HTTP at the Lager Box IP address. On an access-gated box, a request needs a sign-in token, and the url from start() carries none. Use lager webcam url for a link that carries your token
Zoom is digital (crop and scale), not optical

Getting Started

Development

Power & Simulation

Measurement

I/O & Communication

Utilities

Import

Methods

Method Reference

`Net.get(name, type=NetType.Webcam)`

`start(box_ip)`

`stop()`

`get_info(box_ip)`

`get_url(box_ip)`

`is_active()`

Examples

Start Multiple Cameras

Stream Management

Visual Inspection Test

Camera Discovery and Testing

Already Running Detection

Web Interface

API Endpoints

Hardware Requirements

Notes

​Import

​Methods

​Method Reference

​Net.get(name, type=NetType.Webcam)

​start(box_ip)

​stop()

​get_info(box_ip)

​get_url(box_ip)

​is_active()

​Examples

​Start Multiple Cameras

​Stream Management

​Visual Inspection Test

​Camera Discovery and Testing

​Already Running Detection

​Web Interface

​API Endpoints

​Hardware Requirements

​Notes

Import

Methods

Method Reference

`Net.get(name, type=NetType.Webcam)`

`start(box_ip)`

`stop()`

`get_info(box_ip)`

`get_url(box_ip)`

`is_active()`

Examples

Start Multiple Cameras

Stream Management

Visual Inspection Test

Camera Discovery and Testing

Already Running Detection

Web Interface

API Endpoints

Hardware Requirements

Notes