feat: validate published EM trajectories

ClumsyPilot/ParkrobTrajplanner/EMPlanner/Validation/EmTrajectoryValidator.cs

@@ -0,0 +1,342 @@
+using System;
+using MultiWheelC.TrajectoryPlanning.CoarsePath;
+using MultiWheelC.TrajectoryPlanning.CoarsePath.Vehicle;
+using MultiWheelC.TrajectoryPlanning.Mapping;
+
+namespace MultiWheelC.TrajectoryPlanning.EMPlanner;
+
+public enum EmTrajectoryValidationFailure
+{
+    None,
+    InvalidInput,
+    NonFinite,
+    TimeNotStrictlyIncreasing,
+    PathSDecreased,
+    SegmentBoundaryExceeded,
+    MissingTerminalAnchor,
+    TerminalSpeedNotZero,
+    TerminalYawRateNotZero,
+    DirectionMismatch,
+    DirectionSignMismatch,
+    RedundantSpeedMismatch,
+    WorldVelocityMismatch,
+    YawRateMismatch,
+    SpeedLimitExceeded,
+    AccelerationLimitExceeded,
+    JerkLimitExceeded,
+    CurvatureLimitExceeded,
+    CurvatureRateLimitExceeded,
+    PoseCollision,
+    SweptCollision,
+}
+
+public sealed class EmTrajectoryValidationResult
+{
+    private EmTrajectoryValidationResult(EmTrajectoryValidationFailure failure, int pointIndex, string message)
+    {
+        Failure = failure;
+        PointIndex = pointIndex;
+        Message = message ?? string.Empty;
+    }
+
+    public bool IsValid { get { return Failure == EmTrajectoryValidationFailure.None; } }
+
+    public EmTrajectoryValidationFailure Failure { get; }
+
+    public int PointIndex { get; }
+
+    public string Message { get; }
+
+    internal static EmTrajectoryValidationResult Success()
+    {
+        return new EmTrajectoryValidationResult(EmTrajectoryValidationFailure.None, -1, string.Empty);
+    }
+
+    internal static EmTrajectoryValidationResult Reject(EmTrajectoryValidationFailure failure, int pointIndex,
+        string message)
+    {
+        return new EmTrajectoryValidationResult(failure, pointIndex, message);
+    }
+}
+
+/// <summary>Independently checks the public world-space trajectory before it can be published.</summary>
+public sealed class EmTrajectoryValidator
+{
+    private const double MaximumSweptCollisionStepMeters = 0.025d;
+    private readonly FootprintCollisionChecker collisionChecker;
+
+    public EmTrajectoryValidator()
+        : this(new FootprintCollisionChecker())
+    {
+    }
+
+    public EmTrajectoryValidator(FootprintCollisionChecker collisionChecker)
+    {
+        this.collisionChecker = collisionChecker ?? throw new ArgumentNullException(nameof(collisionChecker));
+    }
+
+    public EmTrajectoryValidationResult Validate(EmTrajectory trajectory, PlanningGridMap map, VehicleParameters vehicle,
+        EmPlannerConfiguration configuration, int segmentIndex, double terminalPathS, EmBoundaryType terminalBoundary)
+    {
+        if (trajectory == null || map == null || vehicle == null || configuration == null || configuration.Validation == null ||
+            configuration.Longitudinal == null || configuration.Corridor == null || segmentIndex < 0 ||
+            !IsFinite(terminalPathS) || terminalPathS < 0d || !Enum.IsDefined(typeof(EmBoundaryType), terminalBoundary) ||
+            !TryReadLimits(configuration, vehicle, trajectory.Metadata.Direction, out ValidationLimits limits))
+        {
+            return EmTrajectoryValidationResult.Reject(EmTrajectoryValidationFailure.InvalidInput, -1,
+                "Trajectory publication inputs or validation limits are invalid.");
+        }
+
+        for (int index = 0; index < trajectory.Points.Count; index++)
+        {
+            EmTrajectoryPoint point = trajectory.Points[index];
+            if (point == null || !HasOnlyFiniteValues(point))
+                return Reject(EmTrajectoryValidationFailure.NonFinite, index, "Trajectory contains a non-finite point.");
+            if (point.SegmentIndex != segmentIndex || point.SegmentLocalS > terminalPathS + limits.SpatialTolerance ||
+                point.PathS > terminalPathS + limits.SpatialTolerance)
+            {
+                return Reject(EmTrajectoryValidationFailure.SegmentBoundaryExceeded, index,
+                    "Trajectory point lies outside the current direction segment.");
+            }
+            if (index == 0)
+                continue;
+
+            EmTrajectoryPoint previous = trajectory.Points[index - 1];
+            if (point.TimeFromStart <= previous.TimeFromStart)
+                return Reject(EmTrajectoryValidationFailure.TimeNotStrictlyIncreasing, index,
+                    "Trajectory time must be strictly increasing.");
+            if (point.PathS + limits.SpatialTolerance < previous.PathS ||
+                point.SegmentLocalS + limits.SpatialTolerance < previous.SegmentLocalS)
+            {
+                return Reject(EmTrajectoryValidationFailure.PathSDecreased, index,
+                    "Trajectory PathS must not decrease.");
+            }
+        }
+
+        int terminalIndex = FindTerminalAnchor(trajectory, terminalPathS, terminalBoundary, limits.SpatialTolerance);
+        if (terminalIndex < 0)
+        {
+            return Reject(EmTrajectoryValidationFailure.MissingTerminalAnchor,
+                FindFirstTerminalPathIndex(trajectory, terminalPathS, limits.SpatialTolerance),
+                "Trajectory does not contain the exact terminal boundary anchor.");
+        }
+
+        EmTrajectoryPoint terminal = trajectory.Points[terminalIndex];
+        if (Math.Abs(terminal.SignedLongitudinalVelocity) > limits.KinematicTolerance)
+            return Reject(EmTrajectoryValidationFailure.TerminalSpeedNotZero, terminalIndex,
+                "Terminal signed speed must be zero.");
+        if (Math.Abs(terminal.YawRate) > limits.KinematicTolerance)
+            return Reject(EmTrajectoryValidationFailure.TerminalYawRateNotZero, terminalIndex,
+                "Terminal yaw rate must be zero.");
+
+        double directionSign = trajectory.Metadata.Direction == TravelDirection.Forward ? 1d : -1d;
+        double previousAcceleration = 0d;
+        bool hasPreviousAcceleration = false;
+        for (int index = 0; index < trajectory.Points.Count; index++)
+        {
+            EmTrajectoryPoint point = trajectory.Points[index];
+            if (point.Direction != trajectory.Metadata.Direction)
+                return Reject(EmTrajectoryValidationFailure.DirectionMismatch, index,
+                    "Trajectory point direction differs from trajectory metadata.");
+            if (Math.Abs(point.SignedLongitudinalVelocity) > limits.KinematicTolerance &&
+                point.SignedLongitudinalVelocity * directionSign < 0d)
+            {
+                return Reject(EmTrajectoryValidationFailure.DirectionSignMismatch, index,
+                    "Trajectory signed speed has the wrong direction sign.");
+            }
+            if (!NearlyEqual(Math.Abs(point.SignedLongitudinalVelocity), point.Speed, limits.KinematicTolerance))
+                return Reject(EmTrajectoryValidationFailure.RedundantSpeedMismatch, index,
+                    "Trajectory Speed is inconsistent with signed speed.");
+            if (!NearlyEqual(point.SignedLongitudinalVelocity * Math.Cos(point.Yaw), point.VelocityX,
+                    limits.KinematicTolerance) ||
+                !NearlyEqual(point.SignedLongitudinalVelocity * Math.Sin(point.Yaw), point.VelocityY,
+                    limits.KinematicTolerance))
+            {
+                return Reject(EmTrajectoryValidationFailure.WorldVelocityMismatch, index,
+                    "Trajectory world velocity is inconsistent with signed speed and yaw.");
+            }
+            if (!NearlyEqual(point.SignedLongitudinalVelocity * point.VehicleCurvature, point.YawRate,
+                    limits.KinematicTolerance))
+            {
+                return Reject(EmTrajectoryValidationFailure.YawRateMismatch, index,
+                    "Trajectory yaw rate is inconsistent with signed speed and curvature.");
+            }
+            if (point.Speed > limits.MaximumSpeed + limits.KinematicTolerance)
+                return Reject(EmTrajectoryValidationFailure.SpeedLimitExceeded, index,
+                    "Trajectory speed exceeds its direction limit.");
+            if (Math.Abs(point.VehicleCurvature) > limits.MaximumCurvature + limits.KinematicTolerance)
+                return Reject(EmTrajectoryValidationFailure.CurvatureLimitExceeded, index,
+                    "Trajectory vehicle curvature exceeds the vehicle limit.");
+
+            if (index == 0)
+                continue;
+
+            EmTrajectoryPoint previous = trajectory.Points[index - 1];
+            double dt = point.TimeFromStart - previous.TimeFromStart;
+            double previousProgressSpeed = directionSign * previous.SignedLongitudinalVelocity;
+            double progressSpeed = directionSign * point.SignedLongitudinalVelocity;
+            double acceleration = (progressSpeed - previousProgressSpeed) / dt;
+            if (acceleration > limits.MaximumAcceleration + limits.KinematicTolerance ||
+                -acceleration > limits.MaximumDeceleration + limits.KinematicTolerance)
+            {
+                return Reject(EmTrajectoryValidationFailure.AccelerationLimitExceeded, index,
+                    "Trajectory finite-difference acceleration exceeds its limit.");
+            }
+            if (hasPreviousAcceleration && Math.Abs((acceleration - previousAcceleration) / dt) > limits.MaximumJerk +
+                limits.KinematicTolerance)
+            {
+                return Reject(EmTrajectoryValidationFailure.JerkLimitExceeded, index,
+                    "Trajectory finite-difference jerk exceeds its limit.");
+            }
+            if (Math.Abs(point.VehicleCurvature - previous.VehicleCurvature) / dt > limits.MaximumCurvatureRate +
+                limits.KinematicTolerance)
+            {
+                return Reject(EmTrajectoryValidationFailure.CurvatureRateLimitExceeded, index,
+                    "Trajectory finite-difference curvature rate exceeds its limit.");
+            }
+            previousAcceleration = acceleration;
+            hasPreviousAcceleration = true;
+        }
+
+        for (int index = 0; index < trajectory.Points.Count; index++)
+        {
+            EmTrajectoryPoint point = trajectory.Points[index];
+            if (!collisionChecker.IsPoseCollisionFree(new Pose2D(point.X, point.Y, point.Yaw), map, vehicle, 0d, out _))
+                return Reject(EmTrajectoryValidationFailure.PoseCollision, index,
+                    "Trajectory point fails the full-body world-space collision check.");
+        }
+        double sweptStepMeters = Math.Min(MaximumSweptCollisionStepMeters, limits.ConfiguredCollisionStepMeters);
+        for (int index = 1; index < trajectory.Points.Count; index++)
+        {
+            EmTrajectoryPoint previous = trajectory.Points[index - 1];
+            EmTrajectoryPoint point = trajectory.Points[index];
+            if (!collisionChecker.IsSweptMotionCollisionFree(new Pose2D(previous.X, previous.Y, previous.Yaw),
+                    new Pose2D(point.X, point.Y, point.Yaw), map, vehicle, sweptStepMeters, out _))
+            {
+                return Reject(EmTrajectoryValidationFailure.SweptCollision, index,
+                    "Trajectory segment fails the full-body swept world-space collision check.");
+            }
+        }
+
+        return EmTrajectoryValidationResult.Success();
+    }
+
+    private static int FindTerminalAnchor(EmTrajectory trajectory, double terminalPathS, EmBoundaryType terminalBoundary,
+        double spatialTolerance)
+    {
+        for (int index = 0; index < trajectory.Points.Count; index++)
+        {
+            EmTrajectoryPoint point = trajectory.Points[index];
+            if (point.BoundaryType == terminalBoundary && Math.Abs(point.PathS - terminalPathS) <= spatialTolerance)
+                return index;
+        }
+        return -1;
+    }
+
+    private static int FindFirstTerminalPathIndex(EmTrajectory trajectory, double terminalPathS, double spatialTolerance)
+    {
+        for (int index = 0; index < trajectory.Points.Count; index++)
+        {
+            if (Math.Abs(trajectory.Points[index].PathS - terminalPathS) <= spatialTolerance)
+                return index;
+        }
+        return trajectory.Points.Count - 1;
+    }
+
+    private static bool HasOnlyFiniteValues(EmTrajectoryPoint point)
+    {
+        return IsFinite(point.X) && IsFinite(point.Y) && IsFinite(point.Yaw) &&
+            IsFinite(point.SignedLongitudinalVelocity) && IsFinite(point.Speed) && IsFinite(point.VelocityX) &&
+            IsFinite(point.VelocityY) && IsFinite(point.YawRate) && IsFinite(point.TimeFromStart) &&
+            IsFinite(point.VehicleCurvature) && IsFinite(point.SegmentLocalS) && IsFinite(point.PathS) &&
+            IsFinite(point.LongitudinalAcceleration) && IsFinite(point.LongitudinalJerk);
+    }
+
+    private static bool TryReadLimits(EmPlannerConfiguration configuration, VehicleParameters vehicle,
+        TravelDirection direction, out ValidationLimits limits)
+    {
+        limits = default;
+        double maximumCurvature;
+        if (vehicle.MaximumCurvaturePerMeter.HasValue)
+            maximumCurvature = vehicle.MaximumCurvaturePerMeter.Value;
+        else if (vehicle.MinimumTurningRadiusMeters.HasValue && vehicle.MinimumTurningRadiusMeters.Value > 0d)
+            maximumCurvature = 1d / vehicle.MinimumTurningRadiusMeters.Value;
+        else
+            return false;
+
+        if (direction != TravelDirection.Forward && direction != TravelDirection.Reverse)
+            return false;
+        double maximumSpeed = direction == TravelDirection.Forward
+            ? configuration.Longitudinal.MaximumForwardSpeedMetersPerSecond
+            : configuration.Longitudinal.MaximumReverseSpeedMetersPerSecond;
+        if (!IsFinite(maximumSpeed) || maximumSpeed <= 0d || !IsFinite(maximumCurvature) || maximumCurvature <= 0d ||
+            !IsFinite(configuration.Longitudinal.MaximumAccelerationMetersPerSecondSquared) ||
+            configuration.Longitudinal.MaximumAccelerationMetersPerSecondSquared <= 0d ||
+            !IsFinite(configuration.Longitudinal.MaximumDecelerationMetersPerSecondSquared) ||
+            configuration.Longitudinal.MaximumDecelerationMetersPerSecondSquared <= 0d ||
+            !IsFinite(configuration.Longitudinal.MaximumJerkMetersPerSecondCubed) ||
+            configuration.Longitudinal.MaximumJerkMetersPerSecondCubed <= 0d ||
+            !IsFinite(configuration.Longitudinal.MaximumCurvatureRatePerMeterPerSecond) ||
+            configuration.Longitudinal.MaximumCurvatureRatePerMeterPerSecond <= 0d ||
+            !IsFinite(configuration.Validation.SpatialToleranceMeters) || configuration.Validation.SpatialToleranceMeters < 0d ||
+            !IsFinite(configuration.Validation.KinematicTolerance) || configuration.Validation.KinematicTolerance < 0d ||
+            !IsFinite(configuration.Corridor.MaximumCollisionCheckStepMeters) ||
+            configuration.Corridor.MaximumCollisionCheckStepMeters <= 0d)
+        {
+            return false;
+        }
+
+        limits = new ValidationLimits(maximumSpeed, maximumCurvature,
+            configuration.Longitudinal.MaximumAccelerationMetersPerSecondSquared,
+            configuration.Longitudinal.MaximumDecelerationMetersPerSecondSquared,
+            configuration.Longitudinal.MaximumJerkMetersPerSecondCubed,
+            configuration.Longitudinal.MaximumCurvatureRatePerMeterPerSecond,
+            configuration.Validation.SpatialToleranceMeters, configuration.Validation.KinematicTolerance,
+            configuration.Corridor.MaximumCollisionCheckStepMeters);
+        return true;
+    }
+
+    private static bool NearlyEqual(double expected, double actual, double tolerance)
+    {
+        double scale = Math.Max(1d, Math.Max(Math.Abs(expected), Math.Abs(actual)));
+        return Math.Abs(expected - actual) <= tolerance + tolerance * scale;
+    }
+
+    private static bool IsFinite(double value)
+    {
+        return !double.IsNaN(value) && !double.IsInfinity(value);
+    }
+
+    private static EmTrajectoryValidationResult Reject(EmTrajectoryValidationFailure failure, int index, string message)
+    {
+        return EmTrajectoryValidationResult.Reject(failure, index, message);
+    }
+
+    private readonly struct ValidationLimits
+    {
+        public ValidationLimits(double maximumSpeed, double maximumCurvature, double maximumAcceleration,
+            double maximumDeceleration, double maximumJerk, double maximumCurvatureRate, double spatialTolerance,
+            double kinematicTolerance, double configuredCollisionStepMeters)
+        {
+            MaximumSpeed = maximumSpeed;
+            MaximumCurvature = maximumCurvature;
+            MaximumAcceleration = maximumAcceleration;
+            MaximumDeceleration = maximumDeceleration;
+            MaximumJerk = maximumJerk;
+            MaximumCurvatureRate = maximumCurvatureRate;
+            SpatialTolerance = spatialTolerance;
+            KinematicTolerance = kinematicTolerance;
+            ConfiguredCollisionStepMeters = configuredCollisionStepMeters;
+        }
+
+        public double MaximumSpeed { get; }
+        public double MaximumCurvature { get; }
+        public double MaximumAcceleration { get; }
+        public double MaximumDeceleration { get; }
+        public double MaximumJerk { get; }
+        public double MaximumCurvatureRate { get; }
+        public double SpatialTolerance { get; }
+        public double KinematicTolerance { get; }
+        public double ConfiguredCollisionStepMeters { get; }
+    }
+}

ClumsyPilot/tests/EMPlannerVerificationHost/TrajectoryChecks.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using EMPlannerVerificationHost;
 using MultiWheelC.TrajectoryPlanning.CoarsePath;
+using MultiWheelC.TrajectoryPlanning.Mapping;
 
 namespace MultiWheelC.TrajectoryPlanning.EMPlanner;
 
@@ -12,6 +14,8 @@ internal static class TrajectoryChecks
         VerifiesForwardFieldsExactTerminalAndHold();
         VerifiesReverseTravelVelocityAndUnwrappedYaw();
         VerifiesPublishedListsAreImmutable();
+        VerifiesWorldSpacePublicationMutationsAreRejected();
+        VerifiesReverseSpeedLimitUsesReverseConfiguration();
     }
 
     private static void VerifiesForwardFieldsExactTerminalAndHold()
@@ -51,6 +55,185 @@ internal static class TrajectoryChecks
             "trajectory public point list is immutable");
     }
 
+    private static void VerifiesWorldSpacePublicationMutationsAreRejected()
+    {
+        ValidationContext context = CreateValidationContext();
+        EmTrajectory valid = CreateValidationTrajectory(TravelDirection.Forward);
+        EmTrajectoryValidationResult accepted = new EmTrajectoryValidator().Validate(valid, context.EmptyMap, context.Vehicle,
+            context.Configuration, 2, 0.0055d, EmBoundaryType.Goal);
+        Verification.True(accepted.IsValid, "valid world-space trajectory is publishable: " + accepted.Message);
+
+        AssertRejected(context, CorruptDouble(valid, 1, "X", double.NaN), EmTrajectoryValidationFailure.NonFinite, 1,
+            "non-finite point");
+        AssertRejected(context, Replace(valid, 1, Clone(valid.Points[1], timeFromStart: valid.Points[0].TimeFromStart)),
+            EmTrajectoryValidationFailure.TimeNotStrictlyIncreasing, 1, "non-increasing time");
+        AssertRejected(context, Replace(valid, 2, Clone(valid.Points[2], pathS: 0.0005d)),
+            EmTrajectoryValidationFailure.PathSDecreased, 2, "decreasing PathS");
+        AssertRejected(context, Replace(valid, 1, Clone(valid.Points[1], signedSpeed: -valid.Points[1].Speed)),
+            EmTrajectoryValidationFailure.DirectionSignMismatch, 1, "direction sign");
+        AssertRejected(context, CorruptDouble(valid, 1, "Speed", valid.Points[1].Speed + 0.01d),
+            EmTrajectoryValidationFailure.RedundantSpeedMismatch, 1, "redundant speed");
+        AssertRejected(context, CorruptDouble(valid, 1, "VelocityX", valid.Points[1].VelocityX + 0.01d),
+            EmTrajectoryValidationFailure.WorldVelocityMismatch, 1, "world velocity");
+        AssertRejected(context, CorruptDouble(valid, 1, "YawRate", valid.Points[1].YawRate + 0.01d),
+            EmTrajectoryValidationFailure.YawRateMismatch, 1, "yaw rate");
+        AssertRejected(context, Replace(valid, 1, Clone(valid.Points[1], signedSpeed: 0.30d)),
+            EmTrajectoryValidationFailure.SpeedLimitExceeded, 1, "speed limit");
+        AssertRejected(context, Replace(valid, 2, Clone(valid.Points[2], signedSpeed: 0.19d)),
+            EmTrajectoryValidationFailure.AccelerationLimitExceeded, 2, "acceleration limit");
+
+        EmTrajectory jerkMutated = Replace(valid, 1, Clone(valid.Points[1], signedSpeed: 0.035d));
+        jerkMutated = Replace(jerkMutated, 2, Clone(jerkMutated.Points[2], signedSpeed: 0.03d));
+        AssertRejected(context, jerkMutated, EmTrajectoryValidationFailure.JerkLimitExceeded, 2, "jerk limit");
+
+        AssertRejected(context, Replace(valid, 1, Clone(valid.Points[1], vehicleCurvature: 2d)),
+            EmTrajectoryValidationFailure.CurvatureLimitExceeded, 1, "curvature limit");
+        AssertRejected(context, Replace(valid, 1, Clone(valid.Points[1], vehicleCurvature: 0.75d)),
+            EmTrajectoryValidationFailure.CurvatureRateLimitExceeded, 1, "curvature-rate limit");
+
+        const int terminalIndex = 8;
+        AssertRejected(context, Replace(valid, terminalIndex, Clone(valid.Points[terminalIndex], boundaryType: EmBoundaryType.None)),
+            EmTrajectoryValidationFailure.MissingTerminalAnchor, terminalIndex, "missing exact terminal anchor");
+        AssertRejected(context, Replace(valid, terminalIndex, Clone(valid.Points[terminalIndex], signedSpeed: 0.01d)),
+            EmTrajectoryValidationFailure.TerminalSpeedNotZero, terminalIndex, "terminal speed");
+        AssertRejected(context, CorruptDouble(valid, terminalIndex, "YawRate", 0.01d),
+            EmTrajectoryValidationFailure.TerminalYawRateNotZero, terminalIndex, "terminal yaw rate");
+
+        AssertRejected(context, Replace(valid, 1, Clone(valid.Points[1], x: 1d)), context.PoseCollisionMap,
+            EmTrajectoryValidationFailure.PoseCollision, 1, "pose collision");
+        AssertRejected(context, Replace(valid, 1, Clone(valid.Points[1], x: 1d)), context.SweptCollisionMap,
+            EmTrajectoryValidationFailure.SweptCollision, 1, "swept collision");
+        EmTrajectoryValidationResult beyondSegment = new EmTrajectoryValidator().Validate(valid, context.EmptyMap, context.Vehicle,
+            context.Configuration, 2, 0.004d, EmBoundaryType.Goal);
+        Verification.Equal(EmTrajectoryValidationFailure.SegmentBoundaryExceeded, beyondSegment.Failure,
+            "segment-boundary failure code");
+        Verification.Equal(4, beyondSegment.PointIndex, "segment-boundary first point");
+    }
+
+    private static void VerifiesReverseSpeedLimitUsesReverseConfiguration()
+    {
+        ValidationContext context = CreateValidationContext();
+        context.Configuration.Longitudinal.MaximumForwardSpeedMetersPerSecond = 0.20d;
+        context.Configuration.Longitudinal.MaximumReverseSpeedMetersPerSecond = 0.02d;
+        EmTrajectoryValidationResult result = new EmTrajectoryValidator().Validate(
+            CreateValidationTrajectory(TravelDirection.Reverse), context.EmptyMap, context.Vehicle, context.Configuration,
+            2, 0.0055d, EmBoundaryType.Goal);
+        Verification.Equal(EmTrajectoryValidationFailure.SpeedLimitExceeded, result.Failure,
+            "reverse speed uses the configured reverse limit");
+        Verification.Equal(0, result.PointIndex, "reverse speed first over-limit point");
+    }
+
+    private static void AssertRejected(ValidationContext context, EmTrajectory trajectory,
+        EmTrajectoryValidationFailure expectedFailure, int expectedIndex, string name)
+    {
+        AssertRejected(context, trajectory, context.EmptyMap, expectedFailure, expectedIndex, name);
+    }
+
+    private static void AssertRejected(ValidationContext context, EmTrajectory trajectory, PlanningGridMap map,
+        EmTrajectoryValidationFailure expectedFailure, int expectedIndex, string name)
+    {
+        EmTrajectoryValidationResult result = new EmTrajectoryValidator().Validate(trajectory, map, context.Vehicle,
+            context.Configuration, 2, 0.0055d, EmBoundaryType.Goal);
+        Verification.True(!result.IsValid, name + " is rejected");
+        Verification.Equal(expectedFailure, result.Failure, name + " failure code");
+        Verification.Equal(expectedIndex, result.PointIndex, name + " failure index");
+    }
+
+    private static ValidationContext CreateValidationContext()
+    {
+        EmPlannerConfiguration configuration = EmPlannerConfiguration.CreateDefault();
+        return new ValidationContext(configuration, new VehicleParameters
+        {
+            LengthMeters = 0.01d,
+            WidthMeters = 0.01d,
+            SafetyMarginMeters = 0d,
+            MaximumCurvaturePerMeter = 1d,
+        },
+        CreateValidationMap(Array.Empty<IMapObstacle>()),
+        CreateValidationMap(new IMapObstacle[] { new AxisAlignedRectangleObstacle(990f, 1010f, -10f, 10f) }),
+        CreateValidationMap(new IMapObstacle[] { new AxisAlignedRectangleObstacle(490f, 510f, -10f, 10f) }));
+    }
+
+    private static PlanningGridMap CreateValidationMap(IReadOnlyList<IMapObstacle> obstacles)
+    {
+        IMapObstacleSource[] sources = obstacles.Count == 0
+            ? Array.Empty<IMapObstacleSource>()
+            : new IMapObstacleSource[] { new ManualObstacleSource("trajectory-validator", 1L, true, obstacles) };
+        PlanningMapBuildResult result = new PlanningMapFactory().Create(new PlanningMapRequest
+        {
+            Bounds = new MapBoundsMm(-1000f, 3000f, -1000f, 1000f),
+            ResolutionMm = 20f,
+            ObstacleSources = sources,
+            AllowExplicitEmptyMap = obstacles.Count == 0,
+        });
+        Verification.True(result.Succeeded && result.Map != null && result.Map.PlanningReady,
+            "trajectory-validator map builds: " + result.FailureReason);
+        return result.Map!;
+    }
+
+    private static EmTrajectory CreateValidationTrajectory(TravelDirection direction)
+    {
+        double[] times = { 0d, 0.05d, 0.10d, 0.15d, 0.20d, 0.25d, 0.30d, 0.35d, 0.40d };
+        double[] pathS = { 0d, 0.0014375d, 0.00271875d, 0.00378125d, 0.0045625d, 0.0050625d, 0.00534375d,
+            0.00546875d, 0.0055d };
+        double[] speed = { 0.03d, 0.0275d, 0.02375d, 0.01875d, 0.0125d, 0.0075d, 0.00375d, 0.00125d, 0d };
+        double[] acceleration = { -0.05d, -0.075d, -0.10d, -0.125d, -0.10d, -0.075d, -0.05d, -0.025d, 0d };
+        double[] jerk = { -0.5d, -0.5d, -0.5d, 0.5d, 0.5d, 0.5d, 0.5d, 0.5d };
+        var candidate = new LongitudinalCandidate(times, pathS, speed, acceleration, jerk);
+        var result = new LongitudinalPlanningResult(EmPlanningStatus.Success, candidate, string.Empty);
+        var path = new LateralPath(new[]
+        {
+            new LateralPathPoint(0d, 0d, 0d, 0d, 0d, 0d, 0d, 0d, 0d, 0d, 0d, 0d),
+            new LateralPathPoint(1d, 0.0055d, 0d, 0d, 0d, 0d, 0.0055d, 0d, 0d, 0d, 0d, 0d),
+        }, true);
+        return new EmTrajectoryAssembler().Assemble(path, result, CreateMetadata(direction, EmTerminalType.Goal));
+    }
+
+    private static EmTrajectory Replace(EmTrajectory trajectory, int index, EmTrajectoryPoint replacement)
+    {
+        var points = new List<EmTrajectoryPoint>(trajectory.Points);
+        points[index] = replacement;
+        return new EmTrajectory(trajectory.Metadata, points);
+    }
+
+    private static EmTrajectory CorruptDouble(EmTrajectory trajectory, int index, string propertyName, double value)
+    {
+        EmTrajectoryPoint replacement = Clone(trajectory.Points[index]);
+        FieldInfo field = typeof(EmTrajectoryPoint).GetField("<" + propertyName + ">k__BackingField",
+            BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new InvalidOperationException("Missing backing field " + propertyName);
+        field.SetValue(replacement, value);
+        return Replace(trajectory, index, replacement);
+    }
+
+    private static EmTrajectoryPoint Clone(EmTrajectoryPoint point, double? x = null, double? timeFromStart = null,
+        double? signedSpeed = null, double? pathS = null, double? vehicleCurvature = null,
+        EmBoundaryType? boundaryType = null)
+    {
+        return new EmTrajectoryPoint(x ?? point.X, point.Y, point.Yaw, signedSpeed ?? point.SignedLongitudinalVelocity,
+            timeFromStart ?? point.TimeFromStart, vehicleCurvature ?? point.VehicleCurvature, point.SegmentIndex,
+            pathS ?? point.SegmentLocalS, pathS ?? point.PathS, point.Direction, boundaryType ?? point.BoundaryType,
+            0d, 0d);
+    }
+
+    private sealed class ValidationContext
+    {
+        public ValidationContext(EmPlannerConfiguration configuration, VehicleParameters vehicle, PlanningGridMap emptyMap,
+            PlanningGridMap poseCollisionMap, PlanningGridMap sweptCollisionMap)
+        {
+            Configuration = configuration;
+            Vehicle = vehicle;
+            EmptyMap = emptyMap;
+            PoseCollisionMap = poseCollisionMap;
+            SweptCollisionMap = sweptCollisionMap;
+        }
+
+        public EmPlannerConfiguration Configuration { get; }
+        public VehicleParameters Vehicle { get; }
+        public PlanningGridMap EmptyMap { get; }
+        public PlanningGridMap PoseCollisionMap { get; }
+        public PlanningGridMap SweptCollisionMap { get; }
+    }
+
     private static void VerifyKinematicFields(EmTrajectory trajectory, TravelDirection direction, string name)
     {
         double directionSign = direction == TravelDirection.Forward ? 1d : -1d;