public static NullStates getNullState(Context context) {
final VehicleState state = context.getState();
// final Observation obs = context.getObservation();
final BlockStateObservation blockStateObs = state.getBlockStateObservation();
EVehiclePhase phase = state.getJourneyState().getPhase();
if (blockStateObs == null) {
return NullStates.NULL_STATE;
} else {
final boolean hasScheduledTime =
FastMath.abs(state.getBlockStateObservation().getScheduleDeviation()) > 0d;
if (!hasScheduledTime) {
return NullStates.NULL_STATE;
}
if (!state.getBlockStateObservation().isSnapped()
&& ((EVehiclePhase.DEADHEAD_AFTER == phase
&& state.getBlockStateObservation().getScheduleDeviation() == 0d)
|| EVehiclePhase.AT_BASE == phase
|| (EVehiclePhase.DEADHEAD_BEFORE == phase
&& state.getBlockStateObservation().getScheduleDeviation() == 0d)
|| (EVehiclePhase.LAYOVER_BEFORE == phase)
&& state.getBlockStateObservation().getScheduleDeviation() == 0d)) {
return NullStates.NULL_STATE;
}
return NullStates.NON_NULL_STATE;
}
}
@Override
public SensorModelResult likelihood(SensorModelSupportLibrary library, Context context) {
VehicleState parentState = context.getParentState();
VehicleState state = context.getState();
Observation obs = context.getObservation();
JourneyState js = state.getJourneyState();
EVehiclePhase phase = js.getPhase();
BlockState blockState = state.getBlockState();
/** These probabilities only apply if are IN_PROGRESS and have a block state */
if (phase != EVehiclePhase.IN_PROGRESS || blockState == null)
return new SensorModelResult("pInProgress (n/a)");
SensorModelResult result = new SensorModelResult("pInProgress");
/** Rule: IN_PROGRESS => block location is close to gps location */
double pBlockLocation = library.computeBlockLocationProbability(parentState, blockState, obs);
result.addResultAsAnd("pBlockLocation", pBlockLocation);
return result;
}
public DSC_STATE getDscState(final Context context) {
final VehicleState state = context.getState();
final Observation obs = context.getObservation();
final JourneyState js = state.getJourneyState();
EVehiclePhase phase = js.getPhase();
final String observedDsc = obs.getLastValidDestinationSignCode();
if (observedDsc == null || !obs.hasValidDsc() || obs.hasOutOfServiceDsc()) {
/** If we haven't yet seen a valid DSC, or it's out of service */
if (!obs.hasValidDsc()) {
return DSC_STATE.DSC_NOT_VALID;
} else if (EVehiclePhase.IN_PROGRESS == phase && obs.hasOutOfServiceDsc()) {
return DSC_STATE.DSC_OOS_IP;
} else {
return DSC_STATE.DSC_OOS_NOT_IP;
}
} else {
final BlockState bs = state.getBlockState();
if (bs == null) {
return DSC_STATE.DSC_IS_NO_BLOCK;
} else {
final Set<String> dscs = Sets.newHashSet();
dscs.add(bs.getDestinationSignCode());
final Set<AgencyAndId> routes = Sets.newHashSet();
routes.add(bs.getBlockLocation().getActiveTrip().getTrip().getRouteCollection().getId());
/*
* dsc changes occur between parts of a block, so account for that
*/
if (EVehiclePhase.LAYOVER_DURING == phase || EVehiclePhase.DEADHEAD_DURING == phase) {
final BlockTripEntry nextTrip = bs.getBlockLocation().getActiveTrip().getNextTrip();
if (nextTrip != null) {
final String dsc =
_destinationSignCodeService.getDestinationSignCodeForTripId(
nextTrip.getTrip().getId());
if (dsc != null) dscs.add(dsc);
routes.add(nextTrip.getTrip().getRouteCollection().getId());
}
}
/*
* Check if it's active, since deadhead-after/before's
* can/should have o.o.s. dsc's, although they often don't.
* TODO perhaps check the last non-o.o.s. dsc to give
* higher weight to deadhead-after's that match (when
* we have good run-info, perhaps).
*/
if (!EVehiclePhase.isActiveAfterBlock(phase)
&& !EVehiclePhase.isActiveBeforeBlock(phase)
&& dscs.contains(observedDsc)) {
if (EVehiclePhase.IN_PROGRESS == phase) return DSC_STATE.DSC_MATCH;
else return DSC_STATE.DSC_DEADHEAD_MATCH;
} else {
/*
* a dsc implies a route. even though the reported dsc may not match,
* we expect the general route to be the same...
*/
boolean routeMatch = false;
for (final AgencyAndId dscRoute : obs.getDscImpliedRouteCollections()) {
if (routes.contains(dscRoute)) {
routeMatch = true;
break;
}
}
if (routeMatch) return DSC_STATE.DSC_ROUTE_MATCH;
else return DSC_STATE.DSC_NO_ROUTE_MATCH;
}
}
}
}
public static boolean isAtPotentialLayoverSpot(VehicleState state, Observation obs) {
return isAtPotentialLayoverSpot(state.getBlockState(), obs);
}
@Override
public SensorModelResult likelihood(Context context)
throws BadProbabilityParticleFilterException {
final VehicleState state = context.getState();
final VehicleState parentState = context.getParentState();
final Observation obs = context.getObservation();
final EVehiclePhase phase = state.getJourneyState().getPhase();
final BlockStateObservation blockStateObs = state.getBlockStateObservation();
// /*-
// * TODO clean up this hack
// * We are really in-progress, but because of the
// * out-of-service headsign, we can't report it as in-progress
// */
// if (obs.hasOutOfServiceDsc() && EVehiclePhase.DEADHEAD_DURING == phase
// && (blockStateObs != null && blockStateObs.isOnTrip()))
// phase = EVehiclePhase.IN_PROGRESS;
final SensorModelResult result = new SensorModelResult("pEdge", 1d);
if (obs.getPreviousObservation() == null || parentState == null) {
if (EVehiclePhase.isActiveDuringBlock(phase)) {
result.addResultAsAnd("no prev. obs./vehicle-state(in-progress)", 1d);
} else {
result.addResultAsAnd("no prev. obs./vehicle-state", 1d);
}
return result;
}
if (obs.isAtBase()) {
result.addResultAsAnd("pNotInProgress(base)", 1d);
return result;
}
if (blockStateObs == null) {
result.addResultAsAnd(computeNoEdgeMovementLogProb(state, obs));
return result;
}
/*
* Edge Movement
*/
final boolean previouslyInactive = parentState.getBlockState() == null;
final boolean newRun =
MotionModelImpl.hasRunChanged(
parentState.getBlockStateObservation(), state.getBlockStateObservation());
final boolean hasMoved = !state.getMotionState().hasVehicleNotMoved();
if (!previouslyInactive && !newRun) {
/*
* This could be a transition from being on a trip geom to off, and vice
* versa.
*/
if (EVehiclePhase.IN_PROGRESS != phase) {
/*
* We're currently not in-progress
*/
if (EVehiclePhase.isActiveDuringBlock(phase)) {
if (state
.getBlockState()
.getBlockInstance()
.equals(parentState.getBlockState().getBlockInstance())) {
result.addResultAsAnd(
computeEdgeMovementLogProb(obs, state, parentState, hasMoved, true));
} else {
result.addResultAsAnd(computeNoEdgeMovementLogProb(state, parentState, obs));
}
} else {
result.addResultAsAnd(computeNoEdgeMovementLogProb(state, obs));
}
} else if (EVehiclePhase.IN_PROGRESS != parentState.getJourneyState().getPhase()) {
/*
* We were previously not in-progress, and now we are.
*/
if (EVehiclePhase.isActiveDuringBlock(parentState.getJourneyState().getPhase())) {
result.addResultAsAnd(
computeEdgeMovementLogProb(obs, state, parentState, hasMoved, true));
} else {
result.addResultAsAnd(computeNoEdgeMovementLogProb(state, parentState, obs));
}
} else {
/*
* We're in-progress and were before.
*/
result.addResultAsAnd(computeEdgeMovementLogProb(obs, state, parentState, hasMoved, false));
}
} else {
/*
* We have a new run, or just got one after having nothing.
*/
if (EVehiclePhase.IN_PROGRESS == phase) {
if (EVehiclePhase.isActiveDuringBlock(parentState.getJourneyState().getPhase())) {
result.addResultAsAnd(
computeEdgeMovementLogProb(obs, state, parentState, hasMoved, false));
} else {
result.addResultAsAnd(computeNoEdgeMovementLogProb(state, parentState, obs));
}
} else {
result.addResultAsAnd(computeNoEdgeMovementLogProb(state, obs));
}
}
return result;
}
private static final SensorModelResult computeEdgeMovementLogProb(
Observation obs,
VehicleState state,
VehicleState parentState,
boolean hasMoved,
boolean isDuring)
throws BadProbabilityParticleFilterException {
final BlockState blockState = state.getBlockState();
final BlockState parentBlockState = parentState.getBlockState();
final double currentDab;
final double prevDab;
if (!blockState.getBlockInstance().equals(parentBlockState.getBlockInstance())) {
/*
* Note: this isn't really working like we want it to, since there are
* separate shapes that share the same segments of geometry.
*/
if (!Objects.equal(
parentBlockState.getBlockLocation().getActiveTrip().getTrip().getShapeId(),
blockState.getBlockLocation().getActiveTrip().getTrip().getShapeId())) {
return computeNoEdgeMovementLogProb(state, parentState, obs);
}
currentDab =
blockState.getBlockLocation().getDistanceAlongBlock()
- blockState.getBlockLocation().getActiveTrip().getDistanceAlongBlock();
prevDab =
parentBlockState.getBlockLocation().getDistanceAlongBlock()
- parentBlockState.getBlockLocation().getActiveTrip().getDistanceAlongBlock();
} else {
currentDab = blockState.getBlockLocation().getDistanceAlongBlock();
prevDab = parentBlockState.getBlockLocation().getDistanceAlongBlock();
}
final SensorModelResult result = new SensorModelResult("edge-move");
final double dabDelta = currentDab - prevDab;
if (ParticleFilter.getDebugEnabled()) result.addResult("dist: " + dabDelta, 0d);
final double obsTimeDelta = (obs.getTime() - obs.getPreviousObservation().getTime()) / 1000d;
final double expAvgDist;
if (hasMoved) {
if (!isDuring || blockState.getBlockLocation().getNextStop() == null) {
expAvgDist = getAvgVelocityBetweenStops(blockState) * obsTimeDelta;
} else {
expAvgDist = getAvgVelocityToNextStop(obs, blockState) * obsTimeDelta;
}
} else {
expAvgDist = 0d;
}
if (ParticleFilter.getDebugEnabled()) result.addResult("expAvgDist: " + expAvgDist, 0d);
final double x = dabDelta - expAvgDist;
/*
* Now, we need to measure the state transition likelihood
* wrt. heading.
* For the in-progress -> in-progress transition, we need
* to calculate the expected turn-rate/orientation between the two states.
*/
double obsOrientation = Math.toRadians(obs.getOrientation());
if (Double.isNaN(obsOrientation)) {
obsOrientation = Math.toRadians(blockState.getBlockLocation().getOrientation());
}
if (ParticleFilter.getDebugEnabled()) result.addResult("obsOrient:" + obsOrientation, 0d);
final double orientDiff;
final double logpOrient;
if (hasMoved) {
if (!isDuring || blockState.getBlockLocation().getNextStop() == null) {
/*
* TODO
* We could use a polar velocity model and the turn rate...
*/
final double prevOrientation =
Math.toRadians(parentBlockState.getBlockLocation().getOrientation());
final double currentOrientation =
Math.toRadians(blockState.getBlockLocation().getOrientation());
final double angleDiff = Angle.diff(prevOrientation, currentOrientation);
final double avgExpOrientation =
Angle.normalizePositive(
prevOrientation
+ (Angle.getTurn(prevOrientation, currentOrientation) == Angle.CLOCKWISE
? -1d
: 1d)
* angleDiff
/ 2d);
orientDiff = Angle.diff(obsOrientation, avgExpOrientation);
if (ParticleFilter.getDebugEnabled())
result.addResult("expOrient: " + avgExpOrientation, 0d);
logpOrient = _inProgressProb * logVonMisesPdf(orientDiff, _inProgressConcParam);
} else {
/*
* The orientation is wrt. the next stop destination, i.e.
* we want to check that we're heading toward it.
*/
double pathOrDestOrientation =
Math.toRadians(
SphericalGeometryLibrary.getOrientation(
obs.getLocation().getLat(),
obs.getLocation().getLon(),
blockState
.getBlockLocation()
.getNextStop()
.getStopTime()
.getStop()
.getStopLocation()
.getLat(),
blockState
.getBlockLocation()
.getNextStop()
.getStopTime()
.getStop()
.getStopLocation()
.getLon()));
if (Double.isNaN(pathOrDestOrientation)) {
pathOrDestOrientation = obsOrientation;
}
orientDiff = Angle.diff(obsOrientation, pathOrDestOrientation);
if (ParticleFilter.getDebugEnabled())
result.addResult("expOrient: " + pathOrDestOrientation, 0d);
logpOrient = _inProgressProb * logVonMisesPdf(orientDiff, _deadheadEntranceConcParam);
}
} else {
// /*
// * What if we're switching trips while in the middle of doing one?
// * We assume that it's unlikely to do a complete 180 when we're
// * stopped.
// */
// if (parentState.getJourneyState().getPhase() == EVehiclePhase.IN_PROGRESS
// && state.getJourneyState().getPhase() == EVehiclePhase.IN_PROGRESS) {
// orientDiff = Math.toRadians(blockState.getBlockLocation().getOrientation()
// - parentBlockState.getBlockLocation().getOrientation());
// } else {
orientDiff =
Angle.diff(
obsOrientation, Math.toRadians(blockState.getBlockLocation().getOrientation()));
// }
if (ParticleFilter.getDebugEnabled())
result.addResult("orientDiff (stopped):" + orientDiff, 0d);
logpOrient = _inProgressProb * logVonMisesPdf(orientDiff, _stoppedConcParam);
}
final double logpMove =
UnivariateGaussian.PDF.logEvaluate(x, 0d, Math.pow(obsTimeDelta, 4) / 4d) + logpOrient;
result.addLogResultAsAnd("lik", logpMove);
return result;
}
private static final SensorModelResult computeNoEdgeMovementLogProb(
VehicleState state, VehicleState prevState, Observation obs)
throws BadProbabilityParticleFilterException {
final SensorModelResult result = new SensorModelResult("no-edge");
final Observation prevObs = obs.getPreviousObservation();
final double obsDistDelta = obs.getDistanceMoved();
if (ParticleFilter.getDebugEnabled()) result.addResult("dist: " + obsDistDelta, 0d);
final double expAvgDist;
final double logpDistAlong;
if (prevObs != null) {
/*
* Trying to get away with not using a real tracking filter.
* FIXME really lame. use a Kalman filter.
*/
final double obsTimeDelta = obs.getTimeDelta();
if (prevObs.getTimeDelta() != null) {
final double prevObsDistDelta = prevObs.getDistanceMoved();
final double prevObsTimeDelta = prevObs.getTimeDelta();
final double velocityEstimate = prevObsDistDelta / prevObsTimeDelta;
expAvgDist =
state.getMotionState().hasVehicleNotMoved() ? 0d : velocityEstimate * obsTimeDelta;
} else {
expAvgDist = state.getMotionState().hasVehicleNotMoved() ? 0d : _avgVelocity * obsTimeDelta;
}
if (ParticleFilter.getDebugEnabled()) result.addResult("expAvgDist: " + expAvgDist, 0d);
/*
* TODO: Is this needed?
*/
final boolean prevInProgress;
double prevOrientation;
if (prevState != null
&& prevState.getBlockState() != null
&& prevState.getJourneyState().getPhase() == EVehiclePhase.IN_PROGRESS) {
prevOrientation = prevState.getBlockState().getBlockLocation().getOrientation();
prevInProgress = true;
if (ParticleFilter.getDebugEnabled())
result.addResult("prevOrient (state): " + prevOrientation, 0d);
} else {
prevOrientation = prevObs.getOrientation();
prevInProgress = false;
if (ParticleFilter.getDebugEnabled())
result.addResult("prevOrient: " + prevOrientation, 0d);
}
final boolean isOff;
final double currentOrientation;
if (state.getBlockState() != null
&& state.getJourneyState().getPhase() == EVehiclePhase.IN_PROGRESS) {
/*
* We're entering an edge in progress, so we want to compare the
* entrance orientation to the direction of the edge
*/
isOff = false;
currentOrientation = state.getBlockState().getBlockLocation().getOrientation();
/*
* We don't want to use the obs orientation when we're considered stopped
* since gps error can reverse the orientation, making reverse
* trip transitions look reasonable.
* Similarly, if we were on a trip, use that orientation.
* TODO FIXME: we should have the orientation in the motion state, then
* we wouldn't need to evaluate this logic here.
*/
if (!state.getMotionState().hasVehicleNotMoved()) {
if (!prevInProgress) {
prevOrientation = obs.getOrientation();
}
if (ParticleFilter.getDebugEnabled())
result.addResult("new prevOrient (state): " + prevOrientation, 0d);
}
} else {
isOff = true;
currentOrientation = obs.getOrientation();
}
if (ParticleFilter.getDebugEnabled())
result.addResult("curOrient: " + currentOrientation, 0d);
final double orientDiff;
if (Double.isNaN(prevOrientation) || Double.isNaN(currentOrientation)) {
orientDiff = 0d;
} else {
orientDiff =
Angle.diff(Math.toRadians(prevOrientation), Math.toRadians(currentOrientation));
}
logpDistAlong =
UnivariateGaussian.PDF.logEvaluate(
obsDistDelta, expAvgDist, Math.pow(obsTimeDelta, 4) / 4d)
+ (isOff
? _deadheadOffProb * logVonMisesPdf(orientDiff, _deadheadConcParam)
: _inProgressProb * logVonMisesPdf(orientDiff, _deadheadEntranceConcParam));
} else {
/*
* No movement
*/
logpDistAlong = 1d;
}
result.addLogResultAsAnd("lik", logpDistAlong);
return result;
}
public RUN_TRANSITION_STATE getRunTransitionState(Context context) {
final VehicleState state = context.getState();
final VehicleState parentState = context.getParentState();
final Observation obs = context.getObservation();
final Observation prevObs = obs.getPreviousObservation();
final BlockStateObservation blockStateObs = state.getBlockStateObservation();
if (parentState != null
&& prevObs != null
&& MotionModelImpl.hasRunChanged(
parentState.getBlockStateObservation(), state.getBlockStateObservation())) {
if (!Objects.equal(obs.getRecord().getRunId(), prevObs.getRecord().getRunId())
|| !Objects.equal(obs.getRecord().getOperatorId(), prevObs.getRecord().getOperatorId())) {
return RUN_TRANSITION_STATE.RUN_CHANGE_INFO_DIFF;
} else {
EVehiclePhase parentPhase = parentState.getJourneyState().getPhase();
/*
* TODO clean up this hack We are really in-progress, but because of the
* out-of-service headsign, we can't report it as in-progress
*/
if (context.getObservation().hasOutOfServiceDsc()
&& EVehiclePhase.DEADHEAD_DURING == parentPhase
&& (blockStateObs != null && blockStateObs.isOnTrip()))
parentPhase = EVehiclePhase.IN_PROGRESS;
if (EVehiclePhase.isLayover(parentPhase)
|| EVehiclePhase.DEADHEAD_AFTER == parentPhase
|| EVehiclePhase.DEADHEAD_BEFORE == parentPhase
|| EVehiclePhase.DEADHEAD_DURING == parentPhase) {
if (parentState.getBlockStateObservation() != null
&& !parentState.getBlockStateObservation().isRunFormal()
&& state.getJourneyState().getPhase() == EVehiclePhase.IN_PROGRESS)
return RUN_TRANSITION_STATE.RUN_CHANGE_FROM_OOS_NORUN_TO_IN;
else if (state.getJourneyState().getPhase() == EVehiclePhase.IN_PROGRESS)
return RUN_TRANSITION_STATE.RUN_CHANGE_FROM_OOS_TO_IN;
else return RUN_TRANSITION_STATE.RUN_CHANGE_FROM_OOS_TO_OSS;
} else {
return RUN_TRANSITION_STATE.RUN_CHANGE_FROM_IS;
}
}
} else {
if (blockStateObs == null
&& parentState != null
&& parentState.getBlockStateObservation() == null)
return RUN_TRANSITION_STATE.RUN_CHANGE_FROM_OOS_TO_OSS;
else return RUN_TRANSITION_STATE.RUN_NOT_CHANGED;
}
}