1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
package rideanalysis
import (
"slices"
"github.com/martinlehoux/biking_home/mountain_pass"
"github.com/martinlehoux/biking_home/official_climb"
"github.com/martinlehoux/biking_home/ride"
)
const (
passMatchRadiusM = 300
passMatchElevationToleranceM = 50
passCrossingRadiusM = 100
passCrossingElevationToleranceM = 25
)
type Result struct {
Climbs []AnalyzedClimb
Crossings []mountain_pass.Crossing
}
type AnalyzedClimb struct {
Segment ride.Climb
Name string
Category string
DistanceM float64
SlopePercent float64
Cotacol float64
OfficialClimbID int64
OfficialName string
}
func Analyze(parsed ride.Ride, passes []mountain_pass.MountainPass, officialClimbs []official_climb.OfficialClimb, matchPolicy official_climb.MatchPolicy) Result {
result := Result{
Climbs: make([]AnalyzedClimb, 0),
Crossings: make([]mountain_pass.Crossing, 0),
}
claimedClimbs := make([]AnalyzedClimb, 0)
claimedRanges := make([]ride.Range, 0)
for _, official := range officialClimbs {
for _, matched := range official_climb.MatchClimbs(parsed.Coords(), official, matchPolicy.EndpointRadiusM) {
claimedRanges = append(claimedRanges, ride.Range{Start: matched.StartIndex, End: matched.EndIndex})
claimedClimbs = append(claimedClimbs, analyzedClimb(parsed, parsed.ClimbFromIndexes(matched.StartIndex, matched.EndIndex), official.Name, official.ID))
}
}
slices.SortFunc(claimedRanges, func(a, b ride.Range) int { return a.Start - b.Start })
for _, detectedClimb := range parsed.DetectClimbs(claimedRanges, ride.ClimbSlopeMinimum) {
displayClimb := detectedClimb
if matchedPass, ok := mountain_pass.MatchClimb(displayClimb, passes, passMatchRadiusM, passMatchElevationToleranceM); ok {
displayClimb.Name = matchedPass.Name
}
result.Climbs = append(result.Climbs, analyzedClimb(parsed, displayClimb, displayClimb.Name, 0))
}
climbs := make([]AnalyzedClimb, 0, len(claimedClimbs)+len(result.Climbs))
climbs = append(climbs, claimedClimbs...)
climbs = append(climbs, result.Climbs...)
slices.SortFunc(climbs, func(a, b AnalyzedClimb) int {
return a.Segment.StartIndex() - b.Segment.StartIndex()
})
result.Climbs = climbs
for _, crossing := range mountain_pass.DetectCrossings(parsed.Coords(), parsed.Distances(), parsed.Elevations(), passes, passCrossingRadiusM, passCrossingElevationToleranceM) {
result.Crossings = append(result.Crossings, crossing)
}
return result
}
func analyzedClimb(parsed ride.Ride, segment ride.Climb, name string, officialID int64) AnalyzedClimb {
cotacol := segment.DifficultyScore()
return AnalyzedClimb{
Segment: segment,
Name: name,
Category: ride.CategoryOf(cotacol).String(),
DistanceM: segment.EndDistanceM() - segment.StartDistanceM(),
SlopePercent: ride.Slope(parsed.Distances(), parsed.Elevations(), segment.StartIndex(), segment.EndIndex()) * 100,
Cotacol: cotacol,
OfficialClimbID: officialID,
OfficialName: officialClimbNameForID(name, officialID),
}
}
func officialClimbNameForID(name string, officialID int64) string {
if officialID == 0 {
return ""
}
return name
}
|
