flightanalysis 0.2.13__tar.gz → 0.2.14__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.13
+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.13 → flightanalysis-0.2.14}/examples/scoring/f3a_criteria_maker.py

@@ -1,20 +1,20 @@
 from flightanalysis.scoring.criteria import Single, Exponential, ContAbs, ContRat, InsideBound, MaxBound, Comparison, free, OutsideBound
 import numpy as np
-from itertools import chain
+
 
 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]),
@@ -25,10 +25,10 @@ f3a=dict(
         depth=MaxBound(Exponential.fit_points([20, 40], [0.5, 1]), 170)
     ),
     inter=dict(
-        radius=Comparison(Exponential.fit_points([1,2], [1.5, 3])),
-        speed=Comparison(Exponential.fit_points([1,5], [0.25, 1.0])),
-        roll_rate=Comparison(Exponential.fit_points([1,5], [0.25, 1.5])),
-        length=Comparison(Exponential.fit_points([1,2], [1.5, 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),
     )
 )

{flightanalysis-0.2.13 → 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.13 → 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.13 → 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.13 → 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.13 → 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')

{flightanalysis-0.2.13 → flightanalysis-0.2.14}/flightanalysis/definition/__init__.py

@@ -12,6 +12,6 @@ from .manparm import ManParm, ManParms, DummyMPs
 from .eldef import ElDef, ElDefs
 from .mandef import ManDef
 from .manoption import ManOption
-from .scheduleinfo import ScheduleInfo, fcj_schedule_names, schedule_library
+from .scheduleinfo import ScheduleInfo, schedule_library
 from .scheddef import SchedDef
 from .builders.manbuilder import ManBuilder, f3amb, MBTags, centred, imacmb, r, c45, dp

{flightanalysis-0.2.13 → flightanalysis-0.2.14}/flightanalysis/definition/mandef.py

@@ -34,6 +34,9 @@ class ManDef:
         self.mps: ManParms = ManParms.create_defaults_f3a() if mps is None else mps
         self.eds: ElDefs = ElDefs() if eds is None else eds
 
+    def __repr__(self):
+        return f"ManDef({self.info.name})"
+
     @property
     def uid(self):
         return self.info.short_name

{flightanalysis-0.2.13 → flightanalysis-0.2.14}/flightanalysis/definition/manparm.py

@@ -25,7 +25,7 @@ class ManParm(Opp):
 
     """
     criteria: Criteria
-    defaul:Any=None
+    defaul:Number=None
     collectors:Collectors=field(default_factory=lambda : Collectors())
 
 
@@ -78,7 +78,7 @@ class ManParm(Opp):
             [c(els) for c in self.collectors],
             self.defaul,
             direction,
-            [vis[0]] + [max(va, vb) for va, vb in zip(vis[:-1], vis[1:])],
+            np.array([vis[0]] + [max(va, vb) for va, vb in zip(vis[:-1], vis[1:])]),
             [str(c) for c in self.collectors]
         )
 

{flightanalysis-0.2.13 → flightanalysis-0.2.14}/flightanalysis/definition/scheddef.py

@@ -1,4 +1,4 @@
-from . import ManDef, ManInfo, ManOption, ScheduleInfo, fcj_schedule_names
+from . import ManDef, ManInfo, ManOption, ScheduleInfo
 from flightdata import State
 from typing import Tuple, Union, Self
 from geometry import Transformation
@@ -95,7 +95,7 @@ class SchedDef(Collection):
         fcj = self.label_exit_lines(template).create_fc_json(
             [0] + [man.info.k for man in self] + [0],
             sname,
-            fcj_schedule_names[kind.lower()][-1]
+            kind.lower()
         )
             
         with open(path, 'w') as f:

flightanalysis-0.2.14/flightanalysis/definition/scheduleinfo.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+from flightanalysis.data import list_resources
+
+
+fcj_categories = {
+    'F3A FAI':'f3a',
+    'F3A':'f3a',
+    'US AMA':'nsrca',
+    'F3A UK':'f3auk',
+    'F3A US':'nsrca',
+    'IMAC':'imac',
+}
+
+fcj_schedules = {
+    'P23': 'p23',
+    'F23': 'f23',
+    'P25': 'p25',
+    'F25': 'f25',
+}
+
+
+
+@dataclass
+class ScheduleInfo:
+    category: str
+    name: str
+
+    @staticmethod
+    def from_str(fname):
+        if fname.endswith("_schedule.json"):
+            fname = fname[:-14]
+        info = fname.split("_")
+        if len(info) == 1:
+            return ScheduleInfo("f3a", info[0].lower())
+        else:
+            return ScheduleInfo(info[0].lower(), info[1].lower())
+
+    def __str__(self):
+        return f"{self.category}_{self.name}".lower()
+
+    def fcj_to_pfc(self):
+        def lookup(val, data):
+            return data[val] if val in data else val
+
+        return ScheduleInfo(
+            lookup(self.category, fcj_categories),
+            lookup(self.name, fcj_schedules)
+        )
+
+    def pfc_to_fcj(self):
+
+        def rev_lookup(val, data):
+            return next(k for k, v in data.items() if v == val) if val in data.values() else val
+
+        return ScheduleInfo(
+            rev_lookup(self.category, fcj_categories),
+            rev_lookup(self.name, fcj_schedules)
+        )
+
+    @staticmethod
+    def from_fcj_sch(sch):
+        return ScheduleInfo(*sch).fcj_to_pfc()
+
+    def to_fcj_sch(self):
+        return list(self.pfc_to_fcj().__dict__.values())
+
+    @staticmethod
+    def build(category, name):
+        return ScheduleInfo(category.lower(), name.lower())
+
+
+schedule_library = [ScheduleInfo.from_str(fname) for fname in list_resources('schedule')]

{flightanalysis-0.2.13 → flightanalysis-0.2.14}/flightanalysis/elements/element.py

@@ -62,11 +62,11 @@ class Element:
     def score_series_builder(self, index):
         return lambda data: pd.Series(data, index=index)
 
-    def analyse(self, flown:State, template:State) -> Results:
-        return self.intra_scoring.apply(self, flown, template)
+    def analyse(self, flown:State, template:State, limits=True) -> Results:
+        return self.intra_scoring.apply(self, flown, template, limits)
 
-    def analyse_exit(self, fl, tp) -> Results:
-        return self.exit_scoring.apply(self, fl, tp)
+    def analyse_exit(self, fl, tp, limits=True) -> Results:
+        return self.exit_scoring.apply(self, fl, tp, limits)
 
     def ref_frame(self, template: State) -> g.Transformation:
         return template[0].transform
@@ -140,9 +140,9 @@ class Element:
         istate = istate if isinstance(istate, State) else State.from_transform(istate)
         tp = self.create_template(istate, fl.time)
         if self.uid=='entry_line':
-            res = self.analyse_exit(fl, tp)
+            res = self.analyse_exit(fl, tp, False)
         else:
-            res = self.analyse(fl, tp)
+            res = self.analyse(fl, tp, False)
         return res, tp
         
     @staticmethod

{flightanalysis-0.2.13 → flightanalysis-0.2.14}/flightanalysis/scoring/criteria/exponential.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 import numpy as np
-from typing import Union
+
 
 @dataclass
 class Exponential:
     factor: float
     exponent: float
-    limit: Union[float, None] = None
-    def __call__(self, value):
-        val = self.factor * value ** self.exponent
-        if self.limit:
+    limit: float | None = None
+    def __call__(self, value, visibility=1, limits=True):
+        if np.isscalar(visibility) and not np.isscalar(value):
+            visibility = np.full_like(value, visibility)
+        val = visibility * self.factor * value ** self.exponent
+        if self.limit and limits:
             val = np.minimum(val, self.limit)
         return val