{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":22559,"databundleVersionId":1923081,"sourceType":"competition"}],"dockerImageVersionId":30055,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Introduction\n\nYou probably have experienced this before: You are in an underground carpark and you have just activated your navigation system. But the navigation system has trouble locating you on the map due to poor GPS signal quality caused by the concrete walls. Although, in this use case a better accuracy would only be a \"nice to have\", in other cases it could become a necessity for indoor applications.\n\nTo **improve the accuracy of indoor positioning systems**, we are asked to predict the indoor position of smartphones based on real-time sensor data in this competition.\n\nThe aim of this notebook is to give you an **introduction to the topic** and making you **familiar with the data**.\n\n# Dataset Overview\n\nThe dataset we are working with is provided by the Chinese company XYZ10 specialized in indoor positioning technology. The dataset consists of path trace recordings of a person walking from one point to another. During the walk, the following sensor signals are recorded:\n* accelerometer\n* magnetic field\n* gyroscope\n* rotation vector\n* WiFi\n* Bluetooth iBeacon\n* ground truths (waypoint locations)\n\nAdditional information on the data can be found on the [competition's Github page](https://github.com/location-competition/indoor-location-competition-20). There, you will also find some [webinar slides](https://github.com/location-competition/indoor-location-competition-20/blob/master/webinar.pdf).","metadata":{}},{"cell_type":"code","source":"import numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\nfrom dataclasses import dataclass\n\nimport matplotlib.pyplot as plt # visualization\nplt.rcParams.update({'font.size': 14})\nimport seaborn as sns # visualization\n\nimport warnings # Supress warnings \nwarnings.filterwarnings('ignore')\n\nfrom tqdm import tqdm\n\nimport json\nimport plotly.graph_objs as go\nfrom PIL import Image","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"_kg_hide-input":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Let's have a first look at one of the trace files to get a rough feeling for the data. Unfortunately, this time we don't have the comfort of .csv format. Instead, we are provided text files. The **text files** start with a header and end with a footer containing some meta information. The **header and footer are lines which start with a has sign ('#')**. In between, we have the sensor data. The sensor data is **delimited with a tab** ('\\t'). Each row starts with a **timestamp, followed by the sensor name and the sensor values**. However, if you try to read it with pandas and a specified delimiter, you will notice that the **number of columns in each row can vary depending on the sensor**. ","metadata":{}},{"cell_type":"code","source":"!head -n 15 \"../input/indoor-location-navigation/train/5a0546857ecc773753327266/F2/5dccf516c04f060006e6e3c9.txt\"","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"To retrieve the data, we will go through the file line by line and append the relevant data to its assigned array. Below, we can see that each array has a different shape. For example, we only has 6 data points for waypoint, while we have 1743 datapoints from the acceleration sensor.\n\nThe following code is copied and edited from [@ihelon's notebook](https://www.kaggle.com/ihelon/indoor-location-exploratory-data-analysis) and is originally from the [competition's Github page](https://github.com/location-competition/indoor-location-competition-20/blob/master/io_f.py).","metadata":{}},{"cell_type":"code","source":"# copy from https://github.com/location-competition/indoor-location-competition-20/blob/master/io_f.py\n\n@dataclass\nclass ReadData:\n    acce: np.ndarray\n    acce_uncali: np.ndarray\n    gyro: np.ndarray\n    gyro_uncali: np.ndarray\n    magn: np.ndarray\n    magn_uncali: np.ndarray\n    ahrs: np.ndarray\n    wifi: np.ndarray\n    ibeacon: np.ndarray\n    waypoint: np.ndarray\n\n\ndef read_data_file(data_filename):\n    acce = []\n    acce_uncali = []\n    gyro = []\n    gyro_uncali = []\n    magn = []\n    magn_uncali = []\n    ahrs = []\n    wifi = []\n    ibeacon = []\n    waypoint = []\n\n    with open(data_filename, 'r', encoding='utf-8') as file:\n        lines = file.readlines()\n\n    for line_data in lines:\n        line_data = line_data.strip()\n        if not line_data or line_data[0] == '#':\n            continue\n\n        line_data = line_data.split('\\t')\n\n        if line_data[1] == 'TYPE_WAYPOINT':\n            waypoint.append([int(line_data[0]), float(line_data[2]), float(line_data[3])])\n            continue\n       \n        if line_data[1] == 'TYPE_ACCELEROMETER':\n            acce.append([int(line_data[0]), float(line_data[2]), float(line_data[3]), float(line_data[4])])\n            continue\n        \n        if line_data[1] == 'TYPE_ACCELEROMETER_UNCALIBRATED':\n            acce_uncali.append([int(line_data[0]), float(line_data[2]), float(line_data[3]), float(line_data[4])])\n            continue\n        \n        if line_data[1] == 'TYPE_GYROSCOPE':\n            gyro.append([int(line_data[0]), float(line_data[2]), float(line_data[3]), float(line_data[4])])\n            continue\n\n        if line_data[1] == 'TYPE_GYROSCOPE_UNCALIBRATED':\n            gyro_uncali.append([int(line_data[0]), float(line_data[2]), float(line_data[3]), float(line_data[4])])\n            continue\n        \n        if line_data[1] == 'TYPE_MAGNETIC_FIELD':\n            magn.append([int(line_data[0]), float(line_data[2]), float(line_data[3]), float(line_data[4])])\n            continue\n\n        if line_data[1] == 'TYPE_MAGNETIC_FIELD_UNCALIBRATED':\n            magn_uncali.append([int(line_data[0]), float(line_data[2]), float(line_data[3]), float(line_data[4])])\n            continue\n\n        if line_data[1] == 'TYPE_ROTATION_VECTOR':\n            ahrs.append([int(line_data[0]), float(line_data[2]), float(line_data[3]), float(line_data[4])])\n            continue\n\n        if line_data[1] == 'TYPE_WIFI':\n            sys_ts = line_data[0]\n            ssid = line_data[2]\n            bssid = line_data[3]\n            rssi = line_data[4]\n            lastseen_ts = line_data[6]\n            wifi_data = [sys_ts, ssid, bssid, rssi, lastseen_ts]\n            wifi.append(wifi_data)\n            continue\n\n        if line_data[1] == 'TYPE_BEACON':\n            ts = line_data[0]\n            uuid = line_data[2]\n            major = line_data[3]\n            minor = line_data[4]\n            rssi = line_data[6]\n            ibeacon_data = [ts, '_'.join([uuid, major, minor]), rssi]\n            ibeacon.append(ibeacon_data)\n            continue\n        \n    \n    acce = np.array(acce)\n    acce_uncali = np.array(acce_uncali)\n    gyro = np.array(gyro)\n    gyro_uncali = np.array(gyro_uncali)\n    magn = np.array(magn)\n    magn_uncali = np.array(magn_uncali)\n    ahrs = np.array(ahrs)\n    wifi = np.array(wifi)\n    ibeacon = np.array(ibeacon)\n    waypoint = np.array(waypoint)\n    \n    return ReadData(acce, acce_uncali, gyro, gyro_uncali, magn, magn_uncali, ahrs, wifi, ibeacon, waypoint)\n\nsample_file = read_data_file(\"../input/indoor-location-navigation/train/5a0546857ecc773753327266/F2/5dccf516c04f060006e6e3c9.txt\")\n\nprint('acce shape:', sample_file.acce.shape)\nprint('acce_uncali shape:', sample_file.acce_uncali.shape)\nprint('gyro shape:', sample_file.gyro.shape)\nprint('gyro_uncali shape:', sample_file.gyro_uncali.shape)\nprint('magn shape:', sample_file.magn.shape)\nprint('magn_uncali shape:',sample_file.magn_uncali.shape)\nprint('ahrs shape:', sample_file.ahrs.shape)\nprint('wifi shape:', sample_file.wifi.shape)\nprint('ibeacon shape:', sample_file.ibeacon.shape)\nprint('waypoint shape:', sample_file.waypoint.shape)","metadata":{"trusted":true,"_kg_hide-input":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Unix Timestamp\nThe first column is the **Unix Time in milliseconds**. If you are not familiar with Unix time, then I recommend reading up on it on [wikipedia](https://en.wikipedia.org/wiki/Unix_time). But in short, the unix time is the time elapsed since 00:00:00 UTC on 1 January 1970. \n\nAt this point, I am not yet sure if we really need to convert Unix timestamps to human understandable timestamps but here is the conversion - just in case. Since we are working with milliseconds, we need to divide the timestamps by 1000. The above sample starts at 1573713056850 and ends at 1573713091483, which corresponds to a short 34.633 s long trace done on November 14th 2019.","metadata":{}},{"cell_type":"code","source":"from datetime import datetime\nstart_time = 1573713056850\nend_time = 1573713091483\n\nprint(datetime.fromtimestamp(start_time/1000.0))\nprint(datetime.fromtimestamp(end_time/1000.0))\nprint(datetime.fromtimestamp(end_time/1000.0)-datetime.fromtimestamp(start_time/1000.0))","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"\n\n# Waypoint\nLet's plot the trace of the waypoint on the map first to get a feeling for this example.\n\nThe following code is also copied and edited from [@ihelon's notebook](https://www.kaggle.com/ihelon/indoor-location-exploratory-data-analysis) and is originally from the [competition's Github page](https://github.com/location-competition/indoor-location-competition-20/blob/master/visualize_f.py).","metadata":{}},{"cell_type":"code","source":"waypoint_df = pd.DataFrame(sample_file.waypoint)\nwaypoint_df.columns = ['timestamp', 'waypoint_x','waypoint_y']\ndisplay(waypoint_df.style.set_caption('Waypoint'))","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def visualize_trajectory(trajectory, floor_plan_filename, width_meter, height_meter, title=None, mode='lines + markers + text', show=False):\n    \"\"\"\n    Copied from from https://github.com/location-competition/indoor-location-competition-20/blob/master/visualize_f.py\n\n    \"\"\"\n    fig = go.Figure()\n\n    # add trajectory\n    size_list = [6] * trajectory.shape[0]\n    size_list[0] = 10\n    size_list[-1] = 10\n\n    color_list = ['rgba(4, 174, 4, 0.5)'] * trajectory.shape[0]\n    color_list[0] = 'rgba(12, 5, 235, 1)'\n    color_list[-1] = 'rgba(235, 5, 5, 1)'\n\n    position_count = {}\n    text_list = []\n    for i in range(trajectory.shape[0]):\n        if str(trajectory[i]) in position_count:\n            position_count[str(trajectory[i])] += 1\n        else:\n            position_count[str(trajectory[i])] = 0\n        text_list.append('        ' * position_count[str(trajectory[i])] + f'{i}')\n    text_list[0] = 'Start 0'\n    text_list[-1] = f'End {trajectory.shape[0] - 1}'\n\n    fig.add_trace(\n        go.Scattergl(\n            x=trajectory[:, 0],\n            y=trajectory[:, 1],\n            mode=mode,\n            marker=dict(size=size_list, color=color_list),\n            line=dict(shape='linear', color='lightgrey', width=3, dash='dash'),\n            text=text_list,\n            textposition=\"top center\",\n            name='trajectory',\n        ))\n\n    # add floor plan\n    floor_plan = Image.open(floor_plan_filename)\n    fig.update_layout(images=[\n        go.layout.Image(\n            source=floor_plan,\n            xref=\"x\",\n            yref=\"y\",\n            x=0,\n            y=height_meter,\n            sizex=width_meter,\n            sizey=height_meter,\n            sizing=\"contain\",\n            opacity=1,\n            layer=\"below\",\n        )\n    ])\n\n    # configure\n    fig.update_xaxes(autorange=False, range=[0, width_meter])\n    fig.update_yaxes(autorange=False, range=[0, height_meter], scaleanchor=\"x\", scaleratio=1)\n    fig.update_layout(\n        title=go.layout.Title(\n            text=title or \"No title.\",\n            xref=\"paper\",\n            x=0,\n        ),\n        autosize=True,\n        width=800,\n        height=  800 * height_meter / width_meter,\n        template=\"plotly_white\",\n    )\n\n    if show:\n        fig.show()\n\n    return fig\n\ndef visualize_train_trajectory(path):\n    \"\"\"\n    Edited from \n    https://www.kaggle.com/ihelon/indoor-location-exploratory-data-analysis\n    \"\"\"\n    _id, floor = path.split(\"/\")[:2]\n    \n    train_floor_data = read_data_file(f\"../input/indoor-location-navigation/train/{path}\")\n    with open(f\"../input/indoor-location-navigation/metadata/{_id}/{floor}/floor_info.json\") as f:\n        train_floor_info = json.load(f)\n\n    return visualize_trajectory(\n        train_floor_data.waypoint[:, 1:3], \n        f\"../input/indoor-location-navigation/metadata/{_id}/{floor}/floor_image.png\",\n        train_floor_info[\"map_info\"][\"width\"], \n        train_floor_info[\"map_info\"][\"height\"],\n        f\"Visualization of {path}\"\n    )\n\nvisualize_train_trajectory(\"5a0546857ecc773753327266/F2/5dccf516c04f060006e6e3c9.txt\")","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Inertial Measurement Unit (IMU)\nThe inertial measurement unit (IMU) is a sensor that measures the force, angular rate and orientation of a body. In this case, the body is a phone. These values are measured by accelerometers, gyroscopes, and in this case also magnetometers. \n* **Accelerometer**: Measures change in velocity ($m/s^2$) \n* **Gyroscopes**: Measures change in rotation ($rad/s$)\n* **Magnetometer**: Measures magnetic field ($\\mu T$)\n\nThe IMU sensor data has the same shape in this case. Note, that this is true for a lot of traces but not all of them. We can concatenate them to a dataframe for the initial analysis of the data.\n\n![10421a93-a1dd-41a8-a9c0-7147d3f47f27.png](attachment:10421a93-a1dd-41a8-a9c0-7147d3f47f27.png)\nImage Source: https://developer.apple.com/documentation/coremotion/getting_processed_device-motion_data/understanding_reference_frames_and_device_attitude\n\n","metadata":{},"attachments":{"10421a93-a1dd-41a8-a9c0-7147d3f47f27.png":{"image/png":"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"}}},{"cell_type":"code","source":"temp = np.concatenate([sample_file.acce, \n                       sample_file.acce_uncali[:, 1:],\n                       sample_file.gyro[:, 1:],\n                       sample_file.gyro_uncali[:, 1:],\n                       sample_file.magn[:, 1:],\n                       sample_file.magn_uncali[:, 1:],\n                       sample_file.ahrs[:, 1:],\n                      ], axis=1)\n\nimu_df = pd.DataFrame(temp)\n\nimu_df.columns = ['timestamp', 'acce_x','acce_y', 'acce_z','acce_uncali_x','acce_uncali_y', 'acce_uncali_z',\n              'gyro_x','gyro_y', 'gyro_z','gyro_uncali_x','gyro_uncali_y', 'gyro_uncali_z',\n              'magn_x','magn_y', 'magn_z','magn_uncali_x','magn_uncali_y', 'magn_uncali_z',\n              'ahrs_x','ahrs_y', 'ahrs_z']\n\ndisplay(imu_df.head(8).style.set_caption('IMU Data'))","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Let's have a look at the acceleration first.","metadata":{}},{"cell_type":"code","source":"def plot_imu_signals(col, uncali = True):\n    fig, ax = plt.subplots(nrows=3, ncols=1, figsize=(14, 9))\n    ax[0].set_ylabel(f\"{col}_x\")\n    ax[1].set_ylabel(f\"{col}_y\")\n    ax[2].set_ylabel(f\"{col}_z\")\n    if uncali:\n        sns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_uncali_x\"], ax=ax[0], label = 'uncali', color='orange')\n        sns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_uncali_y\"], ax=ax[1], label = 'uncali', color='orange')\n        sns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_uncali_z\"], ax=ax[2], label = 'uncali', color='orange')\n        ax[0].set_ylabel(f\"{col}_x \\n(calib./uncalib.)\")\n        ax[1].set_ylabel(f\"{col}_y \\n(calib./uncalib.)\")\n        ax[2].set_ylabel(f\"{col}_z \\n(calib./uncalib.)\")\n    \n    sns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_x\"], ax=ax[0], label='cali', color='cornflowerblue')\n    sns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_y\"], ax=ax[1], label='cali', color='cornflowerblue')\n    sns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_z\"], ax=ax[2], label='cali', color='cornflowerblue')\n\n    for i in range(3):\n        ax[i].set_xlim([start_time, end_time])\n    plt.tight_layout()\n    plt.show()\n    \nplot_imu_signals('acce')\n    \n","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"The first thing, we can notice is that the mean value of acce_z looks familiarly close to the standard gravity $g=9.80665 m/s^2$. In contrast to the above picture, the phone is not help upright during the trace but instead it is\n> [...] is held flat in front of the surveyors body [...]. \n\nThat is why the value of the z-axis corresponds to $g$.","metadata":{}},{"cell_type":"code","source":"imu_df.acce_z.mean()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# > Therefore, to measure the real acceleration of the device, the contribution of the force of gravity must be removed from the accelerometer data. \n# This can be achieved by applying a high-pass filter. Conversely, a low-pass filter can be used to isolate the force of gravity. \n# The following example shows how you can do this -[Android Developer Docs: Motion Sensors](https://developer.android.com/guide/topics/sensors/sensors_motion#java)\n\n# In this example, alpha is calculated as t / (t + dT),\n# where t is the low-pass filter's time-constant and\n# dT is the event delivery rate.\n\n\"\"\"alpha = 0.8\n\nimu_df['g_x'] = 0\nimu_df['g_y'] = 0\nimu_df['g_z'] = 9.81\n\n# Isolate the force of gravity with the low-pass filter.\nimu_df['g_x'] = alpha * imu_df['g_x'] + (1 - alpha) * imu_df['acce_x'];\nimu_df['g_y'] = alpha * imu_df['g_y'] + (1 - alpha) * imu_df['acce_y'];\nimu_df['g_z'] = alpha * imu_df['g_z']  + (1 - alpha) * imu_df['acce_z'];\n\n# Remove the gravity contribution with the high-pass filter.\nimu_df['lin_acce_x'] = imu_df['acce_x'] - imu_df['g_x'];\nimu_df['lin_acce_y'] = imu_df['acce_y'] - imu_df['g_y'];\nimu_df['lin_acce_z'] = imu_df['acce_z'] - imu_df['g_z'];\n\n#imu_df['lin_acce_y'].iloc[0]\nfig, ax = plt.subplots(nrows=1, ncols=1, figsize=(14, 3))\n\nsns.lineplot(x=imu_df.timestamp, y=imu_df[\"acce_x\"], label = 'orgi')\nsns.lineplot(x=imu_df.timestamp, y=imu_df[\"lin_acce_x\"], label='lin')\nsns.lineplot(x=imu_df.timestamp, y=imu_df[\"g_x\"], label='grav')\nplt.show()\"\"\"","metadata":{"_kg_hide-input":true,"_kg_hide-output":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Now let's try to make sense of the x and y components of the acceleration. For this we will calculate the velocity and position from the acceleration and then cross check it with the actual position. To avoid mistakes, we will first play with a little high school level example :)","metadata":{}},{"cell_type":"code","source":"def calc_from_pos(timestamp, pos):\n    df = pd.DataFrame({'timestamp' : timestamp, 'position' : pos})\n    df['timestamp_ms'] = df['timestamp'].apply(lambda x: datetime.fromtimestamp(x/1000.0))\n    df['timedelta_ms'] = df['timestamp_ms'].diff()\n    df['timedelta_s'] = df['timedelta_ms'].apply(lambda x: x.total_seconds()).fillna(0)\n    df['velocity'] = (df['position'].diff() / df['timedelta_s']).fillna(0)\n    df['acceleration'] = (df['velocity'].diff() / df['timedelta_s']).fillna(0)\n\n    return df[['timestamp', 'timestamp_ms', 'timedelta_s', 'position', 'velocity', 'acceleration']]\n\ndef calc_from_acce(timestamp, acce, p_0):\n    df = pd.DataFrame({'timestamp' : timestamp, 'acceleration' : acce})\n    df['timestamp_ms'] = df['timestamp'].apply(lambda x: datetime.fromtimestamp(x/1000.0))\n    df['timedelta_ms'] = df['timestamp_ms'].diff()\n    df['timedelta_s'] = df['timedelta_ms'].apply(lambda x: x.total_seconds()).fillna(0)\n    df['velocity'] = (df['acceleration']*df['timedelta_s']).cumsum()\n    df['position'] = p_0 + (df['velocity']*df['timedelta_s']).cumsum()\n\n    return df[['timestamp', 'timestamp_ms', 'timedelta_s', 'position', 'velocity', 'acceleration']]\n\na_df = calc_from_acce(pd.Series([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) * 1000 + start_time, \n               pd.Series([0, 0, 1.2, 1.2, 1.2, 0, 0, 0, -1.2, -1.2, -1.2, 0, 0]), -6)\ndisplay(a_df.style.set_caption('Calculated Position and Velocity from Acceleration'))\n\nb_df = calc_from_pos(a_df.timestamp, a_df.position)\ndisplay(b_df.style.set_caption('Calculated Acceleration and Velocity from Position'))\n\nfig, ax = plt.subplots(nrows=1, ncols=1, figsize=(14, 6))\nsns.lineplot(x=a_df.timestamp, y=a_df.position, ax=ax, color='cornflowerblue', marker='o', label='Position ($m$)')\nsns.lineplot(x=a_df.timestamp, y=a_df.velocity, ax=ax, color='blue', marker='o', label='Velocity ($m/s$)')\nsns.lineplot(x=a_df.timestamp, y=a_df.acceleration, ax=ax, color='seagreen', marker='o', label='Acceleration ($m/s^2$)')\n\nplt.show()","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Let's apply this to the sample data (Unhide output to see dataframe -->).\n\nAlthough, we were able to see from the example above that the functions seem to be correct, the `waypoint` data and the `acce` data don't match. This could be caused by the signal's noise. By integrating over the acceleration, we will also integrate the error for each sample, which can quickly accumulate and cause large deviations, as we can see.\n","metadata":{}},{"cell_type":"code","source":"imu_df_temp = calc_from_acce(imu_df.timestamp, \n                      (-1)*imu_df.acce_x, \n                      waypoint_df.waypoint_x.iloc[0])\n\ndisplay(imu_df_temp.head(5).style.set_caption('Calculated Position and Velocity from acce_x'))\n\nwaypoint_df_temp = calc_from_pos(waypoint_df.timestamp, waypoint_df.waypoint_x)\ndisplay(waypoint_df_temp.style.set_caption('Calculated Acceleration and Velocity from waypoint_x'))\n\n\nfig, ax = plt.subplots(nrows=3, ncols=1, figsize=(14, 14))\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.position, ax=ax[0], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.position, ax=ax[0], color='cornflowerblue', label='acce_x')\nax[0].set_ylabel('Position x \\n($m$)')\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.velocity, ax=ax[1], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.velocity, ax=ax[1], color='cornflowerblue', label='acce_x')\nax[1].set_ylabel('Velocity x \\n($m/s$)')\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.acceleration, ax=ax[2], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.acceleration, ax=ax[2], color='cornflowerblue', label='acce_x')\nax[2].set_ylabel('Acceleration x \\n($m/s^2$)')\n\nplt.show()","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Let's see what happens if we **resample** `acce_x` to 1s samples instead of 0.02s samples. This way, we could smooth out some noise.\n\nUnfortunately, as you can see, the values still seem inplausible. **Analysis is on-going...**","metadata":{}},{"cell_type":"code","source":"# Resampled\nimu_df_resampled = imu_df[['timestamp', 'acce_x' ]].copy()\nimu_df_resampled.index = imu_df_resampled['timestamp'].apply(lambda x: datetime.fromtimestamp(x/1000.0))\nimu_df_resampled = imu_df_resampled.resample('1S').mean().reset_index(drop=True)\nimu_df_resampled.acce_x.iloc[0] = 0\nimu_df_resampled.head()\n\nimu_df_temp_resampled = calc_from_acce(imu_df_resampled.timestamp, \n                      (-1)*imu_df_resampled.acce_x , \n                      waypoint_df.waypoint_x.iloc[0])\n\ndisplay(imu_df_temp_resampled.head(5).style.set_caption('Calculated Position and Velocity from resampled acce_x'))\n\nfig, ax = plt.subplots(nrows=3, ncols=1, figsize=(14, 14))\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.position, ax=ax[0], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.position, ax=ax[0], color='cornflowerblue', label='acce_x')\nsns.lineplot(x=imu_df_temp_resampled.timestamp, y=imu_df_temp_resampled.position, ax=ax[0], color='green', marker='o', label='resampled acce_x')\nax[0].set_ylabel('Position x \\n($m$)')\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.velocity, ax=ax[1], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.velocity, ax=ax[1], color='cornflowerblue', label='acce_x')\nsns.lineplot(x=imu_df_temp_resampled.timestamp, y=imu_df_temp_resampled.velocity, ax=ax[1], color='green', marker='o', label='resampled acce_x')\n\nax[1].set_ylabel('Velocity x \\n($m/s$)')\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.acceleration, ax=ax[2], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.acceleration, ax=ax[2], color='cornflowerblue', label='acce_x')\nsns.lineplot(x=imu_df_temp_resampled.timestamp, y=imu_df_temp_resampled.acceleration, ax=ax[2], color='green', marker='o', label='resampled acce_x')\n\nax[2].set_ylabel('Acceleration x \\n($m/s^2$)')\n\nplt.show()","metadata":{"trusted":true,"_kg_hide-input":true,"_kg_hide-output":false},"outputs":[],"execution_count":null},{"cell_type":"code","source":"imu_df_temp = calc_from_acce(imu_df.timestamp, \n                      imu_df.acce_y - 3.208404, \n                      waypoint_df.waypoint_y.iloc[0])\n\ndisplay(imu_df_temp.head(5).style.set_caption('Calculated Position and Velocity from acce_y'))\n\nwaypoint_df_temp = calc_from_pos(waypoint_df.timestamp, waypoint_df.waypoint_y)\ndisplay(waypoint_df_temp.style.set_caption('Calculated Acceleration and Velocity from waypoint_y'))\n\n\nfig, ax = plt.subplots(nrows=3, ncols=1, figsize=(14, 14))\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.position, ax=ax[0], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.position, ax=ax[0], color='cornflowerblue', label='acce_y')\nax[0].set_ylabel('Position y \\n($m$)')\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.velocity, ax=ax[1], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.velocity, ax=ax[1], color='cornflowerblue', label='acce_y')\nax[1].set_ylabel('Velocity y \\n($m/s$)')\n\nsns.lineplot(x=waypoint_df_temp.timestamp, y=waypoint_df_temp.acceleration, ax=ax[2], color='orange', marker='o', label='waypoint')\nsns.lineplot(x=imu_df_temp.timestamp, y=imu_df_temp.acceleration, ax=ax[2], color='cornflowerblue', label='acce_y')\nax[2].set_ylabel('Acceleration y \\n($m/s^2$)')\n\nplt.show()","metadata":{"trusted":true,"_kg_hide-input":true,"_kg_hide-output":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"plot_imu_signals('gyro')\nplot_imu_signals('magn')\n\nfig, ax = plt.subplots(nrows=3, ncols=1, figsize=(14, 9))\ncol = 'ahrs'\nsns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_x\"], ax=ax[0], label='cali', color='cornflowerblue')\nsns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_y\"], ax=ax[1], label='cali', color='cornflowerblue')\nsns.lineplot(x=imu_df.timestamp, y=imu_df[f\"{col}_z\"], ax=ax[2], label='cali', color='cornflowerblue')\nfor i in range(3):\n    ax[i].set_xlim([start_time, end_time])\n\nplt.tight_layout()\nplt.show()","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# WiFi\n* Service set ID (SSID): name identifier for wireless networks (can be changed)\n* Basic Service Set ID (BSSID): MAC address of the access point (cannot be changed)\n* Received signal strength indication (RSSI)\n","metadata":{}},{"cell_type":"code","source":"wifi_df = pd.DataFrame(sample_file.wifi)\nwifi_df.columns = ['timestamp', 'ssid', 'bssid', 'rssi', 'last_seen_timestamp']\nwifi_df = wifi_df.pivot(index='timestamp', columns=['ssid', 'bssid'])['rssi']\nwifi_df.reset_index(drop=False, inplace=True)\nwifi_df.style.set_caption('WiFi')","metadata":{"trusted":true,"_kg_hide-input":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(20, 8))\n\nfor i, c in enumerate(wifi_df.columns):\n    if c != ('timestamp', ''):\n        sns.lineplot(x=wifi_df.timestamp.astype(int), y=wifi_df[c].replace('NaN', np.nan).astype(float), ax=ax, marker='o', label=c)\n    if i == 8:\n        break\nax.set_xlim([start_time, end_time])\nax.set_ylim([-80, 0])\n\nax.set_ylabel('RSSI')\nax.set_title('8 Sample RSSI')\nplt.show()","metadata":{"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# iBeacon\nThere iBeacon data is analyzed separately in [this notebook](https://www.kaggle.com/iamleonie/ibeacon-feasibility-analysis).","metadata":{}}]}