Reduced_Update, Error_Threshold Plots

ANR_high_level.ipynb

@@ -70,6 +70,7 @@
     "\n",
     "# Low-Level ANR Algorithmmus (wie in C)\n",
     "def anr_function_c(input, ref_noise, coefficients, mu, adaption_step = 1):\n",
+    "    counter = 0\n",
     "    sample_count = len(input)\n",
     "    filter_line = np.zeros(coefficients)\n",
     "    sample_line = np.zeros(coefficients)\n",
@@ -88,11 +89,15 @@
     "        output[n] = error\n",
     "        # update_filter_coeffcients: Filterkoeffizienten adaptieren\n",
     "        if (n % adaption_step) == 0:     # bei Rate x/adatpion_step:  if (n % adaption_step) < x:\n",
+    "        #if abs(error) > 0.00:  # nur adaptieren wenn Fehler über Schwellwert\n",
+    "            counter += 1\n",
     "            filter_line += mu * error * sample_line\n",
     "        # Filterkoeffizienten expoertieren\n",
     "        coeffient_matrix[n, :] = filter_line\n",
+    "    print(f\"Anpassungen: {counter}\")\n",
     "    return output, coeffient_matrix\n",
     "    \n",
+    "\n",
     "\n"
    ]
   },
@@ -642,7 +647,7 @@
     "])\n",
     "\n",
     "# Punktweiser Mittelwert\n",
-    "mean_curve = np.mean(all_curves, axis=0)\n",
+    "mean_gain = np.mean(all_curves, axis=0)\n",
     "\n",
     "# Plot\n",
     "plt.figure(figsize=(15, 7))\n",
@@ -651,7 +656,7 @@
     "plt.plot(x, male_scratching, linestyle='-.', linewidth=1.5, alpha=0.7, label='Scratching Noise')\n",
     "plt.plot(x, male_drinking, linestyle=':',  linewidth=1.5, alpha=0.7, label='Drinking Noise')\n",
     "plt.plot(x, male_coughing, linestyle=(0, (3, 1, 1, 1)), linewidth=1.5, alpha=0.7, label='Coughing Noise')\n",
-    "plt.plot(x, mean_curve, linestyle='--', color='red', linewidth=2.5, label='Mean SNR-Gain')\n",
+    "plt.plot(x, mean_gain, linestyle='--', color='red', linewidth=2.5, label='Mean SNR-Gain')\n",
     "\n",
     "plt.rcParams.update({\n",
     "    \"text.usetex\": True,\n",
@@ -946,7 +951,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Reduced Update Plot\n",
+    "#Single Reduced Update Plot\n",
     "\n",
     "import matplotlib.ticker as mtick\n",
     "from scipy.interpolate import make_interp_spline\n",
@@ -954,7 +959,7 @@
     "PLOT = False\n",
     "\n",
     "# Daten aus .csv laden\n",
-    "data_reduced_update = np.loadtxt('reduced_update.txt', delimiter=\",\")\n",
+    "data_reduced_update = np.loadtxt('reduced_update.txt', delimiter=\",\", skiprows=1)\n",
     "\n",
     "# Daten laden\n",
     "x = data_reduced_update[:, 0]\n",
@@ -986,7 +991,7 @@
     "plt.figure(figsize=(15, 7))\n",
     "plt.plot(x_smooth, gain_smooth, linestyle='--', color='indianred', linewidth=2, alpha=0.9, label='SNR-Gain')\n",
     "plt.plot(x_smooth, cycles_smooth, linestyle='-.', color='skyblue', linewidth=2, alpha=0.9, label='Cycles/Sample')\n",
-    "plt.plot(x_smooth, comp_smooth, linestyle=':', color='forestgreen', linewidth=2, alpha=0.9, label='DSP Computing')\n",
+    "plt.plot(x_smooth, comp_smooth, linestyle=':', color='forestgreen', linewidth=2, alpha=0.9, label='DSP Load')\n",
     "plt.plot([x_max, x_max], [y1_max, y2_max], color='black', linestyle=':', linewidth=2)\n",
     "\n",
     "plt.scatter(x, reduced_gain, color='indianred', s=40)\n",
@@ -1023,6 +1028,265 @@
     "    plt.savefig(f'plots/fig_snr_reduced_update', dpi=600)\n",
     "plt.show()\n"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Single Error Threshold Plot\n",
+    "\n",
+    "import matplotlib.ticker as mtick\n",
+    "from scipy.interpolate import make_interp_spline\n",
+    "\n",
+    "PLOT = False\n",
+    "\n",
+    "# Daten aus .csv laden\n",
+    "data_error_threshold = np.loadtxt('threshold_evaluation/error_threshold_breathing.csv', delimiter=\";\", skiprows=1)\n",
+    "\n",
+    "# Daten laden\n",
+    "x = data_error_threshold[:, 0]\n",
+    "error_gain = data_error_threshold[:, 2]\n",
+    "error_cycles = data_error_threshold[:, 6]\n",
+    "error_computing = data_error_threshold[:, 7]\n",
+    "\n",
+    "# Sortieren\n",
+    "idx = np.argsort(x)\n",
+    "x = x[idx]\n",
+    "error_gain = error_gain[idx]\n",
+    "error_cycles = error_cycles[idx]\n",
+    "error_computing = error_computing[idx]\n",
+    "\n",
+    "# Smoothing\n",
+    "x_smooth = np.linspace(x.min(), x.max(), 300)\n",
+    "\n",
+    "gain_smooth = make_interp_spline(x, error_gain)(x_smooth)\n",
+    "cycles_smooth = make_interp_spline(x, error_cycles)(x_smooth)\n",
+    "comp_smooth = make_interp_spline(x, error_computing)(x_smooth)\n",
+    "\n",
+    "diff_smooth = np.abs(gain_smooth - cycles_smooth)\n",
+    "idx_max = np.argmax(diff_smooth)\n",
+    "x_max = x_smooth[idx_max]\n",
+    "y1_max = gain_smooth[idx_max]\n",
+    "y2_max = cycles_smooth[idx_max]\n",
+    "\n",
+    "# Plot\n",
+    "plt.figure(figsize=(15, 7))\n",
+    "plt.plot(x_smooth, gain_smooth, linestyle='--', color='indianred', linewidth=2, alpha=0.9, label='SNR-Gain')\n",
+    "plt.plot(x_smooth, cycles_smooth, linestyle='-.', color='skyblue', linewidth=2, alpha=0.9, label='Cycles/Sample')\n",
+    "plt.plot(x_smooth, comp_smooth, linestyle=':', color='forestgreen', linewidth=2, alpha=0.9, label='DSP Load')\n",
+    "plt.plot([x_max, x_max], [y1_max, y2_max], color='black', linestyle=':', linewidth=2)\n",
+    "\n",
+    "plt.scatter(x, error_gain, color='indianred', s=40)\n",
+    "plt.scatter(x, error_cycles, color='skyblue', s=40)\n",
+    "plt.scatter(x, error_computing, color='forestgreen', s=40)\n",
+    "\n",
+    "plt.text(x_max, (y1_max + y2_max)/2+0.21,\n",
+    "         f'Maximum Offset at {x_max:.2f}',\n",
+    "         fontsize=20,\n",
+    "         ha='left')\n",
+    "\n",
+    "plt.rcParams.update({\n",
+    "    \"text.usetex\": True,\n",
+    "    \"font.family\": \"serif\",\n",
+    "    'font.size': 16,          # Standardtext\n",
+    "    'axes.labelsize': 30,     # Achsenbeschriftungen\n",
+    "    'xtick.labelsize': 25,    # Tick-Beschriftungen\n",
+    "    'ytick.labelsize': 25,\n",
+    "    'legend.fontsize': 25     # Legende\n",
+    "})\n",
+    "\n",
+    "plt.xlabel(\"Error Threshold\")\n",
+    "plt.ylabel(\"Relative Performance\")\n",
+    "plt.grid(True, linestyle='-.', alpha=0.4)\n",
+    "#Spines auf ganzen Plot anwenden\n",
+    "plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter(1.0))\n",
+    "plt.gca().spines['top'].set_visible(False)\n",
+    "plt.gca().spines['right'].set_visible(False)\n",
+    "#plt.gca().invert_xaxis()\n",
+    "plt.legend(frameon=False, loc='upper right')\n",
+    "plt.tight_layout()\n",
+    "if PLOT == True:\n",
+    "    plt.savefig(f'plots/fig_snr_error_threshold', dpi=600)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Multi Error Threshold Plot\n",
+    "\n",
+    "import matplotlib.ticker as mtick\n",
+    "from scipy.interpolate import make_interp_spline\n",
+    "\n",
+    "PLOT = False\n",
+    "\n",
+    "# Daten aus .csv laden\n",
+    "error_threshold_breathing = np.loadtxt('threshold_evaluation/error_threshold_breathing.csv', delimiter=\";\", skiprows=1)\n",
+    "error_threshold_chewing = np.loadtxt('threshold_evaluation/error_threshold_chewing.csv', delimiter=\";\", skiprows=1)\n",
+    "error_threshold_coughing = np.loadtxt('threshold_evaluation/error_threshold_coughing.csv', delimiter=\";\", skiprows=1)\n",
+    "error_threshold_drinking = np.loadtxt('threshold_evaluation/error_threshold_drinking.csv', delimiter=\";\", skiprows=1)\n",
+    "error_threshold_scratching = np.loadtxt('threshold_evaluation/error_threshold_scratching.csv', delimiter=\";\", skiprows=1)\n",
+    "\n",
+    "# Daten laden\n",
+    "x = error_threshold_breathing[:, 0]\n",
+    "error_gain_breathing = error_threshold_breathing[:, 2]\n",
+    "error_cycles_breathing = error_threshold_breathing[:, 6]\n",
+    "error_computing_breathing = error_threshold_breathing[:, 7]\n",
+    "error_gain_chewing = error_threshold_chewing[:, 2]\n",
+    "error_cycles_chewing = error_threshold_chewing[:, 6]\n",
+    "error_computing_chewing = error_threshold_chewing[:, 7]\n",
+    "error_gain_coughing = error_threshold_coughing[:, 2]\n",
+    "error_cycles_coughing = error_threshold_coughing[:, 6]\n",
+    "error_computing_coughing = error_threshold_coughing[:, 7]\n",
+    "error_gain_drinking = error_threshold_drinking[:, 2]\n",
+    "error_cycles_drinking = error_threshold_drinking[:, 6]\n",
+    "error_computing_drinking = error_threshold_drinking[:, 7]\n",
+    "error_gain_scratching = error_threshold_scratching[:, 2]\n",
+    "error_cycles_scratching = error_threshold_scratching[:, 6]  \n",
+    "error_computing_scratching = error_threshold_scratching[:, 7] \n",
+    "\n",
+    "# Sortieren\n",
+    "idx = np.argsort(x)\n",
+    "x = x[idx]\n",
+    "error_gain_breathing = error_gain_breathing[idx]\n",
+    "error_cycles_breathing = error_cycles_breathing[idx]\n",
+    "error_computing_breathing = error_computing_breathing[idx]\n",
+    "error_gain_chewing = error_gain_chewing[idx]\n",
+    "error_cycles_chewing = error_cycles_chewing[idx]\n",
+    "error_computing_chewing = error_computing_chewing[idx]\n",
+    "error_gain_coughing = error_gain_coughing[idx]\n",
+    "error_cycles_coughing = error_cycles_coughing[idx]\n",
+    "error_computing_coughing = error_computing_coughing[idx]\n",
+    "error_gain_drinking = error_gain_drinking[idx]\n",
+    "error_cycles_drinking = error_cycles_drinking[idx]\n",
+    "error_computing_drinking = error_computing_drinking[idx]\n",
+    "error_gain_scratching = error_gain_scratching[idx]\n",
+    "error_cycles_scratching = error_cycles_scratching[idx]\n",
+    "error_computing_scratching = error_computing_scratching[idx]\n",
+    "\n",
+    "# Smoothing\n",
+    "x_smooth = np.linspace(x.min(), x.max(), 300)\n",
+    "\n",
+    "gain_smooth_breathing = make_interp_spline(x, error_gain_breathing)(x_smooth)\n",
+    "cycles_smooth_breathing = make_interp_spline(x, error_cycles_breathing)(x_smooth)\n",
+    "computing_smooth_breathing = make_interp_spline(x, error_computing_breathing)(x_smooth)\n",
+    "gain_smooth_chewing = make_interp_spline(x, error_gain_chewing)(x_smooth)\n",
+    "cycles_smooth_chewing = make_interp_spline(x, error_cycles_chewing)(x_smooth)\n",
+    "computing_smooth_chewing = make_interp_spline(x, error_computing_chewing)(x_smooth)\n",
+    "gain_smooth_coughing = make_interp_spline(x, error_gain_coughing)(x_smooth)\n",
+    "cycles_smooth_coughing = make_interp_spline(x, error_cycles_coughing)(x_smooth)\n",
+    "computing_smooth_coughing = make_interp_spline(x, error_computing_coughing)(x_smooth)\n",
+    "gain_smooth_drinking = make_interp_spline(x, error_gain_drinking)(x_smooth)\n",
+    "cycles_smooth_drinking = make_interp_spline(x, error_cycles_drinking)(x_smooth)\n",
+    "computing_smooth_drinking = make_interp_spline(x, error_computing_drinking)(x_smooth)\n",
+    "gain_smooth_scratching = make_interp_spline(x, error_gain_scratching)(x_smooth)\n",
+    "cycles_smooth_scratching = make_interp_spline(x, error_cycles_scratching)(x_smooth)\n",
+    "computing_smooth_scratching = make_interp_spline(x, error_computing_scratching)(x_smooth)\n",
+    "\n",
+    "diff_smooth_breathing = gain_smooth_breathing - cycles_smooth_breathing\n",
+    "diff_smooth_chewing = gain_smooth_chewing - cycles_smooth_chewing\n",
+    "diff_smooth_coughing = gain_smooth_coughing - cycles_smooth_coughing\n",
+    "diff_smooth_drinking = gain_smooth_drinking - cycles_smooth_drinking\n",
+    "diff_smooth_scratching = gain_smooth_scratching - cycles_smooth_scratching\n",
+    "\n",
+    "# Alle Kurven in ein Array stapeln\n",
+    "stack_difference = np.vstack([\n",
+    "    diff_smooth_breathing,\n",
+    "    diff_smooth_chewing,\n",
+    "    diff_smooth_coughing,\n",
+    "    diff_smooth_drinking,\n",
+    "    diff_smooth_scratching\n",
+    "])\n",
+    "\n",
+    "# Alle Kurven in ein Array stapeln\n",
+    "stack_computing = np.vstack([\n",
+    "    computing_smooth_breathing,\n",
+    "    computing_smooth_chewing,\n",
+    "    computing_smooth_coughing,\n",
+    "    computing_smooth_drinking,\n",
+    "    computing_smooth_scratching\n",
+    "])\n",
+    "\n",
+    "# Punktweiser Mittelwert\n",
+    "mean_gain = np.mean(stack_difference, axis=0)\n",
+    "mean_computing = np.mean(stack_computing, axis=0)   \n",
+    "\n",
+    "idx_max_gain = np.argmax(mean_gain)\n",
+    "x_max_gain = x_smooth[idx_max_gain]\n",
+    "y_max_gain = mean_gain[idx_max_gain]\n",
+    "x_max_computing = x_smooth[idx_max_gain]\n",
+    "y_max_computing = mean_computing[idx_max_gain]\n",
+    "\n",
+    "\n",
+    "# Plot\n",
+    "figure1, ax1 = plt.subplots(figsize=(15, 7))\n",
+    "ax1.plot(x_smooth, diff_smooth_breathing, linestyle='--', color='indianred', linewidth=1.5, alpha=0.7, label='Breathing Noise')\n",
+    "ax1.plot(x_smooth, diff_smooth_chewing, linestyle='-.', color='skyblue', linewidth=1.5, alpha=0.7, label='Chewing Noise')\n",
+    "ax1.plot(x_smooth, diff_smooth_coughing, linestyle=':', color='forestgreen', linewidth=1.5, alpha=0.7, label='Coughing Noise')\n",
+    "ax1.plot(x_smooth, diff_smooth_drinking, linestyle='--', color='darkorange', linewidth=1.5, alpha=0.7, label='Drinking Noise')\n",
+    "ax1.plot(x_smooth, diff_smooth_scratching, linestyle='-.', color='darkorchid', linewidth=1.5, alpha=0.7, label='Scratching Noise')\n",
+    "ax1.plot(x_smooth, mean_gain, linestyle='--', color='red', linewidth=2.5, alpha=1, label='Mean Performance Gain')\n",
+    "ax1.plot([x_max_gain, x_max_gain], [y_max_gain, 0], color='black', linestyle=':', linewidth=2)\n",
+    "\n",
+    "ax1.text(x_max_gain, y_max_gain+0.01,\n",
+    "         f'{y_max_gain*100:.1f} \\% mean performance gain at error threshold {x_max_gain:.2f}',\n",
+    "         fontsize=20,\n",
+    "         ha='left')\n",
+    "\n",
+    "figure2, ax2 = plt.subplots(figsize=(15, 7))\n",
+    "ax2.plot(x_smooth, computing_smooth_breathing, linestyle='--', color='indianred', linewidth=1.5, alpha=0.7, label='Breathing Noise')\n",
+    "ax2.plot(x_smooth, computing_smooth_chewing, linestyle='-.', color='skyblue', linewidth=1.5, alpha=0.7, label='Chewing Noise')\n",
+    "ax2.plot(x_smooth, computing_smooth_coughing, linestyle=':', color='forestgreen', linewidth=1.5, alpha=0.7, label='Coughing Noise')\n",
+    "ax2.plot(x_smooth, computing_smooth_drinking, linestyle='--', color='darkorange', linewidth=1.5, alpha=0.7, label='Drinking Noise')\n",
+    "ax2.plot(x_smooth, computing_smooth_scratching, linestyle='-.', color='darkorchid', linewidth=1.5, alpha=0.7, label='Scratching Noise')\n",
+    "ax2.plot(x_smooth, mean_computing, linestyle='--', color='blue', linewidth=2.5, alpha=1, label='Mean DSP Load')\n",
+    "ax2.plot([x_max_computing, x_max_computing], [y_max_computing, 0], color='black', linestyle=':', linewidth=2)\n",
+    "\n",
+    "ax2.text(x_max_computing, y_max_computing+0.01,\n",
+    "         f'{y_max_computing*100:.1f} \\% mean DSP load at error threshold {x_max_computing:.2f}',\n",
+    "         fontsize=20,\n",
+    "         ha='left')\n",
+    "\n",
+    "plt.rcParams.update({\n",
+    "    \"text.usetex\": True,\n",
+    "    \"font.family\": \"serif\",\n",
+    "    'font.size': 16,          # Standardtext\n",
+    "    'axes.labelsize': 30,     # Achsenbeschriftungen\n",
+    "    'xtick.labelsize': 25,    # Tick-Beschriftungen\n",
+    "    'ytick.labelsize': 25,\n",
+    "    'legend.fontsize': 25     # Legende\n",
+    "})\n",
+    "\n",
+    "ax1.set_xlabel(\"Error Threshold\")\n",
+    "ax2.set_xlabel(\"Error Threshold\")\n",
+    "ax1.set_ylabel(\"Performance Gain\")\n",
+    "ax2.set_ylabel(\"DSP Load\")\n",
+    "ax1.grid(True, linestyle='-.', alpha=0.4)\n",
+    "ax2.grid(True, linestyle='-.', alpha=0.4)\n",
+    "ax1.set_ylim(0, 1)\n",
+    "ax2.set_ylim(0, 0.5)\n",
+    "#Spines auf ganzen Plot anwenden\n",
+    "ax1.yaxis.set_major_formatter(mtick.PercentFormatter(1.0))\n",
+    "ax2.yaxis.set_major_formatter(mtick.PercentFormatter(1.0))\n",
+    "ax1.spines['top'].set_visible(False)\n",
+    "ax2.spines['top'].set_visible(False)\n",
+    "ax1.spines['right'].set_visible(False)\n",
+    "ax2.spines['right'].set_visible(False)\n",
+    "ax1.legend(frameon=False, loc='upper right')\n",
+    "ax2.legend(frameon=False, loc='upper right')\n",
+    "figure1.tight_layout()\n",
+    "figure2.tight_layout()\n",
+    "if PLOT == True:\n",
+    "    figure1.savefig(f'plots/fig_snr_error_threshold', dpi=600)\n",
+    "    figure2.savefig(f'plots/fig_snr_error_threshold_computing', dpi=600)\n",
+    "figure1.show()\n",
+    "figure2.show()\n"
+   ]
   }
  ],
  "metadata": {

reduced_update.txt

@@ -1,7 +0,0 @@
-1, 9.47, 1, 357, 1, 0.446 
-0.75, 8.54, 0.902, 288, 0.807, 0.358 
-0.66, 8.16, 0.863, 263, 0.737, 0.328 
-0.5, 7.27, 0.768, 218, 0.611, 0.272 
-0.33, 6.05, 0.642, 171, 0.479, 0.213 
-0.25, 5.21, 0.551, 149, 0.417, 0.186 
-0.20, 4.59, 0.478, 135, 0.378, 0.168

threshold_evaluation/error_threshold_breathing.csv

@@ -0,0 +1,18 @@
+Threshold;SNR_Gain;%SNR_Gain;Adjustments;%Adjustments;Cycles;%Cycles;DSP_Load
+0;9.47;1.000;200000;1.000;357;1.000;0.446
+0.001;9.47;1.000;174704;0.874;322;0.902;0.402
+0.005;9.43;0.996;133980;0.670;265;0.743;0.332
+0.01;9.27;0.979;108728;0.544;230;0.645;0.288
+0.02;8.63;0.911;81434;0.407;192;0.538;0.240
+0.03;7.84;0.828;66027;0.330;171;0.478;0.213
+0.04;7.12;0.752;55964;0.280;157;0.439;0.196
+0.05;6.56;0.693;48488;0.242;146;0.410;0.183
+0.06;6.12;0.646;42814;0.214;139;0.388;0.173
+0.07;5.75;0.607;37829;0.189;132;0.369;0.164
+0.08;5.46;0.577;33634;0.168;126;0.352;0.157
+0.09;5.28;0.558;29944;0.150;121;0.338;0.151
+0.1;5.15;0.544;26675;0.133;116;0.325;0.145
+0.2;4.19;0.442;7867;0.039;90;0.252;0.112
+0.3;2.87;0.303;1852;0.009;82;0.228;0.102
+0.4;1.24;0.131;268;0.001;79;0.222;0.099
+0.5;0.47;0.050;55;0.000;79;0.222;0.099

threshold_evaluation/error_threshold_chewing.csv

@@ -0,0 +1,18 @@
+Threshold;SNR_Gain;%SNR_Gain;Adjustments;%Adjustments;Cycles;%Cycles;DSP_Load
+0;14.73;1.000;200000;1.000;357;1.000;0.446
+0.001;14.73;1.000;165597;0.828;309;0.866;0.386
+0.005;14.71;0.999;122374;0.612;249;0.698;0.311
+0.01;14.66;0.995;99585;0.498;217;0.609;0.272
+0.02;14.54;0.987;77702;0.389;187;0.524;0.234
+0.03;14.42;0.979;64922;0.325;169;0.474;0.212
+0.04;14.28;0.969;55559;0.278;156;0.438;0.195
+0.05;14.16;0.961;48584;0.243;147;0.410;0.183
+0.06;14.04;0.953;42922;0.215;139;0.388;0.173
+0.07;13.89;0.943;38016;0.190;132;0.369;0.165
+0.08;13.7;0.930;33790;0.169;126;0.353;0.157
+0.09;13.53;0.919;30161;0.151;121;0.339;0.151
+0.1;13.33;0.905;26947;0.135;116;0.326;0.146
+0.2;11.21;0.761;7958;0.040;90;0.252;0.113
+0.3;8.5;0.577;1954;0.010;82;0.229;0.102
+0.4;5.62;0.382;333;0.002;79;0.223;0.099
+0.5;2.82;0.191;92;0.000;79;0.222;0.099

threshold_evaluation/error_threshold_coughing.csv

@@ -0,0 +1,18 @@
+Threshold;SNR_Gain;%SNR_Gain;Adjustments;%Adjustments;Cycles;%Cycles;DSP_Load
+0;16.16;1.000;200000;1.000;357;1.000;0.446
+0.001;16.16;1.000;162975;0.815;306;0.856;0.382
+0.005;16.15;0.999;115499;0.577;240;0.671;0.299
+0.01;16.14;0.999;98322;0.492;216;0.604;0.270
+0.02;16.13;0.998;80002;0.400;190;0.533;0.238
+0.03;16.09;0.996;67510;0.338;173;0.484;0.216
+0.04;16.05;0.993;58126;0.291;160;0.448;0.200
+0.05;15.98;0.989;50618;0.253;149;0.418;0.187
+0.06;15.9;0.984;44366;0.222;141;0.394;0.176
+0.07;15.83;0.980;39322;0.197;134;0.374;0.167
+0.08;15.72;0.973;34938;0.175;128;0.357;0.159
+0.09;15.66;0.969;31110;0.156;122;0.342;0.153
+0.1;15.54;0.962;27649;0.138;117;0.329;0.147
+0.2;14.41;0.892;8105;0.041;90;0.253;0.113
+0.3;12.19;0.754;2009;0.010;82;0.229;0.102
+0.4;9.78;0.605;381;0.002;80;0.223;0.099
+0.5;6.37;0.394;118;0.001;79;0.222;0.099

threshold_evaluation/error_threshold_drinking.csv

@@ -0,0 +1 @@
+Threshold;SNR_Gain;%SNR_Gain;Adjustments;%Adjustments;Cycles;%Cycles;DSP_Load

threshold_evaluation/error_threshold_scratching.csv

@@ -0,0 +1,18 @@
+Threshold;SNR_Gain;%SNR_Gain;Adjustments;%Adjustments;Cycles;%Cycles;DSP_Load
+0;7.78;1.000;200000;1.000;357;1.000;0.446
+0.001;7.78;1.000;175840;0.879;323;0.906;0.404
+0.005;7.75;0.996;128988;0.645;258;0.724;0.323
+0.01;7.66;0.985;104311;0.522;224;0.627;0.280
+0.02;7.44;0.956;79884;0.399;190;0.532;0.238
+0.03;7.2;0.925;65731;0.329;170;0.477;0.213
+0.04;6.98;0.897;56297;0.281;157;0.440;0.197
+0.05;6.77;0.870;48985;0.245;147;0.412;0.184
+0.06;6.61;0.850;43085;0.215;139;0.389;0.174
+0.07;6.44;0.828;38061;0.190;132;0.369;0.165
+0.08;6.29;0.808;33901;0.170;126;0.353;0.158
+0.09;6.1;0.784;30072;0.150;121;0.338;0.151
+0.1;5.95;0.765;26803;0.134;116;0.326;0.145
+0.2;4.78;0.614;7910;0.040;90;0.252;0.112
+0.3;3.61;0.464;1837;0.009;82;0.228;0.102
+0.4;2.16;0.278;270;0.001;79;0.222;0.099
+0.5;0.71;0.091;48;0.000;79;0.221;0.099

update_rate_evaluation/update_rate_breathing.csv

@@ -0,0 +1,8 @@
+Update_Rate;SNR_Gain;%SNR_Gain;Cycles;%Cycles;%DSP_Load
+1;9.47;1;357;1;0.446
+0.75;8.54;0.902;288;0.805;0.359
+0.66;8.16;0.862;262;0.735;0.328
+0.5;7.27;0.768;218;0.611;0.273
+0.33;6.05;0.639;171;0.478;0.213
+0.25;5.21;0.550;149;0.416;0.186
+0.2;4.59;0.485;135;0.377;0.168

update_rate_evaluation/update_rate_chewing.csv

@@ -0,0 +1,8 @@
+Update_Rate;SNR_Gain;%SNR_Gain;Cycles;%Cycles;%DSP_Load
+1;14.73;1;357;1;0.446
+0.75;14;0.950;288;0.805;0.359
+0.66;13.63;0.925;262;0.735;0.328
+0.5;12.78;0.868;218;0.611;0.273
+0.33;11.35;0.771;171;0.478;0.213
+0.25;10.13;0.688;149;0.416;0.186
+0.2;9.22;0.626;135;0.377;0.168

update_rate_evaluation/update_rate_coughing.csv

@@ -0,0 +1,8 @@
+Update_Rate;SNR_Gain;%SNR_Gain;Cycles;%Cycles;%DSP_Load
+1;16.16;1;357;1;0.446
+0.75;15.86;0.981;288;0.805;0.359
+0.66;15.72;0.973;262;0.735;0.328
+0.5;15.35;0.950;218;0.611;0.273
+0.33;14.58;0.902;171;0.478;0.213
+0.25;13.8;0.854;149;0.416;0.186
+0.2;13.07;0.809;135;0.377;0.168

update_rate_evaluation/update_rate_drinking.csv

@@ -0,0 +1,8 @@
+Update_Rate;SNR_Gain;%SNR_Gain;Cycles;%Cycles;%DSP_Load
+1;9.92;1;357;1;0.446
+0.75;8.91;0.898;288;0.805;0.359
+0.66;8.51;0.858;262;0.735;0.328
+0.5;7.54;0.760;218;0.611;0.273
+0.33;6.13;0.618;171;0.478;0.213
+0.25;5.3;0.534;149;0.416;0.186
+0.2;4.63;0.467;135;0.377;0.168

update_rate_evaluation/update_rate_scratching.csv

@@ -0,0 +1,8 @@
+Update_Rate;SNR_Gain;%SNR_Gain;Cycles;%Cycles;%DSP_Load
+1;7.78;1;357;1;0.446
+0.75;7.12;0.915;288;0.805;0.359
+0.66;6.83;0.878;262;0.735;0.328
+0.5;6.25;0.803;218;0.611;0.273
+0.33;5.48;0.704;171;0.478;0.213
+0.25;5.09;0.654;149;0.416;0.186
+0.2;4.46;0.573;135;0.377;0.168