flightanalysis 0.2.12__tar.gz → 0.2.14__tar.gz

{flightanalysis-0.2.12 → flightanalysis-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.12
+Version: 0.2.14
 Summary: A package for analysing flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -16,7 +16,7 @@ Requires-Dist: simplejson
 Requires-Dist: loguru
 Requires-Dist: joblib
 Requires-Dist: pfc-geometry>=0.2.6
-Requires-Dist: flightdata>=0.2.11
+Requires-Dist: flightdata>=0.2.13
 Provides-Extra: dev
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: pandas; extra == "dev"
@@ -26,7 +26,7 @@ Requires-Dist: simplejson; extra == "dev"
 Requires-Dist: loguru; extra == "dev"
 Requires-Dist: joblib; extra == "dev"
 Requires-Dist: pfc-geometry>=0.2.6; extra == "dev"
-Requires-Dist: flightdata>=0.2.11; extra == "dev"
+Requires-Dist: flightdata>=0.2.13; extra == "dev"
 Requires-Dist: ardupilot_log_reader>=0.3.1; extra == "dev"
 Requires-Dist: pymavlink; extra == "dev"
 

{flightanalysis-0.2.12 → flightanalysis-0.2.14}/examples/scoring/f3a_criteria_maker.py

@@ -4,31 +4,31 @@ import numpy as np
 
 f3a=dict(
     single=dict(
-        track=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 100)),
-        roll=Single(Exponential.fit_points(np.radians([30, 90]), [1, 6], 100)),
-        angle=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 100)),
+        track=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6)),
+        roll=Single(Exponential.fit_points(np.radians([30, 90]), [1, 6], 6)),
+        angle=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6)),
 #        distance = Single(Exponential.fit_points([20, 40], [0.5, 1]))
     ),
     intra=dict(
-        track=ContAbs(Exponential.fit_points(np.radians([30, 90]), [2, 6])),
-        roll=ContAbs(Exponential.fit_points(np.radians([30, 90]), [1.5, 6])),
-        radius=ContRat(Exponential.fit_points([1,5], [0.5, 4], 2)),
+        track=ContAbs(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6)),
+        roll=ContAbs(Exponential.fit_points(np.radians([30, 90]), [1.5, 6], 6)),
+        radius=ContRat(Exponential.fit_points([1,5], [0.5, 4], 3)),
         speed=ContRat(Exponential.fit_points([1,5], [0.15, 0.75], 1)),
-        roll_rate=ContRat(Exponential.fit_points([1,5], [0.15, 0.75], 1)),
+        roll_rate=ContRat(Exponential.fit_points([1,5], [0.15, 0.75], 2)),
         stallturn_speed=InsideBound(Exponential.fit_points([2, 5], [0.3,1.5]), [-2,2]),
         stallturn_width=InsideBound(Exponential.fit_points([2, 5], [0.5,2.5]), [-2,2]),
         spin_entry_length=InsideBound(Exponential.fit_points([2, 5], [0.3,1.5]), [-5,5]),
         pitch_break_length=InsideBound(Exponential.fit_points([1, 2], [0.7,3.5]), [-2,2]),
         nose_drop_amount=OutsideBound(Exponential(20,1), [-np.radians(15), np.radians(15)]),
         recovery_length=MaxBound(Exponential.fit_points([1, 2], [0.7,3.5]), 2),
-        box=InsideBound(Exponential(10/np.radians(15), 1), [-np.radians(60), np.radians(60)]), # 10 points if the entire manoeuvre is 15 degrees outside the box
+        box=InsideBound(Exponential(10/np.radians(7.5), 1), [-np.radians(60), np.radians(60)]), # 10 points if the entire manoeuvre is 7.5 degrees outside the box
         depth=MaxBound(Exponential.fit_points([20, 40], [0.5, 1]), 170)
     ),
     inter=dict(
-        radius=Comparison(Exponential.fit_points([1,5], [1, 2], 2)),
-        speed=Comparison(Exponential.fit_points([1,5], [0.25, 1.0])),
-        roll_rate=Comparison(Exponential.fit_points([1,5], [0.25, 1.5],2)),
-        length=Comparison(Exponential.fit_points([1,5], [1, 3], 3)),
+        radius=Comparison(Exponential.fit_points([1,2], [1, 2], 2)),
+        speed=Comparison(Exponential.fit_points([1,2], [0.25, 0.5], 1)),
+        roll_rate=Comparison(Exponential.fit_points([1,2], [0.25, 0.5], 1)),
+        length=Comparison(Exponential.fit_points([1,2], [1, 2], 2)),
         free=Comparison(free),
     )
 )
@@ -47,7 +47,24 @@ def plot_lookup(lu, v0=0, v1=10):
     x = np.linspace(v0, v1, 30)
     px.line(x=x,y=lu(x)).show()
 
+def plot_all(crits):
+    from plotly.subplots import make_subplots
+    import plotly.graph_objects as go
+    criteria = [cr for crit in crits.values() for cr in crit.values()]
+    names = [cr for crit in crits.values() for cr in crit.keys()]
+
+    nplots = sum([len(cr) for cr in crits.values()])
+    ncols=5
+    fig = make_subplots(int(np.ceil(nplots / ncols)), ncols, subplot_titles=names)
+    
+    for i, crit in enumerate(criteria):
+        row, col = 1 + i // ncols, 1 + i % ncols
+        x = np.linspace(0, 10, 30)
+        fig.add_trace(go.Scatter(x=x, y=crit.lookup(x), showlegend=False), row=row, col=col)
+    fig.show()
+
 if __name__ == "__main__":
     #plot_lookup(f3a['intra']['recovery_length'].lookup,-10,10)
 
+#    plot_all(f3a)
     dump_criteria_to_py(f3a)

{flightanalysis-0.2.12 → flightanalysis-0.2.14}/flightanalysis/analysis/el_analysis.py

@@ -16,9 +16,9 @@ class ElementAnalysis:
     tp: State
     ref_frame: g.Transformation
 
-    def plot_3d(self, origin=False, **kwargs):
+    def plot_3d(self, **kwargs):
         from flightplotting import plotsec
-        return plotsec([self.fl, self.tp], 2, 5, origin=origin, **kwargs)
+        return plotsec([self.fl, self.tp], **kwargs)
 
     def to_dict(self):
         return {k: v.to_dict() for k, v in self.__dict__.items()}

flightanalysis-0.2.14/flightanalysis/analysis/manoeuvre_analysis/__init__.py

@@ -0,0 +1,14 @@
+from .analysis import Analysis
+from .basic import Basic
+from .alignment import Alignment
+from .complete import Complete, Scored
+
+
+def parse_dict(data: dict) -> Analysis:
+    return Scored.from_dict(data)
+
+def parse(data: dict) -> Basic | Alignment | Complete | Scored:
+    if 'parameters' in data:
+        return Basic.from_mindict(data).proceed()
+    else:
+        return parse_dict(data).proceed()

flightanalysis-0.2.14/flightanalysis/analysis/manoeuvre_analysis/alignment.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from flightdata import State
+from flightanalysis.manoeuvre import Manoeuvre
+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:
+        return ElementAnalysis(
+            self.mdef.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
+        )
+
+    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()
+            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:    
+            ia = Alignment(
+                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)}')
+            else:
+                raise e
+        return ia
+
+    def run(self) -> Alignment | Complete:
+        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)}')
+                return self
+        try:
+            return self._run(False)[1].proceed()
+        except Exception as e:
+            logger.error(f'Failed to run alignment stage 2: {repr(e)}')
+            return self
+
+    def _run(self, mirror=False, radius=10) -> Alignment:
+        dist, aligned = State.align(self.flown, self.template, radius, mirror)
+        return dist, self.update(aligned)
+
+    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)
+
+    def _proceed(self) -> Complete:
+        if 'element' in self.flown.data.columns:
+            correction = self.mdef.create(self.template[0].transform)
+            return Complete(
+                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')
+        )
+        if full:
+            data = dict(
+                **super().to_mindict(sinfo),
+                **data
+            )
+        return data
+        
+from .complete import Complete  # noqa: E402
+from .scored import Scored  # noqa: E402

{flightanalysis-0.2.12 → flightanalysis-0.2.14}/flightanalysis/analysis/manoeuvre_analysis/analysis.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 from dataclasses import dataclass
-
-class AlinmentStage:
-    SETUP=0
-    PRELIM=1
-    SECONDARY=2
-    OPTIMISED=3
-
+from flightanalysis.definition import ScheduleInfo
 
 @dataclass
 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 {
+            "sinfo": sinfo.__dict__,
+        }
+        

flightanalysis-0.2.14/flightanalysis/analysis/manoeuvre_analysis/basic.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from flightdata import State, Flight, Origin
+from flightanalysis.definition import ManDef, SchedDef, ManOption
+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
+
+
+@dataclass
+class Basic(Analysis):
+    mdef: ManDef | ManOption
+    flown: State
+    direction: int
+
+    @property
+    def name(self):
+        return self.mdef.uid
+
+    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:
+            return self
+        mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
+        elnames = self.flown.data.element.unique()
+        for md in mopt:
+            if np.all(elnames[1:-1] == list( 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()}")
+
+        itrans = self.create_itrans()
+        man, tp = mdef.create(itrans).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()
+        return Complete(
+            self.id, mdef, self.flown, self.direction,
+            man, tp, corr, corr.create_template(itrans, self.flown)
+        )
+
+    @classmethod
+    def from_dict(Cls, data:dict) -> Basic:
+        return Basic(
+            -1,
+            ManDef.from_dict(data["mdef"]),
+            State.from_dict(data["flown"]),
+            data['direction']
+        )
+
+    def create_itrans(self) -> g.Transformation:
+        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:
+            data = load(f)
+        flight = Flight.from_fc_json(data)
+        box = Origin.from_fcjson_parmameters(data["parameters"])
+
+        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]
+        )
+        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 = []        
+        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)
+            ))
+        return als
+
+    def to_mindict(self, sinfo: ScheduleInfo):
+        data = dict(
+            **super().to_mindict(sinfo),
+            name=self.name,
+            id=self.id,
+            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"])
+        )
+        
+        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

{flightanalysis-0.2.12 → flightanalysis-0.2.14}/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 from dataclasses import dataclass
 from ..el_analysis import ElementAnalysis
 from flightdata import State
-from flightanalysis.definition import ManDef
+from flightanalysis.definition import ManDef, ScheduleInfo
 from flightanalysis.manoeuvre import Manoeuvre
 from flightanalysis.scoring import Results, ManoeuvreResults, Measurement
 from flightanalysis.scoring.criteria.f3a_criteria import F3A
 from flightanalysis.definition.maninfo import Position
 import numpy as np
-from .alignment import Alignment, AlinmentStage
+from .alignment import Alignment
 from loguru import logger
 
 
@@ -34,7 +34,7 @@ class Complete(Alignment):
         return pa
 
     def run(self, optimise_aligment=True) -> Scored:
-        if self.stage < AlinmentStage.OPTIMISED and optimise_aligment:
+        if optimise_aligment:
             self = self.optimise_alignment()
         self = self.update_templates()
         return Scored(**self.__dict__, 
@@ -63,6 +63,7 @@ class Complete(Alignment):
         tp = el.get_data(self.template).relocate(st.pos[0])
         return ElementAnalysis(edef, self.mdef.mps, el, st, tp, el.ref_frame(tp))
 
+
     def update_templates(self):
         if not np.all(self.flown.element == self.template.element):    
             manoeuvre, template = self.manoeuvre.match_intention(self.template[0], self.flown)
@@ -70,8 +71,9 @@ class Complete(Alignment):
             correction = mdef.create(self.template[0].transform).add_lines()
 
             return Complete(
-                mdef, self.flown, self.direction, AlinmentStage.OPTIMISED, self.dist,
-                manoeuvre, template, correction, correction.create_template(template[0])
+                self.id, mdef, self.flown, self.direction,
+                manoeuvre, template, correction, 
+                correction.create_template(template[0])
             )
         else:
             return self
@@ -127,13 +129,6 @@ class Complete(Alignment):
             Measurement.depth(self.flown)
         )
         
-#        val = self.flown.pos.y.mean()
-#        id = np.abs(self.flown.pos.y - val).argmin()
-#        m = Measurement.depth(self.flown[id])
-#        error = np.maximum(m.value, 170) - 170
-#        dist_dg = F3A.single.distance.lookup(error) * m.visibility
-#        return Result("distance", m, m.value, error, dist_dg, [id])
-
     def intra(self):
         return self.manoeuvre.analyse(self.flown, self.template)
 
@@ -160,4 +155,6 @@ class Complete(Alignment):
         fig = plotdtw(self.flown, self.flown.data.element.unique())
         return plotsec(self.flown, color="blue", nmodels=20, fig=fig, **kwargs)
 
+
+
 from .scored import Scored  # noqa: E402

{flightanalysis-0.2.12 → flightanalysis-0.2.14}/flightanalysis/analysis/manoeuvre_analysis/scored.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from .complete import Complete
 from flightanalysis.scoring import ManoeuvreResults
+from flightanalysis.definition.scheduleinfo import ScheduleInfo
 from loguru import logger
 
 
@@ -8,6 +9,13 @@ from loguru import logger
 class Scored(Complete):
     scores: ManoeuvreResults
 
+    def downgrade(self) -> Complete:
+        return Complete(
+            self.id, self.mdef, self.flown, self.direction, 
+            self.manoeuvre, self.template, self.corrected, 
+            self.corrected_template
+        )
+    
     @staticmethod
     def from_dict(data:dict, fallback=True):
         ca = Complete.from_dict(data, fallback)
@@ -22,6 +30,16 @@ class Scored(Complete):
             else:
                 raise e
         return ca
-    
-    def run(self, optimise_alignment=True):
-        return self
+        
+    def to_mindict(self, sinfo: ScheduleInfo=None, full=False):
+        data = dict(
+            **super().to_mindict(sinfo, full),
+            scores=dict(
+                **self.scores.summary(),
+                total=self.scores.score(),
+                k=self.mdef.info.k
+            )
+        )
+        
+        return data
+        

{flightanalysis-0.2.12 → flightanalysis-0.2.14}/flightanalysis/analysis/sch_analysis.py

@@ -41,16 +41,15 @@ class ScheduleAnalysis(Collection):
 
         return ScheduleAnalysis(
             [analysis.Basic(
+                i,
                 mdef, 
                 state.get_manoeuvre(mdef.uid), 
-                direction,
-                analysis.AlinmentStage.SETUP
-            ) for mdef in sdef],
+                direction
+            ) for i, mdef in enumerate(sdef)],
             info
         )
     
     def run_all(self) -> Self:
-
         def parse_analyse_serialise(pad):
             res = analysis.Basic.from_dict(pad).run_all()
             logger.info(f'Completed {res.name}')
@@ -67,7 +66,6 @@ class ScheduleAnalysis(Collection):
 
         def parse_analyse_serialise(mad):
             an = analysis.Complete.from_dict(mad)
-            an.stage = analysis.AlinmentStage.SECONDARY
             return an.run_all().to_dict()
 
         logger.info(f'Starting {os.cpu_count()} alinment optimisation processes')