flightdata 0.2.25__tar.gz → 0.2.27__tar.gz

{flightdata-0.2.25 → flightdata-0.2.27}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: flightdata
-Version: 0.2.25
+Version: 0.2.27
 Summary: Python tools for handling flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
+License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: numpy>=2.1.3
 Requires-Dist: pandas>=2.2.3

{flightdata-0.2.25 → flightdata-0.2.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flightdata"
-version = "0.2.25"
+version = "0.2.27"
 description = "Python tools for handling flight data"
 readme = "README.md"
 authors = [{ name = "Thomas David", email = "thomasdavid0@gmail.com" }]
@@ -11,6 +11,10 @@ dependencies = [
     "pfc-geometry>=0.2.13",
 ]
 
+[project.scripts]
+collect_logs = "flightdata.scripts.collect_logs:main"
+flightline = "flightdata.scripts.flightline:main"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{flightdata-0.2.25 → flightdata-0.2.27}/src/flightdata/__init__.py

@@ -1,7 +1,6 @@
-from .schemas import fcj
 from .base import *
 from .bindata import BinData
-from .origin import Origin, FCJOrigin
+from .origin import Origin
 from .flight import *
 from .environment import *
 from .coefficients import Coefficients

{flightdata-0.2.25 → flightdata-0.2.27}/src/flightdata/flight/flight.py

@@ -21,7 +21,8 @@ from time import time
 from json import load, dump
 from flightdata.base.numpy_encoder import NumpyEncoder
 from .ardupilot import flightmodes
-from flightdata import Origin, fcj
+from flightdata import Origin
+from schemas import fcj
 from numbers import Number
 from scipy.signal import filtfilt, butter
 from datetime import datetime

{flightdata-0.2.25 → flightdata-0.2.27}/src/flightdata/origin.py

@@ -1,12 +1,11 @@
+from __future__ import annotations
 import geometry as g
 import numpy as np
 from json import load, dump
 from typing import Self
-import json_stream
-from pathlib import Path
 from dataclasses import dataclass   
-from pydantic import BaseModel
-from flightdata import fcj  
+from schemas import fcj  
+
 
 @dataclass
 class Origin(object):
@@ -141,35 +140,26 @@ class Origin(object):
             ),
             float(parms.rotation)
         )
-        
+    
     def gps_to_point(self, gps: g.GPS) -> g.Point:
         return self.rotation.transform_point(gps - self.pos)
 
-    
-
-class FCJOrigin(BaseModel):
-    lat: float
-    lng: float
-    alt: float
-    heading: float
-    move_east: float=0
-    move_north: float=0
-
-    def origin(self):
-        """Create a flightdata.Origin object from the FCJOrigin object."""
+    @staticmethod
+    def from_fcj_origin(fcj_origin: fcj.Origin):
         return Origin(
             "fcj",
-            g.GPS(self.lat, self.lng, self.alt).offset(
-                g.Point(self.move_north, self.move_east, 0)
+            g.GPS(fcj_origin.lat, fcj_origin.lng, fcj_origin.alt).offset(
+                g.Point(fcj_origin.move_north, fcj_origin.move_east, 0)
             ),
-            np.radians(self.heading),
+            np.radians(fcj_origin.heading),
         )
 
-    def shift(self):
-        return self.origin().rotation.transform_point(
-            g.Point(self.move_east, -self.move_north, 0)
-        )
     
-    @staticmethod
-    def zero():
-        return FCJOrigin(lat=0, lng=0, alt=0, heading=0)
+    @property
+    def fcj_origin(self):
+        return fcj.Origin(
+            lat=self.lat,
+            lng=self.long,
+            alt=self.alt,
+            heading=np.degrees(self.heading),
+        )

{flightdata-0.2.25 → flightdata-0.2.27}/src/flightdata/scripts/flightline.py

@@ -1,8 +1,10 @@
+from ast import In
+import sys
 from flightdata import Flight, Origin
 from geometry import GPS
 from pathlib import Path
 import argparse
-
+import re
 
 
 def get_con_groups(log: Flight, channel: int):
@@ -14,64 +16,78 @@ def box_from_log(log: Flight, channel: int):
     grps = get_con_groups(log, channel)
     pilot = grps[0]
     centre = grps[1]
-#    c6on = Flight(log.data.loc[log.data[f'rcin_c{channel}']>=1500])
-#    groups = (c6on.time_flight.diff() > 1).cumsum()
-#    pilot = Flight(c6on.data.loc[groups==0])
-#    centre = Flight(c6on.data.loc[groups==1])
 
     return Origin.from_points("new", GPS(pilot.pos)[-1], GPS(centre.pos)[-1])
 
 def box_from_logs(pilot: Flight, centre: Flight):
     return Origin.from_points("new", GPS(*pilot.pos.iloc[-1]), GPS(*centre.pos.iloc[-1]))
 
+re_logid = re.compile(r'[\d+]$')
+def get_bin_from_number(folder: Path, number: str):
+    try:
+        return list(folder.glob(f"*{number}.BIN"))[0]
+    except IndexError:
+        return list(folder.glob(f"*{number}.bin"))[0]
 
-def main():
-    parser = argparse.ArgumentParser(description='A tool for creating a flightline .f3a file from bin logs')
 
-    parser.add_argument('-l', '--logdir', default='', help='folder to look for logs in')
-    parser.add_argument('-p', '--pilot', default=None, help='flight log bin file to use, None for first')
-    parser.add_argument('-c', '--centre', default=None, help='centre position bin file to use if input==None')
-    parser.add_argument('-d', '--direction', default=None, help='heading of the box, if this is specified only pilot will be read')
-    parser.add_argument('-i', '--input', default=6, help='channel used to indicate pilot or centre postions (pwm>=1500), None for two files')
 
-    args = parser.parse_args()
+def create_flightline(args) -> argparse.Namespace:
+    logdir = Path(args.logdir)
 
-    print(args)
+    plog = logdir / args.pilot
+    if not plog.exists():
+        if args.pilot is None:
+            plog=sorted(list(logdir.glob("*.BIN")))[0]
+        elif args.pilot.isdigit():
+            plog = get_bin_from_number(logdir, args.pilot)
+        else:
+            raise FileNotFoundError(f'Could not find pilot log file: {args.pilot}')
     
-    logs = sorted(list(Path(args.logdir).glob("*.BIN")))
-    logids = [int(log.stem) for log in logs]
-
-    if args.pilot in logs:
-        plog = args.pilot
-    elif args.pilot is None:
-        plog=logs[0]
-    elif args.pilot.isdigit():
-        plog = logs[logids.index(int(args.pilot))]
-
     pilot = Flight.from_log(plog)
 
     print(f'Pilot position log: {plog}')
 
-    if args.centre in logs:
-        clog = args.centre
-    elif args.centre is None:
-        clog=None
-    elif args.centre.isdigit():
-        clog = logs[logids.index(int(args.centre))]
-    if clog:
-        centre = Flight.from_log(clog)
-    print(f'Centre position log: {clog}')
-
     if args.centre:
+        clog = logdir / args.centre
+        if not clog.exists():
+            if args.centre is None:
+                clog=None
+            elif args.centre.isdigit():
+                clog = get_bin_from_number(logdir, args.centre)
+        
+        print(f'Centre position log: {clog}' if clog else "No centre position log")
+        centre = Flight.from_log(clog) if clog else None
+        
         box = Origin.from_points("new", GPS(*pilot.pos.iloc[-1]), GPS(*centre.pos.iloc[-1]))
     else:
-        groups = get_con_groups(pilot, args.input)
         if args.direction:
-            box = Origin("new", GPS(groups[0].pos)[-1], float(args.direction))
+            box = Origin("new", GPS(plog.pos)[-1], float(args.direction))
         else:
+            groups = get_con_groups(pilot, args.input)
             box = Origin.from_points("new", GPS(groups[0].pos)[-1], GPS(groups[1].pos)[-1])
             
-    box.to_f3a_zone(Path(args.logdir) / f'box_{plog.stem}.f3a')
+    return box, plog.stem
+
+
+def parse_args(args):
+    parser = argparse.ArgumentParser(description='A tool for creating a flightline .f3a file from bin logs')
+
+    parser.add_argument('-l', '--logdir', default='', help='folder to look for logs in')
+    parser.add_argument('-p', '--pilot', default=None, help='flight log bin file to use, None for first')
+    parser.add_argument('-c', '--centre', default=None, help='centre position bin file to use if input==None')
+    parser.add_argument('-d', '--direction', default=None, help='heading of the box, if this is specified only pilot will be read')
+    parser.add_argument('-i', '--input', default=6, help='channel used to indicate pilot or centre postions (pwm>=1500), None for two files')
+
+    args = parser.parse_args(args)
+
+    return args
+
+
+def main():
+    args = parse_args(sys.argv[1:])
+    box, name = create_flightline(args)
+    box.to_f3a_zone(Path(args.logdir) / f'box_{name}.f3a')
+    
 
 if __name__ == '__main__':
     main()

{flightdata-0.2.25 → flightdata-0.2.27}/src/flightdata/state.py

@@ -8,7 +8,8 @@ import numpy.typing as npt
 import pandas as pd
 
 import geometry as g
-from flightdata import Constructs, Environment, Flight, Flow, Origin, SVar, Table, fcj
+from flightdata import Constructs, Environment, Flight, Flow, Origin, SVar, Table
+from schemas import fcj
 
 
 class State(Table):

flightdata-0.2.27/test/test_scripts.py

@@ -0,0 +1,25 @@
+from flightdata.scripts import flightline as fl
+import geometry as g
+from pathlib import Path
+import numpy as np
+from pytest import approx
+
+def test_get_bin_from_number():
+    bin = fl.get_bin_from_number(Path("test/data/script_tests"), 1)
+    assert bin.stem == "c6_on_0001"
+
+    bin = fl.get_bin_from_number(Path("test/data/script_tests"), 3)
+    assert bin.stem == "center_0003"
+
+
+
+def test_flightline_two_bins():
+    box, name  = fl.create_flightline(fl.parse_args(["-l", "test/data/script_tests", "-p", "pilot_0004.BIN", "-c", "3"]))
+    assert name == "pilot_0004"
+    assert isinstance(box.pos, g.GPS)
+
+def test_flightline_c6on():
+    box, name  = fl.create_flightline(fl.parse_args(["-l", "test/data/script_tests", "-p", "1"]))
+    assert name == "c6_on_0001"
+
+    assert np.degrees(box.heading) == approx(-34.44699010)

flightdata-0.2.25/src/flightdata/schemas/fcj.py

@@ -1,174 +0,0 @@
-from __future__ import annotations
-from pydantic import BaseModel
-import pandas as pd
-import datetime
-import re
-
-
-class FCJ(BaseModel):
-    version: str
-    comments: str
-    name: str
-    view: View
-    parameters: Parameters
-    scored: bool
-    scores: list[float]
-    human_scores: list[HumanResult] = []
-    fcs_scores: list[Result] = []
-    mans: list[Man]
-    data: list[Data]
-    jhash: int | None = None
-
-
-    def score_df(self):
-        return pd.concat(
-            {fcjr.fa_version: fcjr.to_df() for fcjr in self.fcs_scores},
-            axis=0,
-            names=["version", "manoeuvre", "difficulty", "truncate"],
-        )
-
-    def man_df(self):
-        return pd.DataFrame(
-            [man.__dict__ for man in self.mans[1:-1]],
-            index=pd.Index(range(len(self.mans[1:-1])), name="manoeuvre"),
-        )
-
-    def pfc_version_df(self):
-        sdf = self.score_df().loc[pd.IndexSlice[:, :, 3, False]]
-        return pd.concat(
-            [sdf, sdf.mul(self.man_df().k, axis=0)], axis=1, keys=["raw", "kfac"]
-        )
-
-    def version_summary_df(self):
-        return self.pfc_version_df().groupby("version").kfac.sum()
-
-    def latest_version(self):
-        return max([fcjr.fa_version for fcjr in self.fcs_scores])
-
-    @property
-    def id(self):
-        return re.search(r"\d{8}", self.name)[0]
-
-    @property
-    def created(self):
-        try:
-            return datetime.datetime.strptime(
-                re.search(r"_\d{2}_\d{2}_\d{2}_", self.name)[0], "_%y_%m_%d_"
-            )
-        except Exception:
-            return None
-
-
-class View(BaseModel):
-    position: dict
-    target: dict
-
-class Parameters(BaseModel):
-    rotation: float
-    start: int
-    stop: int
-    moveEast: float
-    moveNorth: float
-    wingspan: float
-    modelwingspan: float
-    elevate: float
-    originLat: float
-    originLng: float
-    originAlt: float
-    pilotLat: str | float
-    pilotLng: str | float
-    pilotAlt: str | float
-    centerLat: str | float
-    centerLng: str | float
-    centerAlt: str | float
-    schedule: list[str]
-
-class HumanResult(BaseModel):
-    name: str
-    date: datetime.date
-    scores: list[float]
-
-class Result(BaseModel):
-    fa_version: str
-    manresults: list[ManResult | None]
-
-    def to_df(self) -> pd.DataFrame:
-        return pd.concat(
-            {i: fcjmr.to_df() for i, fcjmr in enumerate(self.manresults[1:]) if fcjmr},
-            axis=0,
-            names=["manoeuvre", "difficulty", "truncate"],
-        )
-
-class ManResult(BaseModel):
-    els: list[El]
-    results: list[Score] = []
-
-    def to_df(self) -> pd.DataFrame:
-        return pd.DataFrame(
-            data=[res.score.__dict__ for res in self.results],
-            index=pd.MultiIndex.from_frame(
-                pd.DataFrame([res.properties.__dict__ for res in self.results])
-            ),
-        )
-
-    def get_score(self, props: ScoreProperties):
-        for r in self.results:
-            if r.properties == props:
-                return r.score
-
-class El(BaseModel):
-    name: str
-    start: int
-    stop: int
-
-class Score(BaseModel):
-    score: ScoreValues
-    properties: ScoreProperties
-
-class ScoreValues(BaseModel):
-    intra: float
-    inter: float
-    positioning: float
-    total: float
-
-class ScoreProperties(BaseModel):
-    difficulty: int=3
-    truncate: bool=False
-
-    def __eq__(self, other):
-        if not isinstance(other, ScoreProperties):
-            return False
-        return self.difficulty == other.difficulty and self.truncate == other.truncate
-
-class Man(BaseModel):
-    name: str
-    k: float
-    id: str
-    sp: int
-    wd: float
-    start: int
-    stop: int
-    sel: bool
-    background: str
-
-class Data(BaseModel):
-    VN: float = None
-    VE: float = None
-    VD: float = None
-    dPD: float = None  #
-    r: float
-    p: float
-    yw: float
-    N: float
-    E: float
-    D: float
-    time: int
-    roll: float
-    pitch: float
-    yaw: float
-
-
-
-def get_scores(file: str) -> pd.DataFrame:
-    fcj = FCJ.model_validate_json(open(file, "r").read())
-    return fcj.pfc_version_df()