Motion Detection

Motion Detection#

Introduction#

The Motion Detection Example Application for the A212 sensor detects and locates moving objects in a 3D volume in front of the sensor. The processor:

high-pass filters the IQ data to suppress static reflectors,
builds per-range channel covariance matrices,
beamforms an azimuth/elevation/distance heatmap,
applies a CFAR threshold,
refines local maxima through interpolation,
and returns the surviving detections as 3D Spherical peaks in the sensor frame and Cartesian peaks in the world frame.

Configuration#

This section describes the most important configuration parameters and how to tune them. The processor is configured with four classes: MotionDetectionConfig holds the processing parameters, SensorInstallation describes how the sensor is mounted, DetectionVolume the region to detect within, and WallMountSessionAbstractionConfig abstracts the sensor configuration settings. The fields described below are the common-case parameters exposed in the Exploration Tool GUI’s main view. Advanced fields (beamformer internals, CFAR kernel shape, peak interpolation tuning, …) live behind the GUI’s Advanced section and remain visible in the full API listing at the bottom of this page.

MotionDetectionConfig#

The high_pass_filter_time_constant_s controls the IIR high-pass filter applied to the IQ data before the covariance matrices are formed. Its purpose is to suppress static reflectors so that only the moving component reaches the beamformer. A larger value lets slower motion through but also keeps stationary reflectors visible for longer when the scene changes (e.g. a moved chair will look like presence for several seconds). A smaller value adapts faster to scene changes at the cost of suppressing slow targets. A starting range of 0–10 s works for most human-motion use cases. A value of 0 means each frame is detrended only by the mean sweep. This will suppress slow movements while passing faster movements such as walking. Setting the parameter higher will apply a detrend of a low-pass version of the mean sweep over frames. This is suitable to detect slower motions such as sitting persons that change on the timescale of frame_rate.

The covariance_matrix_time_constant_s is the time constant of the IIR low-pass filter applied to the per-range channel covariance matrices. It controls how much temporal averaging the beamformer sees: larger values stabilize the beamformer, reduce beamformer variance and improve the SNR for slow motions, while smaller values track fast motion more responsively. Setting it to 0 disables temporal smoothing entirely and gives the highest signal strength at the cost of higher variance.

The DetectionVolume defines the region in which motion is to be detected, and the sensor configuration is adapted to cover it: a box in the world frame, cut by a range and angle sector in the sensor frame. The world frame has z up and its origin at the sensor; the sensor frame has its y axis along the boresight. az_angle_range / el_angle_range set the (min, max) azimuth/elevation coverage in degrees, in the sensor frame. If needed, a MotionDetectionConfig can override either axis for itself via az_angle_range / el_angle_range (None, the default, uses the detection volume’s value).

The x_bounds_m / y_bounds_m are the (min, max) bounds in meters of the box, in the world frame; set them together, or neither to leave out the box. The box has no height: when sizing the range to measure, it is taken as high as the room, from the floor (mount_height_m below the sensor) up to 2.5 m above it. Peaks outside the box are dropped before being returned. The bounds are intended to suppress reflectors outside the physical room or volume to be covered (walls in front or to the side of the sensor). start_m / end_m limit the range from the sensor. Either set the box or the end, so that the volume has a farthest point; where the box and the range limits both limit the range, the stricter one applies. If needed, a MotionDetectionConfig can adjust the box per axis for itself via detection_volume_x_bound_offset_m / detection_volume_y_bound_offset_m / detection_volume_z_bound_offset_m, each a (lo, hi) offset added to the detection volume’s bound for that axis, or for z to the room’s height (None drops the bound on that axis for this processor, as does a detection volume without a box).

The cfar_sensitivity controls the detection threshold on a 0–1 scale. A higher value increases sensitivity (lower threshold, more detections, more false positives); a lower value reduces sensitivity (higher threshold, fewer detections, less false positives). Internally the value is mapped log-linearly onto a theoretical per-pixel (CA-CFAR) false-positive rate; this should be viewed as a tuning parameter and not an exact false positive rate indication since it relies on an approximate noise model.

The z_rotation is the sensor rotation about its z (boresight-perpendicular vertical) axis in degrees — a pan. Positive values follow the right-handed convention. Use it e.g. when the sensor is mounted in a corner pointing \(45^\circ\) in relation to the wall.

The x_rotation is the sensor rotation about its x axis (tilt) in degrees. Set it to match the sensor’s tilt relative to the world frame. The normal usage is to set it if the sensor is placed on a wall tilted downward.

The mount_height_m is the height of the sensor above the floor. It places the floor, from which the room is taken to be 2.5 m high.

The measured range is derived from the detection volume: it covers the nearest and farthest points of the box, or start_m / end_m where those are stricter. Without a box, the range limits alone set it, so tight bounds or range limits are the primary way to cut compute on the near-sensor region and to cap the far-side range.

WallMountSessionAbstractionConfig#

The profile selects the pulse profile. Longer profiles trade range resolution for SNR; shorter profiles do the opposite. Since the angular resolution at the typical distances used in this processor typically corresponds to a wider footprint than the radial resolution with profile 6 there is little benefit of using shorter profiles in most applications.

The frame_rate sets the sensor’s frame rate in Hz; the sensor times the frames itself. It mainly affects latency and the amount of temporal averaging that can be done at a given filter time constant. A frame rate higher than the sensor configuration can sustain is reported as a validation error.

The signal_quality_db sets the target SNR (in dB) for a 0 dBsm reflector, guaranteed everywhere in the detection volume — not just on boresight — at the snr_evaluation_height_m plane. The sensor configuration (subsweep count and per-subsweep HWAAS, up to max_num_subsweeps) needed to reach it is derived automatically, accounting for the antenna’s angle-dependent gain falloff. The SNR includes the processing gain from using all 12 TX/RX channels and all sweeps within a frame. If the requested SNR cannot be reached, HWAAS saturates and a warning is shown in the GUI.

The max_num_subsweeps caps how many subsweeps the automatic layout may use. More subsweeps let HWAAS track the SNR requirement more closely across range and angle, at the cost of higher frame overhead.

The snr_evaluation_height_m is the height above the floor, in meters, of the horizontal plane at which signal_quality_db is guaranteed. It must not lie below the floor, and is at most 2.5 m, the room’s height. The default, 1.2 m, is about the chest height of people in front of the sensor.

Tuning Guide#

Slow detection response:

Increase frame_rate.

Decrease covariance_matrix_time_constant_s.
False positives too frequent:

Decrease cfar_sensitivity to raise the CFAR threshold map and reject more spurious detections.
Low detection of fast moving objects:

Decrease covariance_matrix_time_constant_s to reduce beamformer lag.

Increase frame_rate.
Low detection of slow moving objects:

Increase high_pass_filter_time_constant_s so that slowly moving targets are not high-pass filtered out together with the static clutter.

Increase signal_quality_db.

Increase covariance_matrix_time_constant_s
Static objects detected as motion:

Decrease high_pass_filter_time_constant_s for faster adaptation to changes in the static environment (e.g. moved furniture). A rule of thumb is that it takes about \(3 \cdot\) high_pass_filter_time_constant_s seconds to adapt to scene changes.
Field of view too narrow:

Widen az_angle_range / el_angle_range (and the x/y bounds, if they cut off those angles). The automatic subsweep layout raises HWAAS as needed to keep signal_quality_db across the whole range/angle span, at the cost of increased current consumption.

Presets#

Two presets share the same 5 m baseline configuration and differ only in high_pass_filter_time_constant_s — pick the one matching the motion class to be detected. Each returns a (MotionDetectionConfig, WallMountSessionAbstractionConfig, SensorInstallation, DetectionVolume) tuple; call get_session_config() with the SensorInstallation and the DetectionVolume to obtain an SessionConfig.

get_walking_detection_configs() — for fast motion such as walking. Sets high_pass_filter_time_constant_s = 0.0 (no temporal high-pass; each frame is detrended against its own mean sweep).
get_sitting_detection_configs() — for slow motion such as a sitting or breathing person. Sets high_pass_filter_time_constant_s = 0.5 so that slow targets are not high-pass filtered out together with the static clutter.

Physical Integration#

The algorithm assumes the sensor’s azimuth plane is horizontal to the surface being monitored. Tilts and rotations of the physical installation are compensated by setting z_rotation (pan) and x_rotation (tilt) so that the reported Cartesian peaks (and the x_bounds_m / y_bounds_m filters) are expressed in the world frame.

Processor Output#

class acconeer.exptool.a2.algo.motion_detection.MotionDetectionResult(*, peaks: list[Peak3DCart], heatmap: NDArray[float64], threshold_map: NDArray[float64], el_spectra: NDArray[float64])#

peaks: list[Peak3DCart]#: Refined peak locations from the heatmap.

heatmap: NDArray[float64]#

The (D, Az) Capon heatmap formed from the azimuth sub-array.

The dedicated azimuth sub-array (Rx0 dropped) has a single virtual elevation row, so the heatmap is 2D and provided directly to consumers for plotting and analysis.

threshold_map: NDArray[float64]#: The CFAR threshold map. Provided for plotting and analysis purposes.

el_spectra: NDArray[float64]#

Per-peak elevation spectrum of shape (N_peaks, El).

Each row is the conventional beamform output along the elevation grid for a single 2D peak, computed from the full-channel covariance at the peak’s distance bin and the elevation steering vectors at the peak’s az index.

Exploration Tool Python API#

class acconeer.exptool.a2.algo.motion_detection.MotionDetectionConfig(antenna_array, beamforming_method=BeamformingMethod.ROBUST_CAPON, robust_capon_epsilon: float = 0.1, covariance_matrix_time_constant_s: float = 0.0, high_pass_filter_time_constant_s: float = 5.0, spatial_high_pass_filter_time_constant_s: float = 5.0, jitter_averaging_efficiency: float = 0.7, spatial_uncorr_jitter_factor: float = 0.1, az_angle_range: Iterable[float] | None = None, el_angle_range: Iterable[float] | None = None, az_grid_resolution_deg: float = 2.0, el_grid_resolution_deg: float | None = 15.0, vibration_std_um: float = 0.0, cfar_kernel_type=CFARKernelType.THICK_CROSS, cfar_aggregate_method: Iterable[Any] = (CFARAggregateMethod.GO, CFARAggregateMethod.SO), cfar_az_guard_fwhm_factor: float = 0.78, cfar_dist_guard_envelope_len_factor: float = 0.5, cfar_az_reference_fwhm_factor: float = 0.78, cfar_dist_reference_envelope_len_factor: float = 0.5, cfar_sensitivity: float = 0.75, cfar_fixed_threshold: float = 1.0, cfar_side_lobe_compensation_db: float | None = -10.0, peak_min_dist_separation_m: float = 0.2, peak_interpolation_az_dist_method=InterpolationMethod2D.GAUSSIAN_INDEPENDENT, peak_finding_dist_radius_fwhm_factor: float = 0.5, peak_finding_az_radius_fwhm_factor: float = 0.5, detection_volume_x_bound_offset_m: Iterable[float] | None = None, detection_volume_y_bound_offset_m: Iterable[float] | None = None, detection_volume_z_bound_offset_m: Iterable[float] | None = None)#

antenna_array: AntennaArray#: The antenna layout for the sensor used.

beamforming_method: BeamformingMethod#: Will set the beamforming method used. See BeamformingMethod class.

robust_capon_epsilon: float#: Steering-vector loading factor for the robust Capon beamformer if used.

covariance_matrix_time_constant_s: float#: Time constant for IIR low-pass filter of the covariance matrices.

high_pass_filter_time_constant_s: float#: Time constant for the IIR high-pass filter of the IQ data.

spatial_high_pass_filter_time_constant_s: float#: Time constant for the IIR spatial high-pass filter used to suppress static clutter

jitter_averaging_efficiency: float#: Effective averaging efficiency for correlated jitter. Empirical default is 0.7 (see JitterAndVibrationScalingNode).

spatial_uncorr_jitter_factor: float#: Fraction of jitter assumed spatially uncorrelated across channels.

az_angle_range: tuple[float, float] | None#: Min and max az angle (degrees), overriding the detection volume’s own az_angle_range for this processor. None uses the detection volume’s value unmodified.

el_angle_range: tuple[float, float] | None#: Min and max el angle (degrees), overriding the detection volume’s own el_angle_range for this processor. None uses the detection volume’s value unmodified. Ignored when el_grid_resolution_deg is None.

az_grid_resolution_deg: float#: Desired azimuth grid resolution in degrees. The actual resolution is rounded to the nearest value that produces an integer number of bins across the effective az angle range; inspect num_az_angles() or az_angles() to see the resulting grid.

el_grid_resolution_deg: float | None#: Desired elevation grid resolution in degrees. None collapses the el grid to a single boresight point at el = 0° (and ignores el_angle_range).

vibration_std_um: float#: Standard deviation of sensor vibration in micrometres for jitter/vibration compensation.

cfar_kernel_type: CFARKernelType#: THIN_CROSS: Standard cross with single-bin width arms. THICK_CROSS: Wider cross where arm width matches the guard width.

cfar_aggregate_method: tuple[CFARAggregateMethod, CFARAggregateMethod]#

Per-axis arm aggregation (distance, azimuth). Each entry is an CFARAggregateMethod (CA/GO/SO/DROP); DROP skips that axis. At least one entry must be non-DROP.

Common combinations:

(CA, CA) — cell-average all four arms (standard CA-CFAR).
(GO, SO) — greatest-of on distance, smallest-of on azimuth.
(DROP, CA) — average azimuth arms only (no distance arms).

cfar_az_guard_fwhm_factor: float#: Guard interval in Azimuth as a multiple of CONVENTIONAL_AZ_FWHM_DEG. Factor > 1 is allowed since CFAR guards should reach past the main lobe.

cfar_dist_guard_envelope_len_factor: float#: Guard interval in Distance as a factor of the pulse envelope length.

cfar_az_reference_fwhm_factor: float#: Reference window size in Azimuth as a multiple of CONVENTIONAL_AZ_FWHM_DEG. Factor > 1 is allowed for the same reason as the guard factor.

cfar_dist_reference_envelope_len_factor: float#: Reference window size in Distance as a factor of the pulse envelope length.

cfar_sensitivity: float#: Sensitivity of the CFAR threshold. High sensitivity equals low detection threshold, low sensitivity equals high detection threshold. The processor maps this log-linearly onto a theoretical per-pixel false-positive rate.

cfar_fixed_threshold: float#: Hard lower bound on the CFAR threshold map, in heatmap units. The noise-normalisation pipeline divides the IQ frame by the noise floor so the thermal-noise mean at the beamformer output is ≈ 1; raising this above 1 implements the absolute-floor term that some classical CFAR formulations write as thermal_mean + N·σ_thermal.

cfar_side_lobe_compensation_db: float | None#: Limit threshold relative to the per-range-bin peak by this value (dB). Set to None to disable.

peak_min_dist_separation_m: float#: Minimum Cartesian separation between retained peaks in the az-dist plane.

peak_interpolation_az_dist_method: InterpolationMethod2D#: Interpolation method for peak position refinement in the (azimuth, distance) plane.

peak_finding_dist_radius_fwhm_factor: float#: Peak-finding half-width along distance as a multiple of the measured envelope FWHM (ENVELOPE_FWHM_M). Sizes both the LocalMaxima2DNode search window and the Interpolation2DNode fitting window.

peak_finding_az_radius_fwhm_factor: float#: Peak-finding half-width along azimuth as a multiple of the conventional beamformer’s azimuth FWHM (CONVENTIONAL_AZ_FWHM_DEG). Sizes both the LocalMaxima2DNode search window and the Interpolation2DNode fitting window. Conventional beamforming defines the FWHM; for Capon / robust Capon the main lobe is narrower so this serves as a loose upper bound.

detection_volume_x_bound_offset_m: tuple[float, float] | None#: (lo, hi) offset in metres added to the detection volume’s x_bounds_m to get this processor’s actual x bound, or None for no box bound in x (unbounded on that axis for this processor, independent of the detection volume). Without a box in the detection volume, this processor has no bound on that axis either.

detection_volume_y_bound_offset_m: tuple[float, float] | None#: (lo, hi) offset in metres added to the detection volume’s y_bounds_m to get this processor’s actual y bound, or None for no box bound in y (unbounded on that axis for this processor, independent of the detection volume). Without a box in the detection volume, this processor has no bound on that axis either.

detection_volume_z_bound_offset_m: tuple[float, float] | None#: (lo, hi) offset in metres added to the room’s height (see room_z_bounds_m) to get this processor’s actual z bound, or None for no box bound in z (unbounded on that axis for this processor, independent of the detection volume). Without a box in the detection volume, this processor has no bound on that axis either.

to_dict() → dict[str, Any]#

effective_az_angle_range(detection_volume: DetectionVolume) → tuple[float, float]#

effective_el_angle_range(detection_volume: DetectionVolume) → tuple[float, float]#

effective_x_bounds_m(detection_volume: DetectionVolume) → tuple[float, float] | None#: This processor’s x bound: None (unbounded) if detection_volume_x_bound_offset_m or the detection volume’s x_bounds_m is None, else the latter offset by the former.

effective_y_bounds_m(detection_volume: DetectionVolume) → tuple[float, float] | None#: This processor’s y bound: None (unbounded) if detection_volume_y_bound_offset_m or the detection volume’s y_bounds_m is None, else the latter offset by the former.

effective_z_bounds_m(sensor_installation: SensorInstallation, detection_volume: DetectionVolume) → tuple[float, float] | None#: This processor’s z bound: None (unbounded) if detection_volume_z_bound_offset_m is None or the detection volume has no box, else the room’s height (see room_z_bounds_m) offset by the former.

num_az_angles(detection_volume: DetectionVolume) → int#: Number of azimuth bins, derived from az_grid_resolution_deg and the effective az angle range.

num_el_angles(detection_volume: DetectionVolume) → int#: Number of elevation bins, derived from el_grid_resolution_deg and the effective el angle range. Returns 1 when el_grid_resolution_deg is None.

az_angles(detection_volume: DetectionVolume) → NDArray[float64]#: The az angles defined by this config.

el_angles(detection_volume: DetectionVolume) → NDArray[float64]#: The el angles defined by this config. Returns [0.0] when el_grid_resolution_deg is None.

az_span(detection_volume: DetectionVolume) → float#: Largest minus smallest az angle (0.0 when only one angle).

n_el_interpolation(detection_volume: DetectionVolume) → int#: Elevation interpolation half-width in cells. Falls back to 0 when fewer than 2 * _N_EL_INTERPOLATION + 1 el angles are configured.

get_cfar_radii(detection_volume: DetectionVolume, profile: Profile, step_length_m: float, num_points: int) → tuple[tuple[int, int], tuple[int, int]]#

(guard_radii, ref_radii) for the heatmap CFAR step.

profile, step_length_m, and num_points come from the session config; detection_volume supplies the az grid (unless overridden by az_angle_range); the rest is taken from this config’s CFAR fields.

property cfar_theoretical_fpr: float#

CA-CFAR target false-positive rate derived from cfar_sensitivity (log-linear).

cfar_sensitivity = 0 -> FPR = _CFAR_FPR_MIN (strictest). cfar_sensitivity = 1 -> FPR = _CFAR_FPR_MAX (loosest, no CFAR threshold).

get_peak_finding_radii(detection_volume: DetectionVolume, profile: Profile, step_length_m: float, num_points: int) → tuple[int, int]#: (n_dist, n_az) half-widths in cells used for both the 2D local-maxima search window and the 2D peak-interpolation fitting window. Elevation is handled separately via n_el_interpolation().

validate(session_config: SessionConfig, sensor_installation: SensorInstallation, detection_volume: DetectionVolume) → None#: Run grid-aware validation against session_config and the geometry: raise ValidationError results, emit ValidationWarning results via the warnings system.

class acconeer.exptool.a2.algo.motion_detection.SensorInstallation(y_rotation: float = 180.0, x_rotation: float = 0.0, z_rotation: float = 0.0, *, mount_height_m: float)#

How the sensor is mounted, in the world frame.

The mount rotation starts with the sensor aligned with the world (+x right, +y boresight, +z up), so its original axes are the world’s axes, and rotates it about those fixed axes by y_rotation (roll), then x_rotation (tilt), then z_rotation (pan), each right-handed: p_world = Rz(z_rotation) @ Rx(x_rotation) @ Ry(y_rotation) @ p_sensor.

y_rotation: float#

Roll, i.e. rotation about the sensor’s original y-axis (boresight direction) in degrees, applied first. Roll does not move the boresight, but it flips how x_rotation/z_rotation relate to the sensor’s own azimuth and elevation.

Only 0 and 180 are supported.

x_rotation: float#

Tilt, i.e. rotation about the sensor’s original x-axis in degrees, applied after y_rotation. Positive tilt turns the boresight up in the world.

With y_rotation=0 this is toward positive elevation; with y_rotation=180 the sensor is upside down, so it is toward negative elevation.

z_rotation: float#

Pan, i.e. rotation about the sensor’s original z-axis (the world’s vertical) in degrees, applied last. Positive pan turns the boresight toward -x.

With no tilt, a pan of +θ moves the boresight to sensor azimuth -θ with y_rotation=0, or +θ with y_rotation=180.

mount_height_m: float#: Height of the sensor above the floor, in meters.

classmethod from_dict(dict_repr: dict[str, Any]) → Self#: Also accepts a legacy DetectionVolumeConfig, as the old Detection Volume editor saved it, and takes its rotations; see split_legacy_detection_volume_config().

property mount_rotation: RotationMatrix#: Rotation from sensor-frame to world-frame axes, built from the three rotations.

sensor_to_world(points_m: ArrayLike) → NDArray[float64]#: World positions of sensor-frame points, along the last axis.

world_to_sensor(points_m: ArrayLike) → NDArray[float64]#: Sensor-frame positions of world points, along the last axis; inverse of sensor_to_world().

validate() → None#: Raise the first ValidationError, emit ValidationWarning results via the warnings system.

class acconeer.exptool.a2.algo.motion_detection.DetectionVolume(x_bounds_m: Iterable[float] | None = None, y_bounds_m: Iterable[float] | None = None, start_m: float | None = None, end_m: float | None = None, az_angle_range: Iterable[float] = (-80.0, 80.0), el_angle_range: Iterable[float] = (-30.0, 30.0), exclusion_zones: Iterable[ExclusionZone | Mapping[str, Any]] = NOTHING)#

Region to detect within, the intersection of:

a box in the world frame, bounded in x and y only: x_bounds_m and y_bounds_m;
a sector in the sensor frame’s spherical coordinates (range, azimuth, elevation): start_m, end_m, az_angle_range, and el_angle_range.

The box is bounded in x and y together or not at all. Either bound the box or set end_m, so that the region has a farthest point. Where the box and start_m/end_m both limit the range from the sensor, the stricter one applies. Detections inside any of the exclusion_zones are dropped.

x_bounds_m: tuple[float, float] | None#: (lo, hi) world x extent of the box, in meters, or None for no box. Set together with y_bounds_m.

y_bounds_m: tuple[float, float] | None#: (lo, hi) world y extent of the box, in meters, or None for no box. Set together with x_bounds_m.

start_m: float | None#: Range (distance from the sensor) where detection starts, in meters, or None.

end_m: float | None#: Range (distance from the sensor) where detection ends, in meters, or None.

az_angle_range: tuple[float, float]#: (lo, hi) azimuth angle range in degrees, in the sensor frame.

el_angle_range: tuple[float, float]#: (lo, hi) elevation angle range in degrees, in the sensor frame.

exclusion_zones: tuple[ExclusionZone, ...]#: Circular regions in the world xy plane whose detections are dropped. Empty (the default) disables exclusion.

classmethod from_dict(dict_repr: dict[str, Any]) → Self#: Also accepts a legacy DetectionVolumeConfig, as the old Detection Volume editor saved it, and takes its box and angle ranges; see split_legacy_detection_volume_config(). Drops fields that are gone, such as z_bounds_m, so older recordings still load.

validate() → None#: Raise the first ValidationError, if any.

class acconeer.exptool.a2.algo.motion_detection.WallMountSessionAbstractionConfig(signal_quality_db: float, profile, frame_rate: float, max_snr_drop_db: float = 1.0, sweeps_per_frame: int = 8, receiver_gain: int = 5, max_num_subsweeps: int = 4, *, sweep_rate: float | None, snr_evaluation_height_m: float = 1.2)#

signal_quality_db: float#

Signal quality (SNR in dB) for a 0 dBsm reflector, guaranteed at every point of the snr_evaluation_height_m plane inside the paired DetectionVolume (see get_session_config()).

Includes the processing gain from using all 12 TX/RX channels and all sweeps within a frame.

profile: Profile#: The profile used.

frame_rate: float#: Frame rate used (Hz). The sensor times the frames itself.

max_snr_drop_db: float#: Maximum SNR drop (power-domain dB) allowed between adjacent sample points; sets the step length. At most 3 dB. A lower value gives more points.

sweeps_per_frame: int#: The number of sweeps used per frame.

sweep_rate: float | None#: Sweep rate used (Hz). None lets the sensor pick the maximum allowed given the configured profile, HWAAS and step length.

receiver_gain: int#: Receiver gain.

max_num_subsweeps: int#

Upper bound on how many subsweeps get_session_config() may use.

At most MAX_NUM_SUBSWEEPS - 1: _make_sensor_config always enables jitter_compensation, which occupies one subsweep slot (see SensorConfig validation).

snr_evaluation_height_m: float#: Height above the floor, in meters, at which signal_quality_db is evaluated and guaranteed. The default, 1.2 m, is about the chest height of persons in front of the sensor. At most 2.5 m, the room’s height. Must not lie below the floor, mount_height_m below the sensor; get_session_config raises ValidationError otherwise.

validate(sensor_installation: SensorInstallation, detection_volume: DetectionVolume) → None#: Run cross-field validation: raise the first ValidationError, emit ValidationWarning results via the warnings system.

get_session_config(sensor_installation: SensorInstallation, detection_volume: DetectionVolume) → SessionConfig#

Build the runtime session config from tuning settings and the supplied geometry: a <=``max_num_subsweeps``, angle-aware, dynamic-HWAAS layout guaranteeing signal_quality_db at the snr_evaluation_height_m plane inside detection_volume as seen from sensor_installation, minimizing estimated power (see solve_subsweep_layout()).

Raises:: ValidationError – If the volume does not validate or exceeds the application’s maximum range, snr_evaluation_height_m lies below the floor, or the plane has no observable point.

try_get_session_config(sensor_installation: SensorInstallation, detection_volume: DetectionVolume) → SessionConfig | None#

get_session_config, or None if it raises ValidationError

Validation reports why.

class acconeer.exptool.a2.algo.motion_detection.MotionDetectionProcessor(session_config: SessionConfig, processor_config: MotionDetectionConfig, sensor_installation: SensorInstallation, detection_volume: DetectionVolume, noise_norm_recording: NoiseNormalizationRecording | None)#

process(result: Result) → MotionDetectionResult#

acconeer.exptool.a2.algo.motion_detection.get_walking_detection_configs() → tuple[MotionDetectionConfig, WallMountSessionAbstractionConfig, SensorInstallation, DetectionVolume]#: 5m detection config tuned for walking targets (no temporal high-pass).

acconeer.exptool.a2.algo.motion_detection.get_sitting_detection_configs() → tuple[MotionDetectionConfig, WallMountSessionAbstractionConfig, SensorInstallation, DetectionVolume]#: 5m detection config tuned for sitting targets (0.5 s temporal high-pass).