flightplotting 0.2.12__tar.gz → 0.2.14__tar.gz

{flightplotting-0.2.12 → flightplotting-0.2.14}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: flightplotting
-Version: 0.2.12
+Version: 0.2.14
 Summary: Add your description here
 Author-email: Thomas David <thomasdavid0@gmail.com>
+License-File: COPYING
 Requires-Python: >=3.12
-Requires-Dist: flightanalysis>=0.3.14
+Requires-Dist: flightdata>=0.3.5
 Requires-Dist: numpy>=2.1.3
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: plotly>=5.24.1

{flightplotting-0.2.12 → flightplotting-0.2.14}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "flightplotting"
-version="v0.2.12"
+version="v0.2.14"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Thomas David", email = "thomasdavid0@gmail.com" }]
 requires-python = ">=3.12"
 dependencies = [
-    "flightanalysis>=0.3.14",
     "numpy>=2.1.3",
     "pandas>=2.2.3",
     "plotly>=5.24.1",
+    "flightdata>=0.3.5",
 ]
 
 [build-system]

{flightplotting-0.2.12 → flightplotting-0.2.14}/src/plotting/__init__.py

@@ -4,6 +4,7 @@ from plotting.plots import (
     plotdtw,
     create_3d_plot,
     plot_regions,
+    resize_3d_fig
 )
 from plotting.traces import (
     axestrace,

{flightplotting-0.2.12 → flightplotting-0.2.14}/src/plotting/plots.py

@@ -1,3 +1,4 @@
+import re
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import plotly.express as px
@@ -15,16 +16,18 @@ from plotting.traces import (
 )
 
 from flightdata import State
-from flightdata.base.labeling import get_appended_id
-from geometry import Coord
+import geometry as g
 from plotting.model import obj
 import numpy.typing as npt
 import numpy as np
 import pandas as pd
-from typing import List, Union
-from flightanalysis.scoring.box import Box
+from typing import List, Union, Callable, Literal
 
 
+
+def get_colour(i):
+    return px.colors.qualitative.Plotly[i % len(px.colors.qualitative.Plotly)]
+
 def plotsec(
     secs: State | list[State] | dict[str, State],
     scale=5,
@@ -37,7 +40,10 @@ def plotsec(
     show_axes=False,
     ribb: bool = False,
     tips: bool = True,
+    ribbonhover="t",    
     origin=False,
+    line=None,
+    modelscale=1,
 ):
     traces = []
     keys = None
@@ -51,22 +57,32 @@ def plotsec(
     else:
         keys = list(range(len(secs)))
         showkeys = False
+    
+    def _get_colour(i):
+        if isinstance(color, list):
+            return color[i % len(color)]
+        elif isinstance(color, str):
+            return color
+        else:
+            return get_colour(i)
 
     for i, sec in enumerate(secs):
-        text = sec.data.t #- sec.data.t.iloc[0]
-        _color = color if color is not None else px.colors.qualitative.Plotly[i]
+        text = sec.data.t  # - sec.data.t.iloc[0]
+        
         if ribb:
-            traces += ribbon(sec, scale * 1.85, _color, name=keys[i])
+            traces += ribbon(sec, 0.5 * scale * 1.85, _get_colour(i), name=keys[i], opacity=0.5, hover=ribbonhover)
         if tips:
-            traces += tiptrace(sec, scale * 1.85, text=text, name=keys[i])
+            traces += tiptrace(sec, scale * 1.85, text=text, name=keys[i], line=({} if line is None else line))
         if nmodels > 0:
-            traces += meshes(nmodels, sec, _color, scale)
+            traces += meshes(nmodels, sec, _get_colour(i), scale * modelscale)
         if cg:
-            traces.append(cgtrace(sec, line=dict(color=_color, width=2), name=keys[i], text=text))
+            traces.append(
+                cgtrace(sec, line=dict(color=_get_colour(i), width=2) | ({} if line is None else line), name=keys[i], text=text)
+            )
 
     if origin:
-        traces += axestrace(Coord.zero(), 50)
-
+        traces += axestrace(g.Coord.zero(), 50)
+    
     if showkeys:
         for i, key in enumerate(keys):
             traces.append(
@@ -75,7 +91,7 @@ def plotsec(
                     y=[],
                     z=[],
                     mode="markers",
-                    marker=dict(size=5, color=px.colors.qualitative.Plotly[i]),
+                    marker=dict(size=5, color=_get_colour(i)),
                     name=key,
                     showlegend=True,
                 )
@@ -84,7 +100,7 @@ def plotsec(
     if fig is None:
         fig = go.Figure(
             data=traces,
-            layout=go.Layout(template="flight3d+judge_view", uirevision="foo"),
+            layout=go.Layout(template="flight3d", uirevision="foo"),
         )
         if show_axes:
             fig.update_layout(
@@ -136,47 +152,33 @@ def plotdtw(sec: State, manoeuvres: List[str], span=3, fig=None):
 
 
 def plot_regions(
-    st: State, lab_cols: list[str], span=3, colours=None, fig=None, box:Box=None, **kwargs
+    st: State,
+    label_group_name: str,
+    span=3,
+    colours=None,
+    fig=None,
+    ribbonhover="t",
+    **kwargs,
 ):
     colours = px.colors.qualitative.Plotly if colours is None else colours
-    lab_cols = [lab_cols] if isinstance(lab_cols, str) else lab_cols
-
-    st = st.label(clabs=st.cumulative_labels(*lab_cols))
-
-    colmap = {}
 
     traces = []
-    for i, (k, seg) in enumerate(st.split_labels("clabs").items()):
+    for i, k in enumerate(st.labels[label_group_name].keys()):
+        seg = getattr(st, label_group_name)[k]
         if len(seg) < 3:
             continue
-        blab, id = get_appended_id(k)
-        if blab not in colmap:
-            colmap[blab] = colours[len(colmap) % len(colours)]
         traces += ribbon(
             seg,
             span,
-            colmap[blab],
-            name=blab,
-            showlegend=int(id) == 0,
-            **kwargs[blab] if blab in kwargs else {},
-        )
-        traces.append(
-            go.Scatter3d(
-                x=seg.pos.x,
-                y=seg.pos.y,
-                z=seg.pos.z,
-                mode="lines",
-                line=dict(width=0, color=colmap[blab]),
-                name=k,
-                showlegend=False,
-            )
+            colours[i%len(colours)],
+            name=k,
+            hover=ribbonhover
         )
 
+
     if fig is None:
         fig = go.Figure(layout=go.Layout(template="flight3d+judge_view"))
     fig.add_traces(traces)
-    if box:
-        fig.add_traces(box.plot())
     return fig
 
 
@@ -316,7 +318,7 @@ def multi_y_subplots(data: dict[str, pd.DataFrame], x: npt.NDArray = None):
         cols=1,
         shared_xaxes=True,
         vertical_spacing=0.01,
-        #subplot_titles=list(data.keys()),
+        # subplot_titles=list(data.keys()),
     )
 
     for row, (k, v) in enumerate(data.items(), 1):
@@ -352,7 +354,7 @@ def multi_y_subplots(data: dict[str, pd.DataFrame], x: npt.NDArray = None):
                     yanchor="top",
                 ),
                 f"yaxis{i}": dict(
-                    title=list(data.keys())[i-1],
+                    title=list(data.keys())[i - 1],
                     showline=True,
                 ),
             }
@@ -372,3 +374,144 @@ axis = dict(
     zerolinecolor="lightgrey",
     showline=True,
 )
+
+
+def create_ortho_state(st: State, axis: Literal['x', 'z'], width: g.Point, gap: g.Point) -> State:
+    """rotate by 90 degrees about the given axis,
+    then move to where it should be in an orthographic projection.
+    assumes front view is along the Y axis (x right, z up).
+    also assumes state is centered at the origin.
+    """
+    st = st.move(g.Transformation(g.Euler(
+        np.pi/2 if axis=="x" else 0, 
+        0,
+        np.pi/2 if axis=="z" else 0
+    ))) 
+
+    if axis == 'x':
+        shift = g.PZ((width.y + width.z) / 2 + gap)
+    elif axis == 'z':
+        shift = g.PX(-(width.x + width.y) / 2 - gap)
+
+    st = st.move(g.Transformation( shift) ) # move back to center and offset by shift
+
+    return st
+
+
+def applysts(st: State | list[State] | dict[str, State], fun: Callable[[State], State]) -> Union[State, List[State], dict[str, State]]:
+    """apply a transformation to all states in a list or dict of states"""
+    if isinstance(st, State):
+        return fun(st)
+    elif isinstance(st, list):
+        return [fun(s) for s in st]
+    elif isinstance(st, dict):
+        return {k: fun(v) for k, v in st.items()}
+
+
+def get_points(fig: go.Figure) -> g.Point:
+    """extract all points from a figure"""
+    ps = []
+    for d in fig.data:
+        try:
+            ps.append(g.Point(d.x, d.y, d.z))
+        except Exception:
+            pass
+    return g.Point.concatenate(ps)
+
+
+def plot_3view(st: State | list[State] | dict[str, State], plotfun: Callable, gap: float, legend_vstep=10):
+    
+    allsts = State.stack(st, "grp") if not isinstance(st, State) else st
+
+    width = allsts.pos.max() - allsts.pos.min()
+    center = allsts.pos.min() + width / 2
+
+    st0 = applysts(st, lambda s: s.move(g.Transformation(-center)))
+    st1 = applysts(st0, lambda s: create_ortho_state(s, 'x', width, gap))
+    st2 = applysts(st0, lambda s: create_ortho_state(s, 'z', width, gap))
+
+
+    fig = go.Figure(data=
+        plotfun(st0) + plotfun(st1) + plotfun(st2)
+    )
+
+    anprops = dict(
+        showarrow=False,
+        font=dict(size=16, family="Rockwell"),
+        xanchor="center",
+        yanchor="middle",
+    )
+
+
+    fig = fig.update_layout(
+        template="plotly_white",
+        scene=dict(
+            camera=dict(
+                eye=dict(x=0, y=-1, z=0),
+                center=dict(x=0, y=0, z=0),
+                projection=dict(type="orthographic"),
+            ),
+            xaxis=dict(visible=False),
+            yaxis=dict(visible=False),
+            zaxis=dict(visible=False),
+            annotations=[
+                dict(
+                    x=0, y=0, z=-width.z[0] / 2 - gap/2,
+                    text="Front View",
+                    
+                ) | anprops,
+                dict(
+                    x=0, y=0, z=width.z[0] / 2 + width.y[0] / 2 + gap/2,
+                    text="Top View",
+                ) | anprops
+                ,
+                dict(
+                    x=-width.x[0] / 2 - width.y[0] / 2 - gap, y=0, z=-width.z[0] / 2 - gap/2,
+                    text="Left View",
+                ) | anprops
+            ] + ([] if not isinstance(st, dict) else [dict(
+                x=-width.x[0] / 2 - width.y[0] / 2 - gap,
+                y=0,
+                z=width.z[0] / 2 + width.y[0] / 2 + gap/2 + i * legend_vstep,
+                text=k,
+                font=dict(size=16, family="Rockwell", color=px.colors.qualitative.Plotly[i]),
+                showarrow=False,
+            ) for i, k in enumerate(st.keys())] )
+        ),
+        margin=dict(l=0, r=0, b=0, t=0),
+        
+    )
+
+    return resize_3d_fig(fig, 600, False)
+
+
+def resize_3d_fig(fig: go.Figure, width: int | None, width_is_height: bool=False, scale: float=1):
+    """Resize a figure to the given width, height and zoom level.
+    preserves the aspect ratio of the scene. 
+    Assumes view is in the positive Y direction
+    """
+    
+    all_points = get_points(fig)
+
+    btm_left = all_points.min()
+    top_right = all_points.max() 
+
+    bb = (top_right - btm_left) 
+    width = width or (fig.layout.height if width_is_height else fig.layout.width) or 600
+    zoom = (0.008 * scale*width/(bb.z[0] if width_is_height else bb.x[0])) 
+    ar = bb * zoom
+    height = ar.x[0] * width / ar.z[0] if width_is_height else ar.z[0] * width / ar.x[0]
+    fig.update_layout(
+        width=height if width_is_height  else width,
+        height=width if width_is_height else height,
+        scene=dict(
+            aspectratio=dict(x=ar.x[0], y=ar.y[0], z=ar.z[0]),
+            camera=dict(
+                eye=dict(x=0, y=-1, z=0),
+                center=dict(x=0, y=0, z=0),
+                projection=dict(type="orthographic"),
+            )
+        ),
+    )
+
+    return fig

{flightplotting-0.2.12 → flightplotting-0.2.14}/src/plotting/templates.py

@@ -2,21 +2,14 @@
 import plotly.graph_objects as go
 import plotly.io as pio
 
-flight3d_template = go.layout.Template(layout=go.Layout(
+
+generic3d_template = go.layout.Template(layout=go.Layout(
     margin=dict(l=0, r=0, t=0, b=0),
-    scene=dict(
-        aspectmode='data',
-    ),
-    legend=dict(
-        font=dict(size=20),
-        yanchor="top",
-        y=0.99,
-        xanchor="left",
-        x=0.01
-    )
+    scene=dict(aspectmode='data')
 ))
 
-pio.templates["flight3d"] = flight3d_template
+pio.templates["generic3d"] = generic3d_template
+pio.templates["flight3d"] = generic3d_template
 
 judges_view_template = go.layout.Template(layout=go.Layout(scene_camera=dict(
     up=dict(x=0, y=0, z=1),
@@ -32,10 +25,9 @@ pio.templates["judge_view"] = judges_view_template
 clean_paper_template = go.layout.Template(layout=go.Layout(
     margin=dict(l=0, r=0, t=0, b=0),
     scene=dict(
-        aspectmode='data',
         xaxis = dict(visible=False),
         yaxis = dict(visible=False),
-        zaxis =dict(visible=False)
+        zaxis = dict(visible=False)
     ),
     legend=dict(
         font=dict(size=20),

{flightplotting-0.2.12 → flightplotting-0.2.14}/src/plotting/traces.py

@@ -1,3 +1,4 @@
+from typing import Literal
 import plotly.graph_objects as go
 import plotting.templates
 from geometry import Point, Coord, Transformation
@@ -23,7 +24,7 @@ def boxtrace():
     )]
 
 
-def meshes(npoints, seq: State, colour, scale=1, _obj: OBJ=None):
+def meshes(npoints, seq: State | Transformation, colour: str=None, scale=1, _obj: OBJ=None):
     _obj = obj if _obj is None else _obj
     if scale != 1:
         _obj = _obj.scale(scale)
@@ -36,10 +37,10 @@ def meshes(npoints, seq: State, colour, scale=1, _obj: OBJ=None):
         locs = locs + list(np.cumsum(np.full(npoints-2, len(seq) / (npoints-1))).astype(int))
         
     ms = []
-    for loc in locs:
+    for i, loc in enumerate(locs):
         ms.append(_obj.transform(
-            Transformation(seq.pos[loc], seq.att[loc])
-        ).create_mesh(colour,f"{seq.time.t[loc]:.1f}"))
+            seq.iloc[loc].transform if isinstance(seq, State) else seq[loc]
+        ).create_mesh(colour or "grey",f"{(seq.time.t[loc] if isinstance(seq, State) else i):.1f}"))
     return ms
 
 def vector(origin, direction, **kwargs):
@@ -106,12 +107,12 @@ def elementtraces(manoeuvre, sec: State):
 
 
 
-def tiptrace(seq, span, **kwargs):
+def tiptrace(seq, span, line=None, **kwargs):
     
     def make_offset_trace(pos, colour):
         tr =  trace3d(
             *seq.body_to_world(pos).data.T,
-            **dict(dict(line=dict(color=colour, width=1)), **kwargs)
+            **dict(line=dict(color=colour, width=1) | ({} if line is None else line), **kwargs)
         )
         tr['showlegend'] = False
         return tr
@@ -201,24 +202,25 @@ def aoa_trace(sec, dash="dash", colours = px.colors.qualitative.Plotly):
     #sec = sec.append_columns(sec.aoa())
     return sec_col_trace(sec, ["alpha", "beta"], dash, colours, np.degrees)
 
-def axestrace(cid: Coord, length:float=20.0):
+def axestrace(cid: Coord | Transformation, length:float=20.0, **kwargs):
     ntraces = []
     colours = {"x":"red", "y":"blue", "z":"green"}
     for i, ci in enumerate(cid):
+        if isinstance(ci, Transformation):
+            ci = ci.apply(Coord.zero())
         for ax, col in zip([ci.x_axis, ci.y_axis, ci.z_axis], list("xyz")):
             axis = Point.concatenate([ci.origin, ci.origin + ax * length])
             ntraces.append(go.Scatter3d(
                 x=axis.x, y=axis.y, z=axis.z, mode="lines", 
                 line=dict(color=colours[col]),
-                name=col,
-                showlegend=True if i==0 else False
+                name=f"{i}_{col}",
+                **kwargs
             ))
         
     return ntraces
 
 
 
-
 def _npinterzip(a, b):
     """
     takes two numpy arrays and zips them.
@@ -243,7 +245,7 @@ def _npinterzip(a, b):
     return c
 
 
-def ribbon(sec: State, span: float, color, **kwargs):
+def ribbon(sec: State, span: float, color, hover: Literal["i", "t"]='i', **kwargs):
     """TODO make the colouring more generic
     """
 
@@ -252,7 +254,13 @@ def ribbon(sec: State, span: float, color, **kwargs):
 
     points = Point(_npinterzip(left.data, right.data))
 
-    
+    match hover:
+        case "i":
+            text=[f"{i}" for i in np.arange(len(sec)*2)]
+        case _:
+            text=[f"{t:.1f}" for t in _npinterzip(sec.t, sec.t)]
+        
+
     _i = np.array(range(len(points) - 2))   # 1 2 3 4 5
 
     _js = np.array(range(1, len(points), 2))
@@ -265,5 +273,7 @@ def ribbon(sec: State, span: float, color, **kwargs):
         x=points.x, y=points.y, z=points.z, i=_i, j=_j, k=_k,
         intensitymode="cell",
         facecolor=np.full(len(_i), color),
+        text=text,
+        hovertemplate='i:%{text}<br>',
         **kwargs
     )]