flightanalysis 0.2.6__tar.gz → 0.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.6
+Version: 0.2.7
 Summary: A package for analysing flight data
 Home-page: https://github.com/PyFlightCoach/FlightAnalysis
 Author: Thomas David
@@ -12,8 +12,8 @@ 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
+Requires-Dist: pfc-geometry>=0.2.5
+Requires-Dist: flightdata>=0.2.7
 
 # FlightAnalysis
 

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis/analysis/manoeuvre_analysis/alignment.py

@@ -9,12 +9,14 @@ from flightanalysis.definition import ManDef
 
 @dataclass
 class Alignment(Basic):
+    dist: float
     manoeuvre: Manoeuvre
     template: State
 
-    def run_all(self):
+    def run_all(self, optimise_aligment=True):
+        new = self
         while self.__class__.__name__ != 'Scored':
-            new = self.run()
+            new = self.run(optimise_aligment)
             if new.__class__.__name__ == self.__class__.__name__:
                 break
             self = new
@@ -25,6 +27,7 @@ class Alignment(Basic):
         ia = Basic.from_dict(data)
         try:    
             ia = Alignment(
+                dist=data['dist'] if 'dist' in data else 0,
                 manoeuvre=Manoeuvre.from_dict(data['manoeuvre']),
                 template=State.from_dict(data['template']),
                 **ia.__dict__
@@ -39,13 +42,19 @@ class Alignment(Basic):
     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]
+        dist, aligned = State.align(self.flown, self.template, radius, self.stage==AlinmentStage.SETUP)
         return Alignment(
-            self.mdef, aligned, self.direction, self.stage + 1,
+            self.mdef, aligned, self.direction, self.stage + 1, dist,
             *self.manoeuvre.match_intention(self.template[0], aligned)
         )
+    
 
     def run_alignment(self, radius=10):
+        if self.stage > AlinmentStage.SETUP:
+            self = Alignment(
+                self.mdef, self.flown, self.direction, self.stage + 1, self.dist,
+                *self.manoeuvre.match_intention(self.template[0], self.flown)
+            )
         while self.stage < AlinmentStage.SECONDARY:
             try:
                 self = self.alignment(radius)
@@ -54,8 +63,9 @@ class Alignment(Basic):
                 break
         return self
 
-    def run(self) -> Complete:
+    def run(self, optimise_aligment=True) -> Complete:
         self = self.run_alignment()
+
         if self.stage < AlinmentStage.SECONDARY:
             return self
         else:
@@ -64,7 +74,7 @@ class Alignment(Basic):
 
             return Complete(
                 mdef, self.flown, self.direction, AlinmentStage.SECONDARY, 
-                self.manoeuvre, self.template, correction, 
+                self.dist, self.manoeuvre, self.template, correction, 
                 correction.create_template(self.template[0], self.flown)
             )
 

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis/analysis/manoeuvre_analysis/basic.py

@@ -5,6 +5,7 @@ from flightanalysis.definition import ManDef, SchedDef, ManOption
 import geometry as g
 from json import load
 from .analysis import AlinmentStage, Analysis
+import numpy as np
 
 
 @dataclass
@@ -18,22 +19,22 @@ class Basic(Analysis):
     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 
+    def run_all(self, optimise_aligment=True):
+        res = [s.run_all(False) for s in self.run(False)]
+        self = res[0]
+        if len(res) > 1:
+            for r in res[1:]:
+                if r.stage < self.stage:
+                    continue
+                if r.dist < self.dist:
+                    self = r
+
+        if isinstance(self, Scored) and optimise_aligment:
+            self.stage = AlinmentStage.SECONDARY
+            self = self.run(True)
                    
         return self
         
-
     @classmethod
     def from_dict(Cls, data:dict) -> Basic:
         return Basic(
@@ -65,7 +66,7 @@ class Basic(Analysis):
         mdef= sdef[mid]
         return Basic(mdef, state.get_manoeuvre(mdef.uid), AlinmentStage.SETUP)
 
-    def run(self) -> list[Alignment]:
+    def run(self, optimise_aligment=True) -> list[Alignment]:
         itrans = self.create_itrans()
         mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
 
@@ -74,7 +75,7 @@ class Basic(Analysis):
             man = mdef.create(itrans).add_lines()
             als.append(Alignment(
                 mdef, self.flown, self.direction, AlinmentStage.SETUP, 
-                man, man.create_template(itrans)
+                1e9, man, man.create_template(itrans)
             ))
         return als
 

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -33,9 +33,10 @@ class Complete(Alignment):
                 raise e
         return pa
 
-    def run(self) -> Scored:
-        if self.stage < AlinmentStage.OPTIMISED:
+    def run(self, optimise_aligment=True) -> Scored:
+        if self.stage < AlinmentStage.OPTIMISED and optimise_aligment:
             self = self.optimise_alignment()
+        self = self.update_templates()
         return Scored(**self.__dict__, 
             scores=ManoeuvreResults(self.inter(), self.intra(), self.positioning())
         )
@@ -62,16 +63,22 @@ 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)
+            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.OPTIMISED, self.dist,
+                manoeuvre, template, correction, correction.create_template(template[0])
+            )
+        else:
+            return self
+    
     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])
-        )
+        self.flown = self.manoeuvre.optimise_alignment(self.template, self.flown)
+        return self.update_templates()
     
     def side_box(self):
         return F3A.intra.box(

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis/analysis/manoeuvre_analysis/scored.py

@@ -23,5 +23,5 @@ class Scored(Complete):
                 raise e
         return ca
     
-    def run(self):
+    def run(self, optimise_alignment=True):
         return self

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis/analysis/sch_analysis.py

@@ -39,7 +39,7 @@ class ScheduleAnalysis(Collection):
             sdef.uids
         )#.move(g.Transformation(g.Point(-data['parameters']['moveEast'], -data['parameters']['moveNorth'], 0)))
 
-        direction = -state.get_manoeuvre(0)[0].direction()[0]
+        direction = -state.get_manoeuvre(1)[0].direction()[0]
 
         return ScheduleAnalysis(
             [analysis.Basic(

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis/scoring/criteria/intra/continuous.py

@@ -52,24 +52,22 @@ class Continuous(Criteria):
         outd = np.full(len(data), np.nan)
         conv = np.convolve(data, kernel, mode='valid')
         ld = (len(data) - len(conv))/2
-        outd[int(np.ceil(ld)):-int(np.floor(ld))] = conv
-        outd[:width//2] = np.linspace(np.mean(data[0:width//4]), outd[width//2],width//2)
-        outd[-width//2:] = np.linspace(outd[-width//2], np.mean(data[-1-width//4:-1]),width//2)
+        ldc = int(np.ceil(ld))
+        ldf = int(np.floor(ld))
+        outd[ldf:-ldc] = conv
+        outd[:ldf] = np.linspace(np.mean(data[:ldf]), conv[0],ldf+1)[:-1]
+        outd[-ldc:] = np.linspace(conv[-1], np.mean(data[-ldc:]), ldc+1)[1:]
         return outd
 
 
 class ContAbs(Continuous):
-#    def prepare(self, value: npt.NDArray, expected: float):
-#        
-#        return  value - expected
-
     def prepare(self, values: npt.NDArray, expected: float):
-        window = 30
+#        window = 30
         sample = values - expected
-        if len(sample) <= window:
+        if len(sample) <= 8:
             return np.linspace(values[0],values[-1], len(sample))
         else:
-            return Continuous.convolve(sample, window)
+            return Continuous.convolve(sample, min(len(values)//3, 40))
 
     @staticmethod
     def mistakes(data, peaks, troughs):
@@ -87,15 +85,15 @@ class ContAbs(Continuous):
 class ContRat(Continuous):
     
     def prepare(self, values: npt.NDArray, expected: float):
-        window = 40
-        if len(values) <= window:
+        #window = 40
+        if len(values) <= 8:
             return np.abs(np.linspace(
                 np.mean(values[:1+len(values)//3]), 
                 np.mean(values[-1-len(values)//3:]), 
                 len(values)
             ))
         else:
-            return np.abs(Continuous.convolve(values, window))
+            return np.abs(Continuous.convolve(values, min(len(values)//3, 40)))
             
     @staticmethod
     def mistakes(data, peaks, troughs):

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis/scoring/measurement.py

@@ -74,11 +74,23 @@ class Measurement:
         return direction,  (1 - 0.8* np.abs(Point.cos_angle_between(loc, direction))) * Measurement._pos_vis(loc)
 
     @staticmethod
-    def _roll_vis(loc: Point, att: Quaternion) -> Union[Point, npt.NDArray]:
-        #a roll error is more visible if the movement of the wing tips is perpendicular to the view vector
-        #the wing tips move in the local body Z axis
-        world_tip_movement_direction = att.transform_point(PZ()) 
-        return world_tip_movement_direction, (1-0.8*np.abs(Point.cos_angle_between(loc, world_tip_movement_direction))) * Measurement._pos_vis(loc)
+    def _roll_vis(fl: State, tp: State) -> Union[Point, npt.NDArray]:
+        
+        
+        afl = Point.cos_angle_between(fl.pos, fl.att.transform_point(PZ()))
+        atp = Point.cos_angle_between(tp.pos, tp.att.transform_point(PZ()))
+
+        azfl = np.cos(fl.att.inverse().transform_point(-fl.pos).planar_angles().x)
+        aztp = np.cos(tp.att.inverse().transform_point(-tp.pos).planar_angles().x)
+
+        ao = afl.copy()
+
+        ao[np.abs(afl) > np.abs(atp)] = atp[np.abs(afl) > np.abs(atp)]
+        ao[np.sign(azfl) != np.sign(aztp)] = 0 # wings have passed through the view vector
+
+        rvis = (1-0.8*np.abs(ao))
+        
+        return fl.att.transform_point(PZ()), rvis * Measurement._pos_vis(fl.pos)
 
     @staticmethod
     def _rad_vis(loc:Point, axial_dir: Point) -> Union[Point, npt.NDArray]:
@@ -115,7 +127,7 @@ class Measurement:
         return Measurement(
             np.unwrap(abs(world_roll_error) * np.sign(body_roll_error.x)), 
             0, 
-            *Measurement._roll_vis(fl.pos, fl.att)
+            *Measurement._roll_vis(fl, tp)
         )
 
     @staticmethod
@@ -140,7 +152,7 @@ class Measurement:
         return Measurement(
             int(flturns - tpturns) * 2 * np.pi + fl_roll_angle - tp_roll_angle,
             0, 
-            *Measurement._roll_vis(fl.pos, fl.att)
+            *Measurement._roll_vis(fl, tp)
         )
 
     @staticmethod
@@ -168,14 +180,21 @@ class Measurement:
     def roll_rate(fl: State, tp: State) -> Measurement:
         """vector in the body X axis, length is equal to the roll rate"""
         wrvel = fl.att.transform_point(fl.p * PX())
-        return Measurement(abs(wrvel) * np.sign(fl.p), np.mean(tp.p), *Measurement._roll_vis(fl.pos, fl.att))
+        return Measurement(
+            abs(wrvel) * np.sign(fl.p), 
+            np.mean(tp.p), 
+            *Measurement._roll_vis(fl, tp)
+        )
     
     @staticmethod
     def nose_drop(fl: State, tp: State) -> Measurement:
         """Check the change in body pitch angle between the start and end of the element"""
         flpit = Quaternion.body_axis_rates(fl.att[0], fl.att[-1]).y
-                
-        return Measurement(flpit, np.array([0]), *Measurement._roll_vis(fl.pos[-1], fl.att[-1]))
+        return Measurement(
+            flpit, 
+            np.array([0]), 
+            *Measurement._roll_vis(fl[-1], tp[-1])
+        )
     
     @staticmethod
     def track_proj(fl: State, tp: State, proj: Point, fix='ang'):
@@ -192,7 +211,10 @@ class Measurement:
         fwvel = fl.att.transform_point(fl.vel)
         twvel = tp.att.transform_point(tp.vel)
 
-        direction, vis = Measurement._vector_vis(Point.vector_rejection(fwvel, twvel).unit(), fl.pos)
+        direction, vis = Measurement._vector_vis(
+            Point.vector_rejection(fwvel, twvel).unit(), 
+            fl.pos
+        )
         
         fcvel = tr.transform_point(fwvel)
         tcvel = tr.transform_point(twvel)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.6
+Version: 0.2.7
 Summary: A package for analysing flight data
 Home-page: https://github.com/PyFlightCoach/FlightAnalysis
 Author: Thomas David
@@ -12,8 +12,8 @@ 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
+Requires-Dist: pfc-geometry>=0.2.5
+Requires-Dist: flightdata>=0.2.7
 
 # FlightAnalysis
 

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/flightanalysis.egg-info/requires.txt

@@ -3,5 +3,5 @@ pandas
 scipy
 fastdtw
 simplejson
-pfc-geometry>=0.2.4
-flightdata>=0.2.6
+pfc-geometry>=0.2.5
+flightdata>=0.2.7

{flightanalysis-0.2.6 → flightanalysis-0.2.7}/setup.cfg

@@ -5,7 +5,7 @@ author_email = thomasdavid0@gmail.com
 description = A package for analysing flight data
 long_description = file: README.md
 long_description_content_type = text/markdown
-version = 0.2.6
+version = 0.2.7
 url = https://github.com/PyFlightCoach/FlightAnalysis
 
 [options]
@@ -22,8 +22,8 @@ install_requires =
 	scipy
 	fastdtw
 	simplejson
-	pfc-geometry>=0.2.4
-	flightdata>=0.2.6
+	pfc-geometry>=0.2.5
+	flightdata>=0.2.7
 
 [egg_info]
 tag_build =