This interactive tutorial demonstrates the Kalman Filter algorithm, a powerful recursive state estimation technique widely used in tracking, navigation, control systems, and signal processing. A Kalman Filter is a recursive algorithm that fuses a physics-based prediction with a noisy measurement, weighting them by their respective uncertainties to find the most likely true state. Unlike moving averages that look back at a duration of past data, the Kalman Filter is memory-efficient: it summarizes the entire history into just two quantities - the current state estimate and its uncertainty (covariance). The filter doesn't store raw historical data; instead, it recursively processes measurements one at a time, updating its belief about the state with each new observation.

The visualization consists of two interactive modes: (1) 1D Constant Voltage Mode - demonstrates filtering a constant voltage signal with noisy measurements, showing how the filter converges on the true value over time, and (2) 2D Mouse Tracking Mode - an interactive mode where your mouse cursor is the ground truth, and the filter tracks it through noisy measurements (simulating GPS tracking). The visualization uses p5.js for real-time rendering, a dark theme (slate background) with bright colors for optimal visibility (green for truth, red for noisy measurements, blue for filter estimate, yellow for uncertainty). You can adjust measurement noise (R), process noise (Q), and the state transition parameter (F) using sliders to see how the filter behaves under different noise conditions and model dynamics. The Kalman Gain (K) is displayed in real-time to show the filter's confidence level. A "Bayesian Fusion Inspector" subplot in the top-right corner visualizes the Gaussian probability distributions for prediction, measurement, and estimate, demonstrating how the filter optimally combines these sources of information.

The Kalman Filter operates in two main steps: (1) Predict - uses a physics-based model to project the state forward (e.g., "if velocity is v and time dt has passed, position must be x + v×dt"), and (2) Update - incorporates new measurements to refine the estimate. The filter plays a "weighting game": it constantly asks "Who do I trust more right now?" - the physics model prediction or the sensor measurement? If the filter thinks its past prediction was shaky (high uncertainty P) and the sensor is high-quality (low measurement noise R), it jumps toward the sensor. If the sensor is noisy, it sticks to the physics. This automatic balancing is encoded in the Kalman Gain (K), which adapts in real-time. When measurement noise is high, the filter trusts the prediction more (low Kalman Gain). When measurement noise is low, the filter trusts the measurement more (high Kalman Gain). The uncertainty ellipse in 2D mode shrinks when the mouse stops (convergence) and may grow when the mouse moves quickly (prediction uncertainty).

NOTE : The tutorial uses standard Kalman Filter notation: F (State Transition Matrix), H (Measurement Matrix), Q (Process Noise Covariance), R (Measurement Noise Covariance), P (State Covariance Matrix), and K (Kalman Gain). The filter implementation follows the standard predict-update cycle: x_pred = F × x_prev, P_pred = F × P_prev × F^T + Q (predict), K = P_pred × H^T × (H × P_pred × H^T + R)^(-1) (Kalman Gain), x_new = x_pred + K × (z - H × x_pred) (update state), P_new = (I - K × H) × P_pred (update covariance).

Mathematical Model

The Kalman Filter is a recursive Bayesian filter that optimally estimates the state of a linear dynamic system from noisy observations. The filter assumes the system follows a linear state-space model:

State-Space Model:

x_k = F × x_k-1 + w_k-1 (Process Model)
z_k = H × x_k + v_k (Measurement Model)

where:

• x_k: State vector at time k (what we want to estimate)
• F: State transition matrix (describes how the state evolves)
• w_k: Process noise (zero-mean Gaussian with covariance Q)
• z_k: Measurement vector at time k (what we observe)
• H: Measurement matrix (maps state to measurements)
• v_k: Measurement noise (zero-mean Gaussian with covariance R)

Predict Step:

x̂_k|k-1 = F × x̂_k-1|k-1
P_k|k-1 = F × P_k-1|k-1 × F^T + Q

Update Step:

K_k = P_k|k-1 × H^T × (H × P_k|k-1 × H^T + R)^-1 (Kalman Gain)
x̂_k|k = x̂_k|k-1 + K_k × (z_k - H × x̂_k|k-1) (State Update)
P_k|k = (I - K_k × H) × P_k|k-1 (Covariance Update)

Kalman Gain Interpretation: The Kalman Gain (K) determines how much we trust the measurement versus the prediction. When K is close to 1, we trust the measurement more (low measurement noise R). When K is close to 0, we trust the prediction more (high measurement noise R or high process noise Q). The gain automatically balances these uncertainties to minimize the estimation error.

1D Mode (Constant Voltage): In this mode, we track a constant value (voltage = 200) with noisy measurements. The state is a scalar (1×1), so F = [1], H = [1], Q = [q], R = [r]. The filter predicts no change (F = 1) and directly observes the state (H = 1). Over time, the filter converges to the true value as it accumulates information from multiple measurements. The blue line (filter estimate) should track closer to the green line (truth) than the red dots (noisy measurements).

2D Mode (Mouse Tracking): In this mode, we track your mouse position (ground truth) with noisy measurements (simulating GPS). The state is a 2D position vector [x, y], so F = [[1,0],[0,1]], H = [[1,0],[0,1]], Q = [[q,0],[0,q]], R = [[r,0],[0,r]]. The filter uses a "0th Order" (Constant Position) model, which assumes the object should stay still. The uncertainty ellipse (yellow) represents the covariance P - it shrinks when the mouse stops (convergence) and may grow when the mouse moves quickly (prediction uncertainty). The blue circle (filter estimate) should track closer to the green dot (ground truth) than the red dot (noisy measurement). Note on Tracking Lag: When you move the mouse quickly, the blue estimate will lag behind because the filter treats movement as "Process Noise" (Q) rather than expected dynamics. This demonstrates why Process Noise is necessary - without it, the filter would refuse to believe the mouse moved! For better tracking of moving targets, a "Constant Velocity" model (State: [x, y, vx, vy]^T) would predict movement and reduce lag.

 

Usage Example

Follow these steps to explore the Kalman Filter tutorial:

1. Initial State (1D Mode): When you first load the simulation, you'll see 1D Constant Voltage mode active. The filter starts with high uncertainty (P = 1000) and begins tracking a constant voltage (truth = 200) with noisy measurements. Watch as the blue line (filter estimate) converges toward the green line (truth) over time. The red dots show individual noisy measurements - notice how scattered they are compared to the smooth blue filter estimate.
2. Adjust Measurement Noise (R): Use the "Measurement Noise (R)" slider to change how noisy the measurements are. Try setting R to a very low value (e.g., 0.1) - you'll see the red dots cluster tightly around the truth, and the blue filter line converges quickly. Then try a high value (e.g., 50) - the red dots become very scattered, and the filter takes longer to converge. Notice how the Kalman Gain (K) changes - it's higher when R is low (trusts measurements more) and lower when R is high (trusts prediction more).
3. Adjust Process Noise (Q): Use the "Process Noise (Q)" slider to change how much the process model is trusted. For a constant value (1D mode), Q should be small since we expect no change. Try setting Q very high (e.g., 10) - notice how the filter becomes more responsive to measurements but may also be less stable. The optimal Q for a constant value is very small (e.g., 0.01), which tells the filter "the value shouldn't change much."
4. Adjust Transition (F): Use the "Transition (F)" slider to change the state transition dynamics. F = 1.0 means constant (no change expected). F < 1.0 (e.g., 0.9) means decay/attenuation (value decreases over time). F > 1.0 (e.g., 1.1) means growth/amplification (value increases over time). Try Model Mismatch: In 1D mode, set F = 0.9 or F = 1.1 while the ground truth remains constant (200.0). Observe how the filter's estimate lags or biases as it tries to reconcile the conflicting information between the process model (expecting change) and measurements (showing constant value). This demonstrates the importance of accurate process models. The yellow prediction curve in the Bayesian Fusion Inspector will shift and change shape as you adjust F, showing how the prior belief changes with different transition models.
5. Observe Convergence: In 1D mode, watch how the filter converges over time. Initially, the blue line may be far from the green truth line because the filter starts with high uncertainty. As more measurements arrive, the uncertainty decreases (you can see this in the Kalman Gain settling to a steady value), and the estimate gets closer to the truth. The filter automatically balances between the prediction and the measurement based on their relative uncertainties.
6. Switch to 2D Mode: Click the "Switch to 2D Mode" button to activate interactive mouse tracking. In this mode, your mouse cursor is the ground truth (green dot), and the filter tracks it through noisy measurements (red dot with jitter). Move your mouse around - watch how the blue circle (filter estimate) follows your movement but with less jitter than the red measurement dots. The yellow ellipse represents the uncertainty - it shrinks when you stop moving (convergence) and may grow when you move quickly (prediction uncertainty).
7. Experiment with Noise in 2D Mode: While in 2D mode, adjust the Measurement Noise (R) slider. With low R (e.g., 0.1), the red measurement dots cluster tightly around your mouse, and the blue estimate tracks closely. With high R (e.g., 50), the red dots become very scattered (like a noisy GPS), and the blue estimate lags behind your movements. Notice how the uncertainty ellipse size changes - it's smaller when R is low (more confident) and larger when R is high (less confident).
8. Observe Uncertainty Convergence: In 2D mode, move your mouse to a position and stop. Watch how the yellow uncertainty ellipse shrinks over time as the filter accumulates measurements. This demonstrates convergence - the filter becomes more confident about the position. Then start moving your mouse quickly - the ellipse may grow as the filter struggles to predict the fast movement (process model assumes constant position, but you're moving).
9. Watch Kalman Gain: Observe the Kalman Gain (K) value displayed in real-time. In 1D mode, K is a scalar - it should stabilize to a value between 0 and 1. When R is low (good measurements), K is close to 1 (trusts measurements). When R is high (bad measurements), K is close to 0 (trusts prediction). In 2D mode, K is a 2×2 matrix - the diagonal elements [K11, K22] are shown, representing the gain for x and y positions respectively.
10. Reset and Experiment: Click the "Reset Filter" button to reset the filter to its initial state (high uncertainty). Try different combinations of R and Q values to understand their effects. In 1D mode, optimal settings for a constant value are: R = 10 (moderate measurement noise), Q = 0.01 (very low process noise since value is constant). In 2D mode, try R = 5 (moderate GPS noise) and Q = 0.1 (low process noise for smooth tracking).
11. Understand the Trade-off: The Kalman Filter automatically balances between prediction and measurement based on their uncertainties. If measurements are very noisy (high R), the filter smooths them out more (low K). If measurements are accurate (low R), the filter follows them more closely (high K). If the process is very uncertain (high Q), the filter trusts measurements more. This optimal balancing is what makes the Kalman Filter so powerful - it minimizes the estimation error without manual tuning.

Tip: The key to understanding Kalman Filters is recognizing that they optimally combine predictions (from the process model) with measurements (from sensors) based on their relative uncertainties. The Kalman Gain automatically determines the optimal weighting. When measurements are noisy, trust the prediction more. When measurements are accurate, trust them more. The filter adapts to the noise conditions automatically. Try different noise levels and observe how the filter adapts - this is the power of optimal estimation. The uncertainty ellipse in 2D mode provides visual feedback about the filter's confidence - shrinking when confident, growing when uncertain. Start with 1D mode to understand the basic concepts, then switch to 2D mode for interactive exploration.

Parameters

Followings are short descriptions on each parameter

• State Vector (x): The quantity we want to estimate. In 1D mode, this is a scalar (constant voltage). In 2D mode, this is a 2D position vector [x, y]. The state estimate (x̂) is updated at each time step based on predictions and measurements. The filter starts with an initial state estimate (typically zero or the first measurement) and refines it over time.
• State Transition Matrix (F): Describes how the state evolves from one time step to the next. For a constant value (1D mode), F = [1] (no change). For constant position (2D mode), F = [[1,0],[0,1]] (identity matrix, no change). F can be extended to include velocity models (e.g., constant velocity: F = [[1,dt],[0,1]]), acceleration models, or more complex dynamics. Note on Model Mismatch: In 1D mode, the ground truth is constant (200.0), but if you set F ≠ 1 (e.g., F = 0.9 for decay or F = 1.1 for growth), the filter expects dynamics that don't exist. This creates a "Model Mismatch" scenario where the filter's estimate will lag or bias as it tries to reconcile the conflicting information between the process model (expecting change) and measurements (showing constant value). This is an excellent educational demonstration of how model accuracy affects filter performance. In 2D mode, the filter uses a "0th Order" (Constant Position) model, which assumes the object should stay still. When you move the mouse quickly, the blue estimate will lag behind because the filter treats movement as "Process Noise" rather than expected dynamics. For better tracking of moving targets, a "Constant Velocity" model (State: [x, y, vx, vy]^T) would be more appropriate.
• Measurement Matrix (H): Maps the state to measurements. For direct observation (both modes), H = I (identity matrix). H allows modeling of sensors that measure linear combinations of state variables or subsets of the state (e.g., measuring position but not velocity).
• Process Noise Covariance (Q): Represents uncertainty in the process model. For a constant value (1D mode), Q should be very small (e.g., 0.01) since we expect no change. For constant position (2D mode), Q should also be small (e.g., 0.1) for smooth tracking, but higher values allow the filter to adapt to unexpected movements. Q is a square matrix with the same dimensions as the state. Larger Q means the process model is less reliable, so the filter trusts measurements more.
• Measurement Noise Covariance (R): Represents uncertainty in the measurements (sensor noise). R is a square matrix with the same dimensions as the measurement. Larger R means measurements are more noisy, so the filter trusts predictions more. Smaller R means measurements are accurate, so the filter trusts measurements more. In practice, R is typically estimated from sensor specifications or calibrated measurements. The diagonal elements represent noise variance for each measurement dimension.
• State Covariance Matrix (P): Represents uncertainty in the state estimate. P starts large (high uncertainty) and decreases as the filter accumulates information (convergence). The diagonal elements of P represent the variance of each state variable, and off-diagonal elements represent correlations. In 2D mode, P is visualized as an uncertainty ellipse - the ellipse shrinks when the filter is confident (small P) and grows when uncertain (large P). P is updated at each time step: it increases during prediction (uncertainty grows) and decreases during update (uncertainty decreases when incorporating measurements).
• Kalman Gain (K): The optimal weighting factor that balances prediction and measurement. K is computed as: K = P × H^T × (H × P × H^T + R)^(-1). When K is close to 1, the filter trusts measurements more (low R or low P). When K is close to 0, the filter trusts predictions more (high R or high P). K automatically adapts to noise conditions - this is the key advantage of the Kalman Filter over simple averaging or fixed filtering. K is displayed in real-time so you can observe how the filter adapts to noise conditions.
• Measurement Vector (z): The actual sensor readings (noisy observations). In 1D mode, z is a scalar (single noisy voltage reading). In 2D mode, z is a 2D vector [x, y] (noisy position measurement, like GPS). Measurements are generated by adding Gaussian noise to the true state: z = H × x + v, where v ~ N(0, R). The red dots in the visualization represent these noisy measurements.
• Innovation (y): The difference between the measurement and the predicted measurement: y = z - H × x_pred. The innovation represents the "surprise" or new information in the measurement. Large innovations indicate that the measurement differs significantly from the prediction, which could be due to noise, model error, or actual state changes. The Kalman Gain scales the innovation before adding it to the prediction: x_new = x_pred + K × y.
• Innovation Covariance (S): The covariance of the innovation: S = H × P × H^T + R. S represents the uncertainty in the difference between measurement and prediction. It is used to compute the Kalman Gain: K = P × H^T × S^(-1). Large S means the innovation is uncertain (either measurements are noisy or predictions are uncertain), so the filter applies less correction (smaller K).
• Ground Truth: The actual (unknown) state value. In 1D mode, the ground truth is a constant voltage (200). In 2D mode, the ground truth is your mouse position. The filter doesn't know the ground truth - it only observes noisy measurements. The goal is to estimate the ground truth as accurately as possible. The green line/dot in the visualization represents the ground truth (for educational purposes) so you can see how well the filter performs.
• Filter Estimate (x̂): The Kalman Filter's estimate of the true state. In 1D mode, this is a scalar (estimated voltage). In 2D mode, this is a 2D position vector [x, y]. The estimate is updated at each time step using: x̂_new = x̂_pred + K × (z - H × x̂_pred). The blue line/circle in the visualization represents the filter estimate. The estimate should be closer to the ground truth than individual noisy measurements because the filter combines multiple measurements over time.
• Convergence: The process by which the filter's uncertainty (P) decreases and the estimate (x̂) approaches the true state as more measurements are processed. In 1D mode, you can see convergence as the blue line approaches the green line and the Kalman Gain stabilizes. In 2D mode, convergence is visible as the yellow uncertainty ellipse shrinks when the mouse stops moving. Convergence occurs faster when measurement noise (R) is low and process noise (Q) is appropriately tuned.
• Prediction Step: The first step of the Kalman Filter algorithm. The filter predicts the next state and covariance based on the process model: x̂_pred = F × x̂_prev, P_pred = F × P_prev × F^T + Q. Prediction increases uncertainty (P grows) because the process model is imperfect. The prediction is then refined during the update step using measurements.
• Update Step: The second step of the Kalman Filter algorithm. The filter incorporates a new measurement to refine the prediction: K = P_pred × H^T × (H × P_pred × H^T + R)^(-1), x̂_new = x̂_pred + K × (z - H × x̂_pred), P_new = (I - K × H) × P_pred. The update decreases uncertainty (P shrinks) because measurements provide new information. The Kalman Gain determines how much correction to apply based on relative uncertainties.

Controls and Visualizations

Followings are short descriptions on each control

• Mode Toggle Button: Switches between 1D Constant Voltage mode and 2D Mouse Tracking mode. Click "Switch to 2D Mode" to activate interactive mouse tracking, or "Switch to 1D Mode" to return to the constant voltage demonstration. The filter is reset when switching modes to start with fresh initialization. 1D mode is better for understanding the basic concepts, while 2D mode is more interactive and demonstrates real-time tracking.
• Measurement Noise (R) Slider: Controls the variance of measurement noise. R represents "How bad is the sensor?" - higher R means more noisy measurements. In 1D mode, try R = 0.1 (accurate sensor) to see tight red dots and fast convergence, or R = 50 (noisy sensor) to see scattered dots and slow convergence. In 2D mode, R controls how much the red measurement dots jitter around your mouse - higher R creates GPS-like jitter. The Kalman Gain (K) automatically decreases when R increases (filter trusts measurements less).
• Process Noise (Q) Slider: Controls the variance of process noise. Q represents "How erratic is the object's movement?" - higher Q means the process model is less reliable. For a constant value (1D mode), Q should be very small (e.g., 0.01) since we expect no change. For constant position tracking (2D mode), Q should also be small (e.g., 0.1) for smooth tracking, but higher Q allows the filter to adapt to unexpected movements. The filter trusts measurements more when Q is high (process model is unreliable).
• Transition (F) Slider: Controls the state transition parameter in the F matrix. F = 1.0 means constant dynamics (no change expected). F < 1.0 (e.g., 0.9) means decay/attenuation (value decreases over time). F > 1.0 (e.g., 1.1) means growth/amplification (value increases over time). In 1D mode, setting F ≠ 1 creates a "Model Mismatch" scenario where the filter expects dynamics that don't exist (ground truth is constant), demonstrating how model accuracy affects filter performance. The filter's prediction (yellow curve in the Bayesian Fusion Inspector) will shift based on F, showing how the prior belief changes with different transition models. When F changes, the filter is reinitialized to ensure it uses the new dynamics from the start.
• Kalman Gain (K) Display: Shows the current Kalman Gain value in real-time. In 1D mode, K is a scalar displayed as a single number (e.g., "0.2341"). In 2D mode, K is a 2×2 matrix, and the diagonal elements [K11, K22] are displayed (e.g., "[0.123, 0.145]"). K should stabilize to a steady value after convergence. When R is low (good measurements), K is close to 1 (trusts measurements). When R is high (bad measurements), K is close to 0 (trusts prediction). Observing K helps understand how the filter adapts to noise conditions.
• Reset Filter Button: Resets the Kalman Filter to its initial state (high uncertainty, P = 1000). All histories are cleared, and the filter starts fresh. Use this to observe convergence from scratch or to reset after changing noise parameters. The filter will re-converge from the initial high uncertainty state.
• 1D Mode Canvas: Displays a horizontal line graph showing the filtering of a constant voltage. The green horizontal line represents the ground truth (constant voltage = 200). Red dots show individual noisy measurements (scattered around the truth). The blue line shows the Kalman Filter's estimate (should converge toward the green line). The graph updates in real-time as new measurements arrive. Time progresses from left to right, and the value is plotted vertically. The graph helps visualize convergence - the blue line should get closer to the green line over time, and the red dots should cluster around the blue line. A legend in the top-left corner identifies each element. A "Bayesian Fusion Inspector" subplot in the top-right corner shows the Gaussian probability distributions for prediction (yellow dashed), measurement (red dashed), and estimate (blue solid, filled), demonstrating how the filter optimally combines these sources of information.
• 2D Mode Canvas: Displays an interactive 2D tracking simulation. Your mouse cursor is the ground truth (green dot). The red dot represents noisy measurements (jitters around your mouse, simulating GPS). The blue circle represents the Kalman Filter's estimate (should track your mouse with less jitter than the red dot). The yellow ellipse represents uncertainty (covariance P) - it shrinks when you stop moving (convergence) and may grow when you move quickly (prediction uncertainty). Move your mouse around to see the filter track in real-time. The visualization demonstrates how the filter smooths out noisy measurements while tracking a moving target.
• Uncertainty Ellipse (2D Mode): A translucent yellow ellipse around the blue filter estimate representing the state covariance (P). The ellipse size is proportional to sqrt(P) - larger ellipse means higher uncertainty. When the mouse stops, the ellipse shrinks over time as the filter accumulates measurements (convergence). When the mouse moves quickly, the ellipse may grow because the process model (constant position) doesn't predict the movement well. The ellipse shape shows directional uncertainty - if it's wider horizontally, the x-position is less certain than the y-position. This visual feedback helps understand how uncertainty evolves with measurements and movements.
• Legend (2D Mode): A legend in the top-left corner of the 2D canvas explaining the visualization elements: Green dot = Ground Truth (actual mouse position), Red dot = Noisy Measurement (jittery GPS-like measurement), Blue circle = Kalman Estimate (filter output), Yellow ellipse = Uncertainty (covariance visualization). The legend helps identify each element in the visualization.

Key Concepts

• Optimal Estimation: The Kalman Filter provides the optimal (minimum mean squared error) estimate of the state given noisy measurements and an uncertain process model. "Optimal" means no other filter can do better under the same assumptions (linear dynamics, Gaussian noise). This optimality comes from the Kalman Gain, which is derived using Bayesian inference and minimizes the expected estimation error.
• Recursive Bayesian Filtering: The Kalman Filter is a special case of recursive Bayesian filtering for linear Gaussian systems. Unlike moving averages that look back at a duration of past data, the Kalman Filter is memory-efficient: it summarizes the entire history into just two quantities - the current state estimate (x̂) and its uncertainty (covariance P). The filter doesn't store raw historical data; instead, it recursively processes measurements one at a time, updating its belief about the state with each new observation. This recursive approach is computationally efficient and suitable for real-time applications. The filter maintains a probability distribution (Gaussian) over the state, updating it with each new measurement. It says: "I don't care about the raw data from 5 seconds ago. I already processed that and baked it into my current uncertainty (P)."
• Balance Between Prediction and Measurement: The Kalman Filter automatically balances between trusting the process model (prediction) and trusting measurements (observation) based on their relative uncertainties. If measurements are very noisy (high R), the filter smooths them out by trusting the prediction more. If measurements are accurate (low R), the filter follows them closely. If the process model is uncertain (high Q), the filter adapts more to measurements. This automatic balancing is the key advantage over fixed filters or simple averaging.
• Uncertainty Propagation: The filter not only estimates the state but also quantifies uncertainty through the covariance matrix P. Uncertainty grows during prediction (we become less certain about the state) and decreases during update (measurements provide new information). The uncertainty ellipse in 2D mode visualizes this - it shrinks when confident, grows when uncertain. Understanding uncertainty is crucial for applications like sensor fusion, where multiple sensors are combined based on their relative uncertainties.
• Kalman Gain Interpretation: The Kalman Gain K determines how much correction to apply from the measurement. K is computed to minimize estimation error. When K ≈ 1, the filter trusts measurements almost completely (low measurement noise). When K ≈ 0, the filter ignores measurements (high measurement noise or very accurate prediction). The gain adapts automatically - this is why the Kalman Filter works well in varying noise conditions without manual tuning.
• Convergence: As the filter processes more measurements, the uncertainty (P) decreases and the estimate (x̂) approaches the true state. Convergence occurs because each measurement provides new information that reduces uncertainty. The rate of convergence depends on the noise parameters - lower measurement noise (R) leads to faster convergence. In practice, convergence is important for initialization - the filter needs time to "lock onto" the true state.
• Linear Gaussian Assumptions: The standard Kalman Filter assumes (1) linear dynamics (state evolves linearly), (2) linear measurements (measurements are linear functions of state), and (3) Gaussian noise (process and measurement noise are Gaussian). These assumptions allow for closed-form optimal solutions. For nonlinear systems, extensions like Extended Kalman Filter (EKF) or Unscented Kalman Filter (UKF) are used.
• Applications: Kalman Filters are used in numerous applications: (1) Navigation - GPS tracking, inertial navigation, sensor fusion, (2) Control Systems - state estimation for feedback control, (3) Signal Processing - noise reduction, signal tracking, (4) Robotics - SLAM (Simultaneous Localization and Mapping), localization, (5) Finance - trend estimation, volatility modeling, (6) Computer Vision - object tracking, optical flow, (7) Aerospace - attitude estimation, orbit determination. The filter's ability to optimally combine multiple sources of information makes it fundamental to modern engineering.
• Predict-Update Cycle: The Kalman Filter operates in a two-step cycle: (1) Predict - use the process model to predict the next state and increase uncertainty, (2) Update - incorporate the new measurement to refine the estimate and decrease uncertainty. This cycle repeats for each time step. The prediction step uses the process model (F) and process noise (Q). The update step uses the measurement (z), measurement model (H), and measurement noise (R). This cycle allows the filter to track time-varying states while handling noise.
• Sensor Fusion: The Kalman Filter naturally supports sensor fusion - combining measurements from multiple sensors with different noise characteristics. Each sensor can have its own measurement matrix (H) and noise covariance (R). The filter optimally weights each sensor based on its uncertainty - accurate sensors (low R) are weighted more heavily than noisy sensors (high R). This is why Kalman Filters are used in systems with multiple sensors (e.g., GPS + IMU, multiple cameras).
• Real-Time Processing: The Kalman Filter is computationally efficient and suitable for real-time applications. The matrix operations (predict and update) have predictable computational complexity (O(n³) for n-dimensional state), and the filter processes measurements sequentially without storing history. This makes it ideal for embedded systems, robotics, and other real-time applications where computational resources are limited.
• Noise Parameter Tuning: Choosing appropriate Q and R values is crucial for filter performance. Q and R are typically estimated from sensor specifications, calibrated measurements, or tuned empirically. In practice, it's often easier to estimate R (measurement noise) from sensor data, while Q (process noise) may need tuning based on expected system behavior. Overestimating Q makes the filter more responsive but less smooth. Underestimating Q makes the filter smoother but may lag behind rapid changes. The tutorial's sliders let you experiment with these trade-offs.