Fix issue with bad stop time interpolations when missing shape_dist_t… (#435)

Fix issue with bad stop time interpolations when missing shape_dist_traveled

Author: irees

internal/geomcache/geomcache.go

@@ -12,6 +12,9 @@ func arePositionsSorted(a []float64) bool {
 	if len(a) < 2 {
 		return true
 	}
+	if a[0] == a[len(a)-1] {
+		return false
+	}
 	for i := 1; i < len(a); i++ {
 		if a[i] < a[i-1] {
 			return false
@@ -22,24 +25,27 @@ func arePositionsSorted(a []float64) bool {
 
 type ShapeInfo struct {
 	Line       []tlxy.Point
-	Dists      []float64
 	DistLength float64
-	Length     float64
+}
+
+type stopPositionInfo struct {
+	Positions  []float64
+	DistLength float64
 }
 
 // GeomCache helps speed up StopTime interpolating by caching various results
 type GeomCache struct {
-	stopPositions map[string][]float64
 	stops         map[string]tlxy.Point
 	shapes        map[string]ShapeInfo
+	stopPositions map[string]stopPositionInfo
 }
 
 // NewGeomCache returns an initialized geomCache
 func NewGeomCache() *GeomCache {
 	return &GeomCache{
-		stopPositions: map[string][]float64{},
 		stops:         map[string]tlxy.Point{},
 		shapes:        map[string]ShapeInfo{},
+		stopPositions: map[string]stopPositionInfo{},
 	}
 }
 
@@ -63,31 +69,16 @@ func (g *GeomCache) GetShapeInfo(eid string) ShapeInfo {
 }
 
 func (g *GeomCache) AddShapeGeom(eid string, line []tlxy.Point, dists []float64) {
-	// Check if already exists, re-use slice to reduce mem
-	for _, s := range g.shapes {
-		if tlxy.LineEquals(line, s.Line) {
-			line = s.Line
-			dists = s.Dists
-		}
-	}
 	// Create shapeInfo
-	si := ShapeInfo{
-		Line:   line,
-		Length: tlxy.LengthHaversine(line),
-	}
+	si := ShapeInfo{Line: line}
 	// Validate ShapeDistTraveled values
 	if len(dists) > 0 && len(dists) == len(line) && dists[len(dists)-1]-dists[0] > 0 {
-		// Use supplied ShapeDistTraveled values
-		si.Dists = dists
-		si.DistLength = dists[len(dists)-1]
-	} else {
-		// Calculate our own ShapeDistTraveled values
-		si.Dists = make([]float64, len(line))
-		for i := 1; i < len(line); i++ {
-			si.Dists[i] = si.Dists[i-1] + tlxy.DistanceHaversine(line[i-1], line[i])
-		}
 		si.DistLength = dists[len(dists)-1]
 	}
+	// If we don't have ShapeDistTraveled values, calculate them
+	if si.DistLength == 0 {
+		si.DistLength = tlxy.LengthHaversine(line)
+	}
 	g.shapes[eid] = si
 }
 
@@ -145,11 +136,10 @@ func (g *GeomCache) InterpolateStopTimes(trip *gtfs.Trip) ([]gtfs.StopTime, erro
 // TODO: move to somewhere else
 func (g *GeomCache) setStopTimeDists(shapeId string, patternId int64, sts []gtfs.StopTime) error {
 	// Check cache
-	length := 0.0
 	stopPositionsKey := fmt.Sprintf("%s-%d", shapeId, patternId)
-	stopPositions, ok := g.stopPositions[stopPositionsKey]
+	stopPositionInfo, ok := g.stopPositions[stopPositionsKey]
 	if !ok {
-		// Generate the stop-to-stop geometry as fallback
+		// Generate the stop-to-stop geometry
 		stopLine := make([]tlxy.Point, len(sts))
 		for i := 0; i < len(sts); i++ {
 			point, ok := g.stops[sts[i].StopID.Val]
@@ -159,34 +149,43 @@ func (g *GeomCache) setStopTimeDists(shapeId string, patternId int64, sts []gtfs
 			stopLine[i] = point
 		}
 
+		// Get the known shape line and known shape distance
+		var shapeLength float64
 		var shapeLine []tlxy.Point
 		if si, ok := g.shapes[shapeId]; ok {
 			shapeLine = si.Line
-			length = si.DistLength
+			shapeLength = si.DistLength
 		} else {
 			shapeLine = stopLine
-			length = tlxy.LengthHaversine(stopLine)
+			shapeLength = tlxy.LengthHaversine(stopLine)
 		}
 
 		// Calculate positions
-		stopPositions = tlxy.LineRelativePositions(shapeLine, stopLine)
+		stopPositions := tlxy.LineRelativePositions(shapeLine, stopLine)
 
-		// Check for simple or fallback positions
-		if !arePositionsSorted(stopPositions) || len(stopLine) == 0 {
+		// Check if the positions are sorted
+		if !arePositionsSorted(stopPositions) {
 			// log.For(ctx).Debug().Msgf("positions %f not increasing, falling back to stop positions; shapeline %f stopLine %f", positions, shapeline, stopLine)
 			stopPositions = tlxy.LineRelativePositionsFallback(stopLine)
-			if !arePositionsSorted(stopPositions) {
-				return errors.New("fallback positions not sorted")
-			}
 		}
-		g.stopPositions[stopPositionsKey] = stopPositions
+
+		// Check again
+		if !arePositionsSorted(stopPositions) {
+			return errors.New("fallback positions not sorted")
+		}
+
+		stopPositionInfo.Positions = stopPositions
+		stopPositionInfo.DistLength = shapeLength
+		g.stopPositions[stopPositionsKey] = stopPositionInfo
 	}
-	if len(sts) != len(stopPositions) {
+
+	if len(sts) != len(stopPositionInfo.Positions) {
 		return errors.New("unequal stoptimes and positions")
 	}
+
 	// Set ShapeDistTraveled values
 	for i := 0; i < len(sts); i++ {
-		sts[i].ShapeDistTraveled.Set(stopPositions[i] * length)
+		sts[i].ShapeDistTraveled.Set(stopPositionInfo.Positions[i] * stopPositionInfo.DistLength)
 	}
 	return nil
 }