ssscoring.mapview

  1# See: https://github.com/pr3d4t0r/SSScoring/blob/master/LICENSE.txt
  2
  3from geopy import distance
  4from ssscoring.calc import jumpRunBearing
  5from ssscoring.constants import SAMPLE_RATE
  6from ssscoring.constants import SCORING_INTERVAL
  7from ssscoring.datatypes import JumpResults
  8from ssscoring.notebook import convertHexColorToRGB
  9
 10import pandas as pd
 11import pydeck as pdk
 12
 13
 14# *** constants ***
 15
 16DISTANCE_FROM_MIDDLE = 400.0
 17"""
 18The distance in meters from the middle of the skydive to the outer bounding box
 19for the initial view of a new rendered map.
 20"""
 21
 22JUMP_RUN_BACK_M = 100.0
 23"""
 24Distance in meters back along the approach (upjump) direction from exit.
 25"""
 26
 27JUMP_RUN_AHEAD_M = 750.0
 28"""
 29Distance in meters ahead along the jump run from exit — long arm so judges
 30can visually check whether the jumper stayed on jump run throughout the dive.
 31"""
 32
 33
 34# *** implementation ***
 35
 36def viewPointBox(data: pd.DataFrame) -> pd.DataFrame:
 37    """
 38    Calculate the NW and SE corners of a "box" delimiting the viewport area
 39    `DISTANCE_FROM_MIDDLE` meters away from the middle of the speed skydive.
 40
 41    Arguments
 42    ---------
 43        data
 44    A SSScoring dataframe with jump data.
 45
 46    Returns
 47    -------
 48    The NW and SE corners of the box, as terrestrial coordinates, in a dataframe
 49    with these columns:
 50
 51    - `latitude`
 52    - `lontigude`
 53
 54    See
 55    ---
 56    `ssscoring.calc.convertFlySight2SSScoring`
 57    """
 58    mid = len(data)//2
 59    datum = data.iloc[mid]
 60    origin = (datum.latitude, datum.longitude)
 61    pointNW = distance.distance(meters=DISTANCE_FROM_MIDDLE).destination(origin, bearing=315)
 62    pointSE = distance.distance(meters=DISTANCE_FROM_MIDDLE).destination(origin, bearing=135)
 63    data = list(zip([ pointNW[0], pointSE[0], ], [ pointNW[1], pointSE[1], ]))
 64    result = pd.DataFrame(data, columns=[ 'latitude', 'longitude', ])
 65    return result
 66
 67
 68def _resolveMaxScoreTimeFrom(jumpResult: JumpResults) -> float:
 69    scoreTime = jumpResult.scores[jumpResult.score]
 70    workData = jumpResult.data.reset_index(drop=True).copy()
 71    ref = workData.index[workData.plotTime == scoreTime][0]+round(SCORING_INTERVAL/SAMPLE_RATE/2.0)-1
 72    return workData.iloc[ref].plotTime
 73
 74
 75def _resolveMaxSpeedTimeFrom(jumpResult: JumpResults) -> float:
 76    rowIndex = jumpResult.data.vKMh.idxmax()
 77    plotTime = jumpResult.data.loc[rowIndex, 'plotTime']
 78    return plotTime
 79
 80
 81def speedJumpTrajectory(jumpResult: JumpResults,
 82                        displayScorePoint: bool=True) -> pdk.Deck:
 83    """
 84    Build the layers for a PyDeck map showing a jumper's trajectory.
 85
 86    Arguments
 87    ---------
 88        jumpResult
 89    A SSScoring `JumpResults` instance with the results of the jump.
 90
 91    Returns
 92    -------
 93    A PyDeck `deck` instance ready for rendering using PyDeck or Streamlit
 94    mapping facilities.
 95
 96    See
 97    ---
 98    `st.pydeck_chart`
 99    `st.map`
100    """
101    if jumpResult.data is not None and jumpResult.score != None and jumpResult.scores != None:
102        workData = jumpResult.data.copy()
103        scoresData = pd.DataFrame(list(jumpResult.scores.items()), columns=[ 'score', 'plotTime', ])
104        workData = pd.merge(workData, scoresData, on='plotTime', how='left')
105        workData.vKMh = workData.vKMh.apply(lambda x: round(x, 2))
106        workData.speedAngle = workData.speedAngle.apply(lambda x: round(x, 2))
107        if displayScorePoint:
108            maxValueTime = _resolveMaxScoreTimeFrom(jumpResult)
109            maxColorOuter = [ 0, 255, 0, ]
110            maxCollorDot = [ 0, 128, 0, ]
111        else:
112            maxValueTime = _resolveMaxSpeedTimeFrom(jumpResult)
113            maxColorOuter = [ 255, 0, 0, 255, ]  # red
114            maxCollorDot = [ 255, 255, 0, 255, ]  # yellow
115        bearing = jumpRunBearing(jumpResult.data)
116        exitRow = workData.iloc[0]
117        exitPoint = (exitRow.latitude, exitRow.longitude)
118        backPoint = distance.distance(meters=JUMP_RUN_BACK_M).destination(exitPoint, bearing=(bearing+180)%360)
119        aheadPoint = distance.distance(meters=JUMP_RUN_AHEAD_M).destination(exitPoint, bearing=bearing)
120        jumpRunPath = pd.DataFrame({
121            'path': [[[backPoint[1], backPoint[0]], [exitRow.longitude, exitRow.latitude], [aheadPoint[1], aheadPoint[0]]]],
122            'color': [[200, 200, 200, 180]],
123        })
124        layers = [
125            pdk.Layer(
126                'PathLayer',
127                data=jumpRunPath,
128                get_path='path',
129                get_color='color',
130                width_min_pixels=2,
131            ),
132            pdk.Layer(
133                'ScatterplotLayer',
134                data=workData.head(1),
135                get_color=[ 255, 126, 0, 255 ],
136                get_position=[ 'longitude', 'latitude', ],
137                get_radius=8),
138            pdk.Layer(
139                'ScatterplotLayer',
140                data=workData.tail(1),
141                get_color=[ 0, 192, 0, 160 ],
142                get_position=[ 'longitude', 'latitude', ],
143                get_radius=8),
144            pdk.Layer(
145                'ScatterplotLayer',
146                data=workData[workData.plotTime == maxValueTime],
147                get_color=maxColorOuter,
148                get_position=[ 'longitude', 'latitude', ],
149                get_radius=12),
150            pdk.Layer(
151                'ScatterplotLayer',
152                data=workData,
153                get_color=[ 0x64, 0x95, 0xed, 255 ],
154                get_position=[ 'longitude', 'latitude', ],
155                get_radius=2,
156                pickable=True),
157            pdk.Layer(
158                'ScatterplotLayer',
159                data=workData[workData.plotTime == maxValueTime],
160                get_color=maxCollorDot,
161                get_position=[ 'longitude', 'latitude', ],
162                get_radius=4),
163        ]
164        viewBox = viewPointBox(workData)
165        tooltip = {
166            # TODO:  Figure out how to plot the score @ plotTime here.
167            # 'html': '<b>plotTime:</b> {plotTime} s<br><b>Score:</b> {score} km/h<br><b>Speed:</b> {vKMh} km/h<br><b>speedAngle:</b> {speedAngle}º',
168            'html': '<b>plotTime:</b> {plotTime} s<br><b>Speed:</b> {vKMh} km/h<br><b>speedAngle:</b> {speedAngle}º',
169            'style': {
170                'backgroundColor': 'steelblue',
171                'color': 'white',
172            },
173            'cursor': 'default',
174        }
175        deck = pdk.Deck(
176            map_style = 'road',
177            layers=layers,
178            initial_view_state=pdk.data_utils.compute_view(viewBox[['longitude', 'latitude',]]),
179            tooltip=tooltip,
180        )
181        return deck
182
183
184def multipleSpeedJumpsTrajectories(jumpResults, tagColors: dict):
185    """
186    Build all the layers for a PyDeck map showing the trajectories of every jump
187    in the results set.
188
189    Arguments
190    ---------
191        jumpResults
192    A dictionary of all the jump results after processing.
193
194        tagColors
195    A tag→hex-color mapping produced by `resolveJumpColors`; fastest jump is
196    green, slowest red, others in blue shades.
197
198    Returns
199    -------
200    A PyDeck `deck` instance ready for rendering using PyDeck or Streamlit
201    mapping facilities.
202
203    See
204    ---
205    `st.pydeck_chart`
206    `st.map`
207    """
208    mapLayers = list()
209    resultTags = sorted(list(jumpResults.keys()), reverse=True)
210    for tag in resultTags:
211        result = jumpResults[tag]
212        if result.scores != None:
213            workData = result.data.copy()
214            exitPointData = workData.head(1)
215            exitPointData['label'] = tag
216            maxScoreTime = _resolveMaxScoreTimeFrom(result)
217            trackColor = convertHexColorToRGB(tagColors[tag])
218            layers = [
219                pdk.Layer(
220                    'ScatterplotLayer',
221                    data=exitPointData,
222                    get_color=[ 255, 126, 0, 255 ],
223                    get_position=[ 'longitude', 'latitude', ],
224                    pickable=True,
225                    get_radius=8),
226                pdk.Layer(
227                    'TextLayer',
228                    data=exitPointData,
229                    get_position=[ 'longitude', 'latitude', ],
230                    get_text='label',
231                    get_color=trackColor+[255],
232                    get_background_color=[ 0, 0, 0, 255, ],
233                    background=True,
234                    get_size=12,
235                ),
236                pdk.Layer(
237                    'ScatterplotLayer',
238                    data=workData.tail(1),
239                    get_color=[ 0, 192, 0, 160 ],
240                    get_position=[ 'longitude', 'latitude', ],
241                    get_radius=8),
242                pdk.Layer(
243                    'ScatterplotLayer',
244                    data=workData[workData.plotTime == maxScoreTime],
245                    get_color=[ 0, 255, 0, ],
246                    get_position=[ 'longitude', 'latitude', ],
247                    get_radius=12),
248                pdk.Layer(
249                    'ScatterplotLayer',
250                    data=workData,
251                    get_color=trackColor,
252                    get_position=[ 'longitude', 'latitude', ],
253                    get_radius=2),
254                pdk.Layer(
255                    'ScatterplotLayer',
256                    data=workData[workData.plotTime == maxScoreTime],
257                    get_color=[ 0, 128, 0, ],
258                    get_position=[ 'longitude', 'latitude', ],
259                    get_radius=4),
260            ]
261            mapLayers += layers
262    viewBox = viewPointBox(workData)
263    deck = pdk.Deck(
264        map_style = 'road',
265        initial_view_state=pdk.data_utils.compute_view(viewBox[['longitude', 'latitude',]]),
266        layers=mapLayers,
267    )
268    return deck