pyFlightPlotter 0.3.1__py3-none-any.whl

pyFlightPlotter/crafts.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+from .core import Craft3D
+
+class Quadrotor(Craft3D):
+    def __init__(self, l=0.2, R=0.1):
+        body = np.array([
+            [    l,   -l/4,     0.],
+            [    l,   +l/4,     0.],
+            [    l+l/4,   0,     0.],
+            [    l,   -l/4,     0.],
+        ])
+        geometry = [body]
+        super().__init__(body_geometry=geometry)
+
+        arms = np.array([
+            [ -l, +l, 0.],
+            [ +l, +l, 0.],
+            [ -l, -l, 0.],
+            [ +l, -l, 0.],
+        ])
+
+        for arm in arms:
+            self.addRotor(xyz=arm, axis=[0, 0, -1], R=R)
+
+class Tailsitter(Craft3D):
+    def __init__(self, l=0.3, R=0.1):
+        body = np.array([
+            [    0,   2*l,     l],
+            [    0,   2*l,     0.],
+            [    0,    0.,   -1*l],
+            [    l,    0.,   -1*l],
+            [    0,    0.,   -1*l],
+            [    0,  -2*l,   0.],
+            [    0,  -2*l,   l],
+            [    0,   2*l,   l],
+        ])
+        geometry = [body]
+        super().__init__(body_geometry=geometry)
+
+        self.addRotor(xyz=[0, -l, -l], axis=[0, 0, -1], R=R)
+        self.addRotor(xyz=[0, +l, -l], axis=[0, 0, -1], R=R)
+
+        surface = np.array([
+            [0, -2.*l, 1.0*l],
+            [0, -2.*l, 1.5*l],
+            [0, -0.5*l, 1.5*l],
+            [0, -0.5*l, 1.0*l],
+        ])
+        self.addSurface(
+            tilt_xyz=[0., 0., 1.*l], tilt_axis=[0., +1., 0.], geometry=[surface]
+        )
+        self.addSurface(
+            tilt_xyz=[0., 0., 1.*l], tilt_axis=[0., +1., 0.], geometry=[surface*np.array([1., -1., 1.])]
+        )

pyFlightPlotter/cursor.py

@@ -0,0 +1,107 @@
+
+from matplotlib.backend_bases import MouseEvent
+import matplotlib.pyplot as plt
+from time import sleep
+
+class BlittedCursor(object):
+    def __init__(self, axes, sharex=True):
+        self.axes = axes
+        self.backgrounds = []
+        self.cursors = []
+
+        ax0 = self.axes[0]
+        self.playing = False
+        self.x = 0
+
+        for i, ax in enumerate(self.axes):
+            if i > 0 and sharex:
+                ax.sharex(ax0)
+
+            lines = ax.get_lines()
+            if lines:
+                min_x = min(min(line.get_xdata()) for line in lines)
+                self.cursors.append(ax.axvline(x=min_x,
+                                               color='black',
+                                               linestyle='--',
+                                               lw=0.8,
+                                               visible=False))
+            else:
+                self.cursors.append(None)
+
+        # get unique canvasses by iterating over axes
+        # this is necessary to avoid multiple connections to the same canvas
+        self.canvasses = [self.axes[0].figure.canvas]
+        for ax in self.axes[1:]:
+            if ax.figure.canvas is not self.canvasses:
+                self.canvasses.append(ax.figure.canvas)
+
+        for canvas in self.canvasses:
+            # connect the canvas to the draw and motion events
+            canvas.mpl_connect('draw_event', self._on_draw)
+            canvas.mpl_connect('motion_notify_event', self._on_mouse_move)
+            canvas.mpl_connect('key_press_event', self._on_key_press)
+
+        self.timer = self.axes[0].figure.canvas.new_timer(interval=50)
+        self.timer.add_callback(self._on_timer)
+
+    def _on_draw(self, event):
+        self.backgrounds.clear()
+        for ax in self.axes:
+            canvas = ax.figure.canvas
+            self.backgrounds.append(canvas.copy_from_bbox(ax.bbox))
+
+    def _on_mouse_move(self, event):
+        if event.xdata is None or not self.backgrounds:
+            return
+
+        self.x = event.xdata
+
+        for ax, line, bg in zip(self.axes, self.cursors, self.backgrounds):
+            canvas = ax.figure.canvas
+            canvas.restore_region(bg)
+            if line is not None:
+                line.set_xdata([event.xdata])
+                line.set_visible(True)
+                ax.draw_artist(line)
+            canvas.blit(ax.bbox)
+
+    def _on_timer(self):
+
+        # generate mouse event to canvas, so that all children get updated
+        from matplotlib.backend_bases import MouseEvent
+
+        self.x += 0.02
+        canvas = self.axes[0].figure.canvas
+        event = MouseEvent(
+            name="motion_notify_event",
+            canvas=canvas,
+            x=self.x,      # pixel coordinates
+            y=0,
+            button=None,
+            key=None,
+            step=0,
+            dblclick=False,
+            guiEvent=None
+        )
+        event.xdata = self.x  # data coordinates
+        canvas.callbacks.process(
+            "motion_notify_event", event
+        )
+
+
+    def _on_key_press(self, event):
+        """Callback function to update the viewport on key press
+
+        Args:
+            event (matplotlib.backend_bases.KeyEvent): key event
+
+        Returns:
+            None
+        """
+        if event.key == ' ':
+            if self.playing:
+                self.playing = False
+                self.timer.stop()
+            else:
+                self.playing = True
+                self.timer.start()

pyFlightPlotter/style.py

@@ -0,0 +1,25 @@
+from matplotlib import pyplot as plt
+
+local_rc = plt.rcParams.copy()
+local_rc.update({
+#    "text.usetex": True,
+#    "font.family": "Helvetica",
+    "font.family": "sans-serif",
+    "font.size": 10,
+    "axes.grid": True,
+    "axes.grid.which": 'both',
+    "grid.linestyle": '--',
+    "grid.alpha": 0.7,
+    "axes.labelsize": 10,
+    "axes.titlesize": 14,
+    "xtick.labelsize": 10,
+    "ytick.labelsize": 10,
+    "legend.loc": 'upper left',
+    "legend.fontsize": 8,
+    'figure.subplot.bottom': 0.06,
+    'figure.subplot.left': 0.05,
+    'figure.subplot.right': 0.95,
+    'figure.subplot.top': 0.925,
+    'figure.subplot.wspace': 0.3,
+    'figure.subplot.hspace': 0.433,
+})

pyflightplotter-0.3.1.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: pyFlightPlotter
+Version: 0.3.1
+Summary: Interactive, synchronized 2D time-series and 3D attitude/position plotting for flight logs
+Author-email: Till Blaha <t.m.blaha@tudelft.nl>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/tudelft/pyFlightPlotter
+Project-URL: Repository, https://github.com/tudelft/pyFlightPlotter
+Project-URL: Issues, https://github.com/tudelft/pyFlightPlotter/issues
+Keywords: flight data,log analysis,drone,UAV,quaternion,matplotlib,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Framework :: Matplotlib
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: video
+Requires-Dist: opencv-python; extra == "video"
+Dynamic: license-file
+
+# pyFlightPlotter
+
+[![PyPI](https://img.shields.io/pypi/v/pyFlightPlotter)](https://pypi.org/project/pyFlightPlotter/)
+[![Python](https://img.shields.io/pypi/pyversions/pyFlightPlotter)](https://pypi.org/project/pyFlightPlotter/)
+[![License: GPL v3+](https://img.shields.io/badge/license-GPL--3.0--or--later-blue)](https://github.com/tudelft/pyFlightPlotter/blob/main/LICENSE)
+
+Interactive, configurable and three-dimensional flight data plotting, with little boilerplate.
+
+Hover over a time-series plot and every connected window follows along: the cursor moves in sync in all
+time-series axes, and a 3D viewport shows the vehicle's attitude, position, velocity, acceleration and
+actuator state at that moment. You can also sync an onboard or external video to the log.
+
+![Demo of pyFlightPlotter](https://raw.githubusercontent.com/tudelft/pyFlightPlotter/main/docs/images/demo.gif)
+
+## Features
+
+- **3D viewport** showing estimates, setpoints and measurements of
+  - attitude (quaternions)
+  - position, velocity and acceleration
+  - rotor force commands
+  - control surface deflections
+- **Time-series plotting** in a configurable grid layout. `_plot_timeseries()` takes several line styles
+  (light / solid / dashed / true value) and keeps colours consistent across series.
+- **A synchronized vertical cursor** across all time-series axes, even when they're spread over several
+  figures. The 3D viewport updates on mouse hover.
+- **Playback**: press <kbd>Space</kbd> to play or pause the log in real time.
+- **Video sync** (`VideoViewport`): show an MP4 next to the log, with an adjustable time offset.
+- **Craft builder**: the `Craft3D` class has `addRotor` and `addSurface` methods to define a vehicle quickly.
+  - single-axis surface tilt
+  - dual-axis rotor tilt
+  - presets included: `Quadrotor`, `Tailsitter`
+
+## Installation
+
+```sh
+pip install pyFlightPlotter
+```
+
+With video support (`VideoViewport`, which needs OpenCV):
+
+```sh
+pip install "pyFlightPlotter[video]"
+```
+
+The latest development version from GitHub:
+
+```sh
+pip install "pyFlightPlotter @ git+https://github.com/tudelft/pyFlightPlotter"
+```
+
+Requires Python 3.10 or newer. The dependencies are `numpy`, `scipy` and `matplotlib`. You also need an
+interactive matplotlib backend (e.g. QtAgg or TkAgg).
+
+## Usage
+
+You build a plotter by subclassing `FlightPlotterBase` and implementing `_populate()`, where you add the
+subplots you want. `BlittedCursor` adds the synchronized cursor, and `connect_viewport()` links a 3D
+`Viewport` (or a `VideoViewport`) to the mouse.
+
+A minimal example ([`docs/examples/minimal_example.py`](https://github.com/tudelft/pyFlightPlotter/blob/main/docs/examples/minimal_example.py)):
+
+```python
+import numpy as np
+
+from pyFlightPlotter import FlightPlotterBase, BlittedCursor, Viewport, Quadrotor
+
+class FlightPlotterMinimalExample(FlightPlotterBase):
+    def __init__(self, time, data):
+        self.data = data
+        super().__init__(time, name="MWE")
+        self.define_layout(nrows=1, ncols=1)
+        self.plot()
+
+    def _populate(self):
+        self._plot_timeseries(
+            self.fig.add_subplot(self.gs[0, 0]),
+            light=None,
+            solid=[self.data[2], self.data[3]],
+            dashed=[self.data[0], self.data[1]],
+            series_labels=["Signal 1", "Signal 2"],
+            style_labels=[None, "Estimated", "Setpoint"],
+            title="Example Time Series",
+            ylabel="Amplitude",
+        )
+
+if __name__ == "__main__":
+    t = np.linspace(0, 2, 101)
+    data = [
+        np.sin(2*np.pi*0.5*t), np.sin(2*np.pi*0.5*t + 0.2),
+        np.cos(2*np.pi*0.5*t + 0.4), np.cos(2*np.pi*0.5*t + 0.6),
+    ]
+
+    fp = FlightPlotterMinimalExample(t, data)
+    bc = BlittedCursor(fp.all_axes, sharex=True)
+
+    vp = Viewport(craft=Quadrotor(),
+                  time=np.array([0., 1., 2.]),
+                  att=np.array([[1., 0., 0., 0.], [0.7, 0., 0., 0.7], [0., 0., 0., 1.]]),
+                  # ... many more data can be passed here, but attitude is required
+                  interpolation="linear",
+                  follow=False,
+                  title="Viewport Example",
+                  )
+
+    # connect mouse hover
+    fp.connect_viewport(vp)
+```
+
+Run it with `python -i` so the windows stay open.
+
+For a full example with several figures, a tailsitter, and position/velocity/actuator data, see
+[`docs/examples/complete_example.py`](https://github.com/tudelft/pyFlightPlotter/blob/main/docs/examples/complete_example.py).
+For an example of hooking pyFlightPlotter into your own log-data structure, see
+[indiflight](https://github.com/tudelft/indiflight/blob/global_rls/support/LogAnalysis/indiflightPlotter.py).
+
+### Video synchronization
+
+```python
+from pyFlightPlotter import VideoViewport
+
+vv = VideoViewport(time=t, mp4_path="flight.mp4", offset_s=0.0)
+fp.connect_viewport(vv)
+```
+
+The video time is `data_time + offset`. You can set the offset with the slider or text box in the video
+window, or step one frame at a time with the arrow keys. You can also load a file from inside the window.
+
+### Controls
+
+| Input | Action |
+|---|---|
+| Mouse hover over a time-series axis | Move the cursor; all connected viewports update |
+| <kbd>Space</kbd> | Play / pause real-time playback |
+| <kbd>←</kbd> / <kbd>→</kbd> (video window) | Shift the video offset by one frame |
+
+### Conventions
+
+Quaternions are scalar-first: `[w, x, y, z]`. Arrays are expected with time along the first axis, e.g.
+`Nx4` for attitude and `Nx3` for position, velocity and acceleration. See the `Viewport` docstring for all
+supported inputs.
+
+## Development
+
+```sh
+git clone https://github.com/tudelft/pyFlightPlotter
+cd pyFlightPlotter
+pip install -e ".[video]"
+python -i docs/examples/complete_example.py
+```
+
+## License
+
+GPL-3.0-or-later. See [LICENSE](https://github.com/tudelft/pyFlightPlotter/blob/main/LICENSE).

pyflightplotter-0.3.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyFlightPlotter/__init__.py,sha256=Gq4Qu7E6F25fmDFhoLKBvGjDr8RtFvFUOTg38TT69IM,574
+pyFlightPlotter/core.py,sha256=N-yhz-U-KAQrVtwIv4qh-0rGTPW4Psrrzpp9wW5fO5c,40218
+pyFlightPlotter/crafts.py,sha256=xL2k5ohu4CPbf3ZsWAwdPqfZNh4IbQkhxATpgoyHMIU,1604
+pyFlightPlotter/cursor.py,sha256=TvenyFDVUvNMFlFz-NQ9Bng8f90nCibRSDRj6YZIcRI,3467
+pyFlightPlotter/style.py,sha256=SjsRglz_U91Oq0QnJccr3dfDvjD19KzrcHMqvissivM,677
+pyflightplotter-0.3.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pyflightplotter-0.3.1.dist-info/METADATA,sha256=ff2Zaeom9ez6tkam_Ht3leS6eTw0Bp5xbPj_Y4RrrLw,7029
+pyflightplotter-0.3.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pyflightplotter-0.3.1.dist-info/top_level.txt,sha256=mIR6Po0K39Gzf-hMDp-VJVznog_ZmNxbcEa1WeYWDec,16
+pyflightplotter-0.3.1.dist-info/RECORD,,

pyflightplotter-0.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+