flightanalysis 0.2.4__tar.gz → 0.2.6__tar.gz

{flightanalysis-0.2.4/flightanalysis.egg-info → flightanalysis-0.2.6}/PKG-INFO

@@ -1,12 +1,19 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.4
+Version: 0.2.6
 Summary: A package for analysing flight data
 Home-page: https://github.com/PyFlightCoach/FlightAnalysis
 Author: Thomas David
 Author-email: thomasdavid0@gmail.com
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: fastdtw
+Requires-Dist: simplejson
+Requires-Dist: pfc-geometry>=0.2.4
+Requires-Dist: flightdata>=0.2.6
 
 # FlightAnalysis
 
@@ -14,3 +21,4 @@ This package contains tools for analysing recorded flight log data.The main obje
 to facilitate automated judging for precision aerobatic competitions. 
 
 
+Documentation will follow here: https://pfcdocumentation.readthedocs.io/pyflightcoach/flightanalysis.html

{flightanalysis-0.2.4 → flightanalysis-0.2.6}/README.md

@@ -4,3 +4,4 @@ This package contains tools for analysing recorded flight log data.The main obje
 to facilitate automated judging for precision aerobatic competitions. 
 
 
+Documentation will follow here: https://pfcdocumentation.readthedocs.io/pyflightcoach/flightanalysis.html

flightanalysis-0.2.6/flightanalysis/__init__.py

@@ -0,0 +1,10 @@
+from loguru import logger
+from .elements import *
+from .manoeuvre import Manoeuvre
+from .schedule import Schedule
+from .definition import *
+from .scoring import *
+from .analysis import ScheduleAnalysis, ElementAnalysis
+from .analysis import manoeuvre_analysis as ma
+
+logger.disable('flightanalysis')

flightanalysis-0.2.6/flightanalysis/analysis/__init__.py

@@ -0,0 +1,3 @@
+from .el_analysis import ElementAnalysis
+from .manoeuvre_analysis import Analysis, Basic, Alignment, Complete, Scored
+from .sch_analysis import ScheduleAnalysis

{flightanalysis-0.2.4 → flightanalysis-0.2.6}/flightanalysis/analysis/el_analysis.py

@@ -1,8 +1,8 @@
 
 from flightdata import State
 from typing import Self
-from flightanalysis.definition import ElDef
-from flightanalysis.elements import Element
+from flightanalysis import ElDef, Element, ManParms
+
 from dataclasses import dataclass
 import geometry as g
 
@@ -10,6 +10,7 @@ import geometry as g
 @dataclass
 class ElementAnalysis:
     edef:ElDef
+    mps: ManParms
     el: Element
     fl: State
     tp: State
@@ -24,8 +25,10 @@ class ElementAnalysis:
 
     @staticmethod
     def from_dict(data) -> Self:
+        mps = ManParms.from_dict(data['mps'])
         return ElementAnalysis(
-            ElDef.from_dict(data['edef']),
+            ElDef.from_dict(data['edef'], mps),
+            mps,
             Element.from_dict(data['el']),
             State.from_dict(data['fl']),
             State.from_dict(data['tp']),

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

@@ -0,0 +1,8 @@
+from .analysis import Analysis, AlinmentStage
+from .basic import Basic
+from .alignment import Alignment
+from .complete import Complete, Scored
+
+
+def parse_dict(data: dict) -> Analysis:
+    return Scored.from_dict(data)

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

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from flightdata import State
+from flightanalysis.manoeuvre import Manoeuvre
+from loguru import logger
+from .basic import AlinmentStage, Basic
+from flightanalysis.definition import ManDef
+
+
+@dataclass
+class Alignment(Basic):
+    manoeuvre: Manoeuvre
+    template: State
+
+    def run_all(self):
+        while self.__class__.__name__ != 'Scored':
+            new = 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 alignment(self, radius=10):
+        assert self.stage < AlinmentStage.SECONDARY
+        logger.debug(f'Running alignment stage {self.stage}')
+        aligned = State.align(self.flown, self.template, radius, self.stage==AlinmentStage.SETUP)[1]
+        return Alignment(
+            self.mdef, aligned, self.direction, self.stage + 1,
+            *self.manoeuvre.match_intention(self.template[0], aligned)
+        )
+
+    def run_alignment(self, radius=10):
+        while self.stage < AlinmentStage.SECONDARY:
+            try:
+                self = self.alignment(radius)
+            except Exception as ex:
+                logger.exception(f'Error running alignment stage {self.stage}, {ex}')
+                break
+        return self
+
+    def run(self) -> Complete:
+        self = self.run_alignment()
+        if self.stage < AlinmentStage.SECONDARY:
+            return self
+        else:
+            mdef = ManDef(self.mdef.info, self.mdef.mps.update_defaults(self.manoeuvre), self.mdef.eds)
+            correction = mdef.create(self.template[0].transform).add_lines()
+
+            return Complete(
+                mdef, self.flown, self.direction, AlinmentStage.SECONDARY, 
+                self.manoeuvre, self.template, correction, 
+                correction.create_template(self.template[0], self.flown)
+            )
+
+from .complete import Complete  # noqa: E402

flightanalysis-0.2.6/flightanalysis/analysis/manoeuvre_analysis/analysis.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+class AlinmentStage:
+    SETUP=0
+    PRELIM=1
+    SECONDARY=2
+    OPTIMISED=3
+
+
+@dataclass
+class Analysis:
+    def to_dict(self):
+        return {k: (v.to_dict() if hasattr(v, 'to_dict') else v) for k, v in self.__dict__.items()}
+
+

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

@@ -0,0 +1,83 @@
+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 AlinmentStage, Analysis
+
+
+@dataclass
+class Basic(Analysis):
+    mdef: ManDef | ManOption
+    flown: State
+    direction: int
+    stage: AlinmentStage
+
+    @property
+    def name(self):
+        return self.mdef.uid
+
+    def run_all(self):
+        res = [s for s in [s.run_all() for s in self.run()] if isinstance(s, Scored)]
+        
+        if len(res) == 0:
+            return self
+                
+        min_dg = None
+        for n in res:
+            if hasattr(n, 'scores'):
+                if min_dg is None or n.scores.intra.total < min_dg:
+                    min_dg = n.scores.intra.total
+                    self = n 
+                   
+        return self
+        
+
+    @classmethod
+    def from_dict(Cls, data:dict) -> Basic:
+        return Basic(
+            ManDef.from_dict(data["mdef"]),
+            State.from_dict(data["flown"]),
+            data['direction'],
+            data['stage']
+        )
+
+    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(mdef, state.get_manoeuvre(mdef.uid), AlinmentStage.SETUP)
+
+    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(
+                mdef, self.flown, self.direction, AlinmentStage.SETUP, 
+                man, man.create_template(itrans)
+            ))
+        return als
+
+
+from .alignment import Alignment  # noqa: E402
+from .scored import Scored  # noqa: E402

flightanalysis-0.2.6/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from ..el_analysis import ElementAnalysis
+from flightdata import State
+from flightanalysis.definition import ManDef
+from flightanalysis.manoeuvre import Manoeuvre
+from flightanalysis.scoring import Results, Result, 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 loguru import logger
+
+
+@dataclass
+class Complete(Alignment):
+    corrected: Manoeuvre
+    corrected_template: State
+
+    @staticmethod
+    def from_dict(data:dict, fallback=True):
+        pa = Alignment.from_dict(data, fallback)
+        try:
+            pa = Complete(
+                **pa.__dict__,
+                corrected=Manoeuvre.from_dict(data["corrected"]),
+                corrected_template=State.from_dict(data["corrected_template"]),
+            )
+        except Exception as e:
+            if fallback:
+                logger.debug(f"Failed to parse Complete: {repr(e)}")
+            else:
+                raise e
+        return pa
+
+    def run(self) -> Scored:
+        if self.stage < AlinmentStage.OPTIMISED:
+            self = self.optimise_alignment()
+        return Scored(**self.__dict__, 
+            scores=ManoeuvreResults(self.inter(), self.intra(), self.positioning())
+        )
+
+    @property
+    def elnames(self):
+        return list(self.mdef.eds.data.keys())
+
+    def __iter__(self):
+        for elname in self.manoeuvre.all_elements().data.keys():
+            yield self.get_ea(self.mdef.eds[elname])
+
+    def __getitem__(self, i):
+        return self.get_ea(['entry_line'] + self.mdef.eds[i] + ['exit_line'])
+
+    def __getattr__(self, name):
+        if name in self.mdef.eds.data.keys():
+            return self.get_ea(self.mdef.eds[name])
+        raise AttributeError(f'Attribute {name} not found in {self.__class__.__name__}')
+
+    def get_ea(self, edef):
+        el = getattr(self.manoeuvre.all_elements(), edef.name)
+        st = el.get_data(self.flown)
+        tp = el.get_data(self.template).relocate(st.pos[0])
+        return ElementAnalysis(edef, self.mdef.mps, el, st, tp, el.ref_frame(tp))
+
+    def optimise_alignment(self):
+        aligned = self.manoeuvre.optimise_alignment(self.template, self.flown)
+        manoeuvre, template = self.manoeuvre.match_intention(self.template[0], aligned)
+        mdef = ManDef(self.mdef.info, self.mdef.mps.update_defaults(self.manoeuvre), self.mdef.eds)
+        correction = mdef.create(self.template[0].transform).add_lines()
+
+        return Complete(
+            mdef, aligned, self.direction, AlinmentStage.OPTIMISED, 
+            manoeuvre, template, correction, correction.create_template(template[0])
+        )
+    
+    def side_box(self):
+        return F3A.intra.box(
+            'side box', 
+            Measurement.side_box(self.flown)
+        )
+
+    def top_box(self):
+        return F3A.intra.box(
+            'top box', 
+            Measurement.top_box(self.flown)
+        )
+
+    def centre(self):
+        results = Results('centres')
+        for cpid in self.mdef.info.centre_points:
+            results.add(F3A.single.angle(
+                f'centre point {cpid}',
+                Measurement.centre_box(self.flown.get_element(cpid+1)[0])
+            ))
+
+        for ceid, fac in self.mdef.info.centred_els:
+            ce = self.flown.get_element(ceid+1)
+            path_length = (abs(ce.vel) * ce.dt).cumsum()
+            id = np.abs(path_length - path_length[-1] * fac).argmin()
+            results.add(F3A.single.angle(
+                f'centred element {ceid}',
+                Measurement.centre_box(State(ce.data.iloc[[id], :]))
+            ))
+
+        if len(results) == 0 and self.mdef.info.position == Position.CENTRE:
+            al = self.flown.get_element(slice(1,-1,None))
+            midy = (self.flown.get_element(1).y[0] + self.flown.get_element(-1).y[-1]) / 2
+            midid = np.abs(al.pos.y - midy).argmin()
+            results.add(F3A.single.angle(
+                'centred manoeuvre',
+                Measurement.centre_box(al[midid])
+            ))
+
+        return results
+
+    def distance(self):
+        #TODO doesnt quite cover it, stalled manoeuvres could drift to > 170 for no downgrade
+        return F3A.intra.depth(
+            'distance',
+            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)
+
+    def inter(self):
+        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
+
+    def plot_3d(self, **kwargs):
+        from flightplotting import plotsec, plotdtw
+        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.6/flightanalysis/analysis/manoeuvre_analysis/scored.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from .complete import Complete
+from flightanalysis.scoring import ManoeuvreResults
+from loguru import logger
+
+
+@dataclass
+class Scored(Complete):
+    scores: ManoeuvreResults
+
+    @staticmethod
+    def from_dict(data:dict, fallback=True):
+        ca = Complete.from_dict(data, fallback)
+        try:
+            ca = Scored(
+                **ca.__dict__,
+                scores=ManoeuvreResults.from_dict(data["scores"])
+            )
+        except Exception as e:
+            if fallback:
+                logger.debug(f"Failed to read scores, {repr(e)}")
+            else:
+                raise e
+        return ca
+    
+    def run(self):
+        return self

flightanalysis-0.2.6/flightanalysis/analysis/sch_analysis.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+from typing import Self, Union
+from json import load
+from flightdata import Flight, State, Origin, Collection
+from flightanalysis.definition import SchedDef, ScheduleInfo
+from . import manoeuvre_analysis as analysis
+from loguru import logger
+from joblib import Parallel, delayed
+import os
+import pandas as pd
+from importlib.metadata import version
+import geometry as g
+
+
+class ScheduleAnalysis(Collection):
+    VType=analysis.Analysis
+    uid='name'
+    
+    def __init__(self, data: list[analysis.Analysis], sinfo: ScheduleInfo):
+        super().__init__(data)
+        self.sinfo = sinfo
+
+    @staticmethod
+    def from_fcj(file: Union[str, dict], info: ScheduleInfo=None) -> ScheduleAnalysis:
+        if isinstance(file, str):
+            data = load(open(file, 'r'))
+        else:
+            data = file
+        flight = Flight.from_fc_json(data)
+        box = Origin.from_fcjson_parmameters(data["parameters"])
+        if info is None:
+            info = ScheduleInfo.from_str(data["parameters"]["schedule"][1])
+        sdef = SchedDef.load(info)
+
+        
+
+        state = State.from_flight(flight, box).splitter_labels(
+            data["mans"],
+            sdef.uids
+        )#.move(g.Transformation(g.Point(-data['parameters']['moveEast'], -data['parameters']['moveNorth'], 0)))
+
+        direction = -state.get_manoeuvre(0)[0].direction()[0]
+
+        return ScheduleAnalysis(
+            [analysis.Basic(
+                mdef, 
+                state.get_manoeuvre(mdef.uid), 
+                direction,
+                analysis.AlinmentStage.SETUP
+            ) for mdef in 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}')
+            return res.to_dict()
+        
+        logger.info(f'Starting {os.cpu_count()} analysis processes')
+        madicts = Parallel(n_jobs=os.cpu_count())(
+            delayed(parse_analyse_serialise)(ma.to_dict()) for ma in self
+        )
+
+        return ScheduleAnalysis([analysis.Scored.from_dict(mad) for mad in madicts], self.sinfo)  
+
+    def optimize_alignment(self) -> Self:
+
+        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')
+        inmadicts = [mdef.to_dict() for mdef in self]
+        madicts = Parallel(n_jobs=os.cpu_count())(delayed(parse_analyse_serialise)(mad) for mad in inmadicts)
+        return ScheduleAnalysis([analysis.Scored.from_dict(mad) for mad in madicts], self.sinfo)
+    
+    @staticmethod
+    def from_fcscore(file: Union[str, dict], fallback=True) -> ScheduleAnalysis:
+        if isinstance(file, str) or isinstance(file, os.PathLike):
+            data = load(open(file, 'r'))
+        else:
+            data = file
+        sinfo = ScheduleInfo(**data['sinfo'])
+        sdef = SchedDef.load(sinfo)
+
+        mas = []
+        for mdef in sdef:
+            mas.append(analysis.Scored.from_dict(
+                data['data'][mdef.info.short_name],
+                fallback
+            ))
+
+        return ScheduleAnalysis(mas, sinfo)
+    
+    def scores(self):
+        scores = {}
+        total = 0
+        scores = {ma.name: (ma.scores.score() if hasattr(ma, 'scores') else 0) for ma in self}
+        total = sum([ma.mdef.info.k * v for ma, v in zip(self, scores.values())])
+        return total, scores
+
+    def summarydf(self):
+        return pd.DataFrame([ma.scores.summary() if hasattr(ma, 'scores') else {} for ma in self])
+
+    def to_fcscore(self, name: str) -> dict:        
+        total, scores = self.scores()
+       
+        odata = dict(
+            name = name,
+            client_version = 'Py',
+            server_version = version('flightanalysis'),
+            sinfo = self.sinfo.__dict__,
+            score = total,
+            manscores = scores,
+            data = self.to_dict()
+        )
+        return odata