flightdata 0.2.5__tar.gz → 0.2.7__tar.gz

flightdata-0.2.7/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: flightdata
+Version: 0.2.7
+Summary: Module for handling UAV flight log data
+Home-page: https://github.com/PyFlightCoach/FlightData
+Author: Thomas David
+Author-email: thomasdavid0@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: simplejson
+Requires-Dist: pfc-geometry>=0.2.5
+Requires-Dist: ardupilot-log-reader>=0.3.1
+
+## FlightData
+This repo is contains a set of datastructures and tools for handling flight log data.
+
+### Flight 
+The Flight object represents the data logged by a flight controller. The class wraps a pandas dataframe which is indexed on a single time axis. Where data is logged at different rates for different sensors it is mapped to the closest time index. Attribute access provides individual columns or sets of columns in the groups defined in Fields. Item access subsets the data in the time axis. 
+
+### Table
+The Table is the base type for most of the datastructures. It allows attribute access to individual columns. Attribute access is also available to return basic entities subclassed from the base type in the pfc-geometry package. For example in the state object table.x provides the x position, table.pos provides a Point representing the xyz position. columns that are not represented by geometric base types are considered to be labels for the data.
+
+### State
+The State object is a table representing the position and orientation of the aircraft along with their derivatives, it can be constructed from a Flight or from scratch by extrapolating in lines or around arcs. Many tools are provided to manipulate the data. The position and attitude are in a reference frame (with Z up), the derivatives move with the aircraft in either the body, wind, stability or track (like the wind axis but with no wind) frame.  
+
+
+Further documentation will be provided here: https://pfcdocumentation.readthedocs.io/pyflightcoach/flightdata.html

flightdata-0.2.7/README.md

@@ -0,0 +1,14 @@
+## FlightData
+This repo is contains a set of datastructures and tools for handling flight log data.
+
+### Flight 
+The Flight object represents the data logged by a flight controller. The class wraps a pandas dataframe which is indexed on a single time axis. Where data is logged at different rates for different sensors it is mapped to the closest time index. Attribute access provides individual columns or sets of columns in the groups defined in Fields. Item access subsets the data in the time axis. 
+
+### Table
+The Table is the base type for most of the datastructures. It allows attribute access to individual columns. Attribute access is also available to return basic entities subclassed from the base type in the pfc-geometry package. For example in the state object table.x provides the x position, table.pos provides a Point representing the xyz position. columns that are not represented by geometric base types are considered to be labels for the data.
+
+### State
+The State object is a table representing the position and orientation of the aircraft along with their derivatives, it can be constructed from a Flight or from scratch by extrapolating in lines or around arcs. Many tools are provided to manipulate the data. The position and attitude are in a reference frame (with Z up), the derivatives move with the aircraft in either the body, wind, stability or track (like the wind axis but with no wind) frame.  
+
+
+Further documentation will be provided here: https://pfcdocumentation.readthedocs.io/pyflightcoach/flightdata.html

{flightdata-0.2.5 → flightdata-0.2.7}/flightdata/base/collection.py

@@ -1,5 +1,4 @@
-from typing import Dict, List, Union, Any, Self, TypeVar, Iterable
-import numpy as np
+from typing import Union, Any, Self, TypeVar, Iterable
 import pandas as pd
 
 
@@ -45,7 +44,7 @@ class Collection:
         for v in self.data.values():
             yield v
 
-    def to_list(self) -> List[T]:
+    def to_list(self) -> list[T]:
         return list(self.data.values())
     
     def to_dicts(self, *args, **kwargs) -> list[dict[str, Any]]:
@@ -99,4 +98,8 @@ class Collection:
         return str(pd.Series({k: repr(v) for k, v in self.data.items()}))
     
     def __len__(self) -> int:
-        return len(self.data)
+        return len(self.data)
+    
+    @property
+    def uids(self) -> list[str]:
+        return list(self.data.keys())

flightdata-0.2.7/flightdata/base/labeling.py

@@ -0,0 +1,9 @@
+
+
+
+def get_appended_id(source: str, seperator='_'):
+    try:
+        sloc = source.rfind(seperator)
+        return source[:sloc], source[sloc+1:]
+    except Exception:
+        return source, None

{flightdata-0.2.5 → flightdata-0.2.7}/flightdata/base/table.py

@@ -3,35 +3,29 @@ import numpy as np
 import pandas as pd
 import numpy.typing as npt
 from geometry import Base, Time
-from typing import Union, Self, Tuple
+from typing import Self, Tuple
 from .constructs import SVar, Constructs
 from numbers import Number
 from time import time
 
 
-def make_time(tab):
-    return Time.from_t(tab.t)
-    
-    
 class Table:
     constructs = Constructs([
-        SVar("time", Time,        ["t", "dt"]               , make_time )
+        SVar("time", Time, ["t", "dt"], lambda tab: Time.from_t(tab.t))
     ])
 
     def __init__(self, data: pd.DataFrame, fill=True, min_len=1):
         if len(data) < min_len:
             raise Exception(f"State constructor length check failed, data length = {len(data)}, min_len = {min_len}")
         self.base_cols = [c for c in data.columns if c in self.constructs.cols()]
-        self.label_cols = [c for c in data.columns if not c in self.constructs.cols()]
+        self.label_cols = [c for c in data.columns if c not in self.constructs.cols()]
     
         self.data = data
-
-        self.data.index = self.data.index - self.data.index[0]
+        #self.data.index = self.data.index - self.data.index[0]
         
         if fill:
             missing = self.constructs.missing(self.data.columns)
-            for svar in missing:
-                
+            for svar in missing:                
                 newdata = svar.builder(self).to_pandas(
                     columns=svar.keys, 
                     index=self.data.index
@@ -45,7 +39,7 @@ class Table:
             raise ValueError("nan values in data")
         
 
-    def __getattr__(self, name: str) -> Union[pd.DataFrame, Base]:
+    def __getattr__(self, name: str) -> npt.NDArray | Base:
         if name in self.data.columns:
             return self.data[name].to_numpy()
         elif name in self.constructs.data.keys():
@@ -73,17 +67,20 @@ class Table:
     @property
     def duration(self):
         return self.data.index[-1] - self.data.index[0]
-
+    
     def __getitem__(self, sli):
-        if isinstance(sli, Number):
+        if isinstance(sli, slice):
+            return self.__class__(self.data.loc[slice(sli.start + self.data.index[0], sli.stop + self.data.index[0], sli.step)])
+        elif isinstance(sli, Number):
             if sli<0:
                 return self.__class__(self.data.iloc[[int(sli)], :])
 
             return self.__class__(
-                self.data.iloc[self.data.index.get_indexer([sli], method="nearest"), :]
+                self.data.iloc[self.data.index.get_indexer([sli + self.data.index[0]], method="nearest"), :]
             )
+        else:
+            raise TypeError(f"Expected Number or slice, got {sli.__class__.__name__}")
         
-        return self.__class__(self.data.loc[sli])
 
     def slice_raw_t(self, sli):
         inds = self.data.reset_index(names="t2").set_index("t").loc[sli].t2.to_numpy()#set_index("t", drop=False).columns
@@ -176,13 +173,7 @@ class Table:
         return self.data.loc[:, self.label_cols]
 
     def remove_labels(self) -> Self:
-        return self.__class__(
-            self.data.drop(
-                self.label_keys, 
-                axis=1, 
-                errors="ignore"
-            )
-        )
+        return self.__class__(self.data.drop(self.label_keys, axis=1, errors="ignore"))
     
     def get_subset_df(self, **kwargs) -> pd.DataFrame:
         dfo = self.data
@@ -200,9 +191,10 @@ class Table:
             return 0
 
     def unique_labels(self, cols = None) -> pd.DataFrame:
-        '''TODO Fix This'''
         if cols is None:
             cols = self.label_cols
+        elif isinstance(cols, str):
+            cols = [cols]
         return self.data.loc[:, cols].reset_index(drop=True).drop_duplicates().reset_index(drop=True)
 
     def shift_labels(self, col, elname, offset, allow_label_loss=True) -> Self:
@@ -254,7 +246,7 @@ class Table:
     @classmethod
     def shift_multi(Cls, steps: int, tb1: Self, tb2: Self, min_len=2) -> Tuple(Self, Self):
         '''Take datapoints off the start of tb2 and add to the end tb1'''
-        if (steps>0 and len(tb2)-min_len<steps) or (steps<0 and len(tb1)-2<min_len):
+        if (steps>0 and len(tb2)-min_len<steps) or (steps<0 and min_len - len(tb1) > steps):
             raise ValueError(f'Cannot Squash a Table to less than {min_len} datapoints')
         dfj = Cls.stack([tb1, tb2], overlap=0).data
         return Cls(dfj.iloc[:len(tb1)+steps, :]), \
@@ -280,7 +272,7 @@ class Table:
             res = res.shift_label_ratio(ratio, min_len, **lab)
         return res
     
-    def get_label_id(self, **kwargs) -> Union[int, float]:
+    def get_label_id(self, **kwargs) -> int | float:
         dfo = self.unique_labels()
         for k, v in kwargs.items():
             dfo = dfo.loc[dfo[k] == v, :]            
@@ -317,7 +309,7 @@ class Table:
         labs = np.array(self.single_labels())
         return self.__class__(self.data[labs == lab])
 
-    def split_labels(self, cols=None) -> dict[str, Self]:
+    def split_labels(self, cols:list[str]|str = None) -> dict[str, Self]:
         '''Split into multiple tables based on the labels'''
         res = {}
         for label in self.unique_labels(cols).iterrows():
@@ -341,7 +333,6 @@ class Table:
         strdf = df.copy()
         strdf['indexer'] = strdf['indexer'].astype(int).astype(str)
         strdf  = strdf.stack().groupby(level=0).apply('_'.join)
-        strdf.loc[df.indexer==0] = df[0]
         return strdf.values
 
     @staticmethod

{flightdata-0.2.5 → flightdata-0.2.7}/flightdata/flight/flight.py

@@ -21,10 +21,9 @@ from time import time
 from json import load, dump
 from ardupilot_log_reader.reader import Ardupilot
 from flightdata.base.numpy_encoder import NumpyEncoder
-from flightdata.flight.fields import Fields
 from .ardupilot import flightmodes 
 from flightdata import Origin
-from scipy.signal import butter, filtfilt
+from numbers import Number
 
 
 class Flight:
@@ -34,30 +33,52 @@ class Flight:
         'ARSP', 'GPS', 'RCIN', 'RCOU', 'BARO', 'MODE', 
         'RPM', 'MAG', 'BAT', 'BAT2', 'VEL', 'ORGN', 'ESC', 'CURRENT']
     
-    def __init__(self, data: pd.DataFrame, parameters: list = None, origin: Origin = None, primary_pos_source='gps'):
+    def __init__(self, data: pd.DataFrame, parameters: pd.DataFrame = None, origin: Origin = None, primary_pos_source='gps'):
         self.data = data
         self.parameters = parameters
-        self.data.index = self.data.index - self.data.index[0]
-        self.data.index.name = 'time_index'
         self.origin = origin
         self.primary_pos_source = primary_pos_source
         
     def __getattr__(self, name):
+        if self.parameters is not None:
+            if name in self.parameters.parameter.unique():
+                df =  self.parameters.loc[self.parameters.parameter==name]
+                return df.loc[df.value != df.value.shift()]
         cols = getattr(fields, name)
         if cols is None:
             cols = [f for f in self.data.columns if f.startswith(name)]
             if len(cols) > 0:
                 return self.data[cols]
-        try:
-            if isinstance(cols, Field):
-                return self.data[cols.col]
-            else:
-                return self.data.loc[:, [f.col for f in cols if f.col in self.data.columns]]
-        except KeyError:
-            if isinstance(cols, Field):
-                cols = [cols]
-            return pd.DataFrame(data=np.empty((len(self), len(cols))),columns=[f.col for f in cols])
+        else:
+            try:
+                if isinstance(cols, Field):
+                    return self.data[cols.col]
+                else:
+                    return self.data.loc[:, [f.col for f in cols if f.col in self.data.columns]]
+            except KeyError:
+                if isinstance(cols, Field):
+                    cols = [cols]
+                return pd.DataFrame(data=np.empty((len(self), len(cols))),columns=[f.col for f in cols])
+        raise AttributeError(f"'Flight' object has no attribute '{name}'")
+    
+    def make_param_labels(self, pname: str, prefix:str=None, suffix:str=None, unknown=''):
+        '''Make a series with the parameter values at the correct times.'''
+        ser = pd.Series(np.nan, index=self.data.index, name=pname)
+        param = getattr(self, pname)
+        ser.iloc[ser.index.get_indexer(param.index, 'nearest')] = param.value
+        ser = ser.ffill()
         
+        if prefix or suffix:
+            sout = pd.Series(unknown, index=self.data.index, name=pname)
+            sout[~np.isnan(ser)] = (prefix or '') + ser[~np.isnan(ser)].astype(str) + (suffix or '')
+            return sout
+        else:
+            return ser
+
+    def make_param_df(self, pnames: list[str]):
+        '''Make a dataframe of parameter values'''
+        return pd.DataFrame([self.make_param_labels(p) for p in pnames]).T
+
     def contains(self, name: Union[str, list[str]]):
         cols = getattr(fields, name)
         if isinstance(cols, Field):
@@ -65,35 +86,55 @@ class Flight:
         else:
             return [f.column in self.data.columns for f in cols]
                 
-    def __getitem__(self, sli) -> Self:
-        if isinstance(sli, int) or isinstance(sli, float):
-            return self.data.iloc[self.data.index.get_loc(sli)]
+    def __getitem__(self, sli: Number | slice) -> Flight:
+        if isinstance(sli, Number):
+            if sli < 0:
+                return self.data.iloc[sli]
+            else:
+                gl = self.data.index.get_loc(sli + self.data.index[0])
+                return Flight(
+                    self.data.iloc[gl],
+                    self.parameters.loc[:gl],
+                )
+        elif isinstance(sli, slice):
+            return Flight(
+                self.data.loc[slice(
+                    None if sli.start is None else sli.start + self.data.index[0],
+                    None if sli.stop is None else sli.stop + self.data.index[0],
+                    sli.step
+                )], 
+                self.parameters.loc[:None if sli.stop is None else sli.stop + self.data.index[0]], 
+                self.origin, self.primary_pos_source
+            )
         else:
-            return Flight(self.data.loc[sli], self.parameters, self.origin, self.primary_pos_source)
+            raise TypeError(f'Expected a number or a slice, got a {sli.__class__.__name__}')
 
     def __len__(self):
         return len(self.data)
 
-    def slice_raw_t(self, sli):
+    def slice_raw_t(self, sli: Number | slice) -> Flight:
+        def opp(df: pd.DataFrame, indexer: Number | slice):
+            return df.reset_index(drop=True) \
+                .set_index('time_actual', drop=False) \
+                    .loc[indexer].set_index("time_flight", drop=False)
+            
         return Flight(
-            self.data.reset_index(drop=True)
-                .set_index('time_actual', drop=False)
-                    .loc[sli].set_index("time_flight", drop=False), 
-            self.parameters, self.origin, self.primary_pos_source
+            opp(self.data, sli),
+            opp(self.parameters, slice(None, sli if isinstance(sli, Number) else sli.stop, None)),
+            self.origin, self.primary_pos_source
         )
         
-    def slice_time_flight(self, sli):
+    def slice_time_flight(self, sli) -> Flight:
         return Flight(
-            self.data.reset_index(drop=True)
-                .set_index('time_flight', drop=False)
-                    .loc[sli], 
-            self.parameters, self.origin, self.primary_pos_source
+            self.data.loc[sli], 
+            self.parameters.loc[:sli if isinstance(sli, Number) else sli.stop], 
+            self.origin, self.primary_pos_source
         )
         
-    def copy(self, **kwargs):
+    def copy(self, **kwargs) -> Flight:
         return Flight(
             kwargs['data'] if 'data' in kwargs else self.data.copy() ,
-            kwargs['parameters'] if 'parameters' in kwargs else self.parameters.copy() if self.parameters else None,
+            kwargs['parameters'] if 'parameters' in kwargs else self.parameters.copy() if self.parameters is not None else None,
             kwargs['origin'] if 'origin' in kwargs else self.origin.copy(),
             kwargs['primary_pos_source'] if 'primary_pos_source' in kwargs else self.primary_pos_source
         )
@@ -101,16 +142,16 @@ class Flight:
     def to_dict(self):
         return {
             'data': self.data.to_dict('list'),
-            'parameters': self.parameters,
+            'parameters': self.parameters.to_dict('list'),
             'origin': self.origin.to_dict(),
             'primary_pos_source': self.primary_pos_source
         }
     
     @staticmethod
-    def from_dict(data: dict):
+    def from_dict(data: dict) -> Flight:
         return Flight(
             data=pd.DataFrame.from_dict(data['data']).set_index('time_flight', drop=False),
-            parameters=data['parameters'],
+            parameters=pd.DataFrame.from_dict(data['parameters']).set_index('time_flight', drop=False),
             origin=Origin.from_dict(data['origin']),
             primary_pos_source=data['primary_pos_source']
         )
@@ -122,11 +163,10 @@ class Flight:
 
     @staticmethod
     def from_json(file: str) -> Self:
-        with open(file, 'r') as f:
-            return Flight.from_dict(load(f))
+        return Flight.from_dict(load(open(file, 'r')))
 
     @staticmethod
-    def build_cols(**kwargs):
+    def build_cols(**kwargs) -> pd.DataFrame:
         df = pd.DataFrame(columns=list(fields.data.keys()))
         for k, v in kwargs.items():
             df[k] = v
@@ -151,7 +191,7 @@ class Flight:
                     otf, 
                     fl.data.reset_index(), 
                     on='time_actual'
-                ).set_index('time_index', drop=False)
+                ).set_index('time_flight', drop=False)
             ))
 
         return flos
@@ -173,7 +213,7 @@ class Flight:
 
     @property
     def duration(self):
-        return self.data.tail(1).index.item()
+        return self.data.iloc[-1].name - self.data.iloc[0].name
 
     def flying_only(self, minalt=5, minv=10):
         vs = abs(Point(self.velocity))
@@ -195,29 +235,36 @@ class Flight:
             pd.testing.assert_frame_equal(self.data, other.data)
             assert_almost_equal(self.origin.pos, other.origin.pos)
             assert self.origin.heading == other.origin.heading
+            pd.testing.assert_frame_equal(self.parameters, other.parameters)
             return True
-        except Exception as ex:
+        except Exception:
             return False
         
     @staticmethod
     def from_log(log:Union[Ardupilot, str], extra_types: list[str] = None, **kwargs) -> Flight:
         """Constructor from an ardupilot bin file."""
-        
         extra_types = [] if extra_types is None else extra_types
         
         if isinstance(log, str) or isinstance(log, Path):
-            parser = Ardupilot(str(log), types=list(set(Flight.ardupilot_types + extra_types)))
+            parser = Ardupilot.parse(str(log), types=list(set(Flight.ardupilot_types + extra_types)))
         else:
             parser = log
-
-        if parser.parms['AHRS_EKF_TYPE'] == 2:
+        
+        params = Flight.build_cols(
+            time_actual = parser.PARM.timestamp,
+            time_flight = parser.PARM.TimeUS / 1e6,
+            parameter = parser.PARM.Name,
+            value = parser.PARM.Value
+        ).set_index('time_flight', drop=False)
+       
+        if params.loc[params.parameter=='AHRS_EKF_TYPE'].iloc[0].value == 2:
             ekf1 = 'NKF1'
             ekf2 = 'NKF2'
         else:
             ekf1 = 'XKF1'
             ekf2 = 'XKF2'
 
-        ekf1 = parser.dfs[ekf1] if ekf1 in parser.dfs else  None
+        ekf1 = parser.dfs[ekf1] if ekf1 in parser.dfs else None
         ekf2 = parser.dfs[ekf2] if ekf2 in parser.dfs else None
 
         dfs = []
@@ -263,13 +310,13 @@ class Flight:
             }, 'C')
         if 'RATE' in parser.dfs:
             dfs.append(Flight.build_cols(
-                time_actual = parser.rate.timestamp,
-                axisrate_roll = parser.rate.R,
-                axisrate_pitch = parser.rate.P,
-                axisrate_yaw = parser.rate.Y,
-                desrate_roll = parser.rate.RDes,
-                desrate_pitch = parser.rate.PDes,
-                desrate_yaw = parser.rate.YDes,
+                time_actual = parser.RATE.timestamp,
+                axisrate_roll = parser.RATE.R,
+                axisrate_pitch = parser.RATE.P,
+                axisrate_yaw = parser.RATE.Y,
+                desrate_roll = parser.RATE.RDes,
+                desrate_pitch = parser.RATE.PDes,
+                desrate_yaw = parser.RATE.YDes,
             ))
         
         if 'IMU' in parser.dfs:
@@ -384,7 +431,7 @@ class Flight:
         
         origin = Origin('ekf_origin', GPS(parser.ORGN.iloc[:,-3:]), 0)
         
-        return Flight(dfout.set_index('time_flight', drop=False), parser.parms, origin, ppsorce)
+        return Flight(dfout.set_index('time_flight', drop=False), params, origin, ppsorce)
 
     @staticmethod
     def parse_instances(indf: pd.DataFrame, colmap:dict[str, str], instancecol='Instance'):
@@ -452,6 +499,7 @@ class Flight:
         )
 
     def filter(self, b, a):
+        from scipy.signal import filtfilt
         dont_filter = [c for c in fields.get_cols(['time', 'flightmode', 'rcin', 'rcout']) if c in self.data.columns]
         unwrap_cols = [c for c in fields.get_cols(['attitude']) if c in self.data.columns]
 
@@ -469,6 +517,7 @@ class Flight:
         )
     
     def butter_filter(self, cutoff, order=5):
+        from scipy.signal import butter
         ts = self.time_flight.to_numpy()
         N = len(self)
         T = (ts[-1] - ts[0]) / N

flightdata-0.2.7/flightdata/flight/parameters.py

@@ -0,0 +1,12 @@
+import numpy as np
+import pandas as pd
+from dataclasses import dataclass
+
+
+@dataclass
+class Parameters:
+    parms: dict[str, pd.DataFrame]
+
+    def __getattr(self, name: str) -> np.Any:
+        return self.parms[name]
+    

{flightdata-0.2.5 → flightdata-0.2.7}/flightdata/origin.py

@@ -91,25 +91,24 @@ class Origin(object):
             np.arctan2(direction.y[0], direction.x[0])
         )
 
-    def to_f3a_zone(self):
+    def to_f3a_zone(self, file: str):
         
         centre = self.pilot_position.offset(
             100 * g.Point(np.cos(self.heading), np.sin(self.heading), 0.0)
         )
 
-        oformat = lambda val: "{}".format(val)
-
-        return "\n".join([
-            "Emailed box data for F3A Zone Pro - please DON'T modify!",
-            self.name,
-            oformat(self.pilot_position.lat[0]),
-            oformat(self.pilot_position.long[0]),
-            oformat(centre.lat[0]),
-            oformat(centre.long[0]),
-            "120"
-        ])
-
-
+        with open(file, 'w') as f:
+            for line in [
+                "Emailed box data for F3A Zone Pro - please DON'T modify!",
+                self.name,
+                self.pilot_position.lat[0],
+                self.pilot_position.long[0],
+                centre.lat[0],
+                centre.long[0],
+                self.pilot_position.alt[0]
+            ]:
+                print(line, file=f)
+                
     @staticmethod
     def from_f3a_zone(file_path: str):
         if hasattr(file_path, "read"):
@@ -119,16 +118,16 @@ class Origin(object):
                 lines = f.read().splitlines()
         return Origin.from_points(
             lines[1],
-            g.GPS(float(lines[2]), float(lines[3]), 0),
-            g.GPS(float(lines[4]), float(lines[5]), 0)
+            g.GPS(float(lines[2]), float(lines[3]), float(lines[6])),
+            g.GPS(float(lines[4]), float(lines[5]), float(lines[6]))
         )
 
     @staticmethod
     def from_fcjson_parmameters(data: dict):
         return Origin.from_points(
             "FCJ_box",
-            g.GPS(float(data['pilotLat']), float(data['pilotLng']), 0),
-            g.GPS(float(data['centerLat']), float(data['centerLng']), 0)
+            g.GPS(float(data['pilotLat']), float(data['pilotLng']), float(data['pilotAlt'])),
+            g.GPS(float(data['centerLat']), float(data['centerLng']), float(data['centerAlt']))
         )
 
 

{flightdata-0.2.5 → flightdata-0.2.7}/flightdata/state.py

@@ -103,16 +103,16 @@ class State(Table):
         time = g.Time.from_t(np.array(flight.data.time_flight))
 
         if all(flight.contains('gps')) and flight.primary_pos_source == 'gps':
-            pos = origin.rotation.transform_point(g.GPS(flight.gps) - origin.pos[0])
+            pos = origin.rotation.transform_point(g.GPS(flight.gps.ffill().bfill()) - origin.pos[0])
         else: 
             pos = origin.rotation.transform_point(
-                flight.origin.pos.offset(g.Point(flight.position)) - origin.pos[0]
+                flight.origin.pos.offset(g.Point(flight.position.ffill().bfill())) - origin.pos[0]
             )
         
-        att = origin.rotation * g.Euler(flight.attitude) 
-        vel =  att.inverse().transform_point(origin.rotation.transform_point(g.Point(flight.velocity))) if all(flight.contains('velocity')) else None
-        rvel = g.Point(flight.axisrate) if all(flight.contains('axisrate')) else None
-        acc = g.Point(flight.acceleration) if all(flight.contains('acceleration')) else None
+        att = origin.rotation * g.Euler(flight.attitude.ffill().bfill()) 
+        vel =  att.inverse().transform_point(origin.rotation.transform_point(g.Point(flight.velocity.ffill().bfill()))) if all(flight.contains('velocity')) else None
+        rvel = g.Point(flight.axisrate.ffill().bfill()) if all(flight.contains('axisrate')) else None
+        acc = g.Point(flight.acceleration.ffill().bfill()) if all(flight.contains('acceleration')) else None
         
         return State.from_constructs(time, pos, att, vel, rvel, acc)
 
@@ -123,7 +123,7 @@ class State(Table):
         radius=5, mirror=True,
         weights = g.Point(1,1.2,0.5),
         tp_weights = g.Point(0.6,0.6,0.6),
-    ) -> Tuple(float, Self):
+    ) -> Tuple[float, Self]:
         """Perform a temporal alignment between two sections. return the flown section with labels 
         copied from the template along the warped path. 
         """
@@ -147,8 +147,6 @@ class State(Table):
 
         return distance, State.copy_labels(template, flown, path, 3)
 
-    
-    
     def splitter_labels(self: State, mans: List[dict], better_names: List[str]=None) -> State:
             """label the manoeuvres in a State based on the flight coach splitter information
 

flightdata-0.2.7/flightdata.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: flightdata
+Version: 0.2.7
+Summary: Module for handling UAV flight log data
+Home-page: https://github.com/PyFlightCoach/FlightData
+Author: Thomas David
+Author-email: thomasdavid0@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: simplejson
+Requires-Dist: pfc-geometry>=0.2.5
+Requires-Dist: ardupilot-log-reader>=0.3.1
+
+## FlightData
+This repo is contains a set of datastructures and tools for handling flight log data.
+
+### Flight 
+The Flight object represents the data logged by a flight controller. The class wraps a pandas dataframe which is indexed on a single time axis. Where data is logged at different rates for different sensors it is mapped to the closest time index. Attribute access provides individual columns or sets of columns in the groups defined in Fields. Item access subsets the data in the time axis. 
+
+### Table
+The Table is the base type for most of the datastructures. It allows attribute access to individual columns. Attribute access is also available to return basic entities subclassed from the base type in the pfc-geometry package. For example in the state object table.x provides the x position, table.pos provides a Point representing the xyz position. columns that are not represented by geometric base types are considered to be labels for the data.
+
+### State
+The State object is a table representing the position and orientation of the aircraft along with their derivatives, it can be constructed from a Flight or from scratch by extrapolating in lines or around arcs. Many tools are provided to manipulate the data. The position and attitude are in a reference frame (with Z up), the derivatives move with the aircraft in either the body, wind, stability or track (like the wind axis but with no wind) frame.  
+
+
+Further documentation will be provided here: https://pfcdocumentation.readthedocs.io/pyflightcoach/flightdata.html