Problem Being Solved

This page explains the problem that seekcamera-python solves and why it exists. If you are building a Python application that needs to capture or process thermal image data from a Seek Thermal OEM camera core, understanding what this library provides — and what it abstracts away — will help you make better design decisions from the start.

Working with thermal cameras is complex by default

Seek Thermal OEM camera cores expose their functionality through the Seek Thermal SDK, which has a traditional C interface. Using that interface directly from Python requires writing and maintaining C extension code, managing low-level memory, handling raw binary data structures, and bridging Python's runtime model with a native library — none of which is the actual problem you want to solve.

seekcamera-python removes that burden. It provides official, pre-built Python language bindings that wrap the Seek Thermal SDK's C interface and expose it as an idiomatic Python API you can import and call directly.

What the library enables

With seekcamera-python, you can:

• Capture thermal frames from Seek Thermal OEM cores (both Mosaic and Micro Core cameras share a common API, so you write one integration that works across hardware variants)
• React to camera events asynchronously using an event-driven model, which keeps your application fast and responsive without polling loops
• Work with multiple cameras simultaneously in a single SDK instance, which matters for multi-sensor systems or redundant setups
• Choose from numerous frame output formats to match your downstream processing pipeline — whether you need raw temperature data, colorized images, or pixel arrays compatible with NumPy
• Handle errors and log output robustly using the SDK's built-in error handling and logging interface, so you can diagnose problems in production without guesswork

What the library does not replace

seekcamera-python is a binding layer, not a standalone imaging stack. It still requires the Seek Thermal SDK 4.X to be installed on your system, and it requires a Seek Thermal OEM core to be physically attached. The library translates your Python calls into SDK calls — it does not reimplement the SDK's camera communication, calibration, or frame processing logic.

This means you get the full performance and correctness of the native SDK while writing Python code. You do not have to trade one for the other.

Who this is for

This library is aimed at developers who are integrating thermal imaging into Python applications — whether that is a computer vision pipeline, a data logging tool, an industrial inspection system, or a research instrument. You are expected to be comfortable with Python and with the general concept of calling a library API, but you do not need prior experience with the Seek Thermal SDK or C extension programming.

Reacting to a connected camera and capturing a frame

The following pattern shows the core value of the library: you define event handlers in Python, register them with the SDK, and let the asynchronous event-driven API deliver frames to your code. You never write a polling loop or manage C memory.

from seekcamera import (
    SeekCameraIOType,
    SeekCameraManager,
    SeekCameraManagerEvent,
    SeekCameraFrameFormat,
    SeekFrame,
)

def on_frame(camera, camera_frame, _):
    # Called automatically each time a new frame is available
    frame = camera_frame.thermography_float
    print(f"Frame received: {frame.width}x{frame.height} pixels")

def on_event(camera, event_type, error, _):
    if event_type == SeekCameraManagerEvent.CONNECT:
        print(f"Camera connected: {camera.chipid}")
        camera.register_frame_available_callback(on_frame)
        camera.capture_session_start(SeekCameraFrameFormat.THERMOGRAPHY_FLOAT)
    elif event_type == SeekCameraManagerEvent.DISCONNECT:
        print("Camera disconnected")

with SeekCameraManager(SeekCameraIOType.USB) as manager:
    manager.register_event_callback(on_event)
    input("Press Enter to stop...\n")

Expected output (with a camera attached):

Camera connected: <your-camera-chip-id>
Frame received: 320x240 pixels
Frame received: 320x240 pixels
...

Exporting frame data as a CSV file

This mirrors what the bundled seekcamera-simple sample does — it demonstrates that frame pixel values are accessible as standard Python/NumPy data structures, ready for any downstream processing.

import numpy as np
from seekcamera import (
    SeekCameraIOType,
    SeekCameraManager,
    SeekCameraManagerEvent,
    SeekCameraFrameFormat,
)

def on_frame(camera, camera_frame, _):
    frame = camera_frame.thermography_float
    # frame.data is a NumPy array of float32 temperature values
    np.savetxt("thermal_frame.csv", frame.data, delimiter=",")
    print("Frame saved to thermal_frame.csv")

def on_event(camera, event_type, error, _):
    if event_type == SeekCameraManagerEvent.CONNECT:
        camera.register_frame_available_callback(on_frame)
        camera.capture_session_start(SeekCameraFrameFormat.THERMOGRAPHY_FLOAT)

with SeekCameraManager(SeekCameraIOType.USB) as manager:
    manager.register_event_callback(on_event)
    input("Press Enter to stop...\n")

Expected output:

Frame saved to thermal_frame.csv

The resulting CSV contains one floating-point temperature value per pixel, with rows and columns matching the camera's native resolution.

• Installation — How to install seekcamera-python and its dependencies, including the required Seek Thermal SDK runtime
• Capturing thermal frames — A step-by-step guide to writing your own frame capture application using the event-driven API
• Working with multiple cameras — How to use SeekCameraManager to connect and manage more than one camera in a single SDK instance
• Error handling and logging — How the SDK's error handling and logging interface surfaces problems so you can interpret and respond to them in your application
• Frame output formats — The different SeekCameraFrameFormat values available and when to use each one