flightdata 0.2.1__tar.gz → 0.2.3__tar.gz

{flightdata-0.2.1 → flightdata-0.2.3}/PKG-INFO

@@ -1,12 +1,15 @@
 Metadata-Version: 2.1
 Name: flightdata
-Version: 0.2.1
+Version: 0.2.3
 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: pfc-geometry
 
 ## FlightData
 This repo is contains a set of datastructures and tools for handling flight log data.

flightdata-0.2.3/flightdata/__init__.py

@@ -0,0 +1,8 @@
+from .base import *
+from .origin import Origin
+from .flight import *
+from .environment import *
+from .coefficients import Coefficients
+from .flow import Flow, Attack
+from .state import State
+from .model import *

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata/base/__init__.py

@@ -1,4 +1,4 @@
-from .table import Time, Table, Constructs, SVar
+from .table import Table, Constructs, SVar
 from .collection import Collection
 from .numpy_encoder import NumpyEncoder
 

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata/base/collection.py

@@ -48,11 +48,11 @@ class Collection:
     def to_list(self) -> List[T]:
         return list(self.data.values())
     
-    def to_dicts(self) -> list[dict[str, Any]]:
-        return [v.to_dict() for v in self.data.values()]
+    def to_dicts(self, *args, **kwargs) -> list[dict[str, Any]]:
+        return [v.to_dict(*args, **kwargs) for v in self.data.values()]
 
-    def to_dict(self) -> dict[str, dict[str, Any]]:
-        return {k: v.to_dict() for k, v in self.data.items()}
+    def to_dict(self, *args, **kwargs) -> dict[str, dict[str, Any]]:
+        return {k: v.to_dict(*args, **kwargs) for k, v in self.data.items()}
 
     @classmethod
     def from_dicts(cls, vals: list[dict[str: Any]]) -> Self:

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata/base/table.py

@@ -2,51 +2,20 @@ from __future__ import annotations
 import numpy as np
 import pandas as pd
 import numpy.typing as npt
-from geometry import Base,  Point, Quaternion, Transformation
-from typing import Union, Dict, Self
+from geometry import Base, Time
+from typing import Union, Self, Tuple
 from .constructs import SVar, Constructs
 from numbers import Number
-
 from time import time
 
 
-class Time(Base):
-    cols=["t", "dt"]
-    
-    @staticmethod
-    def from_t(t: np.ndarray) -> Self:
-        if isinstance(t, Number):
-            return Time(t, 1/30)
-        else:
-            dt = np.array([1/30]) if len(t) == 1 else np.gradient(t)
-            return Time(t, dt)
-
-    def scale(self, duration) -> Self:
-        old_duration = self.t[-1] - self.t[0]
-        sfac = duration / old_duration
-        return Time(
-            self.t[0] + (self.t - self.t[0]) * sfac,
-            self.dt * sfac
-        )
-
-    def reset_zero(self):
-        return Time(self.t - self.t[0], self.dt)
-
-    @staticmethod
-    def now():
-        return Time.from_t(time())
-
-    def extend(self):
-        return Time.concatenate([self, Time(self.t[-1] + self.dt[-1], self.dt[-1])])
-
-
 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"]               , make_time )
     ])
 
     def __init__(self, data: pd.DataFrame, fill=True, min_len=1):
@@ -94,6 +63,8 @@ class Table:
     
     @classmethod
     def from_dict(Cls, data):
+        if ['data'] in data:
+            data = data['data']
         return Cls(pd.DataFrame.from_dict(data).set_index("t", drop=False))
 
     def __len__(self):
@@ -118,7 +89,31 @@ class Table:
         inds = self.data.reset_index(names="t2").set_index("t").loc[sli].t2.to_numpy()#set_index("t", drop=False).columns
 
         return self.__class__(self.data.loc[inds])
-        
+
+    @classmethod
+    def stack(Cls, sections: list, overlap: int=1) -> Self:
+        """Stack a list of Tables on top of each other. 
+        The overlap is the number of rows to overlap between each section
+        """
+        # first build list of index offsets, to be added to each dataframe
+        if overlap > 0:
+            offsets = np.cumsum([0] + [sec.data.index[-overlap] for sec in sections[:-1]])
+            dfs = [section.data.iloc[:-overlap] for section in sections[:-1]] + [sections[-1].data]
+        elif overlap == 0:
+            offsets = np.cumsum([0] + [sec.duration + sec.dt[-1] for sec in sections[:-1]])
+            dfs = [section.data for section in sections]
+        else:
+            raise AttributeError("Overlap must be >= 0")
+
+        for df, offset in zip(dfs, offsets):
+            df.index = np.array(df.index) - df.index[0] + offset
+        combo = pd.concat(dfs)
+        combo.index.name = "t"
+
+        combo["t"] = combo.index
+
+        return Cls(combo)
+
     def __iter__(self):
         for ind in list(self.data.index):
             yield self[ind]
@@ -169,6 +164,9 @@ class Table:
             ignore_index=True
         ).set_index("t", drop=False))
 
+    
+    
+    
     def label(self, **kwargs) -> Self:
         return self.__class__(self.data.assign(**kwargs))
 
@@ -239,19 +237,51 @@ class Table:
     def shift_label(self, offset: int, min_len=None, **kwargs) -> Self:
         '''Shift the end of a label forwards or backwards by offset rows
         Do not allow a label to be reduced to less than min_len'''
+        if min_len is None:
+            min_len=1
         ranges = self.label_ranges()
         i = self.get_label_id(**kwargs)
         labels: pd.DataFrame = self.labels.copy()
+        labcols = [labels.columns.get_loc(c) for c in kwargs.keys()]
         if offset > 0 and i < len(ranges):
-            offset = min(offset, self.get_label_len(**ranges.iloc[i+1, :2].to_dict()) - min_len) 
+            offset = min(offset, ranges.iloc[i+1, -1] - min_len) 
             if offset > 0:
-                labels.iloc[ranges.iloc[i+1].start:ranges.iloc[i+1].start+offset, :] = pd.Series(kwargs)
-        elif offset < 0 and i > 0:
-            offset = max(offset, -self.get_label_len(**kwargs) + min_len)
+                labels.iloc[ranges.iloc[i+1].start:ranges.iloc[i+1].start+offset, labcols] = pd.Series(kwargs)
+        elif offset < 0:
+            offset = max(offset, -ranges.iloc[i, -1] + min_len)
             if offset < 0:
-                labels.iloc[ranges.iloc[i].end-offset:ranges.iloc[i].end, :] = pd.Series(kwargs)
+                labels.iloc[ranges.iloc[i].end+offset:ranges.iloc[i].end+1, labcols] = ranges.iloc[i+1].loc[kwargs.keys()]
         return self.label(**labels.to_dict(orient='list'))
     
+    @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):
+            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, :]), \
+               Cls(dfj.iloc[len(tb1)+steps:, :])
+    
+    def shift_label_ratio(self, ratio: float, min_len=None, **kwargs) -> Self:
+        '''shift a label within its allowable bounds, with a ratio of
+        1 representing the maximum allowabe movement forwards or backwards
+        without squashing a label'''
+        ranges = self.label_ranges()
+        i = self.get_label_id(**kwargs)
+        if ratio > 0:
+            limit = ranges.iloc[i+1, -1] - 2
+        else:    
+            limit = ranges.iloc[i, -1] -2
+        
+        return self.shift_label(int(limit * ratio), min_len, **kwargs)
+    
+    def shift_labels_ratios(self, ratios: list[float], min_len: int) -> Self:
+        assert len(ratios) == len(self.unique_labels())-1
+        res = self
+        for lab, ratio in zip([r[1] for r in self.unique_labels()[:-1].iterrows()], ratios):
+            res = res.shift_label_ratio(ratio, min_len, **lab)
+        return res
+    
     def get_label_id(self, **kwargs) -> Union[int, float]:
         dfo = self.unique_labels()
         for k, v in kwargs.items():
@@ -275,8 +305,10 @@ class Table:
         res = []
         for row in df.iterrows():
             res.append(list(self.label_range(t=t,**row[1].to_dict())))
-        return pd.concat([df, pd.DataFrame(res, columns=['start', 'end'])], axis=1)
-
+        df =  pd.concat([df, pd.DataFrame(res, columns=['start', 'end'])], axis=1)
+        df['length'] = df.end - df.start
+        return df
+        
     def single_labels(self) -> list[str]:
         return ['_'.join(r[1]) for r in self.data.loc[:, self.label_cols].iterrows()]
 

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata/environment/environment.py

@@ -1,6 +1,6 @@
 
-from flightdata import Flight, Constructs, SVar, Table, Origin, Time
-from geometry import Point, Base, P0
+from flightdata import Flight, Constructs, SVar, Table, Origin
+from geometry import Point, Base, P0, Time
 import numpy as np
 from .wind import WindModel, WindModelBuilder
 

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata/flight/flight.py

@@ -133,13 +133,12 @@ class Flight:
 
         flos = []
         for fl in fls:
-            flos.append(Flight(
-                pd.merge_asof(
+            flos.append(fl.copy(
+                data=pd.merge_asof(
                     otf, 
                     fl.data.reset_index(), 
                     on='time_actual'
-                ).set_index('time_index', drop=False),
-                fl.parameters
+                ).set_index('time_index', drop=False)
             ))
 
         return flos

{flightdata-0.2.1/flightdata/model → flightdata-0.2.3/flightdata}/flow.py

@@ -1,6 +1,6 @@
 
-from flightdata import Table, Time, SVar, Constructs, SVar, Flight, Origin
-from geometry import Point, Base, PX, Euler
+from flightdata import Table, SVar, Constructs, SVar, Flight, Origin
+from geometry import Point, Base, PX, Euler, Time
 import numpy as np
 
 

flightdata-0.2.3/flightdata/model/__init__.py

@@ -0,0 +1,11 @@
+class Model:
+    def __init__(self, *parms):
+        self.parms = parms
+        
+    def __call__(self, *args):
+        raise NotImplementedError("Model is an abstract class")
+
+
+from .aerodynamic import SimpleAerodynamic
+from .thrust import SimplePropeller
+

flightdata-0.2.3/flightdata/model/aerodynamic.py

@@ -0,0 +1,33 @@
+'''Take a flow and a controls, return the aerodynamic forces and moments'''
+from flightdata import Coefficients
+from . import Model
+import numpy as np
+import geometry as g
+
+
+class SimpleAerodynamic(Model):
+    nparms=12
+    def __call__(self, time,alpha,beta,a,e,r):
+        c = self.parms
+        return Coefficients.from_constructs(
+            time,
+            force=g.Point(
+                c[0] + c[1] * alpha**2 ,
+                c[2] * beta,
+                c[3] + c[4] * alpha
+            ),
+            moment=g.Point(
+                c[5] * a + c[6] * r,
+                c[7] + c[8] * alpha + c[9] * e,
+                c[10] * beta + c[11] * r
+            ),
+        )
+
+    initial = [
+        0.03, 0.2,
+        2,
+        0.0, 3.0,
+        1.0, 1.0,
+        0.0, 1.0, 0.01,
+        0.2, 0.01
+    ]

flightdata-0.2.3/flightdata/model/thrust.py

@@ -0,0 +1,10 @@
+from . import Model
+
+class SimplePropeller(Model):
+    nparms = 2
+    def __call__(self, u, pin):
+        c = self.parms
+        return c[0] + c[1] * pin / u
+
+
+    initial = [0.0, -1.0]

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata/origin.py

@@ -137,3 +137,4 @@ class Origin(object):
         return self.rotation.transform_point(g.Point(pned.y, pned.x, -pned.z ))
 
     
+    

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata/state.py

@@ -6,7 +6,7 @@ import numpy as np
 import pandas as pd
 from pandas.api.types import is_list_like
 import geometry as g
-from flightdata import Table, Constructs, SVar, Time, Origin, Flow, Environment
+from flightdata import Table, Constructs, SVar, Origin, Flow, Environment
 
 
 class State(Table):
@@ -33,7 +33,7 @@ class State(Table):
         if transform is None:
             transform = g.Transformation()
         if not "time" in kwargs: 
-            kwargs["time"] = Time.from_t(np.linspace(0, State._construct_freq*len(transform), len(transform)))
+            kwargs["time"] = g.Time.from_t(np.linspace(0, State._construct_freq*len(transform), len(transform)))
         return State.from_constructs(pos=transform.p, att=transform.q, **kwargs)
 
     def body_to_world(self, pin: g.Point, rotation_only=False) -> g.Point:
@@ -56,7 +56,7 @@ class State(Table):
         else:
             return self.back_transform.g.Point(pin)
 
-    def fill(self, time: Time) -> State:
+    def fill(self, time: g.Time) -> State:
         '''Project forward through time assuming small angles and uniform circular motion'''
         st = self[-1]
         vel = st.vel.tile(len(time))   
@@ -73,7 +73,7 @@ class State(Table):
         """Extrapolate the input state assuming uniform circular motion and small angles
         """
         npoints = np.max([int(np.ceil(duration / self.dt[0])), min_len])
-        time = Time.from_t(np.linspace(0,duration, npoints))
+        time = g.Time.from_t(np.linspace(0,duration, npoints))
         return self.fill(time)
 
     @staticmethod
@@ -101,7 +101,7 @@ class State(Table):
         elif origin is None:
             origin = flight.origin
 
-        time = Time.from_t(np.array(flight.data.time_flight))
+        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])
@@ -114,32 +114,9 @@ class State(Table):
         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
-          
+        
         return State.from_constructs(time, pos, att, vel, rvel, acc)
 
-    @staticmethod
-    def stack(sections: list) -> Self:
-        """Stack a list of States on top of each other. last row of each is replaced with first row of the next, 
-            indexes are offset so they are sequential. 
-            TODO this should move into the parent class.
-        """
-        # first build list of index offsets, to be added to each dataframe
-        offsets = np.cumsum([0] + [sec.duration for sec in sections[:-1]])
-
-        # The sections to be stacked need their last row removed, as the first row of the next replaces it
-        dfs = [section.data.iloc[:-1] for section in sections[:-1]] + \
-            [sections[-1].data.copy()]
-
-        # offset the df indexes
-        for df, offset in zip(dfs, offsets):
-            df.index = np.array(df.index) - df.index[0] + offset
-        combo = pd.concat(dfs)
-        combo.index.name = "t"
-
-        combo["t"] = combo.index
-
-        return State(combo)
-
     @staticmethod
     def align(
         flown: State, 
@@ -169,8 +146,10 @@ class State(Table):
             dist=euclidean
         )
 
-        return distance, State.copy_labels(template, flown, path, 2)
+        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
 
@@ -209,6 +188,7 @@ class State(Table):
 
             return State.stack(labelled)
 
+    
     def get_subset(self: State, mans: Union[list, slice], col="manoeuvre", min_len=1) -> Self:
         selectors = self.data.loc[:,col].unique()
         if isinstance(mans, slice):
@@ -231,7 +211,7 @@ class State(Table):
 
     def get_element(self: State, element: Union[str, list, int]) -> Self:
         return self.get_subset(element, "element") 
-
+        
     def get_man_or_el(self: State, el: str) -> Self:
         if el in self.data.element.unique():
             return self.get_element([el])
@@ -270,6 +250,15 @@ class State(Table):
             racc=self.racc,
         ))
 
+    def mirror_zy(self: State) -> State:
+        att = g.Quaternion.from_euler((self.att.to_euler() + g.Point(0, 0, np.pi)) * g.Point(-1, 1, -1))
+        return State.copy_labels(self, State.from_constructs(
+            time=self.time,
+            pos=self.pos * g.Point(-1, 1, 1),
+            att=att,#g.Quaternion(self.att.w, self.att.x, -self.att.y, -self.att.z),
+            vel=self.vel
+        ))
+
     def to_track(self: State) -> State:
         """This rotates the body so the x axis is in the velocity vector"""
         return self.body_to_wind()
@@ -360,34 +349,35 @@ class State(Table):
 
         return fcd
 
-    def _create_json_mans(self: State, sdef) -> pd.DataFrame:
+    def _create_json_mans(self: State, kfactors: list[int]) -> pd.DataFrame:
+        
         mans = pd.DataFrame(columns=["name", "id", "sp", "wd", "start", "stop", "sel", "background", "k"])
+        mnames = self.data.manoeuvre.unique()
+        mans["name"] = mnames
+        mans["k"] = kfactors
+        mans["id"] = ["sp_{}".format(i) for i in range(len(mnames))]
 
-        mans["name"] = ["tkoff"] + [man.info.short_name for man in sdef]
-        mans["k"] = [0] + [man.info.k for man in sdef]
-        mans["id"] = ["sp_{}".format(i) for i in range(len(sdef.data)+1)]
-
-        mans["sp"] = list(range(len(sdef.data) + 1))
+        mans["sp"] = list(range(len(mnames)))
         
-        itsecs = [self.get_manoeuvre(m.info.short_name) for m in sdef] 
+        itsecs = [self.get_manoeuvre(mn) for mn in mnames] 
 
-        mans["wd"] = [0.0] + [100 * st.duration / self.duration for st in itsecs]
+        mans["wd"] = [100 * st.duration / self.duration for st in itsecs]
         
         dat = self.data.reset_index(drop=True)
 
-        mans["start"] = [0] + [dat.loc[dat.manoeuvre==man.info.short_name].index[0] for man in sdef]
+        mans["start"] = [dat.loc[dat.manoeuvre==mn].index[0] for mn in mnames]
 
-        mans["stop"] = [mans["start"][1] + 1] + [dat.loc[dat.manoeuvre==man.info.short_name].index[-1] + 1 for man in sdef]
+        mans["stop"] = [dat.loc[dat.manoeuvre==mn].index[-1] + 1 for mn in mnames]
             
-        mans["sel"] = np.full(len(sdef.data) + 1, False)
+        mans["sel"] = np.full(len(mnames.data), False)
         mans.loc[1,"sel"] = True
-        mans["background"] = np.full(len(sdef.data) + 1, "")
+        mans["background"] = np.full(len(mnames), "")
 
         return mans
 
-    def create_fc_json(self: State, sdef, schedule_name: str, schedule_category: str="F3A"):
+    def create_fc_json(self: State, kfactors: list[int], schedule_name: str, schedule_category: str="F3A"):
         fcdata = self._create_json_data()
-        fcmans = self._create_json_mans(sdef)
+        fcmans = self._create_json_mans(kfactors)
         return {
             "version": "1.3",
             "comments": "DO NOT EDIT\n",
@@ -558,5 +548,20 @@ class State(Table):
 
     def arc_centre(self) -> g.Point:
         acc = g.Point.vector_rejection(self.zero_g_acc(), self.vel)
-
-        return acc.unit() * abs(self.vel) ** 2 / abs(acc)
+        with np.errstate(invalid='ignore'):
+            return acc.unit() * abs(self.vel) ** 2 / abs(acc)
+        
+    def F_gravity(self, mass: g.Mass):
+        '''Returns the gravitational force in N'''
+        return mass.m * self.att.inverse().transform_point(g.PZ(-9.81))
+    
+    def F_inertia(self, mass: g.Mass):
+        '''Returns the inertial force in N'''
+        return mass.m * (self.zero_g_acc() + g.Point.cross(self.rvel, self.vel))
+    
+    def M_inertia(self, mass: g.Mass):
+        '''return the inertial moment in N'''
+        h = mass.angular_momentum(self.rvel)
+        return h.diff(self.dt) + g.Point.cross(self.rvel, h)
+    
+    

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata.egg-info/PKG-INFO

@@ -1,12 +1,15 @@
 Metadata-Version: 2.1
 Name: flightdata
-Version: 0.2.1
+Version: 0.2.3
 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: pfc-geometry
 
 ## FlightData
 This repo is contains a set of datastructures and tools for handling flight log data.

{flightdata-0.2.1 → flightdata-0.2.3}/flightdata.egg-info/SOURCES.txt

@@ -3,6 +3,8 @@ README.md
 setup.cfg
 setup.py
 flightdata/__init__.py
+flightdata/coefficients.py
+flightdata/flow.py
 flightdata/origin.py
 flightdata/state.py
 flightdata.egg-info/PKG-INFO
@@ -23,9 +25,8 @@ flightdata/flight/ardupilot.py
 flightdata/flight/fields.py
 flightdata/flight/flight.py
 flightdata/model/__init__.py
-flightdata/model/coefficients.py
-flightdata/model/constants.py
-flightdata/model/flow.py
+flightdata/model/aerodynamic.py
+flightdata/model/thrust.py
 test/test_fields.py
 test/test_flight.py
 test/test_origin.py

{flightdata-0.2.1 → flightdata-0.2.3}/setup.cfg

@@ -5,7 +5,7 @@ author_email = thomasdavid0@gmail.com
 description = Module for handling UAV flight log data
 long_description = file: README.md
 long_description_content_type = text/markdown
-version = 0.2.1
+version = 0.2.3
 url = https://github.com/PyFlightCoach/FlightData
 
 [options]

flightdata-0.2.1/flightdata/__init__.py

@@ -1,6 +0,0 @@
-from .base import *
-from .origin import *
-from .flight import *
-from .environment import *
-from .model import *
-from .state import *

flightdata-0.2.1/flightdata/model/__init__.py

@@ -1,3 +0,0 @@
-from .flow import Flow
-from .coefficients import Coefficients
-from .constants import ACConstants, cold_draft

flightdata-0.2.1/flightdata/model/constants.py

@@ -1,19 +0,0 @@
-from geometry import Point, Mass
-from dataclasses import dataclass
-
-@dataclass
-class ACConstants:
-    s: float
-    c: float
-    b: float
-    mass: Mass
-    cg: Point
-
-
-cold_draft = ACConstants(
-    0.569124, 
-    0.31211, 
-    1.8594, 
-    Mass.cuboid(4.5, 800, 400, 100), 
-    Point(0.6192,0.0,0.0)
-)