I have checked that and my sample size has more than 2 data points.
In org.orekit.propagation.covariance.AbstractStateCovarianceInterpolator the interpolate method is defined with
public TimeStampedPair<Orbit, StateCovariance> interpolate(final InterpolationData interpolationData) {
// Interpolate orbit at interpolation date
final Orbit interpolatedOrbit = interpolateOrbit(interpolationData.getInterpolationDate(),
interpolationData.getNeighborList());
So the interpolateOrbit method takes the neighbors of interpolationData as inputs.
In org.orekit.time.AbstractTimeInterpolator the neighbors are defined as
/** Neighbor list around interpolation date. */
private final List<T> neighborList;
And are created like this
if (sample.size() == interpolationPoints) {
// shortcut for simple case
// copy list to make neighborList immutable
this.neighborList = Collections.unmodifiableList(new ArrayList<>(sample));
} else {
// else, select sample.
// Create immutable time stamped cache
final ImmutableTimeStampedCache<T> cachedSamples =
new ImmutableTimeStampedCache<>(interpolationPoints, sample);
// Find neighbors
final AbsoluteDate central = AbstractTimeInterpolator.getCentralDate(
interpolationDate,
cachedSamples,
extrapolationThreshold);
final Stream<T> neighborsStream = cachedSamples.getNeighbors(central);
// Convert to unmodifiable list
this.neighborList = Collections.unmodifiableList(neighborsStream.collect(Collectors.toList()));
}
As both constructor of the StateCovarianceBlender take the default number of interpolation points
public StateCovarianceBlender(final SmoothStepFactory.SmoothStepFunction blendingFunction,
final TimeInterpolator<Orbit> orbitInterpolator,
final LOFType outLOF) {
super(DEFAULT_INTERPOLATION_POINTS, 0., orbitInterpolator, outLOF);
this.blendingFunction = blendingFunction;
}
/**
* Constructor.
*
* @param blendingFunction blending function
* @param orbitInterpolator orbit interpolator
* @param outFrame desired output covariance frame
* @param outPositionAngleType desired output position angle
* @param outOrbitType desired output orbit type
*
* @see Frame
* @see OrbitType
* @see PositionAngleType
*/
public StateCovarianceBlender(final SmoothStepFactory.SmoothStepFunction blendingFunction,
final TimeInterpolator<Orbit> orbitInterpolator,
final Frame outFrame,
final OrbitType outOrbitType,
final PositionAngleType outPositionAngleType) {
super(DEFAULT_INTERPOLATION_POINTS, 0., orbitInterpolator, outFrame, outOrbitType, outPositionAngleType);
this.blendingFunction = blendingFunction;
}
which are set to 2, there will be only 2 data points around the interpolation data available for the interpolation.
! Blending is a concept that is similar yet fundamentally different from interpolation. When i refactored interpolators, i decided to make blending a part of it for simplicity. Consequently, some things do not really make sense such as the “number of interpolation points” which is necessarily two in this case.