The poseplot function has these changes:
Batch Input Support
You can now visualize multiple poses in a single function call by passing arrays of
orientations and positions to the poseplot function.
This approach makes your code more concise and delivers performance improvements for
workflows involving trajectories or time-series pose estimates. For example, this code plots
1000 poses in R2026a, using a loop, and in R2026b, using an array. The R2026b code using an
array is about 5x faster:
R2026a:
function timingTest
numPoses = 1000;
orientations = quaternion(randn(numPoses,4));
positions = cumsum(randn(numPoses,3),1);
for i = 1:numPoses
poseplot(orientations(i),positions(i,:),"ENU",MeshFileName="multirotor.stl");
end
end
R2026b:
function timingTest
numPoses = 1000;
orientations = quaternion(randn(numPoses,4));
positions = cumsum(randn(numPoses,3),1);
poseplot(orientations,positions,"ENU",MeshFileName="multirotor.stl");
end
The approximate execution times are:
R2026a: 45.34 s
R2026b: 9.87 s
The code was timed on a Windows® 11, AMD Epyc® 74F3 24-Core Processor CPU @ 3.19 GHz test system using the
timeit function:
timeit(@timingTest)
Multi-Pose Visualization Improvements
You can now control the visibility of the orientation axis labels and the origin box
using the new PoseAxisLabels and OriginBox properties,
respectively, of the PosePatch object. You can use these properties to
improve plot visibility when displaying many poses simultaneously.
Mesh Visualization Enhancements
You can now tune the rendering of an STL mesh by adjusting the display of mesh edges
using the new EdgeDensity property of the PosePatch
object. You can now also control the color, transparency, and width of edges using the new
EdgeColor, EdgeAlpha, and
EdgeLineWidth properties, respectively, of the
PosePatch object.
These figures compare the display of an STL mesh with the maximum
EdgeDensity value of 1, which renders all mesh
edges, on the left, and a lower EdgeDensity value of
0.97, which renders fewer mesh edges, on the right.
|
|
|
PatchFaceColor and
PatchFaceAlpha properties renamed
The PatchFaceColor and PatchFaceAlpha properties
of the PosePatch object are now called FaceColor and
FaceAlpha, respectively. The behavior of both properties remains the
same. There are no plans to remove support for existing references to
PatchFaceColor and PatchFaceAlpha.
You can now visualize time-varying metrics along satellite trajectories using color scaling with these new SkyPlotChart Properties:
TrajectoryColorColorDataColormapColorScalingColorLimitsColorLimitsModeColorbarLabelColorbarVisible
This enhancement enables you to represent time-varying satellite characteristics such as carrier-to-noise ratio directly on trajectories.
You can also now set the lower elevation limit of the sky plot using the new
MinElevation property. Adjusting this limit enables you to focus the
visualization on the satellites relevant to your analysis:
Specify a negative value, such as
-10, to show satellites below the horizon, as seen from airborne or low Earth orbit (LEO) platforms.Specify a value close to 90, such as
75, to zoom in on satellites near the zenith.
The timescope object includes the following enhancements in R2026b.
Display measurements using power of 3 in engineering notation
The timescope object now displays the cursor measurements, peaks, statistics, and bilevel measurements using the power of 3 in engineering notation.
Interactive cursors panel
In the timescope object display, you can now change the cursor channel and the cursor location directly from the Cursors panel.
New YLimitsMode property
You can control how the timescope object
determines the Y-axis limits using the new
YLimitsMode property.
"auto"— Automatically adjusts the Y-axis limits to fit the currently displayed data."manual"— Uses fixed Y-axis limits.
The YLimitsMode property is recommended over the AxesScaling property for controlling the Y-axis limits.
New fitToView object function
You can now use the new fitToView object function to automatically
adjust the Y-axis limits of a timescope object
to fit the currently displayed data. This function performs a one‑time autoscaling
operation without changing the YLimitsMode property and is useful for
resetting the view or updating Y-axis limits on demand.
New Restore View (Home) button in Axes Toolbar
The Restore View (Home) button in the time scope axes toolbar
resets the X-axis to show only the most recent time span of data after
zooming, panning, or fit-to-view operations. This button also resets the
Y-axis limits based on value of the YLimitsMode
property of the timescope
object.
Support for automatic buffer length
The timescope object
now uses an automatic buffer length by default with the BufferLength
property set to "auto", ensuring that the scope retains sufficient data
to display the full time span. In this mode, the buffer:
Always holds at least one full time span of data.
Typically holds approximately 100× the time span, with a minimum of
1e5samples per channel and an upper limit of1e7samples per channel. If the time span exceeds1e7samples per channel, the buffer grows as needed to store at least one full time span of data.
This release contains the following new example:
Resilient Pose Estimation Using Terrain-Aided Inertial Sensor Fusion in GPS-Denied Environments — Fuse inertial sensor measurements with a radar altimeter and a digital elevation model (DEM) to estimate aircraft pose in GPS-denied environments.
The plannerHybridAStar object has
these changes:
Paths with Only Forward Motion
You can now use the MotionDirection property to restrict the path
planner so that it generates paths with only forward motion, such as in scenarios where
reverse motion is not possible or desired.
The first figure shows the generated path with both forward and reverse motion. The second figure shows the generated path with only forward motion.
Specify Maximum Number of Explored Nodes and Path States
You can now specify the maximum number of nodes to explore and path states using the
MaxNumNodes and MaxNumPathStates properties,
respectively. You can use these properties to limit the number of explored nodes and path
states when dynamic memory allocation is not enabled during code generation.
Cost Functions Are Tunable in MATLAB Simulation Mode
You can now tune the AnalyticalExpansionCostFcn and
TransitionCostFcn properties after object creation in MATLAB simulation
mode.
Default MinTurningRadius Value Has
Changed
The plannerHybridAStar object now uses 2 meters as the default value
of the MinTurningRadius property, independent of map cell size. In
previous releases, the default value is
max(2,2*ceil(sqrt(2)*map_CellSize)/pi) meters, where
map_CellSize is the cell size of the map. To use the previous default
value of MinTurningRadius when the map cell size is greater than 2.122
meters (resolution of map less than 0.471 cells/meter), set
MinTurningRadius based on the value of the
StateValidator property.
If
StateValidatoris avalidatorOccupancyMapobject, setMinTurningRadiusto2*ceil(sqrt(2)/planner.StateValidator.Resolution)/pi, where planner is yourplannerHybridAStarobject.If
StateValidatoris avalidatorVehicleCostmapobject, setMinTurningRadiusto2*ceil(sqrt(2)*planner.StateValidator.CellSize)/pi, where planner is yourplannerHybridAStarobject.
Error About Constraint Between
MotionPrimitiveLength and MinTurningRadius Is Now
Warning
The error returned when MotionPrimitiveLength exceeds one-fourth the
length of the circumference of a circle based on MinTurningRadius is now
a warning.
For example, this code sets MotionPrimitiveLength to greater than
one-fourth the length of the circumference of a circle based on
MinTurningRadius.
load("exampleMaps.mat","simpleMap")
map = binaryOccupancyMap(simpleMap);
validator = validatorOccupancyMap(stateSpaceSE2,Map=map);
planner = plannerHybridAStar(validator);
planner.MotionPrimitiveLength = (pi)*planner.MinTurningRadius| Previous Releases | R2026a |
|---|---|
MATLAB® displays an error. Error using plannerHybridAStar Expected MotionPrimitiveLength to be an array with all of the values <= 3.14159. | MATLAB now displays a warning and sets
Warning: Setting the "MotionPrimitiveLength" has resulted in "MotionPrimitiveLength" value (6.2832 meters)
being greater than (pi/2) times "MinTurningRadius" (3.1416 meters), which can cause motion primitives to
curve back on themselves and result in a less optimal path. To prevent this, set "MotionPrimitiveLength"
to a value less than 3.1416 meters.
planner =
plannerHybridAStar with properties:
StateValidator: [1×1 validatorOccupancyMap]
MinTurningRadius: 2
MotionPrimitiveLength: 6.2832
NumMotionPrimitives: 5
ForwardCost: 1
ReverseCost: 3
DirectionSwitchingCost: 0
AnalyticExpansionInterval: 5
InterpolationDistance: 1
MotionDirection: "forward-reverse"
|
Similarly, this code sets MinTurningRadius such that
MotionPrimitiveLength is greater than one-fourth the length of the
circumference of a circle based on
MinTurningRadius.
load("exampleMaps.mat","simpleMap")
map = binaryOccupancyMap(simpleMap);
validator = validatorOccupancyMap(stateSpaceSE2,Map=map);
planner = plannerHybridAStar(validator);
planner.MinTurningRadius = (1/pi)*planner.MotionPrimitiveLength| Previous Releases | R2026a |
|---|---|
MATLAB displays an error. Error using plannerHybridAStar Expected MinTurningRadius to be an array with all of the values >= 1.27324. | MATLAB now displays a warning and sets Warning: Setting the "MinTurningRadius" has resulted in "MotionPrimitiveLength" value (2 meters)
being greater than (pi/2) times "MinTurningRadius" (1 meters), which can cause motion primitives
to curve back on themselves and result in a less optimal path. To prevent this,
set "MotionPrimitiveLength" to a value less than 1 meters.
planner =
plannerHybridAStar with properties:
StateValidator: [1×1 validatorOccupancyMap]
MinTurningRadius: 0.6366
MotionPrimitiveLength: 2
NumMotionPrimitives: 5
ForwardCost: 1
ReverseCost: 3
DirectionSwitchingCost: 0
AnalyticExpansionInterval: 5
InterpolationDistance: 1
MotionDirection: "forward-reverse"
|
Use the gnssmeasurements
function to compute GNSS measurements, from observation and navigation data, for the
receiverposition
function.
You can use the gnssoptions object
to specify ionospheric and tropospheric delay models, and code bias, to the receiverposition
function. For more information about ionospheric and tropospheric delay models, see the new
gnssIonosphere and
gnssTroposphere
objects, respectively.
You can now specify multiple data cursors in the timescope object using the XLocation field in the
CursorMeasurements property. Data cursors include both screen cursors
and waveform cursors.
Use the polygonDecomposition function to decompose a complex polygon into a set of
nonoverlapping polygons using the boustrophedon decomposition algorithm. This is
particularly useful for coverage planning in agricultural fields, restricted areas, and
complex land excavation.
You can also use the boustrophedonOptions object to specify custom options for generating a graph
that captures the connectivity between the decomposed polygons.
These figures show a complex polyshape being decomposed into a set of
convex polyshape objects, and a connection graph overlay.
Use the interp1 object function of the quaternion object to
interpolate quaternions using interpolation methods such as SQUAD and SLERP.
This figure visualizes interpolated quaternions on a unit sphere by using the sample and
interpolated quaternions to rotate a 3-D point. The annotated numbers on the points are the
sample points and query points that correspond to v and
vq, respectively.
The slerp object function of the quaternion object now supports
spherical interpolation using the "natural" path option, which avoids the
shortest path optimization, resulting in a longer path around the unit sphere that respects
the orientation of the start and end quaternions.
This figure visualizes the difference between the "short" and
"natural" interpolation methods by rotating a point using the
interpolated quaternions on a unit sphere.
You can now perform local path planning in Simulink® by using the Timed Elastic Band Simulink block.
The Avoid Obstacles Using TEB Local Planner in Simulink example shows how to perform local path planning to avoid obstacles and generate a feasible path using the Timed Elastic Band block. This example also shows how to address challenges such as violations of obstacle safety margin and minimum turning radius constraints to achieve an optimized path to the goal pose. The simulation highlights path following and obstacle avoidance, where the robot adheres to the planned trajectory as it navigates through the environment.
The Simulate Path Following on Speedgoat Real-Time Target Machine example shows how to perform real-time simulations for path following in a complex environment using Speedgoat real-time target machines. In this example, you will use different Speedgoat target machines for Rapid Control Prototyping (RCP) and Hardware-in-the-Loop (HIL) simulations. You can use this example to test and validate vehicle's ability to accurately follow paths in a complex environment.
Use the signedDistanceMap3D object to create and store truncated signed distance fields
(TSDF) over voxelized 3-D space. You can use the insertPointCloud function to quickly construct your environments in the signed
distance map using sensor readings. Using signedDistanceMap3D enables
optimization-based motion planners to understand and navigate the environment more
effectively, making it easier to avoid obstacles and plan more efficiently.
The first figure shows a reference STL that was used to create point cloud data. The second figure shows a 3-D TSDF generated from the point cloud data. The third figure shows the mesh generated from that 3-D TSDF.
Use the nodeCovariance function to retrieve stored state covariance from a factor
graph after optimization. Specify a factorGraphSolverOptions and set the StateCovarianceType property to specify one or more node types for which to
estimate and store the state covariance.
The covariance represents the uncertainty associated with the estimated states, which can help you understand the reliability of the state estimates and make informed decisions based on the level of confidence in each estimated state. Incorporating the covariance matrix in state estimation also helps you filter out measurement noise and outliers, thereby improving the overall accuracy and robustness of the estimates.
This figure shows the node state covariances for SE(2) nodes using a helper function. The plotted covariance increases due to drift accumulation with each consecutive node and lowers near loop closures due to the additional state information provided by the loop closure.
Use the IMU Filter Simulink block to estimate orientation based on accelerometer and gyroscope sensor data.
Specify different state space sampling methods for plannerRRT, plannerRRTStar, plannerBiRRT, and plannerPRM path planners.
To specify the type of the state space sampling method, use the
StateSampler property. The value of the
StateSampler property must be a stateSamplerUniform object, stateSamplerGaussian object, or stateSamplerMPNET object, or a custom object inherited from the nav.StateSampler class.
For example, this code shows how to set the StateSampler property
to specify uniform state space sampling when creating a plannerRRT
planner.
sampler = stateSamplerUniform(statespace) planner = plannerRRT(statespace,statevalidator,StateSampler=sampler)
Conventional State Samplers
Use the
stateSamplerUniformobject to sample state space using a uniform distribution.Use the
stateSamplerGaussianobject to sample states in a state space near obstacles using a combination of a Gaussian distribution and a uniform distribution.
Deep-Learning-Based State Sampler
Use the stateSamplerMPNET object to perform informed sampling using a Motion Planning
Networks (MPNet). You can either use a pretrained MPNet or train the network on custom data.
Use the
mpnetSE2object to either load a pretrained MPNet or train the MPNet on an input data set.Use the
mpnetPrepareDatafunction to preprocess the input data set before training the network.
You can use the mpnetSE2 objects with only SE(2) state spaces, such as stateSpaceSE2, stateSpaceDubins, and stateSpaceReedsShepp. For an overview on MPNet and how to use it for state space
sampling, see Get Started with Motion Planning Networks.
For an example, the figure displays state space samples generated by uniform, Gaussian, and MPNet state samplers. It also shows path planning results computed using RRT* path planner for each sampling approach.
|
|
|
|
Custom State Sampler
Use the nav.StateSampler class interface to write your own custom state sampler. You can
also use the createPlanningTemplate function to generate a template for implementing a
subclass of the nav.StateSampler class.
The optimize object function of factorGraph now accepts node IDs, enabling you to incrementally optimize a
factor graph. This is useful for applications such as visual SLAM, which can require a
factor graph containing hundreds of factors to relate poses to feature points. By limiting
the factor graph optimization to a subset of the most recent pose nodes within a sliding
window in the factor graph, you can maintain efficient optimization.
This is an example using sliding window factor graph optimization for a UAV that localizes with a monocular camera. The highlighted section of the trajectory indicates the sliding window containing the most recent pose nodes in the estimated trajectory to optimize at the current time step.
For more information, see the updated Monocular Visual-Inertial Odometry Using Factor Graph example.
Use the collisionVHACD function to decompose non-convex triangulations into a
composite of convex collision meshes for collision checking. This is useful for creating
more accurate collision-mesh approximations of non-convex items. For example, if you need to
perform collision checking with non-convex object such as a bin, you must model it with
convex meshes for efficient collision checking. If you approximate the bins as one convex
collision object, then collision-checking algorithms report collisions between the bin and
anything that is in the bin. Decomposing the non-convex mesh into a composite of convex
meshes resolves this by providing a more accurate representation of the bin.
Here is a comparison of a bin as the original triangulation, as a single convex mesh, and as a composite of convex meshes after V-HACD decomposition:
Use these functions to specify predefined line styles, colors, and marker appearances
for plotting the outputs of plannerHybridAStar, plannerRRT, plannerRRTStar, plannerBiRRT, and plannerPRM path planners.
| Functions | Description | Example Plots with Default Specifications |
plannerLineSpec.goal | Specifications for plotting goal state. |
|
plannerLineSpec.start | Specifications for plotting start state. | |
plannerLineSpec.state | Specifications for plotting generic state. | |
plannerLineSpec.path | Specifications for plotting forward path. | |
plannerLineSpec.heading | Specifications for plotting heading angle. | |
plannerLineSpec.tree | Specifications for plotting forward search tree. |
|
plannerLineSpec.goalTree | Specifications for plotting search tree from goal to start. | |
plannerLineSpec.reversePath | Specifications for plotting reverse path. | |
plannerLineSpec.reverseTree | Specifications for plotting reverse search tree. |
Use the controllerTEB object to create a controller that uses the Timed Elastic Band
(TEB) algorithm to compute velocity commands and an optimal trajectory for a
differential-drive robot. The controller follows the reference path generated by a global
planner, such as RRT or Hybrid A*.
Use the headingFromXY function to find the heading of the robot based on the
XY-points of its path. Use the velocityCommand function to retrieve its velocity at a specified time from a
time series of velocity commands.
Use the plannerAStar object to plan the shortest path in a graph by exploring the nodes
using the A* algorithm.
As of R2023a, Navigation Toolbox™ includes the navGraph object as a graph data structure, which aids search-based
planners.
You can use the navGraph object as a planning environment for the
plannerAStar path planner.
Use the signedDistanceMap object to create a signed distance map. You can use the
distance and gradient information for path planning and optimization.
Use the gnssMeasurementGenerator object to generate GNSS satellite measurements for use
in robot scenario simulations. You can use this object for multipath simulation where the
buildings or obstacles in a scenario affect the line of sight of satellites.
Check collisions between occupancyMap3D map objects and collision geometries using the custom collision
options object occupancyMap3DCollisionOptions and the checkMapCollision function.
The AzimuthData and ElevationData properties of the SkyPlotChart object, now
accept matrices, allowing you to add azimuth and elevation data for each satellite at
multiple time steps. Use this to visualize the trajectory of each satellite in the sky plot
chart.
Use these new SkyPlotChart properties to add elevation and azimuth
angle masks to a sky plot chart:
The elevation and azimuth angle masks make it easier to see when satellites are below and azimuth or elevation range.
See the SkyPlotChart Properties page for more details.
Set the search algorithm mode when using plannerHybridAStar by specifying the mode argument of the plan object function.
The default “greedy” mode prioritizes finding a solution in a shorter
time which may provide an unoptimized path in some scenarios due to cell locking issues. The
“exhaustive” mode prioritizes finding an optimal solution. This enables
you to find more optimal solutions for vehicle path planning.
