flightanalysis 0.2.18__tar.gz → 0.2.20__tar.gz

{flightanalysis-0.2.18 → flightanalysis-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.18
+Version: 0.2.20
 Summary: A package for analysing flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -15,9 +15,10 @@ Requires-Dist: fastdtw
 Requires-Dist: simplejson
 Requires-Dist: loguru
 Requires-Dist: joblib
-Requires-Dist: pfc-geometry>=0.2.8
-Requires-Dist: flightdata>=0.2.16
+Requires-Dist: pfc-geometry>=0.2.10
+Requires-Dist: flightdata>=0.2.18
 Requires-Dist: GitPython
+Requires-Dist: pyperclip
 Provides-Extra: dev
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: pandas; extra == "dev"
@@ -26,11 +27,12 @@ Requires-Dist: fastdtw; extra == "dev"
 Requires-Dist: simplejson; extra == "dev"
 Requires-Dist: loguru; extra == "dev"
 Requires-Dist: joblib; extra == "dev"
-Requires-Dist: pfc-geometry>=0.2.8; extra == "dev"
-Requires-Dist: flightdata>=0.2.16; extra == "dev"
+Requires-Dist: pfc-geometry>=0.2.10; extra == "dev"
+Requires-Dist: flightdata>=0.2.18; extra == "dev"
 Requires-Dist: ardupilot_log_reader>=0.3.3; extra == "dev"
 Requires-Dist: pymavlink; extra == "dev"
 Requires-Dist: GitPython; extra == "dev"
+Requires-Dist: pyperclip; extra == "dev"
 
 # FlightAnalysis
 

flightanalysis-0.2.20/create_schedules.py

@@ -0,0 +1,24 @@
+from flightanalysis.definition.builders.schedules.f3a_p23 import p23_def
+from flightanalysis.definition.builders.schedules.f3a_a25 import a25_def
+from flightanalysis.definition.builders.schedules.f3a_p25 import p25_def
+from flightanalysis.definition.builders.schedules.f3a_f25 import f25_def
+#from imac_unlim2024 import sdef as imac_unl2024_def
+from flightanalysis.definition.builders.schedules.f3auk_clubman import clubman_def as f3auk_club_def
+from flightanalysis.definition.builders.schedules.f3auk_intermediate import intermediate_def as f3auk_int_def
+
+sdefs = {
+    'f3a_p23_schedule': p23_def, 
+    'f3a_a25_schedule': a25_def, 
+    'f3a_p25_schedule': p25_def, 
+    'f3a_f25_schedule': f25_def, 
+    #'IMAC_Unlimited2024_schedule': imac_unl2024_def, 
+    'f3auk_clubman_schedule': f3auk_club_def, 
+    'f3auk_inter_schedule': f3auk_int_def
+}
+
+def create_all():
+    for k, sdef in sdefs.items():
+        sdef.to_json(f"flightanalysis/data/{k}.json")
+
+if __name__ == '__main__':
+    create_all()

flightanalysis-0.2.20/examples/make_manoeuvre.py

@@ -0,0 +1,40 @@
+from flightplotting import plotsec, plot_regions
+from flightplotting.traces import axis_rate_trace
+from flightanalysis import (
+    ManDef, BoxLocation, Position, Height, Direction, 
+    Orientation, ManInfo, r, MBTags, c45, centred, ManParm, Combination)
+import numpy as np
+from flightanalysis.definition import f3amb
+from flightdata import NumpyEncoder
+import plotly.graph_objects as go
+from json import dumps
+import geometry as g
+
+mdef: ManDef = f3amb.create(ManInfo(
+    "Spin", "iSpin", k=3, position=Position.CENTRE, 
+    start=BoxLocation(Height.TOP, Direction.UPWIND, Orientation.INVERTED),
+    end=BoxLocation(Height.BTM),
+),[
+    MBTags.CENTRE,
+    f3amb.spin(r(2)),
+    f3amb.roll(r(0.5), line_length=165),
+    f3amb.loop(np.pi/2),
+])
+
+data = mdef.to_dict()
+print(dumps(data, indent=2, cls=NumpyEncoder))
+mdef = ManDef.from_dict(data)
+
+it = g.Transformation(g.Point(-20,150,50), mdef.info.initial_transform(150, 1).rotation)
+
+man = mdef.create()
+
+tp = man.create_template(it)
+
+fig = plot_regions(tp, 'element', span=5)
+fig = plotsec(tp, fig=fig, nmodels=10, scale=5)
+#fig.add_traces(boxtrace())
+fig.show()
+
+fig = go.Figure(data=axis_rate_trace(tp))
+fig.show()

{flightanalysis-0.2.18 → flightanalysis-0.2.20}/flightanalysis/analysis/el_analysis.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 from flightdata import State
 from typing import Self
 from flightanalysis import ElDef, Element, ManParms
-import numpy as np
 from dataclasses import dataclass
 import geometry as g
 
@@ -18,7 +17,7 @@ class ElementAnalysis:
 
     def plot_3d(self, **kwargs):
         from flightplotting import plotsec
-        return plotsec([self.fl, self.tp], **kwargs)
+        return plotsec(dict(fl=self.fl, tp=self.tp), **kwargs)
 
     def to_dict(self):
         return {k: v.to_dict() for k, v in self.__dict__.items()}
@@ -36,5 +35,5 @@ class ElementAnalysis:
         )
     
     def intra_score(self):
-        return self.edef.dgs.apply(self.el, self.fl, self.tp)
+        return self.edef.dgs.apply(self.el.uid, self.fl, self.tp) #[dg.apply(self.el.uid + (f'_{k}' if len(k) > 0 else ''), self.fl, self.tp) for k, dg in self.edef.dgs.items()]
     

{flightanalysis-0.2.18 → flightanalysis-0.2.20}/flightanalysis/analysis/manoeuvre_analysis/alignment.py

@@ -2,64 +2,73 @@ from __future__ import annotations
 from dataclasses import dataclass
 from flightdata import State
 from flightanalysis.manoeuvre import Manoeuvre
+from flightanalysis.elements import Element
 from loguru import logger
 from .basic import Basic
 from flightanalysis.definition import ManDef, ScheduleInfo
 from ..el_analysis import ElementAnalysis
 
+
 @dataclass
 class Alignment(Basic):
     manoeuvre: Manoeuvre | None
     template: State | None
 
     def __getattr__(self, name) -> ElementAnalysis:
+        el: Element = self.manoeuvre.elements.data[name]
         return ElementAnalysis(
             self.mdef.eds.data[name],
             self.mdef.mps,
-            self.manoeuvre.elements.data[name],
-            self.flown.get_element(name),
-            self.template.get_element(name),
-            self.template.get_element(name)[0].transform
+            el,
+            el.get_data(self.flown),
+            el.get_data(self.template),
+            el.get_data(self.template)[0].transform,
         )
 
-    def run_all(self, optimise_aligment=True, force=False) -> Alignment | Complete | Scored:
-        if self.__class__.__name__ == 'Scored' and force:
+    def run_all(
+        self, optimise_aligment=True, force=False
+    ) -> Alignment | Complete | Scored:
+        if self.__class__.__name__ == "Scored" and force:
             self = self.downgrade()
         new = self
-        while self.__class__.__name__ != 'Scored':
-            new = self.run(optimise_aligment) if isinstance(self, Complete) else self.run()
+        while self.__class__.__name__ != "Scored":
+            new = (
+                self.run(optimise_aligment)
+                if isinstance(self, Complete)
+                else self.run()
+            )
             if new.__class__.__name__ == self.__class__.__name__:
                 break
             self = new
         return new
-    
+
     @staticmethod
     def from_dict(data: dict, fallback=True):
         ia = Basic.from_dict(data)
-        try:    
+        try:
             ia = Alignment(
-                manoeuvre=Manoeuvre.from_dict(data['manoeuvre']),
-                template=State.from_dict(data['template']),
-                **ia.__dict__
+                manoeuvre=Manoeuvre.from_dict(data["manoeuvre"]),
+                template=State.from_dict(data["template"]),
+                **ia.__dict__,
             )
         except Exception as e:
             if fallback:
-                logger.debug(f'Failed to parse Alignment {repr(e)}')
+                logger.debug(f"Failed to parse Alignment {repr(e)}")
             else:
                 raise e
         return ia
 
     def run(self) -> Alignment | Complete:
-        if 'element' not in self.flown.data.columns:
+        if "element" not in self.flown.data.columns:
             try:
                 self = self._run(True)[1]
             except Exception as e:
-                logger.error(f'Failed to run alignment stage 1: {repr(e)}')
+                logger.error(f"Failed to run alignment stage 1: {repr(e)}")
                 return self
         try:
             return self._run(False)[1].proceed()
         except Exception as e:
-            logger.error(f'Failed to run alignment stage 2: {repr(e)}')
+            logger.error(f"Failed to run alignment stage 2: {repr(e)}")
             return self
 
     def _run(self, mirror=False, radius=10) -> Alignment:
@@ -72,33 +81,32 @@ class Alignment(Basic):
         return Alignment(self.id, mdef, aligned, self.direction, man, tp)
 
     def _proceed(self) -> Complete:
-        if 'element' in self.flown.data.columns:
-            correction = self.mdef.create(self.template[0].transform)
+        if "element" in self.flown.data.columns:
+            correction = self.mdef.create()
             return Complete(
-                self.id, self.mdef, self.flown, self.direction, 
-                self.manoeuvre, self.template, correction, 
-                correction.create_template(self.template[0], self.flown)
+                self.id,
+                self.mdef,
+                self.flown,
+                self.direction,
+                self.manoeuvre,
+                self.template,
+                correction,
+                correction.create_template(self.template[0], self.flown),
             )
         else:
             return self
 
-    def to_mindict(self, sinfo: ScheduleInfo=None, full=False):
-        data = dict(
-            els = self.flown.label_ranges('element').to_dict('records')
-        )
+    def to_mindict(self, sinfo: ScheduleInfo = None, full=False):
+        data = dict(els=self.flown.label_ranges("element").to_dict("records"))
         if full:
-            data = dict(
-                **super().to_mindict(sinfo),
-                **data
-            )
+            data = dict(**super().to_mindict(sinfo), **data)
         return data
 
     def fcj_results(self):
-        df = self.flown.label_ranges('element').iloc[:,:3]
-        df.columns = ['name', 'start', 'stop']
-        return dict(
-            els=df.to_dict('records')
-        )
+        df = self.flown.label_ranges("element").iloc[:, :3]
+        df.columns = ["name", "start", "stop"]
+        return dict(els=df.to_dict("records"))
+
 
 from .complete import Complete  # noqa: E402
-from .scored import Scored  # noqa: E402
+from .scored import Scored  # noqa: E402

{flightanalysis-0.2.18 → flightanalysis-0.2.20}/flightanalysis/analysis/manoeuvre_analysis/basic.py

@@ -23,54 +23,64 @@ class Basic(Analysis):
     def run_all(self, optimise_aligment=True, force=False) -> Scored:
         """Run the analysis to the final stage, for the case where the elements have not been labelled"""
         drs = [r._run(True) for r in self.run()]
-        
+
         dr = drs[np.argmin([dr[0] for dr in drs])]
 
         return dr[1].run_all(optimise_aligment, force)
 
     def proceed(self) -> Complete:
         """Proceed the analysis to the final stage for the case where the elements have already been labelled"""
-        if 'element' not in self.flown.data.columns:
+        if "element" not in self.flown.data.columns:
             return self
         mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
-        elnames = self.flown.data.element.unique()
+        elnames = self.flown.data.element.unique().astype(str)
         for md in mopt:
-            if np.all(elnames[1:-1] == list( md.eds.data.keys())):
+            if np.all(
+                [np.any(np.char.startswith(elnames, k)) for k in md.eds.data.keys()]
+            ):
                 mdef = md
                 break
         else:
-            raise ValueError(f"{self.mdef.info.short_name} element sequence doesn't agree with {self.flown.data.element.unique()}")
+            raise ValueError(
+                f"{self.mdef.info.short_name} element sequence doesn't agree with {self.flown.data.element.unique()}"
+            )
 
         itrans = self.create_itrans()
-        man, tp = mdef.create(itrans).add_lines().match_intention(
-            State.from_transform(itrans),
-            self.flown
+        man, tp = (
+            mdef.create()
+            .add_lines()
+            .match_intention(State.from_transform(itrans), self.flown)
         )
         mdef = ManDef(mdef.info, mdef.mps.update_defaults(man), mdef.eds)
-        corr = mdef.create(itrans).add_lines()
+        corr = mdef.create().add_lines()
         return Complete(
-            self.id, mdef, self.flown, self.direction,
-            man, tp, corr, corr.create_template(itrans, self.flown)
+            self.id,
+            mdef,
+            self.flown,
+            self.direction,
+            man,
+            tp,
+            corr,
+            corr.create_template(itrans, self.flown),
         )
 
     @classmethod
-    def from_dict(Cls, data:dict) -> Basic:
+    def from_dict(Cls, data: dict) -> Basic:
         return Basic(
             -1,
             ManDef.from_dict(data["mdef"]),
             State.from_dict(data["flown"]),
-            data['direction']
+            data["direction"],
         )
 
     def create_itrans(self) -> g.Transformation:
-        return g.Transformation( 
-            self.flown[0].pos, 
-            self.mdef.info.start.initial_rotation(self.direction)
+        return g.Transformation(
+            self.flown[0].pos, self.mdef.info.start.initial_rotation(self.direction)
         )
 
     @staticmethod
     def from_fcj(file: str, mid: int):
-        with open(file, 'r') as f:
+        with open(file, "r") as f:
             data = load(f)
         flight = Flight.from_fc_json(data)
         box = Origin.from_fcjson_parmameters(data["parameters"])
@@ -78,23 +88,28 @@ class Basic(Analysis):
         sdef = SchedDef.load(data["parameters"]["schedule"][1])
 
         state = State.from_flight(flight, box).splitter_labels(
-            data["mans"],
-            [m.info.short_name for m in sdef]
+            data["mans"], [m.info.short_name for m in sdef]
         )
-        mdef= sdef[mid]
+        mdef = sdef[mid]
         return Basic(mid, mdef, state.get_manoeuvre(mdef.uid))
 
     def run(self) -> list[Alignment]:
         itrans = self.create_itrans()
         mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
 
-        als = []        
+        als = []
         for mdef in mopt:
-            man = mdef.create(itrans).add_lines()
-            als.append(Alignment(
-                self.id, mdef, self.flown, self.direction, 
-                man, man.create_template(itrans)
-            ))
+            man = mdef.create().add_lines()
+            als.append(
+                Alignment(
+                    self.id,
+                    mdef,
+                    self.flown,
+                    self.direction,
+                    man,
+                    man.create_template(itrans),
+                )
+            )
         return als
 
     def to_mindict(self, sinfo: ScheduleInfo):
@@ -102,30 +117,32 @@ class Basic(Analysis):
             **super().to_mindict(sinfo),
             name=self.name,
             id=self.id,
-            data=self.flown._create_json_data().to_dict('records'),
+            data=self.flown._create_json_data().to_dict("records"),
             direction=self.direction,
-        ) 
+        )
         return data
 
     @staticmethod
     def from_mindict(data: dict):
         info = ScheduleInfo.from_str(data["parameters"]["schedule"][1])
-        
+
         st = State.from_flight(
-            Flight.from_fc_json(data), 
-            Origin.from_fcjson_parmameters(data["parameters"])
+            Flight.from_fc_json(data),
+            Origin.from_fcjson_parmameters(data["parameters"]),
         )
-        
-        mdef = SchedDef.load(info)[data['id']] 
-        
-        if 'els' in data:
-            df = pd.DataFrame(data['els'])
-            df.columns = ['name', 'start', 'stop', 'length']
-            st = st.splitter_labels(df.to_dict('records'), target_col='element').label(manoeuvre=data['name'])
 
-        return Basic(data['id'], mdef, st, data['direction'])
-    
+        mdef = SchedDef.load(info)[data["id"]]
+
+        if "els" in data:
+            df = pd.DataFrame(data["els"])
+            df.columns = ["name", "start", "stop", "length"]
+            st = st.splitter_labels(df.to_dict("records"), target_col="element").label(
+                manoeuvre=data["name"]
+            )
+
+        return Basic(data["id"], mdef, st, data["direction"])
+
 
 from .alignment import Alignment  # noqa: E402
 from .complete import Complete  # noqa: E402
-from .scored import Scored  # noqa: E402
+from .scored import Scored  # noqa: E402