flightanalysis 0.3.4__tar.gz → 0.3.6__tar.gz

{flightanalysis-0.3.4/flightanalysis.egg-info → flightanalysis-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.3.4
+Version: 0.3.6
 Summary: A package for analysing flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -15,10 +15,11 @@ Requires-Dist: fastdtw
 Requires-Dist: simplejson
 Requires-Dist: loguru
 Requires-Dist: joblib
-Requires-Dist: pfc-geometry>=0.2.10
-Requires-Dist: flightdata>=0.2.18
+Requires-Dist: pfc-geometry>=0.2.11
+Requires-Dist: flightdata>=0.2.19
 Requires-Dist: GitPython
 Requires-Dist: pyperclip
+Requires-Dist: packaging
 Provides-Extra: dev
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: pandas; extra == "dev"
@@ -27,8 +28,8 @@ 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.10; extra == "dev"
-Requires-Dist: flightdata>=0.2.18; extra == "dev"
+Requires-Dist: pfc-geometry>=0.2.11; extra == "dev"
+Requires-Dist: flightdata>=0.2.19; extra == "dev"
 Requires-Dist: ardupilot_log_reader>=0.3.3; extra == "dev"
 Requires-Dist: pymavlink; extra == "dev"
 Requires-Dist: GitPython; extra == "dev"

flightanalysis-0.3.6/create_schedules.py

@@ -0,0 +1,25 @@
+from flightanalysis.builders.schedules.f3a_p23 import p23_def
+from flightanalysis.builders.schedules.f3a_a25 import a25_def
+from flightanalysis.builders.schedules.f3a_p25 import p25_def
+from flightanalysis.builders.schedules.f3a_f25 import f25_def
+#from imac_unlim2024 import sdef as imac_unl2024_def
+from flightanalysis.builders.schedules.f3auk_clubman import clubman_def as f3auk_club_def
+from flightanalysis.builders.schedules.f3auk_intermediate import intermediate_def as f3auk_int_def
+from flightanalysis.builders.schedules.baeaglid_intermediate import sdef as baeaglid_intermediate_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,
+    "baeaglid_intermediate_schedule": baeaglid_intermediate_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.3.4 → flightanalysis-0.3.6}/examples/make_manoeuvre.py

@@ -2,30 +2,32 @@ 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)
+    Orientation, ManInfo, Heading)
 import numpy as np
-from flightanalysis.definition import f3amb
+from flightanalysis.builders.manbuilder import r, MBTags, c45, centred
+from flightanalysis.builders.f3a.manbuilder 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, 
+    "half square", "hSqL", k=2, position=Position.END, 
     start=BoxLocation(Height.TOP, Direction.UPWIND, Orientation.INVERTED),
-    end=BoxLocation(Height.BTM),
+    end=BoxLocation(Height.BTM)
 ),[
-    MBTags.CENTRE,
-    f3amb.spin(r(2)),
-    f3amb.roll(r(0.5), line_length=165),
     f3amb.loop(np.pi/2),
+    f3amb.roll(r(1)),
+    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)
+it = mdef.guess_itrans(170, Heading.RIGHT)
+
+mdef.fit_box(it)
 
 man = mdef.create()
 
@@ -36,5 +38,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()
+#fig = go.Figure(data=axis_rate_trace(tp))
+#fig.show()

flightanalysis-0.3.6/examples/plot_manoeuvre.py

@@ -0,0 +1,8 @@
+from flightanalysis import ManDef, SchedDef
+
+from flightanalysis.builders.schedules.baeaglid_intermediate import sdef
+
+
+md: ManDef = sdef[3]
+
+md.plot().show()

flightanalysis-0.3.6/flightanalysis/analysis/analysis_json.py

@@ -0,0 +1,28 @@
+from flightanalysis import ma, ScheduleInfo, ScheduleAnalysis
+from flightdata import Origin, State
+
+
+
+
+
+def create_analysis_json(
+    origin: Origin, sbin: str, sfcj: str, st: State, sa: ScheduleAnalysis
+):
+    pass
+
+
+# readonly box: Origin,
+# readonly isComp: boolean,
+# readonly sourceBin: string,
+# readonly sourceFCJ: string,
+# readonly mans: MAExport[],
+# readonly states: States
+
+
+# readonly name: string,
+# readonly id: number,
+# readonly sinfo: ScheduleInfo,
+# readonly start: number,
+# readonly stop: number,
+#       readonly k: number,
+# readonly history: Record<string, FCJManResult> = {},

{flightanalysis-0.3.4 → flightanalysis-0.3.6}/flightanalysis/analysis/el_analysis.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from flightdata import State
 from typing import Self
-from flightanalysis import ElDef, Element, ManParms
+from flightanalysis import ElDef, Element, ManParms, DownGrades
 from dataclasses import dataclass
 import geometry as g
 
@@ -35,5 +35,5 @@ class ElementAnalysis:
         )
     
     def intra_score(self):
-        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()]
+        return self.edef.dgs.apply(self.el, 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.3.4 → flightanalysis-0.3.6}/flightanalysis/analysis/manoeuvre_analysis/alignment.py

@@ -7,6 +7,7 @@ from loguru import logger
 from .basic import Basic
 from flightanalysis.definition import ManDef, ScheduleInfo
 from ..el_analysis import ElementAnalysis
+import traceback
 
 
 @dataclass
@@ -32,16 +33,27 @@ class Alignment(Basic):
             self = self.downgrade()
         new = self
         while self.__class__.__name__ != "Scored":
-            new = (
-                self.run(optimise_aligment)
-                if isinstance(self, Complete)
-                else self.run()
-            )
+            try:
+                new = (
+                    self.run(optimise_aligment)
+                    if isinstance(self, Complete)
+                    else self.run()
+                )
+            except Exception as e:
+                logger.error(traceback.format_exc())    
             if new.__class__.__name__ == self.__class__.__name__:
                 break
             self = new
         return new
 
+    def to_dict(self):
+        return dict(
+            **super().to_dict(),
+            manoeuvre=self.manoeuvre.to_dict(),
+            template=self.template.to_dict(),
+        )
+
+
     @staticmethod
     def from_dict(data: dict, fallback=True):
         ia = Basic.from_dict(data)
@@ -77,8 +89,8 @@ class Alignment(Basic):
 
     def update(self, aligned: State) -> Alignment:
         man, tp = self.manoeuvre.match_intention(self.template[0], aligned)
-        mdef = ManDef(self.mdef.info, self.mdef.mps.update_defaults(man), self.mdef.eds)
-        return Alignment(self.id, mdef, aligned, self.direction, man, tp)
+        mdef = ManDef(self.mdef.info, self.mdef.mps.update_defaults(man), self.mdef.eds, self.mdef.box)
+        return Alignment(self.id, mdef, aligned, self.entry, self.exit, man, tp)
 
     def _proceed(self) -> Complete:
         if "element" in self.flown.data.columns:
@@ -87,7 +99,8 @@ class Alignment(Basic):
                 self.id,
                 self.mdef,
                 self.flown,
-                self.direction,
+                self.entry,
+                self.exit,
                 self.manoeuvre,
                 self.template,
                 correction,

{flightanalysis-0.3.4 → flightanalysis-0.3.6}/flightanalysis/analysis/manoeuvre_analysis/analysis.py

@@ -6,8 +6,6 @@ from flightanalysis.definition import ScheduleInfo
 class Analysis:
     id: int
 
-    def to_dict(self):
-        return {k: (v.to_dict() if hasattr(v, 'to_dict') else v) for k, v in self.__dict__.items()}
 
     def to_mindict(self, sinfo: ScheduleInfo):
         return {

{flightanalysis-0.3.4 → flightanalysis-0.3.6}/flightanalysis/analysis/manoeuvre_analysis/basic.py

@@ -2,26 +2,39 @@ from __future__ import annotations
 from dataclasses import dataclass
 from flightdata import State, Flight, Origin
 from flightanalysis.definition import ManDef, SchedDef, ManOption
+from flightanalysis.definition.maninfo import Heading
 import geometry as g
 from json import load
 from .analysis import Analysis
 from flightanalysis.definition.scheduleinfo import ScheduleInfo
 import numpy as np
 import pandas as pd
+from typing import Annotated
 
 
 @dataclass
 class Basic(Analysis):
     mdef: ManDef | ManOption
     flown: State
-    direction: int
+    entry: Annotated[Heading | None, "The direction the manoeuvre should start in, None for inferred"]
+    exit: Annotated[Heading | None, "The direction the manoeuvre should end in, None for inferred"]
 
     @property
     def name(self):
         return self.mdef.uid
 
+
+    def to_analysis_dict(self) -> dict:
+        return dict(
+            id=self.id,
+            mdef=self.mdef.to_dict(),
+            flown=self.flown.to_dict(),
+            entry=self.entry.name if self.entry else None,
+            exit=self.exit.name if self.exit else None,
+        )
+
     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"""
+        """Run the analysis to the final stage"""
         drs = [r._run(True) for r in self.run()]
 
         dr = drs[np.argmin([dr[0] for dr in drs])]
@@ -30,7 +43,10 @@ class Basic(Analysis):
 
     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
+            or self.flown.data.element.isna().any()
+        ):
             return self
         mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
         elnames = self.flown.data.element.unique().astype(str)
@@ -51,31 +67,48 @@ class Basic(Analysis):
             .add_lines()
             .match_intention(State.from_transform(itrans), self.flown)
         )
-        mdef = ManDef(mdef.info, mdef.mps.update_defaults(man), mdef.eds)
+        mdef = ManDef(mdef.info, mdef.mps.update_defaults(man), mdef.eds, mdef.box)
         corr = mdef.create().add_lines()
         return Complete(
             self.id,
             mdef,
             self.flown,
-            self.direction,
+            self.entry,
+            self.exit,
             man,
             tp,
             corr,
             corr.create_template(itrans, self.flown),
         )
 
+    def to_dict(self) -> dict:
+        return dict(
+            mdef=self.mdef.to_dict(),
+            flown=self.flown.to_dict(),
+            entry=self.entry.name if self.entry else None,
+            exit=self.exit.name if self.exit else None,
+        )
+
     @classmethod
     def from_dict(Cls, data: dict) -> Basic:
         return Basic(
             -1,
             ManDef.from_dict(data["mdef"]),
             State.from_dict(data["flown"]),
-            data["direction"],
+            Heading[data["entry"]] if data["entry"] else None,
+            Heading[data["exit"]] if data["exit"] else None,
         )
 
     def create_itrans(self) -> g.Transformation:
+        entry = (
+            self.entry
+            if self.entry is not None
+            else Heading.infer(self.flown[0].att.transform_point(g.PX()).bearing()[0])
+        )
+
         return g.Transformation(
-            self.flown[0].pos, self.mdef.info.start.initial_rotation(self.direction)
+            self.flown[0].pos,
+            g.Euler(self.mdef.info.start.orientation.value, 0, entry.value),
         )
 
     @staticmethod
@@ -83,7 +116,7 @@ class Basic(Analysis):
         with open(file, "r") as f:
             data = load(f)
         flight = Flight.from_fc_json(data)
-        box = Origin.from_fcjson_parmameters(data["parameters"])
+        box = Origin.from_fcjson_parameters(data["parameters"])
 
         sdef = SchedDef.load(data["parameters"]["schedule"][1])
 
@@ -105,7 +138,8 @@ class Basic(Analysis):
                     self.id,
                     mdef,
                     self.flown,
-                    self.direction,
+                    self.entry,
+                    self.exit,
                     man,
                     man.create_template(itrans),
                 )
@@ -118,7 +152,8 @@ class Basic(Analysis):
             name=self.name,
             id=self.id,
             data=self.flown._create_json_data().to_dict("records"),
-            direction=self.direction,
+            entry=self.entry.name,
+            exit=self.exit.name,
         )
         return data
 

{flightanalysis-0.3.4 → flightanalysis-0.3.6}/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -1,24 +1,24 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
-from ..el_analysis import ElementAnalysis
+
+import geometry as g
+import numpy as np
 from flightdata import State
-from flightanalysis.definition import ManDef, ElDef
+from loguru import logger
+
+from flightanalysis.definition import ElDef, ManDef
+from flightanalysis.elements import Element
 from flightanalysis.manoeuvre import Manoeuvre
 from flightanalysis.scoring import (
-    Results,
-    ManoeuvreResults,
-    Measurement,
     ElementsResults,
-    Result,
+    ManoeuvreResults,
+    Results,
 )
-from flightanalysis.scoring.criteria.f3a_criteria import F3A
-from flightanalysis.definition.maninfo import Position
-from flightanalysis.elements import Element
-import geometry as g
-import numpy as np
-from .basic import Basic
+
+from ..el_analysis import ElementAnalysis
 from .alignment import Alignment
-from loguru import logger
+from .basic import Basic
 
 
 @dataclass
@@ -26,6 +26,13 @@ class Complete(Alignment):
     corrected: Manoeuvre
     corrected_template: State
 
+    def to_dict(self):
+        return dict(
+            **super().to_dict(),
+            corrected=self.corrected.to_dict(),
+            corrected_template=self.corrected_template.to_dict(),
+        )
+
     @staticmethod
     def from_dict(data: dict, fallback=True):
         pa = Alignment.from_dict(data, fallback)
@@ -56,14 +63,14 @@ class Complete(Alignment):
         return list(self.mdef.eds.data.keys())
 
     def __iter__(self):
-        for edn in ["entry_line"] + list(self.mdef.eds.data.keys()):
+        for edn in list(self.mdef.eds.data.keys()):
             yield self.get_ea(edn)
 
     def __getitem__(self, i):
-        return self.get_ea("entry_line" if i == 0 else self.mdef.eds[i + 1].name)
+        return self.get_ea(self.mdef.eds[i + 1].name)
 
     def __getattr__(self, name):
-        if name in self.mdef.eds.data.keys() or name == "entry_line":
+        if name in self.mdef.eds.data.keys():
             return self.get_ea(name)
         raise AttributeError(f"Attribute {name} not found in {self.__class__.__name__}")
 
@@ -112,7 +119,7 @@ class Complete(Alignment):
         ed: ElDef = self.get_edef(eln)
         el: Element = self.manoeuvre.all_elements()[eln].match_intention(itrans, fl)
         tp = el.create_template(State.from_transform(itrans), fl)
-        return ed.dgs.apply(el.uid, fl, tp, False), tp[-1].att
+        return ed.dgs.apply(el, fl, tp, False), tp[-1].att
 
     def optimise_split(
         self, itrans: g.Transformation, eln1: str, eln2: str, fl: State
@@ -194,97 +201,7 @@ class Complete(Alignment):
                 f"pass {count}, {len(padjusted)} elements adjusted:\n{padjusted}"
             )
 
-        return Basic(self.id, self.mdef, fl, self.direction).proceed()
-
-    def side_box(self):
-        meas = Measurement.side_box(self.flown)
-        errors, dgs, keys = F3A.intra.box(F3A.intra.box.prepare(meas.value))
-        return Result(
-            "side box",
-            meas,
-            meas.value,
-            np.arange(len(meas.value)),
-            errors,
-            dgs * meas.visibility[keys],
-            keys,
-            F3A.intra.box,
-        )
-
-    def top_box(self):
-        meas = Measurement.top_box(self.flown)
-        errors, dgs, keys = F3A.intra.box(F3A.intra.box.prepare(meas.value))
-        return Result(
-            "top box",
-            meas,
-            meas.value,
-            np.arange(len(meas.value)),
-            errors,
-            dgs * meas.visibility[keys],
-            keys,
-            F3A.intra.box,
-        )
-        # return F3A.intra.box("top box", Measurement.top_box(self.flown))
-
-    def create_centre_result(self, name: str, st: State) -> Result:
-        meas = Measurement.centre_box(st)
-        errors, dgs, keys = F3A.intra.angle(meas.value)
-        return Result(
-            name,
-            meas,
-            meas.value,
-            np.arange(len(meas.value)),
-            errors,
-            dgs * meas.visibility[keys],
-            keys,
-            F3A.intra.angle,
-        )
-
-    def centre(self):
-        results = Results("centres")
-        for cpid in self.mdef.info.centre_points:
-            if cpid == len(self.manoeuvre.elements):
-                st = self.manoeuvre.elements[-1].get_data(self.flown)[-1]
-            else:
-                st = self.manoeuvre.elements[cpid].get_data(self.flown)[0]
-            results.add(self.create_centre_result(f"centre point {cpid}", st))
-
-        for ceid, fac in self.mdef.info.centred_els:
-            ce = self.manoeuvre.elements[ceid].get_data(self.flown)
-            path_length = (abs(ce.vel) * ce.dt).cumsum()
-            id = np.abs(path_length - path_length[-1] * fac).argmin()
-            results.add(
-                self.create_centre_result(
-                    f"centred element {ceid}", State(ce.data.iloc[[id], :])
-                )
-            )
-
-        if len(results) == 0 and self.mdef.info.position == Position.CENTRE:
-            al = State(
-                self.flown.data.loc[
-                    (self.flown.data.element != "entry_line")
-                    & (self.flown.data.element != "exit_line")
-                ]
-            )
-            midy = (np.max(al.y) + np.min(al.y)) / 2
-            midid = np.abs(al.pos.y - midy).argmin()
-            results.add(self.create_centre_result("centred manoeuvre", al[midid]))
-
-        return results
-
-    def distance(self):
-        # TODO doesnt quite cover it, stalled manoeuvres could drift to > 170 for no downgrade
-        meas = Measurement.depth(self.flown)
-        mistakes, dgs, dgids = F3A.intra.depth(F3A.intra.depth.prepare(meas.value))
-        return Result(
-            "distance",
-            meas,
-            meas.value,
-            np.arange(len(meas.value)),
-            mistakes,
-            dgs * meas.visibility[dgids],  # should be weighted average visibility
-            dgids,
-            F3A.intra.depth,
-        )
+        return Basic(self.id, self.mdef, fl, self.entry, self.exit).proceed()
 
     def intra(self):
         return ElementsResults([ea.intra_score() for ea in self])
@@ -293,22 +210,10 @@ class Complete(Alignment):
         return self.mdef.mps.collect(self.manoeuvre, self.template)
 
     def positioning(self):
-        pres = Results("positioning")
-        if self.mdef.info.position == Position.CENTRE:
-            pres.add(self.centre())
-        tp_width = max(self.corrected_template.y) - min(self.corrected_template.y)
-        if tp_width < 10:
-            pres.add(self.distance())
-        tb = self.top_box()
-        if tb.total > 0:
-            pres.add(self.top_box())
-        sb = self.side_box()
-        if sb.total > 0:
-            pres.add(self.side_box())
-        return pres
+        return self.mdef.box.score(self.mdef.info, self.flown, self.template)
 
     def plot_3d(self, **kwargs):
-        from flightplotting import plotsec, plotdtw
+        from flightplotting import plotdtw, plotsec
 
         fig = plotdtw(self.flown, self.flown.data.element.unique())
         return plotsec(self.flown, color="blue", nmodels=20, fig=fig, **kwargs)

{flightanalysis-0.3.4 → flightanalysis-0.3.6}/flightanalysis/analysis/manoeuvre_analysis/scored.py

@@ -16,6 +16,13 @@ class Scored(Complete):
             self.corrected_template
         )
     
+    def to_dict(self):
+        return dict(
+            **super().to_dict(),
+            scores=self.scores.to_dict()
+        )
+
+
     @staticmethod
     def from_dict(data:dict, fallback=True):
         ca = Complete.from_dict(data, fallback)