flightanalysis 0.2.0__tar.gz → 0.2.2__tar.gz

{flightanalysis-0.2.0/flightanalysis.egg-info → flightanalysis-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.0
+Version: 0.2.2
 Summary: A package for analysing flight data
 Home-page: https://github.com/PyFlightCoach/FlightAnalysis
 Author: Thomas David

flightanalysis-0.2.2/examples/schedules_construction/create_all.py

@@ -0,0 +1,21 @@
+from .f3a_p23 import p23_def
+from .f3a_a25 import a25_def
+from .f3a_p25 import p25_def
+from .f3a_f25 import f25_def
+from .imac_unlimited_2024 import sdef as imac_unl2024_def
+from .f3auk_clubman import clubman_def as f3auk_club_def
+from .f3auk_Intermediate import intermediate_def as f3auk_int_def
+
+sdefs = {
+    'f3a_p23_schedule': p23_def, 
+    'f3a_a25_schedule': a25_def, 
+    'f3a_p25_schedule': p25_def, 
+    'f3a_f25_schedule': f25_def, 
+    'IMAC_Unlimited2024_schedule': imac_unl2024_def, 
+    'f3auk_clubman_schedule': f3auk_club_def, 
+    'f3auk_inter_schedule': f3auk_int_def
+}
+
+
+for sdef in sdefs:
+    sdef.to_json("flightanalysis/data/p23_schedule.json")

flightanalysis-0.2.0/examples/schedules_construction/a25.py → flightanalysis-0.2.2/examples/schedules_construction/f3a_a25.py

@@ -230,11 +230,9 @@ a25_def = SchedDef([
             MBTags.CENTRE,
         ], )
 
-    ]  #Close Sched_def array 
-)   # close of Sched_def
-       
-
-
+    ]  
+)
+ 
 
 if __name__ == "__main__":
     
@@ -242,8 +240,8 @@ if __name__ == "__main__":
 
 #    for mdef in a25_def:
 #        mdef.plot(depth=170, wind=1).show()
+ #   import os
+ #   a25_def.create_fcjs('a25', f'{os.environ['HOME']}/Desktop/templates/')
 
-#    a25_def.create_fcj('a25', 'a25_template_fcj.json')
-
-    a25_def.to_json("flightanalysis/data/a25_schedule.json")
+    a25_def.to_json("flightanalysis/data/f3a_a25_schedule.json")
 

flightanalysis-0.2.0/examples/schedules_construction/f25.py → flightanalysis-0.2.2/examples/schedules_construction/f3a_f25.py

@@ -260,4 +260,6 @@ if __name__ == "__main__":
  
     #f25_def.plot().show()
 #    f25_def.create_fcj('F25', 'f25_template_fcj.json')
-    f25_def.to_json("flightanalysis/data/f25_schedule.json")
+    f25_def.to_json("flightanalysis/data/f3a_f25_schedule.json")
+    #import os
+    #f25_def.create_fcjs('f25', f'{os.environ['HOME']}/Desktop/templates/')

flightanalysis-0.2.0/examples/schedules_construction/p23.py → flightanalysis-0.2.2/examples/schedules_construction/f3a_p23.py

@@ -226,4 +226,6 @@ if __name__ == "__main__":
     
  #   p23_def.plot().show()
 #    p23_def.create_fcj('P23', 'p23_template_fcj.json')
-    p23_def.to_json("flightanalysis/data/p23_schedule.json")
+    p23_def.to_json("flightanalysis/data/f3a_p23_schedule.json")
+   # import os
+   # p23_def.create_fcjs('p23', f'{os.environ['HOME']}/Desktop/templates/')

flightanalysis-0.2.0/examples/schedules_construction/p25.py → flightanalysis-0.2.2/examples/schedules_construction/f3a_p25.py

@@ -217,4 +217,6 @@ if __name__ == "__main__":
 
     #p25_def.plot().show()
     #p25_def.create_fcj('P25', 'p25_template_fcj.json')
-    p25_def.to_json("flightanalysis/data/p25_schedule.json")
+    p25_def.to_json("flightanalysis/data/f3a_p25_schedule.json")
+#    import os
+#    p25_def.create_fcjs('p25', f'{os.environ['HOME']}/Desktop/templates/')

{flightanalysis-0.2.0 → flightanalysis-0.2.2}/examples/schedules_construction/f3auk_Intermediate.py

@@ -156,7 +156,7 @@ intermediate_def = SchedDef([
         [  
             f3amb.roll(np.pi/2, padded=False),
             centred(f3amb.line(length=100)),
-            f3amb.roll(np.pi/2),
+            f3amb.roll(np.pi/2, padded=False),
         ],         
         ),
         
@@ -196,8 +196,6 @@ intermediate_def = SchedDef([
 if __name__ == "__main__":
 
     #intermediate_def.plot().show()
-    #intermediate_def.create_fcj('intermediate', 'intermediate_template_fcj_170.json', 1)
-    #intermediate_def.create_fcj('intermediate', 'intermediate_template_fcj_170_b.json', -1)
-    #intermediate_def.create_fcj('intermediate', 'intermediate_template_fcj_150.json', 1, 150/170)
-    #intermediate_def.create_fcj('intermediate', 'intermediate_template_fcj_150_b.json', -1, 150/170)
-    intermediate_def.to_json("flightanalysis/data/f3auk_inter_schedule.json")
+    #import os
+    #intermediate_def.create_fcjs('f3auk_intermediate', f'{os.environ['HOME']}/Desktop/templates/')
+    intermediate_def.to_json('flightanalysis/data/f3auk_inter_schedule.json')

{flightanalysis-0.2.0 → flightanalysis-0.2.2}/examples/schedules_construction/f3auk_clubman.py

@@ -193,18 +193,15 @@ clubman_def = SchedDef([
              f3amb.line(),
              ],
         ),
-   
-]#Close Sched_def array 
-)    # close of Sched_def
+    ]
+)
 
 
 
 if __name__ == "__main__":
 
 #    clubman_def.plot().show()
-#    clubman_def.create_fcj('clubman', 'clubman_template_fcj_170.json', 1)
-#    clubman_def.create_fcj('clubman', 'clubman_template_fcj_170_b.json', -1)
-#    clubman_def.create_fcj('clubman', 'clubman_template_fcj_150.json', 1, 150/170)
-#    clubman_def.create_fcj('clubman', 'clubman_template_fcj_150_b.json', -1, 150/170)
-    #clubman_def.create_fcj('clubman', 'clubman_template_fcj.json')
     clubman_def.to_json("flightanalysis/data/f3auk_clubman_schedule.json")
+
+#    import os
+#    clubman_def.create_fcjs('f3auk_clubman', f'{os.environ['HOME']}/Desktop/templates/')

{flightanalysis-0.2.0 → flightanalysis-0.2.2}/examples/schedules_construction/imac_unlimited_2024.py

@@ -71,16 +71,16 @@ sdef = SchedDef([
             end=BoxLocation(Height.BTM)
         ),[
             imacmb.spin('directions[0]'),
-            imacmb.snap(r(1)),
+            imacmb.snap(r(-1), 'directions[1]'),
             imacmb.loop(np.pi),
             imacmb.snap(r(2)),
             imacmb.loop(np.pi),
-            imacmb.roll('directions[1]'),
+            imacmb.roll('directions[2]'),
             imacmb.loop(np.pi/2)
         ],
         directions=ManParm('directions', Combination(desired=[
-            [-r(1.75), r(1.75)],
-            [r(1.75), -r(1.75)]
+            [-r(1.75), r(1), r(1.75)],
+            [r(1.75), -r(1), -r(1.75)]
         ]), 1),
         full_roll_rate=2*np.pi
     ),
@@ -100,7 +100,7 @@ sdef = SchedDef([
             imacmb.loop(-r(1/8)),
             imacmb.roll('4x8', line_length=110 / c45 + 2*50),
             imacmb.loop(r(-3/8)),
-            imacmb.roll([r(1.25), r(-0.75)], rolltypes='rs', line_length=110),
+            imacmb.roll([r(1.25), r(-0.75)], rolltypes='rs', break_angle=-np.radians(15), line_length=110),
             imacmb.loop(r(1/4)),
         ], partial_roll_rate=np.pi/2, full_roll_rate=1.5*np.pi
     ),
@@ -115,15 +115,6 @@ sdef = SchedDef([
             imacmb.roll([r(1/4), r(1/4), r(1)], rolltypes='rrs', line_length=130, break_angle=-np.radians(15)),
             imacmb.loop(r(1/4)),
         ]),
-    imacmb.create(ManInfo(
-            "Half Cuban", "hcu", k=41, position=Position.END, 
-            start=BoxLocation(Height.BTM, Direction.UPWIND, Orientation.UPRIGHT), 
-            end=BoxLocation(Height.BTM)
-        ),[
-            imacmb.snap(r(1.5), padded=False),
-            imacmb.loop(-r(5/8)),
-            imacmb.roll([r(1/4), r(1/4), -r(1)], line_length=130 / c45),
-        ]),
     imacmb.create(ManInfo(
             "Half Cuban", "hcu", k=41, position=Position.END, 
             start=BoxLocation(Height.BTM, Direction.UPWIND, Orientation.UPRIGHT), 
@@ -142,6 +133,7 @@ sdef = SchedDef([
 if __name__ == "__main__":
 
  
-#    sdef.plot().show()
-#    sdef.create_fcj('Unl2024', 'imac_unlimited_2024.json')
-    sdef.to_json("flightanalysis/data/IMAC_Unlimited2024_schedule.json")
+    sdef.plot().show()
+#    import os
+#    sdef.create_fcjs('imac_unlimited_2024', f'{os.environ['HOME']}/Desktop/templates', 'IMAC')
+#    sdef.to_json("flightanalysis/data/IMAC_Unlimited2024_schedule.json")

flightanalysis-0.2.2/examples/schedules_construction/make_manoeuvre.py

@@ -0,0 +1,56 @@
+from flightanalysis.schedule import *
+import numpy as np
+from flightanalysis import *
+from flightdata import State
+
+if True:
+    mdef = f3amb.create(ManInfo(
+            "Square on Corner", "sLoop", k=4, position=Position.CENTRE, 
+            start=BoxLocation(Height.BTM, Direction.UPWIND, Orientation.UPRIGHT),
+            end=BoxLocation(Height.BTM)
+        ),[
+            MBTags.CENTRE,
+            f3amb.loop(np.pi/4, rolls="roll_option[0]"),
+            f3amb.line(),
+            f3amb.loop("roll_option[1]", rolls=r(1/2), ke=True),
+            f3amb.line(),
+            centred(f3amb.loop("roll_option[2]", rolls=r(1/2), ke=True)),
+            f3amb.line(),
+            f3amb.loop("roll_option[3]", rolls=r(1/2), ke=True),
+            f3amb.line(),
+            f3amb.loop("roll_option[4]", rolls="roll_option[5]", ke=True),
+            MBTags.CENTRE
+        ], 
+        roll_option=ManParm("roll_option", Combination(desired=[
+            [r(1/4), -r(1/4), r(1/4), -r(1/4), r(1/8), -r(1/4)], 
+            [-r(1/4), r(1/4), -r(1/4), r(1/4), -r(1/8), r(1/4)]
+        ]), 0),
+        line_length=70
+        )
+else:
+    from imac_unlimited_2024 import  sdef
+    mdef = sdef[7]
+
+#mdef.mps.top_roll_option.default = 1
+
+it = mdef.info.initial_transform(170, 1)
+man = mdef.create(it)
+
+tp = man.create_template(it)
+
+
+
+
+from flightdata import State
+from flightplotting import plotdtw, boxtrace, plotsec
+from flightplotting.traces import axis_rate_trace
+
+import plotly.graph_objects as go
+
+fig = plotdtw(tp, tp.data.element.unique())
+fig = plotsec(tp, fig=fig, nmodels=10, scale=2)
+#fig.add_traces(boxtrace())
+fig.show()
+
+fig = go.Figure(data=axis_rate_trace(tp))
+fig.show()

flightanalysis-0.2.2/examples/scoring/analysis_reprocess.py

@@ -0,0 +1,12 @@
+from flightanalysis import ScheduleAnalysis, DownGrade, Result
+
+sa = ScheduleAnalysis.from_fcscore("examples/scoring/example_analysis_p23.json")
+
+ma=sa.M
+ea=ma.e_2
+
+dg: DownGrade = ea.el.intra_scoring.roll_angle
+res: Result = dg(ea.fl, ea.tp)
+
+
+pass

flightanalysis-0.2.2/examples/scoring/f3a_criteria_maker.py

@@ -0,0 +1,41 @@
+from flightanalysis.scoring.criteria import *
+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)),
+        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)),
+        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)),
+        stallturn_speed=InsideBound(Exponential.fit_points([2, 5], [0.1,0.5]), [-2,2]),
+        stallturn_width=InsideBound(Exponential.fit_points([2, 5], [0.1,0.5]), [-2,2]),
+        spin_entry_length=MaxBound(Exponential.fit_points([2, 5], [0.1,0.5]), 5),
+        pitch_break_length=MaxBound(Exponential.fit_points([2, 5], [0.1,0.5]), 2),
+        recovery_length=MaxBound(Exponential.fit_points([2, 5], [0.1,0.5]), 3),
+    ),
+    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)),
+        free=Comparison(free),
+    )
+)
+
+
+if __name__ == "__main__":
+
+    with open('examples/scoring/temp.py', 'w') as f:
+        for group, v in f3a.items():
+            f.write(f'class F3A{group.capitalize()}:\n')
+            for n, crit in v.items():
+                f.write(f'    {n}={crit.to_py()}\n')
+

{flightanalysis-0.2.0 → flightanalysis-0.2.2}/examples/scoring/judging.py

@@ -4,13 +4,13 @@ from flightanalysis import SchedDef, ScheduleAnalysis, ManoeuvreAnalysis
 from flightdata import Flight
 import numpy as np
 import pandas as pd
-from flightplotting import plotsec
-
+from flightplotting import plotsec, plotdtw
+from time import time
 
 with open("examples/data/manual_F3A_P23_22_05_31_00000350.json", "r") as f:
     data = load(f)
 
-flight = Flight.from_fc_json(data)
+flight = Flight.from_fc_json(data).remove_time_flutter()
 box = Origin.from_fcjson_parmameters(data["parameters"])
 state = State.from_flight(flight, box).splitter_labels(data["mans"])
 sdef = SchedDef.load(data["parameters"]["schedule"][1])
@@ -21,13 +21,26 @@ analysis = ScheduleAnalysis()
 dgs = []
 
 for mdef in sdef:
-    
+    t0 = time()
+    print(f'Analyzing {mdef.info.name}')
     ma = ManoeuvreAnalysis.build(mdef, state.get_manoeuvre(mdef.info.short_name))
-    plotsec(ma.intended_template).show()
     scores = ma.scores()
-
+    print( time()-t0,mdef.info.name, scores.score(), scores.summary())
+    
+    ma.plot_3d().show()
+    
+    print('Optimising Alignment')
+    t0 = time()
+    ma=ma.optimise_alignment()
+    
+    
+    scores = ma.scores()
+    print( time()-t0,mdef.info.name, scores.score(), scores.summary())
+    ma.plot_3d().show()
+    
     dgs.append(scores.summary())
-    print(mdef.info.short_name, scores.score(), dgs[-1])
+    
+    
 
 df = pd.DataFrame.from_dict(dgs)
 print(df)

flightanalysis-0.2.2/examples/scoring/manoeuvres/intra_analysis.py

@@ -0,0 +1,26 @@
+from flightanalysis import ManoeuvreAnalysis as MA, ElementAnalysis as EA
+from json import load, dumps
+import numpy as np
+
+with open('examples/scoring/manoeuvres/mans/tHat_opt.json', 'r') as f:
+    ma = MA.from_dict(load(f))
+
+from flightplotting import plotsec
+from flightplotting.traces import vectors
+from flightanalysis.scoring import Result, DownGrade
+
+ea = ma[0]
+
+
+dg: DownGrade = ea.el.intra_scoring.radius
+res: Result = dg(ea.fl, ea.tp)
+
+
+fig = ea.plot_3d()
+
+fig.add_traces(vectors(5, ea.tp, 5*res.measurement.direction, name='vel_err', line=dict(color='red', width=3)))
+fig.add_traces(vectors(5, ea.tp, 0.5*ea.tp.att.transform_point(ea.tp.vel), name='template_vel', line=dict(color='blue', width=3)))
+fig.add_traces(vectors(5, ea.tp, 0.5*ea.fl.att.transform_point(ea.fl.vel), name='flown_vel', line=dict(color='green', width=3)))
+fig.show()
+res.plot().show()
+pass

flightanalysis-0.2.2/examples/scoring/manoeuvres/mans/extract_mans.py

@@ -0,0 +1,28 @@
+from json import load, dump
+from flightdata import State, Origin
+from flightanalysis import SchedDef
+from flightdata import Flight, NumpyEncoder
+
+    
+
+with open("examples/data/manual_F3A_P23_22_05_31_00000350.json", "r") as f:
+    data = load(f)
+
+
+flight = Flight.from_fc_json(data).remove_time_flutter().butter_filter(4,5)
+box = Origin.from_fcjson_parmameters(data["parameters"])
+state = State.from_flight(flight, box).splitter_labels(data["mans"])
+sdef = SchedDef.load(data["parameters"]["schedule"][1])
+
+from flightanalysis import ScheduleAnalysis, ManoeuvreAnalysis
+
+analysis = ScheduleAnalysis()
+dgs = []
+
+for mdef in sdef:
+    ma = ManoeuvreAnalysis.build(mdef, state.get_manoeuvre(mdef.info.short_name))
+    with open(f'examples/scoring/manoeuvres/mans/{mdef.info.short_name}.json', 'w') as f:
+        dump(ma.to_dict(), f, cls=NumpyEncoder)
+    ma = ma.optimise_alignment()
+    with open(f'examples/scoring/manoeuvres/mans/{mdef.info.short_name}_opt.json', 'w') as f:
+        dump(ma.to_dict(), f, cls=NumpyEncoder)

flightanalysis-0.2.2/examples/scoring/split_optimisation.py

@@ -0,0 +1,50 @@
+'''
+    Trial of running an optimiser to find the optimum split location between two
+    elements. A simple manoeuvre is created(half loop and entry line). a dummy
+    flown manoeuvre is also created with the split in slightly the wrong place. 
+    a local minimizer is then run to find the minimum intra element downgrade, 
+    which corresponds to the split moving back to the correct location.
+'''
+
+from flightdata import *
+from flightanalysis import *
+import geometry as g
+import numpy as np
+from flightplotting import plotdtw, axis_rate_traces
+import plotly.graph_objects as go
+import plotly.express as px
+from time import time
+
+mdef = f3amb.create(ManInfo(
+    "Half Loop", "hloop", k=2, position=Position.END, 
+    start=BoxLocation(Height.BTM, Direction.UPWIND, Orientation.UPRIGHT),
+    end=BoxLocation(Height.TOP)
+),[
+    f3amb.loop(np.pi),
+])
+
+itrans = mdef.info.initial_transform(170, 1)
+man = mdef.create(itrans)
+tp = man.create_template(itrans)
+
+
+man2 = man.copy()
+man2.elements.e_0.radius=40
+fl = man2.create_template(itrans).remove_labels()
+
+al = fl.label(manoeuvre='hloop', element=tp.element[len(tp)-len(fl):])  # simulate a poor alignment
+
+
+els = man.all_elements()
+
+t0=time()
+al2 = man.optimise_alignment(al[0], al)
+print(time() - t0)
+
+
+#px.line(intra.e_0.radius.sample).show()
+plotdtw(al, tp.data.element.unique()).show()
+plotdtw(al2, tp.data.element.unique()).show()
+pass
+#go.Figure(data=axis_rate_traces(dict(tp=tp,al=al))).show()
+

{flightanalysis-0.2.0 → flightanalysis-0.2.2}/flightanalysis/__init__.py

@@ -3,4 +3,4 @@ from .manoeuvre import Manoeuvre
 from .schedule import Schedule
 from .definition import *
 from .scoring import *
-from .manoeuvre_analysis import ManoeuvreAnalysis, ElementAnalysis, ScheduleAnalysis
+from .analysis import ManoeuvreAnalysis, ElementAnalysis, ScheduleAnalysis

flightanalysis-0.2.2/flightanalysis/analysis/__init__.py

@@ -0,0 +1,3 @@
+from .el_analysis import ElementAnalysis
+from .man_analysis import ManoeuvreAnalysis
+from .sch_analysis import ScheduleAnalysis

flightanalysis-0.2.2/flightanalysis/analysis/el_analysis.py

@@ -0,0 +1,33 @@
+
+from flightdata import State
+from typing import Self
+from flightanalysis.definition import ElDef
+from flightanalysis.elements import Element
+from dataclasses import dataclass
+import geometry as g
+
+
+@dataclass
+class ElementAnalysis:
+    edef:ElDef
+    el: Element
+    fl: State
+    tp: State
+    ref_frame: g.Transformation
+
+    def plot_3d(self, origin=False, **kwargs):
+        from flightplotting import plotsec
+        return plotsec([self.fl, self.tp], 2, 5, origin=origin, **kwargs)
+
+    def to_dict(self):
+        return {k: v.to_dict() for k, v in self.__dict__.items()}
+
+    @staticmethod
+    def from_dict(data) -> Self:
+        return ElementAnalysis(
+            ElDef.from_dict(data['edef']),
+            Element.from_dict(data['el']),
+            State.from_dict(data['fl']),
+            State.from_dict(data['tp']),
+            g.Transformation.from_dict(data['ref_frame'])
+        )