flightdata 0.2.11__tar.gz → 0.2.13__tar.gz

{flightdata-0.2.11/flightdata.egg-info → flightdata-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightdata
-Version: 0.2.11
+Version: 0.2.13
 Summary: Module for handling UAV flight log data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3

{flightdata-0.2.11 → flightdata-0.2.13}/flightdata/base/__init__.py

@@ -2,5 +2,8 @@ from .table import Table, Constructs, SVar
 from .collection import Collection
 from .numpy_encoder import NumpyEncoder
 
-
-
+def to_list(obj):
+    if hasattr(obj, 'tolist'):
+        return obj.tolist()
+    else:
+        return list(obj)

{flightdata-0.2.11 → flightdata-0.2.13}/flightdata/base/table.py

@@ -80,40 +80,16 @@ class Table:
         else:
             raise TypeError(f"Expected Number or slice, got {sli.__class__.__name__}")
         
-
     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
 
         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]
 
+
     @classmethod
     def from_constructs(cls, *args,**kwargs) -> Self:
         kwargs = dict(
@@ -132,7 +108,7 @@ class Table:
         )
 
         return cls(df)
-
+    
     def __repr__(self):
         return f"{self.__class__.__name__} Table(duration = {self.duration})"
 
@@ -160,6 +136,30 @@ class Table:
             ignore_index=True
         ).set_index("t", drop=False))
       
+    @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 label(self, **kwargs) -> Self:
         return self.__class__(self.data.assign(**kwargs))
 
@@ -176,9 +176,11 @@ class Table:
     
     def get_subset_df(self, **kwargs) -> pd.DataFrame:
         dfo = self.data
+        sel = np.full(len(self.data), True)
         for k, v in kwargs.items():
-            dfo = dfo.loc[dfo[k] == v, :]            
-        return dfo
+            sel = sel & (dfo[k] == v)
+
+        return self.data.loc[sel + (sel.astype(int).diff() == -1)]
 
     def get_label_subset(self, min_len=1, **kwargs) -> Self:
         return self.__class__(self.get_subset_df(**kwargs), min_len=min_len)
@@ -243,13 +245,14 @@ class Table:
         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]:
+    def shift_multi(Cls, steps: int, tb1: Self, tb2: Self, min_len=1) -> 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 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, :]), \
-               Cls(dfj.iloc[len(tb1)+steps:, :])
+        #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')
+        tj = Cls.stack([tb1, tb2]).shift_label(steps, min_len, **dict(tb1.labels.iloc[0]))
+        
+        return Cls(tj.get_subset_df(**dict(tb1.labels.iloc[0]))), \
+             Cls(tj.get_subset_df(**dict(tb2.labels.iloc[0])))
     
     def shift_label_ratio(self, ratio: float, min_len=None, **kwargs) -> Self:
         '''shift a label within its allowable bounds, with a ratio of
@@ -376,7 +379,7 @@ class Table:
                         if max_bck + max_fwd + get_len(i) < min_len:
                             raise Exception(f'{row.iloc[0]},{row.iloc[1]} too short and cannot shorten adjacent labels further')
                         else:
-                            _extend = (min_len - get_len(i)) / 2
+                            _extend = int(np.ceil((min_len - get_len(i)) / 2))
                             ebck = min(max_bck, int(np.floor(_extend)))
                             efwd = min(max_fwd, int(np.floor(_extend))+1)
 

{flightdata-0.2.11 → flightdata-0.2.13}/flightdata/flight/flight.py

@@ -447,6 +447,27 @@ class Flight:
                 ))
             return dfs
 
+    @staticmethod
+    def parse_fcj_data(origin: Origin, df: pd.DataFrame):
+        df = Flight.build_cols(
+            time_actual = df['time']/1e6 + int(time()),
+            time_flight = df['time']/1e6,
+            attitude_roll = np.radians(df['r']),
+            attitude_pitch = np.radians(df['p']),
+            attitude_yaw = np.radians(df['yw']),
+            position_N = df['N'],
+            position_E = df['E'],
+            position_D = df['D'],
+            velocity_N = df['VN'],
+            velocity_E = df['VE'],
+            velocity_D = df['VD'],
+            wind_N = df['wN'] if 'wN' in df.columns else None,
+            wind_E = df['wE'] if 'wE' in df.columns else None,
+        )
+
+        return Flight(df.set_index('time_flight', drop=False), None, origin, 'position')
+    
+    
     @staticmethod
     def from_fc_json(fc_json: Union[str, dict, IO]) -> Self:
         
@@ -473,20 +494,24 @@ class Flight:
             wind_N = df['wN'] if 'wN' in df.columns else None,
             wind_E = df['wE'] if 'wE' in df.columns else None,
         )
-        origin = Origin(
-            'fcj_origin',
-            GPS(
-                float(fc_json['parameters']['pilotLat']), 
-                float(fc_json['parameters']['pilotLng']), 
-                float(fc_json['parameters']['pilotAlt'])
-            ).offset(-Point(
-                fc_json['parameters']['moveNorth'],
-                fc_json['parameters']['moveEast'],
-                0,
-            )), 
-            0
-        )
-        
+
+        if 'parameters' in fc_json:
+            origin = Origin(
+                'fcj_origin',
+                GPS(
+                    float(fc_json['parameters']['pilotLat']), 
+                    float(fc_json['parameters']['pilotLng']), 
+                    float(fc_json['parameters']['pilotAlt'])
+                ).offset(-Point(
+                    fc_json['parameters']['moveNorth'],
+                    fc_json['parameters']['moveEast'],
+                    0,
+                )), 
+                0
+            )
+        else:
+            origin = Origin('dummy_origin', GPS(0,0,0), -np.pi/2)
+            
         return Flight(df.set_index('time_flight', drop=False), None, origin, 'position')#.remove_time_flutter()
 
     def remove_time_flutter(self):

{flightdata-0.2.11 → flightdata-0.2.13}/flightdata/scripts/collect_logs.py

@@ -25,4 +25,7 @@ def main():
         if not (folder / file.name).exists():
             print(f'copying {file} to {folder / file.name}')
             shutil.copyfile(file, folder / file.name )
-        
+        
+
+if __name__ == '__main__':
+    main()

{flightdata-0.2.11 → flightdata-0.2.13}/flightdata/scripts/flightline.py

@@ -54,4 +54,7 @@ def main():
     else:
         box = box_from_log(Flight.from_log(plog), args.input)
 
-    box.to_f3a_zone(Path(args.logdir) / f'box_{plog.stem}.f3a')
+    box.to_f3a_zone(Path(args.logdir) / f'box_{plog.stem}.f3a')
+
+if __name__ == '__main__':
+    main()

{flightdata-0.2.11 → flightdata-0.2.13}/flightdata/state.py

@@ -15,7 +15,6 @@ class State(Table):
         SVar("vel", g.Point,       ["u", "v", "w"]           , lambda st: g.P0() if len(st)==1 else st.att.inverse().transform_point(st.pos.diff(st.dt))),
         SVar("rvel", g.Point,       ["p", "q", "r"]           , lambda st: g.P0() if len(st)==1 else st.att.body_diff(st.dt)),
         SVar("acc", g.Point,       ["du", "dv", "dw"]        , lambda st : g.P0() if len(st)==1 else st.att.inverse().transform_point(st.att.transform_point(st.vel).diff(st.dt) + g.PZ(9.81, len(st)))),
-        SVar("racc", g.Point,       ["dp", "dq", "dr"]        , lambda st: g.P0() if len(st)==1 else st.rvel.diff(st.dt)),
     ])
     _construct_freq = 30
 
@@ -131,7 +130,7 @@ class State(Table):
         from scipy.spatial.distance import euclidean
         def get_brv(brv):
             if mirror:
-                brv = brv.abs() * g.Point(1, 0, 1) + brv * g.Point(0, 1, 0 )
+                brv = g.Point(np.abs(brv.x), brv.y, np.abs(brv.z))#brv.abs() * g.Point(1, 0, 1) + brv * g.Point(0, 1, 0 )
             return brv * weights
 
         fl = get_brv(flown.rvel)
@@ -147,7 +146,7 @@ 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:
+    def splitter_labels(self: State, mans: List[dict], better_names: List[str]=None, target_col='manoeuvre') -> State:
             """label the manoeuvres in a State based on the flight coach splitter information
 
             TODO this assumes the state only contains the dataset contained in the json
@@ -164,7 +163,7 @@ class State(Table):
             takeoff = self.data.iloc[0:int(mans[0]["stop"])+1]
 
             labels = [mans[0]["name"]]
-            labelled = [State(takeoff).label(manoeuvre=labels[0])]
+            labelled = [State(takeoff).label(**{target_col:labels[0]})]
             if better_names:
                 better_names.append('land')
 
@@ -179,7 +178,7 @@ class State(Table):
                 labelled.append(
                     State(
                         self.data.iloc[int(split_man["start"]):int(split_man["stop"])+1]
-                    ).label(manoeuvre=name)
+                    ).label(**{target_col:name})
                 )
                 labels.append(split_man["name"])
 
@@ -217,7 +216,7 @@ class State(Table):
         
     def get_meid(self: State, manid: int, elid: int=None):
         st = self.get_manoeuvre(manid)
-        if not elid is None:
+        if elid is not None:
             return st.get_element(elid)
         else:
             return st
@@ -233,7 +232,6 @@ class State(Table):
             vel=q.transform_point(self.vel),
             rvel=q.transform_point(self.rvel),
             acc=q.transform_point(self.acc),
-            racc=q.transform_point(self.racc),
         ))
 
     def scale(self: State, factor: float) -> State:
@@ -244,7 +242,6 @@ class State(Table):
             vel=self.vel * factor,
             rvel=self.rvel,
             acc=self.acc * factor,
-            racc=self.racc,
         ))
 
     def mirror_zy(self: State) -> State:
@@ -456,7 +453,6 @@ class State(Table):
             vel=self.vel,
             rvel=self.rvel,
             acc=self.acc,
-            racc=self.racc,
         ))
 
     def move_back(self:State, transform:g.Transformation) -> State:

{flightdata-0.2.11 → flightdata-0.2.13/flightdata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightdata
-Version: 0.2.11
+Version: 0.2.13
 Summary: Module for handling UAV flight log data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3

{flightdata-0.2.11 → flightdata-0.2.13}/test/base/test_table.py

@@ -8,7 +8,7 @@ from pytest import fixture
 
 @fixture
 def df():
-    df = pd.DataFrame(np.linspace(0,100, 100), columns=['t'])
+    df = pd.DataFrame(np.linspace(0,5, 6), columns=['t'])
     return df.set_index("t", drop=False)
 
 @fixture
@@ -54,12 +54,15 @@ def test_get_subset_df(tab_full, labst):
     assert len(tab_full) == len(df)
 
 
-def test_shift_labels_ratios(tab_full):
-    tf = tab_full.label(element='e0', manoeuvre='m0')
-    tf.data.loc[tf.duration/2:,'element'] = 'e1'
-    
+def test_shift_labels_ratios(tab_full: Table):
+    tf: Table = Table.stack([
+        tab_full.label(element='e0', manoeuvre='m0'),
+        tab_full.label(element='e1', manoeuvre='m0')
+
+    ])
+        
     assert sum(tf.shift_labels_ratios([0.5],2).element == 'e1') < sum(tf.element == 'e1')
-    tf
+    
     
 def test_stack(tab_full):
     tfn = Table.stack([tab_full.label(element='e0'), tab_full.label(element='e1')], overlap=0)
@@ -72,18 +75,18 @@ def test_stack(tab_full):
 
 
 def test_shift_multi(tab_full):
-    t1, t2 = tab_full.label(element='e1'), tab_full.label(element='e2')
-    tb1, tb2 = Table.shift_multi(2, t1, t2)
+    tabs = Table.stack([tab_full.label(element='e0'), tab_full.label(element='e1')], overlap=1).split_labels()
+    tb1, tb2 = Table.shift_multi(2, tabs['e0'], tabs['e1'])
     
     assert len(tb1) == len(tab_full) + 2
     assert len(tb2) == len(tab_full) - 2
     assert tb2.duration == tab_full.data.index[-3]
     
-    tb1, tb2 = Table.shift_multi(-5, t1, t2)
+    tb1, tb2 = Table.shift_multi(-3, tabs['e0'], tabs['e1'])
     
-    assert len(tb1) == len(tab_full) - 5
-    assert len(tb2) == len(tab_full) + 5
-    assert tb1.duration == tab_full.data.index[-6]
+    assert len(tb1) == len(tab_full) - 3
+    assert len(tb2) == len(tab_full) + 3
+    assert tb1.duration == tab_full.data.index[-4]
 
 
 def test_table_cumulative_labels(tab_full):
@@ -102,6 +105,6 @@ def test_table_cumulative_labels(tab_full):
     indexes = np.unique(res, return_index=True)[1]
     np.testing.assert_array_equal(
         [res[index] for index in sorted(indexes)],
-        np.array(['a1_b1', 'a2_b1', 'a2_b2', 'a1_b1_1'])
+        np.array(['a1_b1_0', 'a2_b1_0', 'a2_b2_0', 'a1_b1_1'])
     )
     pass