flightanalysis 0.3.16__tar.gz → 0.3.18__tar.gz

{flightanalysis-0.3.16 → flightanalysis-0.3.18}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: flightanalysis
-Version: 0.3.16
+Version: 0.3.18
 Summary: Python tools for Analysis of Flight Data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: fastdtw>=0.3.4
-Requires-Dist: flightdata>=0.2.25
+Requires-Dist: flightdata>=0.3.0
 Requires-Dist: joblib>=1.4.2
 Requires-Dist: json-stream>=2.3.2
 Requires-Dist: loguru>=0.7.2
 Requires-Dist: numpy>=2.1.3
 Requires-Dist: pandas>=2.2.3
-Requires-Dist: pfcschemas>=0.1.7
+Requires-Dist: pfcschemas>=0.1.10
 Requires-Dist: scipy>=1.14.1
 Requires-Dist: simplejson>=3.19.3
 Provides-Extra: dataflash

flightanalysis-0.3.18/examples/tailslide.py

@@ -0,0 +1,25 @@
+from flightanalysis import Loop, Line, Snap, Elements, Manoeuvre
+import numpy as np
+from flightdata import State
+import geometry as g
+from plotting import plotsec
+
+from flightanalysis.elements.tail_slide import TailSlide
+
+
+# man = Manoeuvre(Elements([
+#    Line('entry_line', 30, 60, 0),
+#    Loop('loop', 30, np.pi/2, 50, 0, 0),
+#    Line("upline", 30, 100, 0),
+#    TailSlide("tslide", -5, np.pi, np.radians(30), np.pi),
+#    Line("downline", 30, 100, 0),
+#    Loop("loop2", 30, np.pi/2, 50, 0,0 )
+# ]), Line('exit_line', 30, 60, 0))
+#tp = man.create_template(State.from_transform(g.Transformation()))
+
+
+tp = TailSlide("tslide", -5, -np.pi, np.radians(30), np.pi).create_template(
+    State.from_transform(g.Transformation(g.Euler(0, -np.pi/2, 0)))
+)
+
+plotsec(tp, nmodels=10, scale=1).show()

{flightanalysis-0.3.16 → flightanalysis-0.3.18}/pyproject.toml

@@ -1,19 +1,19 @@
 [project]
 name = "flightanalysis"
-version="0.3.16"
+version="0.3.18"
 description = "Python tools for Analysis of Flight Data"
 readme = "README.md"
 authors = [{ name = "Thomas David", email = "thomasdavid0@gmail.com" }]
 requires-python = ">=3.12"
 dependencies = [
     "fastdtw>=0.3.4",
-    "flightdata>=0.2.25",
+    "flightdata>=0.3.0",
     "joblib>=1.4.2",
     "json-stream>=2.3.2",
     "loguru>=0.7.2",
     "numpy>=2.1.3",
     "pandas>=2.2.3",
-    "pfcschemas>=0.1.7",
+    "pfcschemas>=0.1.10",
     "scipy>=1.14.1",
     "simplejson>=3.19.3",
 ]

{flightanalysis-0.3.16 → flightanalysis-0.3.18}/src/flightanalysis/analysis/el_analysis.py

@@ -15,6 +15,18 @@ class ElementAnalysis:
     tp: State
     ref_frame: g.Transformation
 
+    def update(self, new_fl: State):
+        new_el = self.el.match_intention(self.ref_frame, new_fl)
+        new_tp = new_el.create_template(self.tp[0], new_fl.time)
+        return ElementAnalysis(
+            self.edef,
+            self.mps,
+            new_el,
+            new_fl,
+            new_tp,
+            self.ref_frame
+        )
+
     def plot_3d(self, **kwargs):
         from plotting import plotsec
         return plotsec(dict(fl=self.fl, tp=self.tp), **kwargs)
@@ -34,6 +46,9 @@ class ElementAnalysis:
             g.Transformation.from_dict(data['ref_frame'])
         )
     
+    def score_dg(self, dg: str):
+        return self.edef.dgs[dg](self.el, self.fl, self.tp)
+
     def intra_score(self):
         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.18/src/flightanalysis/analysis/manoeuvre_analysis/alignment.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from flightdata import State, align
+
+from flightanalysis.definition import ManDef
+from flightanalysis.elements import Element
+from flightanalysis.manoeuvre import Manoeuvre
+
+from ..el_analysis import ElementAnalysis
+from .basic import Basic
+
+
+@dataclass(repr=False)
+class Alignment(Basic):
+    manoeuvre: Manoeuvre | None
+    templates: dict[str, State] | None
+
+    @property
+    def template(self):
+        return State.stack(self.templates, "element")
+
+    @property
+    def template_list(self):
+        return list(self.templates.values())
+
+    def get_ea(self, name_or_id: str | int) -> ElementAnalysis:
+        el: Element = self.manoeuvre.elements[name_or_id]
+
+        return ElementAnalysis(
+            self.mdef.eds[name_or_id],
+            self.mdef.mps,
+            el,
+            self.flown.element[el.uid],
+            self.templates[el.uid],
+            self.templates[el.uid][0].transform,
+        )
+
+    def __getattr__(self, name) -> ElementAnalysis:
+        return self.get_ea(name)
+
+    def __getitem__(self, name_or_id) -> ElementAnalysis:
+        return self.get_ea(name_or_id)
+
+    def run_all(
+        self, optimise_aligment=True, force=False
+    ) -> Alignment | Complete | Scored:
+        if self.__class__.__name__ == "Scored" and force:
+            self = self.downgrade()
+        while self.__class__.__name__ != "Scored":
+            self = (
+                self.run(optimise_aligment)
+                if isinstance(self, Complete)
+                else self.run()
+            )
+        return self
+
+    @staticmethod
+    def from_dict(ajman: dict) -> Alignment | Basic:
+        basic = Basic.from_dict(ajman)
+        if isinstance(basic, Basic) and "manoeuvre" in ajman and ajman["manoeuvre"]:
+            if "template" in ajman:
+                if set(ajman["template"].keys()) == set(
+                    [el["uid"] for el in ajman["manoeuvre"]["elements"]] + ["exit_line"]
+                ):
+                    return Alignment(
+                        **basic.__dict__,
+                        manoeuvre=Manoeuvre.from_dict(ajman["manoeuvre"]),
+                        templates={
+                            k: State.from_dict(v) for k, v in ajman["template"].items()
+                        }
+                        if "templates" in ajman
+                        else None,
+                    )
+        return basic
+
+    def to_dict(self, basic: bool = False) -> dict:
+        _basic = super().to_dict(basic)
+        if basic:
+            return _basic
+        return dict(
+            **_basic,
+            manoeuvre=self.manoeuvre.to_dict(),
+            template={k: tp.to_dict(True) for k, tp in self.templates.items()},
+        )
+
+    def run(self) -> Alignment | Complete:
+        if "element" not in self.flown.labels.lgs:
+            return self._run(True)[1]
+        return self._run(False)[1].proceed()
+        
+    def _run(self, mirror=False, radius=10) -> Alignment:
+        res = align(self.flown, self.template, radius, mirror)
+        return res.dist, self.update(res.aligned)
+
+    def update(self, aligned: State) -> Alignment:
+        man, tps = self.manoeuvre.match_intention(self.template_list[0][0], aligned)
+        mdef = ManDef(
+            self.mdef.info,
+            self.mdef.mps.update_defaults(man),
+            self.mdef.eds,
+            self.mdef.box,
+        )
+        return Alignment(self.id, self.schedule_direction, aligned, mdef, man, tps)
+
+    def _proceed(self) -> Complete:
+        if "element" in self.flown.labels.keys():
+            correction = self.mdef.create()
+            return Complete(
+                self.id,
+                self.schedule_direction,
+                self.flown,
+                self.mdef,
+                self.manoeuvre,
+                self.template,
+                correction,
+                correction.create_template(self.template[0], self.flown),
+            )
+        else:
+            return self
+
+
+
+from .complete import Complete  # noqa: E402
+from .scored import Scored  # noqa: E402

{flightanalysis-0.3.16 → flightanalysis-0.3.18}/src/flightanalysis/analysis/manoeuvre_analysis/basic.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+import stat
 from typing import Annotated
+from xmlrpc.client import boolean
 
 import numpy as np
 
@@ -9,8 +11,12 @@ import geometry as g
 from flightdata import State
 from schemas.positioning import Direction, Heading
 from flightanalysis.definition import ManDef, ManOption
+from schemas.sinfo import ScheduleInfo
 
 from .analysis import Analysis
+from schemas import MA, fcj
+from importlib.metadata import version
+
 
 
 @dataclass
@@ -28,10 +34,13 @@ class Basic(Analysis):
 
     def __str__(self):
         res = f"{self.__class__.__name__}({self.id}, {self.mdef.info.short_name})"
-        if hasattr(self, "scores"):
-            res = res[:-1] + f", {', '.join([f'{k}={v:.2f}' for k, v in self.scores.score_summary(3, False).items()])})"
+        if isinstance(self, Scored):
+            res = (
+                res[:-1]
+                + f", {', '.join([f'{k}={v:.2f}' for k, v in self.scores.score_summary(3, False).items()])})"
+            )
         return res
-    
+
     def __repr__(self):
         return str(self)
 
@@ -39,25 +48,20 @@ class Basic(Analysis):
         """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])]
+        dr: Alignment = drs[np.argmin([dr[0] for dr in drs])][1]
 
-        return dr[1].run_all(optimise_aligment, force)
+        return dr.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
-            or self.flown.data.element.isna().any()
-            or not isinstance(self, Basic)
-        ):
+        if "element" not in self.flown.labels.keys() or not isinstance(self, Basic):
             return self
 
         mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
-        elnames = self.flown.data.element.unique().astype(str)
+
+        elnames = list(self.flown.labels.element.keys())
         for md in mopt:
-            if np.all(
-                [np.any(np.char.startswith(elnames, k)) for k in md.eds.data.keys()]
-            ):
+            if len(elnames) != len(md.eds) or np.all([elnames[i] == k for i, k in enumerate(md.eds.data.keys())]):
                 mdef = md
                 break
         else:
@@ -66,22 +70,19 @@ class Basic(Analysis):
             )
 
         itrans = self.create_itrans()
-        man, tp = (
+        man, tps = (
             mdef.create()
             .add_lines()
             .match_intention(State.from_transform(itrans), self.flown)
         )
         mdef = ManDef(mdef.info, mdef.mps.update_defaults(man), mdef.eds, mdef.box)
-        corr = mdef.create().add_lines()
         return Complete(
             self.id,
             self.schedule_direction,
             self.flown,
             mdef,
             man,
-            tp,
-            corr,
-            corr.create_template(itrans, self.flown),
+            tps,
         )
 
     @staticmethod
@@ -89,25 +90,34 @@ class Basic(Analysis):
         return Basic(
             id=data["id"],
             schedule_direction=Heading[data["schedule_direction"]]
-            if (data["schedule_direction"] and data['schedule_direction'] != "Infer")
+            if (data["schedule_direction"] and data["schedule_direction"] != "Infer")
             else None,
             flown=State.from_dict(data["flown"]),
             mdef=ManDef.from_dict(data["mdef"]),
         )
 
-    def to_dict(self, basic:bool=False) -> dict:
+    def to_dict(self, basic: bool = False) -> dict:
         return dict(
             id=self.id,
-            schedule_direction=self.schedule_direction.name if self.schedule_direction else None,
-            flown=self.flown.to_dict(),
+            schedule_direction=self.schedule_direction.name
+            if self.schedule_direction
+            else None,
+            flown=self.flown.to_dict(True),
             **(dict(mdef=self.mdef.to_dict()) if not basic else {}),
         )
 
     def create_itrans(self) -> g.Transformation:
-        if self.schedule_direction and self.mdef.info.start.direction is not Direction.CROSS:
-            entry_direction = self.mdef.info.start.direction.wind_swap_heading(self.schedule_direction)
+        if (
+            self.schedule_direction
+            and self.mdef.info.start.direction is not Direction.CROSS
+        ):
+            entry_direction = self.mdef.info.start.direction.wind_swap_heading(
+                self.schedule_direction
+            )
         else:
-            entry_direction = Heading.infer(self.flown[0].att.transform_point(g.PX()).bearing()[0])
+            entry_direction = Heading.infer(
+                self.flown[0].att.transform_point(g.PX()).bearing()[0]
+            )
 
         return g.Transformation(
             self.flown[0].pos,
@@ -133,6 +143,44 @@ class Basic(Analysis):
             )
         return als
 
+    def export_ma(self, schedule: ScheduleInfo, history: dict = None) -> MA:
+        return MA(
+            **self.to_dict(),
+            name=self.mdef.info.short_name,
+            schedule=schedule,
+            history={
+                **(history if history else {}),
+                **(
+                    {
+                        version("fatuning"): fcj.ManResult.model_validate(
+                            self.fcj_results()
+                        )
+                    }
+                    if self.__class__.__name__ == "Scored"
+                    else {}
+                ),
+            },
+        )
+
+    @staticmethod
+    def parse_analyse_serialise(pad: dict, optimise: boolean, name:str):
+        import tuning
+        from flightanalysis import enable_logging
+        logger = enable_logging("INFO")
+        logger.info(f"Running {name}")
+        try:
+            pad = Scored.from_dict(pad)
+        except Exception as e:
+            logger.exception(f"Failed to parse {pad['id']}")
+            return pad
+        
+        try:
+            pad = pad.proceed().run_all(optimise)
+            logger.info(f"Completed {name}")
+            return pad.to_dict()
+        except Exception as e:
+            logger.exception(f"Failed to process {name}")
+            return pad.to_dict()
 
 from .alignment import Alignment  # noqa: E402
 from .complete import Complete  # noqa: E402

{flightanalysis-0.3.16 → flightanalysis-0.3.18}/src/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -1,56 +1,40 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from functools import partial
+from numbers import Number
 
 import geometry as g
 import numpy as np
+import pandas as pd
 from flightdata import State
 from loguru import logger
+from joblib import Parallel, delayed
 
 from flightanalysis.definition import ElDef, ManDef
 from flightanalysis.elements import Element
-from flightanalysis.manoeuvre import Manoeuvre
 from flightanalysis.scoring import (
     ElementsResults,
     ManoeuvreResults,
     Results,
 )
-
+import os
 from ..el_analysis import ElementAnalysis
 from .alignment import Alignment
 from .basic import Basic
 
 
-@dataclass
+@dataclass(repr=False)
 class Complete(Alignment):
-    corrected: Manoeuvre
-    corrected_template: State
+    # corrected: Manoeuvre
+    # corrected_templates: dict[str, State]
 
     @staticmethod
     def from_dict(ajman: dict) -> Complete | Alignment | Basic:
-        analysis = Alignment.from_dict(ajman)
-        if (
-            isinstance(analysis, Alignment)
-            and ajman["corrected"]
-            and ajman["corrected_template"]
-        ):
-            return Complete(
-                **analysis.__dict__,
-                corrected=Manoeuvre.from_dict(ajman["corrected"]),
-                corrected_template=State.from_dict(ajman["corrected_template"]),
-            )
-        else:
-            return analysis
-
-    def to_dict(self, basic: bool=False) -> dict:
-        _basic = super().to_dict(basic)
-        if basic:
-            return _basic
-        return dict(
-            **_basic,
-            corrected=self.corrected.to_dict(),
-            corrected_template=self.corrected_template.to_dict(),
-        )
+        return Alignment.from_dict(ajman).proceed()
+
+    def to_dict(self, basic: bool = False) -> dict:
+        return super().to_dict(basic)
 
     def run(self, optimise_aligment=True) -> Scored:
         if optimise_aligment:
@@ -70,7 +54,10 @@ class Complete(Alignment):
             yield self.get_ea(edn)
 
     def __getitem__(self, i):
-        return self.get_ea(self.mdef.eds[i + 1].name)
+        if isinstance(i, Number):
+            return self.get_ea(self.mdef.eds[i + 1].name)
+        else:
+            return self.get_ea(i)
 
     def __getattr__(self, name):
         if name in self.mdef.eds.data.keys():
@@ -83,7 +70,7 @@ class Complete(Alignment):
     def get_ea(self, name):
         el: Element = getattr(self.manoeuvre.all_elements(), name)
         st = el.get_data(self.flown)
-        tp = el.get_data(self.template).relocate(st.pos[0])
+        tp = self.templates[el.uid].relocate(st.pos[0])
 
         return ElementAnalysis(
             self.get_edef(name), self.mdef.mps, el, st, tp, el.ref_frame(tp)
@@ -100,8 +87,8 @@ class Complete(Alignment):
                 self.mdef.info,
                 self.mdef.mps.update_defaults(self.manoeuvre),
                 self.mdef.eds,
+                self.mdef.box,
             )
-            correction = mdef.create().add_lines()
 
             return Complete(
                 self.id,
@@ -110,8 +97,6 @@ class Complete(Alignment):
                 mdef,
                 manoeuvre,
                 template,
-                correction,
-                correction.create_template(template[0], self.flown),
             )
         else:
             return self
@@ -129,9 +114,9 @@ class Complete(Alignment):
     ) -> int:
         el1: Element = self.manoeuvre.all_elements()[eln1]
         el2: Element = self.manoeuvre.all_elements()[eln2]
-
+        min_len = 3
         def score_split(steps: int) -> float:
-            new_fl = fl.shift_label(steps, 2, manoeuvre=self.name, element=eln1)
+            new_fl = fl.step_label("element", eln1, steps, fl.t, min_len)
             res1, new_iatt = self.get_score(eln1, itrans, el1.get_data(new_fl))
 
             el2fl = el2.get_data(new_fl)
@@ -145,9 +130,17 @@ class Complete(Alignment):
             return res1.total + res2.total
 
         dgs = {0: score_split(0)}
+        
+        def check_steps(stps: int):
+            return not ((stps > 0 and len(el2.get_data(fl)) <= stps + min_len) or (
+                stps < 0 and len(el1.get_data(fl)) <= -stps + min_len
+            ))
 
         steps = int(len(el1.get_data(fl)) > len(el2.get_data(fl))) * 2 - 1
-
+        
+        if not check_steps(steps):
+            return 0
+        
         new_dg = score_split(steps)
         if new_dg > dgs[0]:
             steps = -steps
@@ -155,12 +148,11 @@ class Complete(Alignment):
             steps += np.sign(steps)
             dgs[steps] = new_dg
 
-        while True:
-            if (steps > 0 and len(el2.get_data(fl)) <= steps + 3) or (
-                steps < 0 and len(el1.get_data(fl)) <= -steps + 3
-            ):
+        while check_steps(steps):
+            try:
+                new_dg = score_split(steps)
+            except ValueError:
                 break
-            new_dg = score_split(steps)
 
             if new_dg < list(dgs.values())[-1]:
                 dgs[steps] = new_dg
@@ -194,8 +186,8 @@ class Complete(Alignment):
                             f"Adjusting split between {eln1} and {eln2} by {steps} steps"
                         )
 
-                        fl = fl.shift_label(steps, 2, manoeuvre=self.name, element=eln1)
-
+                        # fl = fl.shift_label(steps, 2, manoeuvre=self.name, element=eln1)
+                        fl = fl.step_label("element", eln1, steps, fl.t, 3)
                         adjusted.update([eln1, eln2])
 
             padjusted = adjusted
@@ -206,6 +198,9 @@ class Complete(Alignment):
 
         return Basic(self.id, self.schedule_direction, fl, self.mdef).proceed()
 
+    def optimise_alignment_v2(self):
+        pass
+
     def intra(self):
         return ElementsResults([ea.intra_score() for ea in self])
 
@@ -216,10 +211,55 @@ class Complete(Alignment):
         return self.mdef.box.score(self.mdef.info, self.flown, self.template)
 
     def plot_3d(self, **kwargs):
-        from plotting import plotdtw, plotsec
+        from plotting import plotsec
 
-        fig = plotdtw(self.flown, self.flown.data.element.unique())
+        fig = self.flown.plotlabels("element")
         return plotsec(self.flown, color="blue", nmodels=20, fig=fig, **kwargs)
 
+    def set_boundaries(self, boundaries: list[float]):
+        new_man = Basic(
+            self.id,
+            self.schedule_direction,
+            self.flown.set_boundaries("element", boundaries),#.resample(),
+            self.mdef,
+        ).proceed()
+
+        return new_man.run_all(False) if isinstance(self, Scored) else new_man
+
+    def set_boundary(self, el: str | int, boundary: float):
+        # TODO check if boundary is within bounds
+        boundaries = self.flown.labels.element.boundaries
+        elid = el if isinstance(el, int) else self.elnames.index(el)
+        boundaries[elid] = boundary
+        return self.set_boundaries(boundaries)
+
+    def boundary_sweep(self, el: str | int, width: float, substeps: int = 5):
+        """Sweep an element boundary through a width and return a set of results
+        width is in seconds,
+        substeps is the number of steps to take within each timestep
+        TODO make sure range doesn't cross adjacent boundary
+        """
+        elid = el if isinstance(el, int) else self.elnames.index(el)
+        bopt = self.flown.labels.element.boundaries[elid]
+        tstart = bopt - width
+        tstop = bopt + width
+        ts = self.flown.data.t[tstart:tstop].to_numpy()
+        splits = np.array(
+            [
+                t0 + (t1 - t0) * i / substeps
+                for t0, t1 in zip(ts[:-1], ts[1:])
+                for i in range(substeps)
+            ]
+        )
+        logger.info(f"Starting {os.cpu_count() * 2 - 1} processes to run {len(splits)} manoeuvres")
+        madicts = Parallel(n_jobs=os.cpu_count() * 2 - 1)(
+            delayed(partial(Basic.parse_analyse_serialise, optimise=False, name=i))(self.set_boundary(el, ic).to_dict())
+            for i, ic in enumerate(splits)
+        )
+        outdata = {ic: Scored.from_dict(mad).scores.dg_dict() for ic, mad in zip(splits, madicts) }
+
+        return pd.DataFrame(outdata).T
+
+
 
 from .scored import Scored  # noqa: E402

{flightanalysis-0.3.16 → flightanalysis-0.3.18}/src/flightanalysis/analysis/manoeuvre_analysis/scored.py

@@ -4,7 +4,7 @@ from flightanalysis.scoring import ManoeuvreResults
 from .complete import Complete
 
 
-@dataclass
+@dataclass(repr=False)
 class Scored(Complete):
     scores: ManoeuvreResults
 
@@ -16,14 +16,16 @@ class Scored(Complete):
             self.mdef,
             self.manoeuvre,
             self.template,
-            self.corrected,
-            self.corrected_template,
         )
 
     @staticmethod
     def from_dict(ajman: dict) -> Scored:
         analysis = Complete.from_dict(ajman)
-        if isinstance(analysis, Complete) and ajman["scores"]:
+        if (
+            isinstance(analysis, Complete)
+            and "scores" in ajman
+            and ajman["scores"] is not None
+        ):
             return Scored(
                 **analysis.__dict__, scores=ManoeuvreResults.from_dict(ajman["scores"])
             )
@@ -39,4 +41,10 @@ class Scored(Complete):
         return dict(**_basic, scores=self.scores.to_dict())
 
     def fcj_results(self):
-        return dict(**super().fcj_results(), results=self.scores.fcj_results())
+        return dict(
+            els=[
+                dict(name=k, start=v.start, stop=v.stop)
+                for k, v in self.flown.labels.element.labels.items()
+            ],
+            results=self.scores.fcj_results(),
+        )