LYNX Python API Reference

Quick start

No catalog models are available yet. Bringing your own ONNX model is the only way to run the SDK today. lynx.open("<slug>") appears throughout these pages and is the real API, but every catalog slug returns model_not_in_production until the catalog publishes — contact sales@synetic.ai for access.

Your own ONNX model:

1import lynx
2 
3with lynx.open_standard("your-model.onnx") as model:
4    result = model.predict("street.jpg")
5 
6    for det in result:
7        print(det.class_name, det.box.trust.confidence, det.depth.value)
8 
9    result.show()

LYNX provides logic on top of trained models, so in order to separate measurements from the model and LYNX, measurements include their source.

The surface

Model

Two ways in.

open

open() resolves a slug against the LYNX registry.

open_standard

open_standard() imports an ONNX model you already have.

Members

1model = lynx.open("your-model-slug", tasks=lynx.FrameTask.BOUNDING_BOX | lynx.FrameTask.DEPTH)
2 
3print(model.slug, model.version, model.precision)
4print(model.providers)                       # (Provider.TENSORRT,)
5print(len(model.classes), "classes")
6 
7result = model.predict("street.jpg")
8result, timing = model.predict_profiled("street.jpg")
9print(timing.total_us)
10 
11model.close()

available_batch_sizes

tuple[int, ...] — Batch sizes that already have an engine

build_id

str — Exact build, for reproducing a result

capabilities

Capabilities — Which heads this model has

classes

ClassList — The taxonomy it was trained on

license

LicenseInfo — Coverage and expiry

precision

str — Weight precision in use

providers

tuple[Provider, ...] — Runtimes it is executing on

slug

str — Registry name it was opened by

version

str — Catalogue version actually loaded

predict options

stream options

FrameResult

Iterating a FrameResult yields Detection. It is a Sequence[Detection], so len(result) and result[0] work directly.

1result = model.predict("street.jpg")
2 
3print(len(result), "detections at", result.timestamp)
4 
5if result.depth_map:
6    print(result.depth_at(640, 360).value, "m at centre")
7 
8a, b = result[0], result[1]
9print(result.distance(a, b).value, "m apart")
10 
11result.save("annotated.jpg")
12result.close()

camera_id

str \ — None — Label of the stream that produced it

classifications

tuple[Classification, ...] — Whole image labels

depth_map

DepthMap \ — None — Dense depth for the whole frame

detections

DetectionList — Everything found in the frame

frame_index

int — Position in the stream, 0 for predict

normals_map

ndarray \ — None — Surface normals for the whole frame

scene_text

SceneText \ — None — Text read from the frame

segmentation_map

SegmentationMap \ — None — Dense per pixel class labels

source_image

ndarray \ — None — The frame as it went in

source_image_is_bgr

bool — Channel order of source_image

stream

Stream \ — None — The stream, when there was one

timestamp

float — When the frame was taken

tracked

FrameResultTracked \ — None — Frame level tracking state

distance takes two Detection. point_distance takes two (x, y) pairs.

DetectionList

Sequence[Detection]. Indexable, sliceable, iterable, len().

FrameResultTracked

None unless a stream produced the result. Everything here needs more than one frame, which is why it lives on the tracked result rather than on FrameResult.

flow

ndarray \ — None

stream_id

int

Detection

1person = model.classes["person"]
2nose = person.keypoints["nose"] if person.has_pose else None
3 
4for det in model.predict("street.jpg"):
5    print(det.class_name, det.box.trust.confidence)
6 
7    if det.depth.value:
8        print("  ", det.depth.value, "m,", det.size_m.value, "m tall")
9 
10    kp = det.keypoints[nose] if nose and det.class_name == "person" else None
11    if kp:
12        print("  nose at", kp.x)

A detection names its class but does not hand you the class object: reach it through model.classes. Keypoints index by KeypointDef, never by a raw integer, so a model upgrade that reorders the schema cannot silently move them.

amodal_box

Box \ — None — Full extent including the occluded part

box

Box — Where it is, and how trusted

class_id

int — Numeric class, matches Class.id

class_name

str — Human readable class

cls

Class — The full class definition

depth

Measure — Metres from the camera

embedding

ndarray \ — None — Identity vector for matching across cameras

keypoints

Sequence[Keypoint] — Pose points, in schema order

occlusion

Measure — How much of it is hidden

segmentation

Mask \ — None — Its outline, not just its box

size_m

Measure — Metric extent of the object

tracked

DetectionTracked \ — None — Identity and history, streams only

yaw

Measure — Degrees of rotation about the vertical

angle takes three KeypointDef, vertex first, matching FrameResult.angle. angle_at takes one and uses the angle_pair declared on it.

box.angle is the oriented-box heading and is a different quantity from both.

depth is metres from the camera. size_m is the object's metric extent, also metres. yaw is degrees. Read depth.trust.source to know whether the distance rests on a measured focal length or an assumed one.

DetectionTracked

None when the detection matched no track. Always None on predict().

age_s

float

approach

Reading \ — None

behavior

LabelReading \ — None

global_id

int \ — None

heading

Reading \ — None

id

int

lifecycle

TrackState

pulse

Reading \ — None

respiration

Reading \ — None

speed

Reading \ — None

ApproachPair

Closing behaviour between two tracked subjects. Returned by DetectionTracked.approach_pair.

attached

bool — The two are moving as one system, a load on a vehicle

basis

ApproachBasis — What the geometry was computed from

bucket

ApproachBucket — The banded verdict. Act on this

closest_approach

ClosestApproach — Where they end up if both hold course

separation

Measure — The gap now

trust

Trust — About the pairing, not about any one number

ClosestApproach

separation

Measure

time

Measure

Three numeric quantities, and they do not share a provenance, which is why each carries its own Measure rather than one covering the set.

separation is a measurement off two positions. It always resolves and is the best conditioned of the three.

closest_approach.separation is a prediction and needs both velocities. As the closing rate approaches zero it tends toward the current gap and stays finite.

closest_approach.time takes the same inputs plus whether they meet at all, and runs to infinity where the closing rate does not. One shared margin across the three would have to be the worst of them, so the gap you can always measure would carry the uncertainty of a prediction that may not exist.

trust is about the pairing. It qualifies bucket, attached and basis, the same way Box carries one trust over its extent.

bucket is the output to act on. Nobody acts on "3.2 seconds", they act on "closing fast", and banding also makes the error compounding moot: dividing a distance by a closing rate roughly halves the precision of both.

attached says the two are one moving system rather than two converging ones. A forklift and the pallet it carries have zero relative velocity and overlapping extents, and their collision geometry is the union of the two rather than either box.

Both predictions are straight line extrapolations. Over half a second that holds. Over three seconds people and vehicles turn, and the numbers stop meaning anything.

A pair with no prediction reports None rather than zero. Zero reads as "certainly not approaching", which is the opposite of "we could not say".

Stream

camera_id

str \ — None

model

Model

stream_id

int

temporal

TrackedTask

tracking

TrackOpts

window_s

float

tracking reads back the options the stream is actually running. Zero means "use the default" per field, so the values you passed in are not necessarily the values in force.

weak_box_conf lets the tracker continue a track through a frame where the detector's score dipped below threshold. A weak box exactly where a confirmed track was predicted is much more likely real than the same box in empty space, which is why this is not the same as lowering confidence: that would admit weak boxes everywhere, including where there is no track to continue.

Weak boxes never start a track and are never returned to you. They exist to keep an id alive across a gap.

ref decides which point of a box is tested against the geometry: ZoneRef.BASE uses the bottom centre, ZoneRef.CENTRE uses the box centre.

Passing no zone to on_zone, or no line to on_line, registers for all of them.

Zone

id

int

name

str \ — None

polygon

ndarray

ref

ZoneRef

Line

a

tuple[float, float]

b

tuple[float, float]

id

int

name

str \ — None

ref

ZoneRef

Cross.FORWARD is left to right when walking from a to b.

Event

box

Box \ — None

class_id

int

class_name

str

detection

Detection \ — None

direction

Cross

dwell_s

float \ — None

kind

EventKind

label

str \ — None

line

Line \ — None

timestamp

float

track_id

int

value

float

zone

Zone \ — None

StreamManager

1manager = lynx.StreamManager()
2manager.add(model.stream(camera_id="north"), "rtsp://north/live")
3manager.add(model.stream(camera_id="south"), "rtsp://south/live")
4manager.cross_camera(True, threshold=0.7, confirm=3)
5 
6for result in manager:
7    for det in result:
8        if det.tracked and det.tracked.global_id:
9            print(result.camera_id, det.tracked.global_id)

streams

tuple[Stream, ...]

Lifetime

Three rules cover every borrowed object in the SDK.

Results from the StreamManager iterator expire on the next iteration. Reading an expired result raises lynx.errors.ResultExpired. Copy anything you need to keep before advancing.

Event handlers fire inside process() on the calling thread. Event.detection is valid for the duration of that call only.

Model, Stream, StreamManager, FrameResult, Camera, VideoWriter and Magnifier all hold native resources and all expose close(). All of them work as context managers.

1with lynx.open("your-model-slug") as model:
2    with model.predict("street.jpg") as result:
3        ...

Measurement types

Trust

Carried by Box, Measure, Mask and Keypoint. Every one of them answers the same question: how much of this number came from the model, and how much came from something the SDK inferred.

confidence

float

margin

float \ — None

raw

float

size_basis

SizeBasis \ — None

size_check

SizeCheck \ — None

source

Source

raw is the model's score before calibration. confidence is after. On a model opened in ConfidenceMode.NON_CALIBRATED the two are equal.

confidence and margin are different quantities. A depth has both. A box has a confidence and no margin.

margin is plus or minus in the value's own units, metres for a depth and degrees for an angle. None when nothing reports one, never 0, because 0 reads as exact.

raw is the value before the SDK adjusted it, and is always a real number. Where nothing was adjusted it equals the adjusted value.

derivations is the chain that produced the number. source is its last step.

source says where the number came from, and on a distance it also says what the units are. Read it before treating a distance as metres.

Under DERIVED_ASSUMED_FOCAL the SDK assumed a normal lens at roughly 60 degrees horizontal field of view. Ordering and ratios between objects are correct, and the absolute scale carries the error of that assumption. margin widens to reflect it. Supply intrinsics to replace the assumption with your real lens.

Size is not affected. size_m is metric under every source, because the focal length cancels out of it. Only distance depends on knowing the focal length.

Measure

trust

Trust

value

float \ — None

value is None when there is no measurement. trust is always present, and trust.source says why.

Box

Coordinates are source pixels.

angle

float \ — None

center

tuple[float, float]

h

float

trust

Trust

w

float

x

float

x1

float

x2

float

y

float

y1

float

y2

float

x and y are the centre. x1, y1, x2, y2 are the corners.

angle is None when the model has no orientation head, and 0.0 when the model measured the box and found it axis aligned.

Other geometry

Mask.xy is an (N, 2) polygon in source pixels. Intrinsics is the one thing in this list you supply rather than receive.

DepthMap

height

int

metric

bool

scale

float \ — None

scale_age_s

float

scale_anchors

int

scale_rejected

int

scale_se

float \ — None

scale_undeclared

int

shape

tuple[int, int]

width

int

Metric depth is recovered per frame from objects of declared size. The scale_* fields report that recovery: how many candidate anchors were found, how many were rejected as inconsistent, how many detections had no declared size to contribute, and how old the scale in force actually is.

scale_age_s is 0.0 when the scale came from this frame. A non zero value means the scale is being held from an earlier frame under scale_hold_s.

Reading

A windowed estimate. It composes a Measure rather than restating one: the value and its trust both come from measure, and the rest says what window produced it.

age_s

float

measure

Measure

reason

VitalReason

samples

int

window_s

float

1r = det.tracked.pulse
2r.measure.value              # the rate
3r.measure.trust.source       # whether it came off a held estimate
4r.measure.trust.margin       # plus or minus, when stated
5r.age_s, r.samples           # how fresh, and from how many frames

reason says why a reading is what it is, and is the field to read when one is absent or stale rather than inferring it from age_s alone.

LabelReading

The categorical counterpart to Reading. It carries a Trust directly rather than composing a Measure, because a label has no value to be uncertain about.

age_s

float

label

str

trust

Trust

window_s

float

trust.margin is always None. A plus or minus on a categorical label is not a quantity, and that is the honest answer rather than an omission.

trust.source is what distinguishes a label served from a held estimate from one computed on this frame. age_s says the reading is old; source says it was never recomputed.

A Reading is a windowed estimate, not a per frame value. window_s is the window it was computed over, age_s is how long ago that window closed, and samples is how many frames contributed.

LabelReading is the categorical counterpart and does not compose a Measure, because a label has no value to be uncertain about.

measure.trust.margin is plus or minus on the rate itself. None means unstated rather than broken: a falling confidence says a reading is ageing, and margin says how precise it ever was.

age_s is 0.0 for a reading computed from the current window. A non zero value means the estimator could not produce a fresh one and is holding the last established reading. Treat a growing age_s as the signal that conditions have degraded, since the value itself will not change.

RateBand

Passed as the pulse or respiration option to stream().

filter_max_per_min

float

filter_min_per_min

float

max_age_s

float

min_confidence

float

The filter fields bound what the estimator searches, not what is clinically normal. Widening them costs accuracy.

DepthGate

Passed as the depth_gate option to predict(). Rejects detections whose recovered metric size falls outside the class size band.

stats

dict

Classes and keypoints

1nose = model.classes["person"].keypoints["nose"]     # KeypointDef
2det.keypoints[nose.index]                            # Keypoint

Detection.keypoints indexes by position. A name resolves through the class:

Keypoint.present means the decode located the keypoint. It is not a confidence threshold. A present keypoint can still have low trust.confidence.

SizeBand is the observed size distribution for a class, in metres. SizeDimensions is its declared physical extent, with a have_* flag per axis because not every class has all three.

Class

One class in the model's taxonomy. Returned by ClassList lookups — model.classes["person"].

dimensions

SizeDimensions \ — None

has_pose

bool

id

int

keypoints

KeypointSchema

name

str

size_band

SizeBand \ — None

id is the class id the model emits, and is what Detection.class_id holds. It is not the position of the class within ClassList.

name is the catalogue name, and is what Detection.class_name holds.

has_pose is whether the class declares keypoints. When it is False, keypoints is empty and so is Detection.keypoints for that class.

keypoints is the schema: which keypoints the class declares, their order, and how they connect. keypoint(name) is the single lookup, equivalent to keypoints[name].

size_band is how large members of the class are observed to be, in metres, as p1, median and p99. It is what a DepthGate tests against and what makes SizeCheck meaningful.

dimensions is the class's declared physical extent, in metres, with a have_* flag per axis because not every class declares all three. This is the input to metric depth: a detection of a class with a declared height is a scale anchor.

height_stable gates whether the class may anchor a scale, not how good the measurement is. A seated person is not a short person, so a class whose height varies with posture is excluded rather than allowed to poison the scale for the whole frame. An undeclared class contributes nothing at all, deliberately: a guessed focal length would be wrong for every object in the frame instead of one.

size_band and dimensions come from the catalogue on a catalogue model. On an imported model they are None until you declare them with lynx_size_dims. See Bring your own model.

ClassList

Returned by Model.classes. A Sequence, built on first access and cached for the life of the model.

1model.classes["person"]        # Class
2model.classes[det.class_id]    # Class, by class id
3model.classes.names            # ('person', 'car', ...)
4 
5for cls in model.classes:
6    print(cls.id, cls.name)

[id]

Class

[name]

Class

[slice]

tuple[Class, ...]

names

tuple[str, ...]

Iterating yields Class.

Subscripting raises on a miss: UnknownClass for an unknown name, IndexError for an unknown id. get raises neither and returns default.

A slice returns a plain tuple. The result has no name lookup and no names.

names is rebuilt on every access, so read it once rather than in a loop.

Indexing is by Class.id, so model.classes[det.class_id] is correct by construction. Iteration walks the classes in order and is unaffected by gaps in the id space.

KeypointSchema

Returned by Class.keypoints. Same shape as ClassList, keyed over the keypoints a class declares.

1schema = model.classes["person"].keypoints
2 
3if "nose" in schema:
4    det.keypoints[schema["nose"].index]

[index]

KeypointDef

[name]

KeypointDef

[slice]

tuple[KeypointDef, ...]

in

bool

names

tuple[str, ...]

Iterating yields KeypointDef.

Subscripting raises NotFound for an unknown name and IndexError for an out of range index. get returns default instead.

Here the index is the keypoint's declared position, and matches KeypointDef.index and the ordering of Detection.keypoints.

Scene text

SceneText is the frame level grouped read. Detection carries no per object text.

Capabilities

What the model can do. Returned by Model.capabilities.

1if lynx.FrameTask.DEPTH in model.capabilities.tasks:
2    ...

nms_free

bool

pr_curves

bool

tasks

FrameTask

temporal

TrackedTask

tasks and temporal are flag enums, so test with in.

tasks is what the model actually has, and is the thing to branch on rather than assuming a head is present.

pr_curves is True when the model ships calibration curves, which is what makes the CALIBRATED_* confidence modes meaningful.

LicenseInfo

Returned by Model.license.

expires_at

int

status

LicenseStatus

expires_at is Unix epoch seconds.

ModelEntry

One row of the registry. Returned by available_models.

available

bool

class_count

int

latest_version

str

license_tier

str

licensed

bool

name

str

openable

bool

public_trial

bool

slug

str

licensed is whether your licence covers it. available is whether it is published. openable is whether open() will succeed right now, which is the one to test.

Timing

Returned by Model.predict_profiled.

inference_us

float

postprocess_us

float

preprocess_us

float

tiles

int

total_us

float

Microseconds. total_us is the wall time for the call and is not the sum of the other three.

tiles is how many forward passes actually ran, and 0 when the frame ran whole. Without it, 520 ms of inference cannot be told apart as one slow forward or eight ordinary ones.

Bring your own model

open_standard takes a path instead of a slug. It reads ONNX graphs and .lnxp packages, and dispatches on the file's magic rather than its extension.

1model = lynx.open_standard("your-model.onnx")

That works when the file declares enough about itself. Most do not, which is why the rest of this section exists.

Why there is a configuration

An ONNX file states the shape of its outputs. It does not state what they mean. Given a [300, 6] tensor, nothing in the file separates one detection per row from the transpose, box4, score, class_id from box4 plus two class scores, corner boxes from centre form boxes, or coordinates in the letterboxed input from coordinates already mapped back to the source.

Every wrong reading produces plausible boxes, not an error. Boxes on roughly the right objects, slightly wrong, with confident scores. Getting lynx_box_space wrong on a real export measured at IoU 0.22 where the correct reading gave 0.99, and nothing in either run reported a problem.

So every key is declared, never defaulted.

Probe

probe_config runs the real pipeline over your model and returns the configuration document.

1config = lynx.probe_config("your-model.onnx", "frame.jpg")

The image must be non-square. Letterbox and stretch agree exactly on a square frame, so a square probe image cannot separate them. Probe reports that rather than picking one.

Probe does not guess. A field it cannot settle comes back unresolved, with what would settle it, because a guessed key is indistinguishable from a fact once it is written to the file.

A value your model already declares is carried through as DECLARED. Where observation contradicts it the field becomes CONFLICT and the declared value still wins. That disagreement is usually a real bug in the export, and silently correcting it hides the thing most worth seeing.

Reviewing what probe decided

Config subclasses dict, so it prints, serialises and indexes like the document it is.

1config["lynx_box_space"]                # 'input_px'
2config.provenance("lynx_box_space")     # Provenance.DEDUCED
3config.margin("lynx_box_space")         # 0.34, how close the call was
4config.detail("lynx_box_space")         # why, and what would settle it
5 
6config["lynx_box_space"] = "orig_px"    # yours now, probing will not overwrite it
7config.save("your-model.lynx.json")
8 
9model = lynx.open_standard("your-model.onnx", config)

get, keys, [key]

as dict

VitalReason

Why a rate reading is absent, held, or fresh

Provenance

Configuration keys

lynx_box_space is the field that fails most quietly. The SDK applies its inverse letterbox on your word. Declare input_px for a graph that already un letterboxed internally and the transform runs twice.

Declaring class sizes

Without dimensions, an imported model has no metric size, no SizeCheck and no DepthGate, and distances rest on an assumed lens. Declare them and all four work.

1config["lynx_size_dims"] = {"by_class_id": {
2    "0": {"height_m": [0.75, 1.70, 2.05], "height_stable": True},
3    "5": {"height_m": [2.80, 3.20, 3.60], "height_stable": True}}}

height_m is [p1, median, p99] in metres. The median is what the scale uses. Set height_stable to False for a class whose height depends on posture, and it will still be measured but will not anchor a scale.

The lookup is by class id, not by name. There is no name keyed size table inside the SDK.

Supply intrinsics to predict() as well and distances come back in metres. Without it they are correct for ordering and for ratios, but scaled by an unknown constant.

Dense heads

An export whose decode was stripped, as for INT8 quantisation, needs four more keys.

The anchor grid is derived from lynx_strides and lynx_img_size, never declared, so a grid that disagrees with the tensor is caught instead of shifting every box by one level.

Autotune

autotune brute forces preprocessing over one image when probe leaves the choice open.

1tune = lynx.autotune("your-model.onnx", "frame.jpg")
2tune.best.channel_order, tune.best.resize_mode
3tune.lead                                   # 1.02 means no real preference

best is None when no candidate produced detections, and also when the winner's decode kept every row, since noise still sorts and a ranking over noise is not a result.

lead is the ratio of the first candidate's score to the second, and a lead near 1.0 means the result is not a preference worth acting on. It reports the weakest axis, which understates the case where the grid was certain about one thing and undecided about another.

axis_lead(axis) gives the margin per axis. The top two candidates usually differ in one axis only, so a headline lead of 1.03 can sit alongside a rotation margin of 2.05.

Autotune is not a first resort. Its grid is channel order by rotation by resize, so a model whose column layout is undeclared cannot be fixed by it. Declare the metadata, probe the graph, and reach for autotune only when decode already works and the orientation or channel order is genuinely unknown. It costs sixteen forward passes.

Calibrating

A model you brought yourself has no per class thresholds, so every class uses the same one. Pass a validation folder and probe_config produces them in the same document.

1config = lynx.probe_config("your-model.onnx", "frame.jpg", val_dir="val/")
2config.thresholds()          # {'person': 0.41, 'car': 0.33, ...}

The folder is standard YOLO layout: a val/ holding images/ and labels/.

Packaging

Four files and a runbook is how a fleet ends up running default thresholds while nobody notices. package writes the model and its configuration as one .lnxp.

1model = lynx.open_standard("your-model.onnx", config)
2model.package("your-model.lnxp")
3 
4model = lynx.open_standard("your-model.lnxp")      # nothing else needed

The model knows the file it was opened from and the config it was opened with, so neither is passed back in.

Engine prebuilding is TensorRT only. CoreML compiles per shape at load, and the ONNX Runtime CPU path has nothing to prebuild, so on those hosts engine_target() is empty and there is no engine to package.

1lynx.engine_target()                             # 'linux-aarch64-trt10.3-sm87'
2lynx.package_add_engine("your-model.lnxp", target, "engine.plan")
3lynx.package_inspect("your-model.lnxp")             # segments, sizes, digests, targets

package_add_engine is the only way one package carries engines for more than one kind of hardware.

Limits

ONNX only. No .pt, no pickle, no framework dependency.

Detection layouts only. Pose, segmentation and depth on foreign models are not covered by the configuration vocabulary.

Everything that is not a signed .lnx opens with a non catalogue origin, so nothing keyed on catalogue conventions applies by default. Metric size, SizeCheck and DepthGate all need class dimensions, which a catalogue model carries and an imported one does not. Declare them yourself with lynx_size_dims and all three work.

When boxes look wrong

They will look plausible, so work through the declarations rather than the model.

1. Run probe with a non-square image and read unresolved().
2. Check lynx_box_space first.
3. Compare against onnxruntime directly, preprocessing the image the way your configuration says: square letterbox for letterbox, plain resize for stretch.
4. If the top detection is a different class than expected, check preprocessing before the decode. The same model under two letterbox conventions genuinely ranks detections differently.

Capture and output

1camera = lynx.camera_open(0)
2stream = model.stream(camera_id="north-gate")
3 
4for frame in camera.frames():
5    result = stream.process(frame)

Configuration

Process wide, and entirely optional. The defaults run without any of it.

You do not need an API key to try the SDK. It runs free for 30 days without one. Set a key to go past that, or to reach models your licence covers.

Inspecting the environment

Errors

All under lynx.errors.

Enums

UNSET is 0 on every enum that lands in a struct, and means nobody wrote there. Python reports it as None wherever it describes an absence rather than a state.

What None means

None is always an absence, never a zero. A member that has a value but a bad one reports that through trust, not by going None.

Detection.tracked

The detection matched no track

Detection.amodal_box

The model emits no amodal extent, or FrameTask.AMODAL_BOX was not enabled

FrameResult.tracked

No stream produced the result

FrameResult.stream

The result came from predict()

FrameResult.depth_map

The model has no depth head, or FrameTask.DEPTH was not enabled

Box.angle

The model has no orientation head, or FrameTask.ORIENTED_BOUNDING_BOX was not enabled

Measure.value

There is no measurement

Trust.margin

Nothing reports one for this quantity

DetectionTracked.speed

There is no scale to convert with

DetectionTracked.heading

The subject is stationary

DetectionTracked.pulse

No pose model, no eyes visible, or no reading ever established

DetectionTracked.respiration

No reading ever established

DetectionTracked.global_id

The subject has been seen in one camera only

DepthMap.scale

No anchor was recovered this frame

DepthMap.scale_se

Fewer than two anchors

Autotune.best

No candidate produced detections, or the ranking was over noise

Complete surface

Everything the SDK exports appears here; the sections above explain when to reach for it.

Module functions

__version__, __commit__, __build_number__, open, open_standard, probe_config, engine_target, package_add_engine, package_inspect, despeckle, depth_to_u8, camera_open, video_writer, magnifier, version, set_apikey, set_device_name, set_cache_dir, set_telemetry_enabled, set_feedback_enabled, set_diagnostic_callback, set_workers, cuda_device_count, available_providers, provider_name, available_models, shutdown, autotune, errors

Model and results

Streaming and events

Bring your own model

Geometry and measurement

Text and OCR

Capture and output

Enums and everything else

115 exported names.