ast_monitor 0.5.0__py3-none-any.whl

ast_monitor/__init__.py

@@ -0,0 +1,30 @@
+from ast_monitor.basic_data import BasicData
+from ast_monitor.digital_twin import DigitalTwin
+from ast_monitor.goals_processor import GoalsProcessor
+from ast_monitor.gps_sensor import GpsSensor
+from ast_monitor.hr_sensor import HrSensor
+from ast_monitor.interval_training import IntervalTraining
+from ast_monitor.mainwindow import Ui_MainWindow
+from ast_monitor.model import AST
+from ast_monitor.route_reader import RouteReader
+from ast_monitor.simulation import Simulation
+from ast_monitor.training_session import TrainingSession
+from ast_monitor.write_log import WriteLog
+
+__all__ = [
+    'BasicData',
+    'DigitalTwin',
+    'GpsSensor',
+    'HrSensor',
+    'IntervalTraining',
+    'Ui_MainWindow',
+    'AST',
+    'GoalsProcessor',
+    'RouteReader',
+    'Simulation',
+    'TrainingSession',
+    'WriteLog'
+]
+
+__project__ = 'ast_monitor'
+__version__ = '0.5.0'

ast_monitor/basic_data.py

@@ -0,0 +1,116 @@
+import math
+import os
+import time
+
+
+class BasicData:
+    """
+    Class for storing and tracking the basic training data in real time.\n
+    Args:
+        hr_data_path (str):
+            path to the file that contains HR data
+        gps_data_path (str):
+            path to the file that contains GPS data
+    """
+    def __init__(self, hr_data_path: str, gps_data_path: str) -> None:
+        """
+        Initialization method for BasicData class.\n
+        Args:
+            hr_data_path (str):
+                path to the file that contains HR data
+            gps_data_path (str):
+                path to the file that contains GPS data
+        """
+        self.hr_data_path = hr_data_path
+        self.gps_data_path = gps_data_path
+        self.current_speed = None
+        self.current_heart_rate = None
+        self.previous_gps = None
+        self.current_gps = None
+        self.distance = 0.0
+
+        with open(self.gps_data_path, 'a') as f:
+            f.truncate(0)
+        with open(self.hr_data_path, 'a') as f:
+            f.truncate(0)
+
+    def read_current_hr(self) -> None:
+        """
+        Reading the current HR from the file.
+        """
+        if not os.path.exists(self.hr_data_path):
+            self.current_heart_rate = None
+            return
+
+        with open(self.hr_data_path, 'rb') as f:
+            try:
+                f.seek(-2, os.SEEK_END)
+                while f.read(1) != b'\n':
+                    f.seek(-2, os.SEEK_CUR)
+            except OSError:
+                f.seek(0)
+            try:
+                hr = int(f.readline().decode().rstrip())
+                self.current_heart_rate = str(hr)
+            except ValueError:
+                self.current_heart_rate = None
+
+    def read_current_gps(self) -> None:
+        """
+        Reading the current GPS position from the file.
+        """
+        if not os.path.exists(self.gps_data_path):
+            self.current_speed = None
+            return
+
+        with open(self.gps_data_path, 'rb') as f:
+            try:
+                f.seek(-2, os.SEEK_END)
+                while f.read(1) != b'\n':
+                    f.seek(-2, os.SEEK_CUR)
+            except OSError:
+                f.seek(0)
+            try:
+                self.previous_gps = self.current_gps
+
+                # Reading the last GPS data.
+                gps = f.readline().decode().rstrip().split(';')
+                self.current_gps = (
+                    float(gps[1]), float(gps[0]), float(gps[2]), float(gps[3])
+                )
+            except IndexError:
+                self.previous_gps = None
+                self.current_gps = None
+
+    def calculate_speed(self) -> None:
+        """
+        Calculating the speed between the previous and the current trackpoint.
+        """
+        if not self.previous_gps or not self.current_gps:
+            self.current_speed = None
+            return
+
+        # If the last measure is older than 1.5 seconds,
+        # it is considered deprecated.
+        if time.time() - self.current_gps[3] > 1.5:
+            self.current_speed = None
+            return
+
+        # Calculating the distance.
+        R = 6373.0
+        lat1 = math.radians(self.previous_gps[0])
+        lat2 = math.radians(self.current_gps[0])
+        lon1 = math.radians(self.previous_gps[1])
+        lon2 = math.radians(self.current_gps[1])
+        dlon = lon2 - lon1
+        dlat = lat2 - lat1
+        a = (
+            math.sin(dlat / 2)**2 +
+            math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2)**2
+        )
+        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+        self.distance = 1000 * R * c
+        t = self.current_gps[3] - self.previous_gps[3]
+        if t:
+            self.current_speed = 3.6 * self.distance / t

ast_monitor/digital_twin.py

@@ -0,0 +1,155 @@
+import time
+
+
+class DigitalTwin:
+    """
+    Class that represents a digital twin that
+    uses a mathematical prediction model to
+    analyze an exercise in the real time.\n
+    Args:
+        predicted_heart_rate (int):
+            a predicted heart rate of an interval
+            (speed or rest segment) in beats per minute
+        duration (int):
+            duration of an interval in minutes
+    """
+    def __init__(
+        self,
+        proposed_heart_rate: int,
+        duration: int,
+        tick_time: float,
+        basic_data
+    ) -> None:
+        """
+        Initialization method of the DigitalTwin class.\n
+        Args:
+            predicted_heart_rate (int):
+                a predicted heart rate of an interval
+                (speed or rest segment) in beats per minute
+            duration (int):
+                duration of an interval in minutes
+            tick_time (float):
+                a tick time in seconds
+        """
+        self.proposed_heart_rate = proposed_heart_rate
+        self.predicted_duration = 60 * duration
+        self.current_heart_rate = 0
+        self.start_time = time.time()
+        self.expected_trackpoints = (60 * 1000 * duration) // tick_time
+        self.basic_data = basic_data
+
+    def read_control_data(self) -> tuple:
+        """
+        Reading the current heart rate and the interval duration.\n
+        Returns:
+            tuple[int, float]: current heart rate, current duration
+        """
+        # Reading the current heart rate.
+        hr = self.basic_data.current_heart_rate
+        if hr:
+            hr = int(hr)
+
+        # Calculating the current phase time.
+        phase_time = time.time() - self.start_time
+
+        return hr, phase_time
+
+    def calculate_prediction(
+        self,
+        trimp_delta: float,
+        average_heart_rate: float,
+        proposed_heart_rate: int,
+        time_delta: float,
+        expected_trackpoints: int
+    ) -> float:
+        """
+        Calculating the predicted heart rate.\n
+        Args:
+            trimp_delta (float):
+                the calculated TRIMP difference
+            average_heart_rate (float):
+                the average heart rate of the interval in beats per minute
+            proposed_heart_rate (int):
+                the proposed heart rate of the interval in beats per minute
+            time_delta (float):
+                the time difference in seconds
+            expected_trackpoints (int):
+                the number of expected trackpoints
+        Returns:
+            float: the proposed heart rate
+        """
+        if trimp_delta < 0:
+            self.minus += trimp_delta
+        else:
+            self.plus += trimp_delta
+
+        if average_heart_rate < proposed_heart_rate:
+            return proposed_heart_rate
+        else:
+            return (
+                proposed_heart_rate +
+                (self.minus - self.plus) / (expected_trackpoints * time_delta)
+            )
+
+    def predict_heart_rate(self) -> None:
+        """
+        Digital twin algorithm that monitors the athlete
+        performance in the real time and calculates the
+        predicted heart rate.
+        """
+        n = 1
+        current_time = 0
+        current_heart_rate = 0
+        previous_heart_rate, previous_time = self.read_control_data()
+        self.average_heart_rate = previous_heart_rate
+        time_delta = 0
+        self.minus, self.plus = 0, 0
+
+        while current_time <= self.predicted_duration - 1:
+            # Reading the current heart rate and the duration.
+            current_heart_rate, current_time = self.read_control_data()
+
+            time_delta = current_time - previous_time
+            if time_delta == 0:
+                continue
+
+            if self.predicted_duration - 1 <= current_time:
+                break
+
+            if current_heart_rate and previous_heart_rate:
+                # Calculating the average heart rate and the time difference.
+                if self.average_heart_rate:
+                    self.average_heart_rate = (
+                        self.average_heart_rate +
+                        (1 / n) * (
+                            current_heart_rate - self.average_heart_rate
+                        )
+                    )
+                else:
+                    self.average_heart_rate = current_heart_rate
+
+                # Calculating the TRIMP difference.
+                trimp_delta = (
+                    ((current_heart_rate - previous_heart_rate) / 2) *
+                    time_delta -
+                    self.proposed_heart_rate * time_delta
+                )
+
+                # Predicted heart rate calculation.
+                self.predicted_heart_rate = self.calculate_prediction(
+                    trimp_delta,
+                    self.average_heart_rate,
+                    self.proposed_heart_rate,
+                    self.predicted_duration - current_time,
+                    self.expected_trackpoints
+                )
+                if self.predicted_heart_rate:
+                    self.predicted_heart_rate = round(
+                        self.predicted_heart_rate
+                    )
+
+                n += 1
+
+            previous_time = current_time
+            previous_heart_rate = current_heart_rate
+            time.sleep(0.5)

ast_monitor/goals_processor.py

@@ -0,0 +1,106 @@
+import math
+
+
+class GoalsProcessor:
+    def __init__(self, route):
+        """Class for measuring the progress of the user on the route."""
+        self.position = None
+        self.total_ascent = route["evaluation"]["total_ascent"]
+        self.total_distance = route["evaluation"]["total_distance"]
+        self.ascents = route["ascents"]
+        self.distances = route["distances"]
+        self.current_distance = 0
+        self.current_ascent = 0
+        self.progress = 0
+        self.distance_to_go = sum(self.distances)
+        self.ascent_to_go = sum(self.ascents)
+        self.index_closest = None
+        self.route = route
+        filteredIntersections = [sublist[1] for sublist in route["nodes"]]
+
+        # Filter the list of dictionaries based on the IDs and remove duplicates
+        filtered_list = []
+        last_added_id = None
+
+        for obj in route['route_render']:
+            # Check if the id is in filteredIntersections
+            if obj['id'] in filteredIntersections:
+                # Check if the id is the same as the last added id
+                if obj['id'] != last_added_id:
+                    # Add the object to the filtered list
+                    filtered_list.append(obj)
+
+                    # Update the last added id
+                    last_added_id = obj['id']
+
+        # Now filtered_list contains the filtered and unique dictionaries
+        self.filtered_list = filtered_list
+        a = 100
+
+    def add_position(self, position):
+        """Add the current position of the user."""
+        self.position = position[0:2]
+        self.get_progress(self.position)
+
+    def get_progress(self, position):
+        """Calculate the progress of the user on the route, (%) of route, Ascent, Distance."""
+        current_node = self.find_closest_object(position)
+        distance = self.haversine_distance(position, (current_node['lat'], current_node['lon']))
+        if distance < 0.05:
+            self.current_distance += sum(self.distances[0:self.index_closest + 1])
+            self.current_ascent += sum(self.ascents[0:self.index_closest + 1])
+            # remove the summed indexes
+            self.distances = self.distances[self.index_closest + 1:]
+            self.ascents = self.ascents[self.index_closest + 1:]
+            self.filtered_list = self.filtered_list[self.index_closest + 1:]
+            self.index_closest = None
+            self.distance_to_go = self.total_distance - self.current_distance
+            self.ascent_to_go = self.total_ascent - self.current_ascent
+            self.progress = self.current_distance / self.total_distance
+
+    def find_closest_object(self, position):
+        """Finds the closest object in the list to the given point."""
+        smallest_diff = float('inf')
+        closest_object = None
+
+        index = 0
+        # Loop through each object in the list
+        for obj in self.filtered_list:
+            lat_diff = math.fabs(obj['lat'] - position[0])
+            lon_diff = math.fabs(obj['lon'] - position[1])
+
+            # Calculate the total difference for both latitude and longitude
+            total_diff = lat_diff + lon_diff
+
+            # Update smallest_diff and closest_object if this object is closer to the given point
+            if total_diff < smallest_diff:
+                smallest_diff = total_diff
+                closest_object = obj
+                self.index_closest = index
+            index += 1
+
+        return closest_object  # Return the closest object
+
+    def haversine_distance(self, coord1, coord2):
+        """
+        Calculate the Haversine distance between two points on the Earth specified by latitude/longitude.
+        """
+
+        # Radius of Earth in kilometers
+        R = 6371.0
+
+        # Convert latitude and longitude from degrees to radians
+        lat1, lon1 = math.radians(coord1[0]), math.radians(coord1[1])
+        lat2, lon2 = math.radians(coord2[0]), math.radians(coord2[1])
+
+        # Compute differences in latitude and longitude
+        dlat = lat2 - lat1
+        dlon = lon2 - lon1
+
+        # Haversine formula
+        a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+        distance = R * c
+
+        return distance

ast_monitor/gps_sensor.py

@@ -0,0 +1,81 @@
+import time
+
+# It should work on ARM architectures only.
+try:
+    import adafruit_gps
+    import serial
+except BaseException:
+    pass
+
+
+class GpsSensor:
+    """
+    Class for working with GPS sensor.\n
+    Args:
+        gps_path (str):
+            path to file for storing GPS data
+    """
+    def __init__(self, gps_path: str = 'sensor_data/gps.txt') -> None:
+        """
+        Initialisation method for GpsSensor class.\n
+        Args:
+            gps_path (str):
+                path to file for storing gps data
+        """
+        self.gps_path = gps_path
+
+    def write_gps_data_to_file(
+        self,
+        longitude: float,
+        latitude: float,
+        altitude: float
+    ) -> None:
+        """
+        Method for writing GPS data to text file.\n
+        Args:
+            longitude (float):
+                longitude on Earth
+            latitude (float):
+                latitude on Earth
+            altitude (float):
+                current altitude
+        """
+        output = (
+            str(longitude) + ';' + str(latitude) + ';' +
+            str(altitude) + ';' + time.time()
+        )
+        with open(self.gps_path, 'a') as f:
+            f.write(output + '\n')
+
+    def get_gps_data(self) -> None:
+        """
+        Method for listening the channel for obtaining GPS data from sensor.\n
+        Note: Example is based on source code from
+              https://github.com/adafruit/Adafruit_CircuitPython_GPS
+        """
+        uart = serial.Serial('/dev/serial0', baudrate=9600, timeout=10)
+        gps = adafruit_gps.GPS(uart, debug=False)
+        gps.send_command(b'PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
+        gps.send_command(b'PMTK220,1000')
+        last_print = time.monotonic()
+
+        while True:
+            gps.update()
+
+            current = time.monotonic()
+            if current - last_print >= 1.0:
+                last_print = current
+                if not gps.has_fix:
+                    print('Waiting for fix...')
+                    continue
+
+                LATITUDE = gps.latitude
+                LONGITUDE = gps.longitude
+                ALTITUDE = gps.altitude_m
+
+                if (
+                    (LATITUDE is not None) and
+                    (LONGITUDE is not None) and
+                    (ALTITUDE is not None)
+                ):
+                    self.write_gps_data_to_file(LONGITUDE, LATITUDE, ALTITUDE)

ast_monitor/hr_sensor.py

@@ -0,0 +1,71 @@
+# If openant dependency is missing.
+try:
+    from ant.easy.node import Node
+    from ant.easy.channel import Channel
+except BaseException:
+    pass
+
+
+class HrSensor():
+    """
+    Class for working with HR sensor.\n
+    Args:
+        hr_path (str):
+            path to file for storing HR data
+    """
+    def __init__(self, hr_path='sensor_data/hr.txt') -> None:
+        """
+        Initialisation method for HrSensor class.\n
+        Args:
+            hr_path (str):
+                path to file for storing HR data
+        """
+        self.hr_path = hr_path
+
+    def write_hr_data_to_file(self, hr: int) -> None:
+        """
+        Method for writing hr data to text file.\n
+        Args:
+            hr (int):
+                heart rate
+        """
+        with open(self.hr_path, 'a') as f:
+            f.write(hr + "\n")
+
+    def on_data(self, data) -> None:
+        """
+        Extracting and writing heart rate data to file.\n
+        Args:
+            data ():
+                list that contains heart rate
+        """
+        heartrate = data[7]
+        print(heartrate)
+        self.write_hr_data_to_file(str(heartrate))
+
+    def get_hr_data(self) -> None:
+        """
+        Method for listening the channel for obtaining HR data from sensor.\n
+        Note: Example is based on source code from
+              https://github.com/Tigge/openant/blob/master/examples/heart_rate_monitor.py
+        """
+        NETWORK_KEY = [0xB9, 0xA5, 0x21, 0xFB, 0xBD, 0x72, 0xC3, 0x45]
+
+        node = Node()
+        node.set_network_key(0x00, NETWORK_KEY)
+
+        channel = node.new_channel(Channel.Type.BIDIRECTIONAL_RECEIVE)
+
+        channel.on_broadcast_data = self.on_data
+        channel.on_burst_data = self.on_data
+
+        channel.set_period(8070)
+        channel.set_search_timeout(12)
+        channel.set_rf_freq(57)
+        channel.set_id(0, 120, 0)
+
+        try:
+            channel.open()
+            node.start()
+        finally:
+            node.stop()

ast_monitor/html_request_handler.py

@@ -0,0 +1,24 @@
+import http.server
+import os
+from urllib.parse import urlparse
+
+
+class CustomHandler(http.server.SimpleHTTPRequestHandler):
+    """Custom handler to serve the html files from the dist folder instead of the root folder.
+    The handler helps us avoid changing the current directory of the Python script."""
+
+    def translate_path(self, path):
+        """
+        Method that allows the server to serve the html files from the dist folder instead of the root folder.
+        Args:
+            path: url path
+
+        Returns:
+
+        """
+        parsed_path = urlparse(path).path
+        current_file_directory = os.path.dirname(os.path.abspath(__file__))
+        custom_folder = os.path.join(current_file_directory, 'map', 'dist')
+        translated_path = os.path.join(custom_folder, parsed_path.lstrip('/'))
+        print(f"Translated path: {translated_path}")  # Debugging line to print the translated path
+        return translated_path

ast_monitor/icons/arrow_down.svg

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="6.5972247mm"
+   height="8.3541622mm"
+   viewBox="0 0 6.5972248 8.354162"
+   version="1.1"
+   id="svg1844"
+   inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)"
+   sodipodi:docname="arrow_down.svg">
+  <defs
+     id="defs1838" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="11.2"
+     inkscape:cx="-1.0870781"
+     inkscape:cy="16.256367"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     inkscape:document-rotation="0"
+     showgrid="false"
+     inkscape:window-width="1920"
+     inkscape:window-height="1017"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1" />
+  <metadata
+     id="metadata1841">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-109.33837,-90.883931)">
+    <path
+       style="fill:#5bad5e;fill-opacity:1;stroke:#000000;stroke-width:0.19538px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 114.5562,91.037913 c 10e-4,0.05431 0,4.250421 0,4.250421 0,0 0.85295,0.01977 1.27904,0 0.11267,-0.0052 -3.07792,3.854675 -3.19759,3.852091 -0.11723,-0.0025 -3.33164,-3.850198 -3.19759,-3.852091 0.42632,-0.0059 1.27903,0 1.27903,0 0,0 2.7e-4,-4.166126 0,-4.250421 -2.5e-4,-0.07785 3.83576,-0.07221 3.83711,0 z"
+       id="path1484-2"
+       sodipodi:nodetypes="scssscss" />
+  </g>
+</svg>