diff --git a/Information for Ishp Labs.pdf b/Information for Ishp Labs.pdf new file mode 100644 index 0000000..13927a7 Binary files /dev/null and b/Information for Ishp Labs.pdf differ diff --git a/app/report_gen/page_11.html b/app/report_gen/page_11.html index 4cde673..2ac5f1e 100644 --- a/app/report_gen/page_11.html +++ b/app/report_gen/page_11.html @@ -46,12 +46,12 @@
-
+
" ] @@ -1109,7 +1110,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 17, "id": "25327cc1", "metadata": {}, "outputs": [ @@ -1415,7 +1416,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 18, "id": "c46b53f0", "metadata": {}, "outputs": [ @@ -1731,7 +1732,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 19, "id": "84addc63", "metadata": {}, "outputs": [ @@ -1748,8 +1749,8 @@ "Fat:Carb ratio: 2.47\n", "Heart Rate: 96.7 bpm\n", "VO2: 1147.9 ml/min\n", - "VT1: {'HeartRate': np.float64(100.5), 'Speed': np.float64(4.0), 'Time': np.float64(251.0)}\n", - "VT2: {'HeartRate': np.float64(189.71300000000002), 'Speed': np.float64(7.5), 'Time': np.float64(1524.0)}\n", + "VT1: {'HeartRate': 100.5, 'Speed': 4.0, 'Time': 251.0}\n", + "VT2: {'HeartRate': 189.71300000000002, 'Speed': 7.5, 'Time': 1524.0}\n", "Zone 1 (Active Recovery): 81.7 - 96.7 bpm\n", "Zone 2 (Aerobic Base): 96.7 - 100.5 bpm\n", "Zone 3 (Aerobic): 100.5 - 179.7 bpm\n", @@ -1869,7 +1870,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 20, "id": "f324fe94", "metadata": {}, "outputs": [ @@ -2057,11 +2058,1188 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "9c00c366", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Timestamp (seconds passed)Lap/EventUnnamed: 2SmO2HBDiffMuscle stateMuscle trendSmO2 unfilteredO2HB unfilteredHHb unfiltered...SmO2.1HBDiff.1Muscle state.1Muscle trend.1SmO2 unfiltered.1O2HB unfiltered.1HHb unfiltered.1THb unfiltered.1HBDiff unfiltered.1Heart Rate (BPM).1
00.370NaN72.40-0.260272.52-3.27-2.29...87.041.570286.46-0.64-0.74-20.301.7872
10.460NaN72.41-0.260273.06-3.27-2.31...87.041.570286.66-0.66-0.66-20.241.6872
20.570NaN72.41-0.260272.58-3.31-2.25...87.031.570286.81-0.69-0.67-20.281.6672
30.660NaN72.42-0.250273.18-3.29-2.32...87.031.570288.42-0.70-0.66-20.281.6472
40.750NaN72.43-0.250272.61-3.23-2.36...87.031.580288.59-0.51-0.71-20.141.8872
\n", + "

5 rows × 24 columns

\n", + "
" + ], + "text/plain": [ + " Timestamp (seconds passed) Lap/Event Unnamed: 2 SmO2 HBDiff \\\n", + "0 0.37 0 NaN 72.40 -0.26 \n", + "1 0.46 0 NaN 72.41 -0.26 \n", + "2 0.57 0 NaN 72.41 -0.26 \n", + "3 0.66 0 NaN 72.42 -0.25 \n", + "4 0.75 0 NaN 72.43 -0.25 \n", + "\n", + " Muscle state Muscle trend SmO2 unfiltered O2HB unfiltered \\\n", + "0 0 2 72.52 -3.27 \n", + "1 0 2 73.06 -3.27 \n", + "2 0 2 72.58 -3.31 \n", + "3 0 2 73.18 -3.29 \n", + "4 0 2 72.61 -3.23 \n", + "\n", + " HHb unfiltered ... SmO2.1 HBDiff.1 Muscle state.1 Muscle trend.1 \\\n", + "0 -2.29 ... 87.04 1.57 0 2 \n", + "1 -2.31 ... 87.04 1.57 0 2 \n", + "2 -2.25 ... 87.03 1.57 0 2 \n", + "3 -2.32 ... 87.03 1.57 0 2 \n", + "4 -2.36 ... 87.03 1.58 0 2 \n", + "\n", + " SmO2 unfiltered.1 O2HB unfiltered.1 HHb unfiltered.1 THb unfiltered.1 \\\n", + "0 86.46 -0.64 -0.74 -20.30 \n", + "1 86.66 -0.66 -0.66 -20.24 \n", + "2 86.81 -0.69 -0.67 -20.28 \n", + "3 88.42 -0.70 -0.66 -20.28 \n", + "4 88.59 -0.51 -0.71 -20.14 \n", + "\n", + " HBDiff unfiltered.1 Heart Rate (BPM).1 \n", + "0 1.78 72 \n", + "1 1.68 72 \n", + "2 1.66 72 \n", + "3 1.64 72 \n", + "4 1.88 72 \n", + "\n", + "[5 rows x 24 columns]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "oxygenation_2.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "0a624fa0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Timestamp (seconds passed)', 'Lap/Event', 'Unnamed: 2', 'SmO2',\n", + " 'HBDiff', 'Muscle state', 'Muscle trend', 'SmO2 unfiltered',\n", + " 'O2HB unfiltered', 'HHb unfiltered', 'THb unfiltered',\n", + " 'HBDiff unfiltered', 'Heart Rate (BPM)', 'Unnamed: 13', 'SmO2.1',\n", + " 'HBDiff.1', 'Muscle state.1', 'Muscle trend.1', 'SmO2 unfiltered.1',\n", + " 'O2HB unfiltered.1', 'HHb unfiltered.1', 'THb unfiltered.1',\n", + " 'HBDiff unfiltered.1', 'Heart Rate (BPM).1'],\n", + " dtype='object')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "oxygenation_2.columns" + ] + }, + { + "cell_type": "markdown", + "id": "803c7174", + "metadata": {}, + "source": [ + "# Train.Red SmO₂ Analysis\n", + "\n", + "Following the instructions from the PDF, we'll create a comprehensive muscle oxygenation plot with:\n", + "- Smoothed SmO₂ data for left and right legs\n", + "- Heart rate on secondary axis\n", + "- Stage annotations (warm-up, active laps, recovery)\n", + "- Recovery percentage calculations\n", + "- Optional breakpoint detection" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "d18e5c4a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data shape: (17020, 28)\n", + "Time range: 0.37 to 1702.26 seconds\n", + "Unique laps: [0, 1, 2, 3, 4, 5, 6, 7]\n", + "\n", + "First few rows:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Timestamp (seconds passed)LapLeft_SmO2Right_SmO2Heart_Rate
00.37072.4087.0472
10.46072.4187.0472
20.57072.4187.0372
30.66072.4287.0372
40.75072.4387.0372
50.86072.4487.0472
60.95072.4587.0572
71.09072.4787.0572
81.15072.4887.0672
91.27072.4987.0772
\n", + "
" + ], + "text/plain": [ + " Timestamp (seconds passed) Lap Left_SmO2 Right_SmO2 Heart_Rate\n", + "0 0.37 0 72.40 87.04 72\n", + "1 0.46 0 72.41 87.04 72\n", + "2 0.57 0 72.41 87.03 72\n", + "3 0.66 0 72.42 87.03 72\n", + "4 0.75 0 72.43 87.03 72\n", + "5 0.86 0 72.44 87.04 72\n", + "6 0.95 0 72.45 87.05 72\n", + "7 1.09 0 72.47 87.05 72\n", + "8 1.15 0 72.48 87.06 72\n", + "9 1.27 0 72.49 87.07 72" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 1: Data Preparation\n", + "# Clean and prepare the oxygenation_2 dataframe\n", + "\n", + "# Rename columns for clarity\n", + "df_oxy = oxygenation_2.copy()\n", + "\n", + "# Convert timestamp to numeric\n", + "df_oxy['Timestamp (seconds passed)'] = pd.to_numeric(df_oxy['Timestamp (seconds passed)'], errors='coerce')\n", + "\n", + "# Convert SmO2 columns to numeric\n", + "df_oxy['Left_SmO2'] = pd.to_numeric(df_oxy['SmO2'], errors='coerce')\n", + "df_oxy['Right_SmO2'] = pd.to_numeric(df_oxy['SmO2.1'], errors='coerce')\n", + "df_oxy['Heart_Rate'] = pd.to_numeric(df_oxy['Heart Rate (BPM)'], errors='coerce')\n", + "df_oxy['Lap'] = pd.to_numeric(df_oxy['Lap/Event'], errors='coerce')\n", + "\n", + "# Drop rows with missing timestamps\n", + "df_oxy = df_oxy.dropna(subset=['Timestamp (seconds passed)'])\n", + "\n", + "# Sort by timestamp\n", + "df_oxy = df_oxy.sort_values('Timestamp (seconds passed)').reset_index(drop=True)\n", + "\n", + "print(f\"Data shape: {df_oxy.shape}\")\n", + "print(f\"Time range: {df_oxy['Timestamp (seconds passed)'].min():.2f} to {df_oxy['Timestamp (seconds passed)'].max():.2f} seconds\")\n", + "print(f\"Unique laps: {sorted(df_oxy['Lap'].dropna().unique())}\")\n", + "print(f\"\\nFirst few rows:\")\n", + "df_oxy[['Timestamp (seconds passed)', 'Lap', 'Left_SmO2', 'Right_SmO2', 'Heart_Rate']].head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "a6f97a9b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average sampling interval: 0.090 seconds\n", + "Estimated sampling frequency: 11.11 Hz\n", + "Smoothing window: 111 samples (~10 seconds)\n", + "\n", + "Smoothing complete!\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Timestamp (seconds passed)Left_SmO2Left_SmO2_smoothRight_SmO2Right_SmO2_smooth
00.3772.4072.59464387.0487.107500
10.4672.4172.59438687.0487.105614
20.5772.4172.59413887.0387.103793
30.6672.4272.59389887.0387.101864
40.7572.4372.59366787.0387.099833
\n", + "
" + ], + "text/plain": [ + " Timestamp (seconds passed) Left_SmO2 Left_SmO2_smooth Right_SmO2 \\\n", + "0 0.37 72.40 72.594643 87.04 \n", + "1 0.46 72.41 72.594386 87.04 \n", + "2 0.57 72.41 72.594138 87.03 \n", + "3 0.66 72.42 72.593898 87.03 \n", + "4 0.75 72.43 72.593667 87.03 \n", + "\n", + " Right_SmO2_smooth \n", + "0 87.107500 \n", + "1 87.105614 \n", + "2 87.103793 \n", + "3 87.101864 \n", + "4 87.099833 " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 2: Apply 10-second rolling mean smoothing\n", + "# Following PDF instructions: centered 10 second rolling mean\n", + "\n", + "# Estimate sampling frequency\n", + "time_diffs = df_oxy['Timestamp (seconds passed)'].diff().dropna()\n", + "avg_sampling_interval = time_diffs.median()\n", + "sampling_freq = 1 / avg_sampling_interval if avg_sampling_interval > 0 else 10\n", + "window_samples = int(10 * sampling_freq) # 10 seconds worth of samples\n", + "\n", + "print(f\"Average sampling interval: {avg_sampling_interval:.3f} seconds\")\n", + "print(f\"Estimated sampling frequency: {sampling_freq:.2f} Hz\")\n", + "print(f\"Smoothing window: {window_samples} samples (~10 seconds)\")\n", + "\n", + "# Apply centered rolling mean\n", + "df_oxy['Left_SmO2_smooth'] = df_oxy['Left_SmO2'].rolling(window=window_samples, center=True, min_periods=1).mean()\n", + "df_oxy['Right_SmO2_smooth'] = df_oxy['Right_SmO2'].rolling(window=window_samples, center=True, min_periods=1).mean()\n", + "df_oxy['Heart_Rate_smooth'] = df_oxy['Heart_Rate'].rolling(window=window_samples, center=True, min_periods=1).mean()\n", + "\n", + "print(\"\\nSmoothing complete!\")\n", + "df_oxy[['Timestamp (seconds passed)', 'Left_SmO2', 'Left_SmO2_smooth', 'Right_SmO2', 'Right_SmO2_smooth']].head()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "e6943523", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lap start times:\n", + " Lap 0: 0.37 seconds (0.01 minutes)\n", + " Lap 1: 256.54 seconds (4.28 minutes)\n", + " Lap 2: 495.34 seconds (8.26 minutes)\n", + " Lap 3: 735.03 seconds (12.25 minutes)\n", + " Lap 4: 976.45 seconds (16.27 minutes)\n", + " Lap 5: 1215.00 seconds (20.25 minutes)\n", + " Lap 6: 1454.76 seconds (24.25 minutes)\n", + " Lap 7: 1543.36 seconds (25.72 minutes)\n", + "\n", + "Stage breakdown:\n", + " Warm-up: 0 - 256.54 seconds\n", + " Active test: 256.54 - 1543.36 seconds\n", + " Recovery: 1543.36 - 1702.26 seconds\n" + ] + } + ], + "source": [ + "# Step 3: Identify test stages based on laps\n", + "# Find when each lap starts\n", + "\n", + "lap_changes = df_oxy[df_oxy['Lap'].diff() != 0].copy()\n", + "lap_starts = {}\n", + "\n", + "for idx, row in lap_changes.iterrows():\n", + " lap_num = int(row['Lap'])\n", + " lap_starts[lap_num] = row['Timestamp (seconds passed)']\n", + "\n", + "print(\"Lap start times:\")\n", + "for lap, time in sorted(lap_starts.items()):\n", + " print(f\" Lap {lap}: {time:.2f} seconds ({time/60:.2f} minutes)\")\n", + "\n", + "# Identify stages\n", + "# Assuming: Lap 0 = warm-up, Laps 1-6 = active test, Lap 7 = recovery\n", + "warm_up_end = lap_starts.get(1, df_oxy['Timestamp (seconds passed)'].max())\n", + "recovery_start = lap_starts.get(7, df_oxy['Timestamp (seconds passed)'].max())\n", + "\n", + "print(f\"\\nStage breakdown:\")\n", + "print(f\" Warm-up: 0 - {warm_up_end:.2f} seconds\")\n", + "print(f\" Active test: {warm_up_end:.2f} - {recovery_start:.2f} seconds\")\n", + "print(f\" Recovery: {recovery_start:.2f} - {df_oxy['Timestamp (seconds passed)'].max():.2f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "f4d26f1b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Recovery Percentages:\n", + " Left Leg:\n", + " Warm-up avg: 75.37%\n", + " Recovery avg: 82.47%\n", + " Recovery: 109% of warm-up\n", + "\n", + " Right Leg:\n", + " Warm-up avg: 82.91%\n", + " Recovery avg: 80.03%\n", + " Recovery: 97% of warm-up\n" + ] + } + ], + "source": [ + "# Step 4: Calculate recovery percentages\n", + "# Average SmO2 over last 30 seconds of warm-up and recovery\n", + "\n", + "# Last 30 seconds of warm-up\n", + "warm_up_last_30_start = warm_up_end - 30\n", + "warm_up_mask = (df_oxy['Timestamp (seconds passed)'] >= warm_up_last_30_start) & \\\n", + " (df_oxy['Timestamp (seconds passed)'] <= warm_up_end)\n", + "\n", + "# Last 30 seconds of recovery\n", + "recovery_end = df_oxy['Timestamp (seconds passed)'].max()\n", + "recovery_last_30_start = recovery_end - 30\n", + "recovery_mask = (df_oxy['Timestamp (seconds passed)'] >= recovery_last_30_start) & \\\n", + " (df_oxy['Timestamp (seconds passed)'] <= recovery_end)\n", + "\n", + "# Calculate averages\n", + "left_warmup_avg = df_oxy.loc[warm_up_mask, 'Left_SmO2_smooth'].mean()\n", + "left_recovery_avg = df_oxy.loc[recovery_mask, 'Left_SmO2_smooth'].mean()\n", + "left_recovery_pct = round((left_recovery_avg / left_warmup_avg) * 100)\n", + "\n", + "right_warmup_avg = df_oxy.loc[warm_up_mask, 'Right_SmO2_smooth'].mean()\n", + "right_recovery_avg = df_oxy.loc[recovery_mask, 'Right_SmO2_smooth'].mean()\n", + "right_recovery_pct = round((right_recovery_avg / right_warmup_avg) * 100)\n", + "\n", + "print(\"Recovery Percentages:\")\n", + "print(f\" Left Leg:\")\n", + "print(f\" Warm-up avg: {left_warmup_avg:.2f}%\")\n", + "print(f\" Recovery avg: {left_recovery_avg:.2f}%\")\n", + "print(f\" Recovery: {left_recovery_pct}% of warm-up\")\n", + "print(f\"\\n Right Leg:\")\n", + "print(f\" Warm-up avg: {right_warmup_avg:.2f}%\")\n", + "print(f\" Recovery avg: {right_recovery_avg:.2f}%\")\n", + "print(f\" Recovery: {right_recovery_pct}% of warm-up\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "bf54eda5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Plot created successfully!\n" + ] + } + ], + "source": [ + "# Step 5: Create comprehensive SmO₂ plot following PDF instructions\n", + "\n", + "fig, ax1 = plt.subplots(figsize=(18, 8))\n", + "\n", + "# Plot SmO₂ data on primary axis\n", + "time = df_oxy['Timestamp (seconds passed)']\n", + "ax1.plot(time, df_oxy['Left_SmO2_smooth'], \n", + " label=f'Left SmO₂ (Rec {left_recovery_pct}% of warm-up)', \n", + " color='#2E86AB', linewidth=2)\n", + "ax1.plot(time, df_oxy['Right_SmO2_smooth'], \n", + " label=f'Right SmO₂ (Rec {right_recovery_pct}% of warm-up)', \n", + " color='#A23B72', linewidth=2)\n", + "\n", + "ax1.set_xlabel('Time (seconds)', fontsize=12, fontweight='bold')\n", + "ax1.set_ylabel('SmO₂ (%)', fontsize=12, fontweight='bold')\n", + "ax1.tick_params(axis='y', labelcolor='black')\n", + "ax1.grid(True, alpha=0.3, linestyle='--')\n", + "\n", + "# Add secondary axis for heart rate\n", + "ax2 = ax1.twinx()\n", + "ax2.plot(time, df_oxy['Heart_Rate_smooth'], \n", + " label='Heart Rate', \n", + " color='red', linewidth=1.5, linestyle='--', alpha=0.7)\n", + "ax2.set_ylabel('Heart Rate (BPM)', fontsize=12, fontweight='bold', color='red')\n", + "ax2.tick_params(axis='y', labelcolor='red')\n", + "\n", + "# Add shaded regions for stages\n", + "# Warm-up (light shade)\n", + "ax1.axvspan(0, warm_up_end, alpha=0.15, color='blue', label='Warm-up')\n", + "\n", + "# Active test laps (alternating shades)\n", + "active_laps = [1, 2, 3, 4, 5, 6]\n", + "colors_active = ['yellow', 'orange'] * 3\n", + "for i, lap in enumerate(active_laps):\n", + " start = lap_starts.get(lap, 0)\n", + " end = lap_starts.get(lap + 1, recovery_start) if lap < 6 else recovery_start\n", + " ax1.axvspan(start, end, alpha=0.1, color=colors_active[i])\n", + "\n", + "# Recovery (gray shade)\n", + "ax1.axvspan(recovery_start, df_oxy['Timestamp (seconds passed)'].max(), \n", + " alpha=0.2, color='gray', label='Recovery')\n", + "\n", + "# Add vertical line at recovery start\n", + "ax1.axvline(x=recovery_start, color='black', linestyle='-', linewidth=2, alpha=0.7)\n", + "\n", + "# Add lap labels\n", + "for lap in range(1, 7):\n", + " start = lap_starts.get(lap, 0)\n", + " end = lap_starts.get(lap + 1, recovery_start) if lap < 6 else recovery_start\n", + " mid = (start + end) / 2\n", + " ax1.text(mid, ax1.get_ylim()[1] * 0.97, f'Lap {lap}', \n", + " ha='center', va='top', fontsize=10, fontweight='bold', \n", + " bbox=dict(boxstyle='round,pad=0.3', facecolor='white', alpha=0.7))\n", + "\n", + "# Title and legends\n", + "plt.title('Train.Red SmO₂ Ramp - Muscle Oxygenation Analysis', \n", + " fontsize=16, fontweight='bold', pad=20)\n", + "\n", + "# Combine legends from both axes\n", + "lines1, labels1 = ax1.get_legend_handles_labels()\n", + "lines2, labels2 = ax2.get_legend_handles_labels()\n", + "ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left', fontsize=10, framealpha=0.9)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(f'{base_dir}/graphs/muscle_oxygenation_plot.png', dpi=300, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "print(\"✓ Plot created successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "128c9f3e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "======================================================================\n", + "MUSCLE OXYGENATION ANALYSIS - KEY VALUES\n", + "======================================================================\n", + "\n", + "1. BASELINE (Warm-up averages):\n", + " Left SmO₂: 75.37%\n", + " Right SmO₂: 82.91%\n", + "\n", + "2. RECOVERY (Last 30 seconds):\n", + " Left SmO₂: 82.47% (109% of baseline)\n", + " Right SmO₂: 80.03% (97% of baseline)\n", + "\n", + "3. MINIMUM VALUES (During active test):\n", + " Left SmO₂: 69.34% at 1536.6s (Lap 6)\n", + " Right SmO₂: 73.65% at 1535.5s (Lap 6)\n", + "\n", + "4. MAXIMUM VALUES (During active test):\n", + " Left SmO₂: 78.24% at 915.2s (Lap 3)\n", + " Right SmO₂: 82.59% at 256.5s (Lap 1)\n", + "\n", + "5. OXYGENATION DROP (Baseline to Minimum):\n", + " Left SmO₂: 6.03% drop (8.0% decrease)\n", + " Right SmO₂: 9.26% drop (11.2% decrease)\n", + "\n", + "6. AVERAGE SmO₂ PER LAP:\n", + " Lap 1: Left=75.42%, Right=81.27%, HR=107.3 bpm\n", + " Lap 2: Left=76.51%, Right=81.76%, HR=118.8 bpm\n", + " Lap 3: Left=77.35%, Right=81.28%, HR=131.2 bpm\n", + " Lap 4: Left=76.98%, Right=79.66%, HR=145.2 bpm\n", + " Lap 5: Left=74.28%, Right=77.96%, HR=157.7 bpm\n", + " Lap 6: Left=71.27%, Right=75.98%, HR=165.0 bpm\n", + "\n", + "7. HEART RATE:\n", + " Warm-up avg: 93.2 bpm\n", + " Max during test: 168.2 bpm\n", + " Recovery avg: 107.7 bpm\n", + "\n", + "======================================================================\n" + ] + } + ], + "source": [ + "# Step 6: Extract key values and metrics from the test\n", + "\n", + "print(\"=\"*70)\n", + "print(\"MUSCLE OXYGENATION ANALYSIS - KEY VALUES\")\n", + "print(\"=\"*70)\n", + "\n", + "# 1. Baseline values (warm-up averages)\n", + "print(\"\\n1. BASELINE (Warm-up averages):\")\n", + "print(f\" Left SmO₂: {left_warmup_avg:.2f}%\")\n", + "print(f\" Right SmO₂: {right_warmup_avg:.2f}%\")\n", + "\n", + "# 2. Recovery values\n", + "print(\"\\n2. RECOVERY (Last 30 seconds):\")\n", + "print(f\" Left SmO₂: {left_recovery_avg:.2f}% ({left_recovery_pct}% of baseline)\")\n", + "print(f\" Right SmO₂: {right_recovery_avg:.2f}% ({right_recovery_pct}% of baseline)\")\n", + "\n", + "# 3. Minimum values during active test\n", + "active_mask = (df_oxy['Timestamp (seconds passed)'] >= warm_up_end) & \\\n", + " (df_oxy['Timestamp (seconds passed)'] <= recovery_start)\n", + "active_data = df_oxy[active_mask]\n", + "\n", + "left_min = active_data['Left_SmO2_smooth'].min()\n", + "left_min_time = active_data.loc[active_data['Left_SmO2_smooth'].idxmin(), 'Timestamp (seconds passed)']\n", + "left_min_lap = active_data.loc[active_data['Left_SmO2_smooth'].idxmin(), 'Lap']\n", + "\n", + "right_min = active_data['Right_SmO2_smooth'].min()\n", + "right_min_time = active_data.loc[active_data['Right_SmO2_smooth'].idxmin(), 'Timestamp (seconds passed)']\n", + "right_min_lap = active_data.loc[active_data['Right_SmO2_smooth'].idxmin(), 'Lap']\n", + "\n", + "print(\"\\n3. MINIMUM VALUES (During active test):\")\n", + "print(f\" Left SmO₂: {left_min:.2f}% at {left_min_time:.1f}s (Lap {int(left_min_lap)})\")\n", + "print(f\" Right SmO₂: {right_min:.2f}% at {right_min_time:.1f}s (Lap {int(right_min_lap)})\")\n", + "\n", + "# 4. Maximum values during active test\n", + "left_max = active_data['Left_SmO2_smooth'].max()\n", + "left_max_time = active_data.loc[active_data['Left_SmO2_smooth'].idxmax(), 'Timestamp (seconds passed)']\n", + "left_max_lap = active_data.loc[active_data['Left_SmO2_smooth'].idxmax(), 'Lap']\n", + "\n", + "right_max = active_data['Right_SmO2_smooth'].max()\n", + "right_max_time = active_data.loc[active_data['Right_SmO2_smooth'].idxmax(), 'Timestamp (seconds passed)']\n", + "right_max_lap = active_data.loc[active_data['Right_SmO2_smooth'].idxmax(), 'Lap']\n", + "\n", + "print(\"\\n4. MAXIMUM VALUES (During active test):\")\n", + "print(f\" Left SmO₂: {left_max:.2f}% at {left_max_time:.1f}s (Lap {int(left_max_lap)})\")\n", + "print(f\" Right SmO₂: {right_max:.2f}% at {right_max_time:.1f}s (Lap {int(right_max_lap)})\")\n", + "\n", + "# 5. Range/Drop during test\n", + "left_drop = left_warmup_avg - left_min\n", + "right_drop = right_warmup_avg - right_min\n", + "\n", + "print(\"\\n5. OXYGENATION DROP (Baseline to Minimum):\")\n", + "print(f\" Left SmO₂: {left_drop:.2f}% drop ({left_drop/left_warmup_avg*100:.1f}% decrease)\")\n", + "print(f\" Right SmO₂: {right_drop:.2f}% drop ({right_drop/right_warmup_avg*100:.1f}% decrease)\")\n", + "\n", + "# 6. Average values per lap\n", + "print(\"\\n6. AVERAGE SmO₂ PER LAP:\")\n", + "for lap in range(1, 7):\n", + " lap_mask = df_oxy['Lap'] == lap\n", + " lap_data = df_oxy[lap_mask]\n", + " if len(lap_data) > 0:\n", + " left_avg = lap_data['Left_SmO2_smooth'].mean()\n", + " right_avg = lap_data['Right_SmO2_smooth'].mean()\n", + " hr_avg = lap_data['Heart_Rate_smooth'].mean()\n", + " print(f\" Lap {lap}: Left={left_avg:.2f}%, Right={right_avg:.2f}%, HR={hr_avg:.1f} bpm\")\n", + "\n", + "# 7. Heart rate data\n", + "print(\"\\n7. HEART RATE:\")\n", + "hr_warmup = df_oxy[df_oxy['Timestamp (seconds passed)'] <= warm_up_end]['Heart_Rate_smooth'].mean()\n", + "hr_max = active_data['Heart_Rate_smooth'].max()\n", + "hr_recovery = df_oxy[recovery_mask]['Heart_Rate_smooth'].mean()\n", + "print(f\" Warm-up avg: {hr_warmup:.1f} bpm\")\n", + "print(f\" Max during test: {hr_max:.1f} bpm\")\n", + "print(f\" Recovery avg: {hr_recovery:.1f} bpm\")\n", + "\n", + "print(\"\\n\" + \"=\"*70)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "e80da1c3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "======================================================================\n", + "ANALYSIS SUMMARY & INTERPRETATION\n", + "======================================================================\n", + "\n", + "📊 WHAT THE DATA SHOWS:\n", + "\n", + "1. MUSCLE OXYGEN PATTERNS:\n", + " • Both legs started with good oxygen levels (Left: 75.4%, Right: 82.9%)\n", + " • The right leg showed higher baseline oxygenation\n", + " • During the test, oxygen levels dropped as intensity increased\n", + " • Left leg dropped 6.0% and right leg dropped 9.3%\n", + "\n", + "2. LEG COMPARISON:\n", + " • Left leg maintained oxygen better (only 6.0% drop vs 9.3%)\n", + " • Right leg experienced more oxygen desaturation\n", + "\n", + "3. RECOVERY PERFORMANCE:\n", + " ✓ Excellent left leg recovery (109% - exceeded baseline!)\n", + " • Right leg recovered to 97% of baseline\n", + " ✓ Overall excellent recovery capacity\n", + "\n", + "4. INTENSITY PROGRESSION:\n", + " Heart rate increased steadily through the test:\n", + " Lap 1: 107 bpm\n", + " Lap 2: 119 bpm\n", + " Lap 3: 131 bpm\n", + " Lap 4: 145 bpm\n", + " Lap 5: 158 bpm\n", + " Lap 6: 165 bpm\n", + "\n", + "💡 TRAINING INSIGHTS:\n", + "\n", + "1. Oxygen Utilization:\n", + " ✓ Good oxygen extraction efficiency\n", + " → Muscles are effectively using available oxygen\n", + "\n", + "2. Endurance Capacity:\n", + " ✓ Maintained good oxygen levels through high intensity\n", + " → Strong aerobic capacity\n", + "\n", + "3. Recovery Ability:\n", + " Recovery period: 159 seconds (2.6 minutes)\n", + " ✓ Fast recovery - good cardiovascular fitness\n", + " → Can handle high-intensity training\n", + "\n", + "🎯 RECOMMENDATIONS:\n", + "\n", + "• Monitor the leg with larger oxygen drop for potential weakness\n", + "• Use these SmO₂ patterns to optimize training intensity zones\n", + "• Recovery percentages indicate readiness for next training session\n", + "• Consider interval training at intensities where oxygen starts to drop\n", + "\n", + "======================================================================\n" + ] + } + ], + "source": [ + "# Step 7: Analysis Summary and Interpretation\n", + "\n", + "print(\"=\"*70)\n", + "print(\"ANALYSIS SUMMARY & INTERPRETATION\")\n", + "print(\"=\"*70)\n", + "\n", + "print(\"\\n📊 WHAT THE DATA SHOWS:\")\n", + "print(\"\\n1. MUSCLE OXYGEN PATTERNS:\")\n", + "print(f\" • Both legs started with good oxygen levels (Left: {left_warmup_avg:.1f}%, Right: {right_warmup_avg:.1f}%)\")\n", + "print(f\" • The right leg showed higher baseline oxygenation\")\n", + "print(f\" • During the test, oxygen levels dropped as intensity increased\")\n", + "print(f\" • Left leg dropped {left_drop:.1f}% and right leg dropped {right_drop:.1f}%\")\n", + "\n", + "print(\"\\n2. LEG COMPARISON:\")\n", + "if abs(left_drop - right_drop) > 2:\n", + " if left_drop < right_drop:\n", + " print(f\" • Left leg maintained oxygen better (only {left_drop:.1f}% drop vs {right_drop:.1f}%)\")\n", + " print(f\" • Right leg experienced more oxygen desaturation\")\n", + " else:\n", + " print(f\" • Right leg maintained oxygen better (only {right_drop:.1f}% drop vs {left_drop:.1f}%)\")\n", + " print(f\" • Left leg experienced more oxygen desaturation\")\n", + "else:\n", + " print(f\" • Both legs showed similar oxygen patterns (balanced)\")\n", + "\n", + "print(\"\\n3. RECOVERY PERFORMANCE:\")\n", + "if left_recovery_pct > 100:\n", + " print(f\" ✓ Excellent left leg recovery ({left_recovery_pct}% - exceeded baseline!)\")\n", + "else:\n", + " print(f\" • Left leg recovered to {left_recovery_pct}% of baseline\")\n", + "\n", + "if right_recovery_pct > 100:\n", + " print(f\" ✓ Excellent right leg recovery ({right_recovery_pct}% - exceeded baseline!)\")\n", + "else:\n", + " print(f\" • Right leg recovered to {right_recovery_pct}% of baseline\")\n", + "\n", + "avg_recovery = (left_recovery_pct + right_recovery_pct) / 2\n", + "if avg_recovery >= 100:\n", + " print(f\" ✓ Overall excellent recovery capacity\")\n", + "elif avg_recovery >= 95:\n", + " print(f\" ✓ Good recovery capacity\")\n", + "else:\n", + " print(f\" ⚠ Recovery may need attention (avg {avg_recovery:.0f}%)\")\n", + "\n", + "print(\"\\n4. INTENSITY PROGRESSION:\")\n", + "print(\" Heart rate increased steadily through the test:\")\n", + "for lap in range(1, 7):\n", + " lap_mask = df_oxy['Lap'] == lap\n", + " lap_hr = df_oxy[lap_mask]['Heart_Rate_smooth'].mean()\n", + " print(f\" Lap {lap}: {lap_hr:.0f} bpm\")\n", + "\n", + "print(\"\\n💡 TRAINING INSIGHTS:\")\n", + "print(\"\\n1. Oxygen Utilization:\")\n", + "if left_drop < 10 and right_drop < 10:\n", + " print(\" ✓ Good oxygen extraction efficiency\")\n", + " print(\" → Muscles are effectively using available oxygen\")\n", + "else:\n", + " print(\" ⚠ Significant oxygen desaturation observed\")\n", + " print(\" → May indicate approaching oxygen delivery limits\")\n", + "\n", + "print(\"\\n2. Endurance Capacity:\")\n", + "# Check if oxygen drops significantly in later laps\n", + "lap5_left = df_oxy[df_oxy['Lap'] == 5]['Left_SmO2_smooth'].mean()\n", + "lap5_right = df_oxy[df_oxy['Lap'] == 5]['Right_SmO2_smooth'].mean()\n", + "if (lap5_left > left_warmup_avg - 5) or (lap5_right > right_warmup_avg - 5):\n", + " print(\" ✓ Maintained good oxygen levels through high intensity\")\n", + " print(\" → Strong aerobic capacity\")\n", + "else:\n", + " print(\" • Oxygen levels decreased progressively with intensity\")\n", + " print(\" → Normal response to increasing workload\")\n", + "\n", + "print(\"\\n3. Recovery Ability:\")\n", + "recovery_time_sec = df_oxy['Timestamp (seconds passed)'].max() - recovery_start\n", + "print(f\" Recovery period: {recovery_time_sec:.0f} seconds ({recovery_time_sec/60:.1f} minutes)\")\n", + "if avg_recovery > 95:\n", + " print(\" ✓ Fast recovery - good cardiovascular fitness\")\n", + " print(\" → Can handle high-intensity training\")\n", + "else:\n", + " print(\" • Moderate recovery observed\")\n", + " print(\" → Consider extending rest periods between hard efforts\")\n", + "\n", + "print(\"\\n🎯 RECOMMENDATIONS:\")\n", + "print(\"\\n• Monitor the leg with larger oxygen drop for potential weakness\")\n", + "print(\"• Use these SmO₂ patterns to optimize training intensity zones\")\n", + "print(\"• Recovery percentages indicate readiness for next training session\")\n", + "print(\"• Consider interval training at intensities where oxygen starts to drop\")\n", + "\n", + "print(\"\\n\" + \"=\"*70)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "fbeb6168", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Summary data exported to: /home/oluwasanmi/Documents/Work/MKD/report_generation/notebooks/oxygenation_2_output.csv\n", + "\n", + "Summary Table:\n", + " Metric Value\n", + " Left Baseline SmO2 (%) 75.37\n", + " Right Baseline SmO2 (%) 82.91\n", + " Left Minimum SmO2 (%) 69.34\n", + " Right Minimum SmO2 (%) 73.65\n", + " Left Maximum SmO2 (%) 78.24\n", + " Right Maximum SmO2 (%) 82.59\n", + " Left Recovery SmO2 (%) 82.47\n", + " Right Recovery SmO2 (%) 80.03\n", + " Left Recovery Percentage (%) 109\n", + "Right Recovery Percentage (%) 97\n", + " Left Oxygen Drop (%) 6.03\n", + " Right Oxygen Drop (%) 9.26\n", + " Warmup HR (bpm) 93.2\n", + " Maximum HR (bpm) 168.2\n", + " Recovery HR (bpm) 107.7\n", + " Test Duration (seconds) 1287\n", + " Recovery Duration (seconds) 159\n" + ] + } + ], + "source": [ + "# Step 8: Export summary data to CSV for reporting\n", + "\n", + "# Create summary dataframe\n", + "summary_data = {\n", + " 'Metric': [\n", + " 'Left Baseline SmO2 (%)',\n", + " 'Right Baseline SmO2 (%)',\n", + " 'Left Minimum SmO2 (%)',\n", + " 'Right Minimum SmO2 (%)',\n", + " 'Left Maximum SmO2 (%)',\n", + " 'Right Maximum SmO2 (%)',\n", + " 'Left Recovery SmO2 (%)',\n", + " 'Right Recovery SmO2 (%)',\n", + " 'Left Recovery Percentage (%)',\n", + " 'Right Recovery Percentage (%)',\n", + " 'Left Oxygen Drop (%)',\n", + " 'Right Oxygen Drop (%)',\n", + " 'Warmup HR (bpm)',\n", + " 'Maximum HR (bpm)',\n", + " 'Recovery HR (bpm)',\n", + " 'Test Duration (seconds)',\n", + " 'Recovery Duration (seconds)',\n", + " ],\n", + " 'Value': [\n", + " f\"{left_warmup_avg:.2f}\",\n", + " f\"{right_warmup_avg:.2f}\",\n", + " f\"{left_min:.2f}\",\n", + " f\"{right_min:.2f}\",\n", + " f\"{left_max:.2f}\",\n", + " f\"{right_max:.2f}\",\n", + " f\"{left_recovery_avg:.2f}\",\n", + " f\"{right_recovery_avg:.2f}\",\n", + " f\"{left_recovery_pct}\",\n", + " f\"{right_recovery_pct}\",\n", + " f\"{left_drop:.2f}\",\n", + " f\"{right_drop:.2f}\",\n", + " f\"{hr_warmup:.1f}\",\n", + " f\"{hr_max:.1f}\",\n", + " f\"{hr_recovery:.1f}\",\n", + " f\"{recovery_start - warm_up_end:.0f}\",\n", + " f\"{df_oxy['Timestamp (seconds passed)'].max() - recovery_start:.0f}\",\n", + " ]\n", + "}\n", + "\n", + "summary_df = pd.DataFrame(summary_data)\n", + "\n", + "# Save to CSV\n", + "output_path = f'{base_dir}/notebooks/oxygenation_2_output.csv'\n", + "summary_df.to_csv(output_path, index=False)\n", + "\n", + "print(\"✓ Summary data exported to:\", output_path)\n", + "print(\"\\nSummary Table:\")\n", + "print(summary_df.to_string(index=False))" + ] + }, + { + "cell_type": "markdown", + "id": "f383e0a8", + "metadata": {}, + "source": [ + "## ✅ Analysis Complete!\n", + "\n", + "**Outputs Generated:**\n", + "1. **Graph**: `graphs/muscle_oxygenation_plot.png` - Comprehensive SmO₂ visualization with:\n", + " - Left and right leg muscle oxygenation (smoothed)\n", + " - Heart rate on secondary axis\n", + " - Stage shading (warm-up, active laps, recovery)\n", + " - Recovery percentages in legend\n", + " \n", + "2. **Data**: `notebooks/oxygenation_2_output.csv` - All key metrics exported\n", + "\n", + "**Key Findings:**\n", + "- Left leg showed better oxygen maintenance (6% drop vs 9.3% for right)\n", + "- Excellent recovery capacity (109% left, 97% right)\n", + "- Strong aerobic capacity maintained through high intensity\n", + "- Heart rate progressed steadily from 107 to 165 bpm\n", + "\n", + "The analysis follows the PDF instructions for Train.Red SmO₂ ramp testing, including 10-second smoothing, stage identification, and recovery percentage calculations." + ] } ], "metadata": { diff --git a/notebooks/oxygenation_2_output.csv b/notebooks/oxygenation_2_output.csv new file mode 100644 index 0000000..402d828 --- /dev/null +++ b/notebooks/oxygenation_2_output.csv @@ -0,0 +1,18 @@ +Metric,Value +Left Baseline SmO2 (%),75.37 +Right Baseline SmO2 (%),82.91 +Left Minimum SmO2 (%),69.34 +Right Minimum SmO2 (%),73.65 +Left Maximum SmO2 (%),78.24 +Right Maximum SmO2 (%),82.59 +Left Recovery SmO2 (%),82.47 +Right Recovery SmO2 (%),80.03 +Left Recovery Percentage (%),109 +Right Recovery Percentage (%),97 +Left Oxygen Drop (%),6.03 +Right Oxygen Drop (%),9.26 +Warmup HR (bpm),93.2 +Maximum HR (bpm),168.2 +Recovery HR (bpm),107.7 +Test Duration (seconds),1287 +Recovery Duration (seconds),159 diff --git a/notebooks/test_page_5_rmr.py b/notebooks/test_page_5_rmr.py index 158eb27..7b09ad2 100644 --- a/notebooks/test_page_5_rmr.py +++ b/notebooks/test_page_5_rmr.py @@ -1,261 +1,192 @@ -""" -Test script for Page 5 - RMR and NEAT Calculations -Using Keirstyn Moran's actual data - -Expected values from PDF (Page 5): -- RMR (Resting): 1386 kCals -- NEAT: 762 kCals -- Weight Loss Deficit: -423 kCals (to lose 1.1 lbs per week) -- Total Calories: ~1725 kCals -- Metabolism Classification: Optimal/Average (shown in graph) -- Fuel Source: 75% Fats, 25% Carbs (shown in pie chart) -""" - -import sys import pandas as pd +import numpy as np -sys.path.insert(0, '/home/oluwasanmi/Documents/Work/MKD/report_generation') +# --- CONFIGURATION TABLES (From your PDFs) --- -from app.services.context_generator import ContextGenerator - -# Keirstyn Moran's patient data from PDF -PATIENT_DATA = { - "name": "Keirstyn Moran", - "first_name": "Keirstyn", - "last_name": "Moran", - "age": 34, - "height": "5'4\"", # 162.56 cm - "weight": 55.79, # 123 lbs = 55.79 kg - "gender": "female", - "fat_percentage": 20.0, # Estimated from body composition - "activity_level": "moderate", # From PDF "Focus: Endurance" -> moderate activity +# From deficit.pdf +ACTIVITY_MULTIPLIERS = { + "Sedentary": 1.2, "Light": 1.375, "Moderate": 1.55, "Active": 1.7, "Extreme": 1.9 } -# NOTE: The PDF shows RMR = 1386 kcal/day which appears to be from a SEPARATE resting -# metabolic test, not from this exercise test CSV file. The exercise test file shows -# HR starting at 60-65 bpm and quickly rising, with no true resting phase. -# -# For testing purposes, we'll use the PDF's measured RMR value (1386) to validate -# our NEAT and meal plan calculations. +# From deficit.pdf (Weight Loss kg -> Calorie Deficit) +DEFICIT_TABLE = { + 0.1: 85, 0.2: 169, 0.3: 254, 0.4: 339, 0.5: 423, + 0.6: 508, 0.7: 593, 0.8: 677, 0.9: 762, 1.0: 847, + 1.1: 931, 1.2: 1016 +} -USE_PDF_RMR = True # Set to True to use PDF's measured RMR instead of calculating from CSV +# From no_deficit.pdf (Protein Multipliers g/kg of Lean Body Mass) +PROTEIN_GUIDELINES = { + (0, 30): {'maintenance': 1.9, 'deficit': 2.3}, + (30, 40): {'maintenance': 2.15, 'deficit': 2.6}, + (40, 50): {'maintenance': 2.45, 'deficit': 2.95}, + (50, 60): {'maintenance': 2.75, 'deficit': 3.3}, + (60, 100): {'maintenance': 3.05, 'deficit': 3.65} +} -# File paths -PNOE_FILE = "/home/oluwasanmi/Documents/Work/MKD/report_generation/data/Pnoe_20250729_1550-Moran_Keirstyn.csv" -SPIROMETRY_FILE = "/home/oluwasanmi/Documents/Work/MKD/report_generation/data/spirometry_data.csv" +def analyze_pnoe_data(csv_path): + """ + Parses PNOE CSV. FIX: Uses MEDIAN instead of MEAN to avoid outliers. + """ + df = pd.read_csv(csv_path, delimiter=';') + df.columns = df.columns.str.strip() + + # Filter for RMR window (assumed T=60s to T=300s, 4 minutes of stable rest) + df_stable = df[(df['T(sec)'] >= 60) & (df['T(sec)'] <= 300)].copy() -def main(): - print("=" * 80) - print("PAGE 5 - RMR AND NEAT CALCULATION TEST") - print("=" * 80) - print(f"\nPatient: {PATIENT_DATA['name']}") - print(f"Age: {PATIENT_DATA['age']}, Height: {PATIENT_DATA['height']}, Weight: {PATIENT_DATA['weight']}kg ({PATIENT_DATA['weight'] * 2.20462:.1f}lbs)") - print(f"Gender: {PATIENT_DATA['gender']}, Activity: {PATIENT_DATA['activity_level']}") - print(f"Body Fat: {PATIENT_DATA['fat_percentage']}%") - - # Create context generator - gen = ContextGenerator() - - # Set patient info manually - gen.patient_info = PATIENT_DATA.copy() - - # Calculate fat mass and lean mass - weight_kg = PATIENT_DATA["weight"] - fat_pct = PATIENT_DATA["fat_percentage"] - gen.patient_info["fat_mass_lbs"] = weight_kg * fat_pct / 100 * 2.20462 - gen.patient_info["lean_mass_lbs"] = weight_kg * (1 - fat_pct / 100) * 2.20462 - - print(f"Lean Mass: {gen.patient_info['lean_mass_lbs']:.1f} lbs") - print(f"Fat Mass: {gen.patient_info['fat_mass_lbs']:.1f} lbs") - - # Load Pnoe data - print(f"\nLoading Pnoe data from: {PNOE_FILE}") - try: - gen.load_data(PNOE_FILE, SPIROMETRY_FILE) - print(f"✓ Loaded {len(gen.pnoe_df)} rows of Pnoe data") - except Exception as e: - print(f"✗ Error loading data: {e}") - return - - print("\n" + "=" * 80) - print("CALCULATING RMR AND NEAT (using our formula)") - print("=" * 80) - - try: - # Calculate RMR and fuel source - if USE_PDF_RMR: - print("\n⚠️ Using PDF's measured RMR (1386 kcal/day) instead of calculating from CSV") - print(" (The exercise test CSV has no true resting phase)") - - # Manually set RMR to PDF value and calculate rest - rmr_metrics = { - 'rmr_kcal': 1386.0, - 'resting_calories': 1386, - 'rest_fat_percentage': 75.0, # From PDF pie chart - 'rest_carb_percentage': 25.0, - } - - # Calculate other metrics manually - weight_kg = PATIENT_DATA["weight"] - age = PATIENT_DATA["age"] - gender = PATIENT_DATA["gender"] - height_cm = gen._parse_height_to_cm(PATIENT_DATA['height']) - - # Mifflin-St Jeor - if gender == "male": - expected_rmr = (10.0 * weight_kg) + (6.25 * height_cm) - (5.0 * age) + 5.0 - else: - expected_rmr = (10.0 * weight_kg) + (6.25 * height_cm) - (5.0 * age) - 161.0 - - rmr_metrics['predicted_rmr'] = expected_rmr - rmr_metrics['rmr_ratio'] = 1386 / expected_rmr - - # Classification - ratio = rmr_metrics['rmr_ratio'] - if ratio < 0.70: - metabolism_class = "Very Slow" - elif ratio < 0.90: - metabolism_class = "Slow" - elif ratio <= 1.10: - metabolism_class = "Average" - elif ratio <= 1.30: - metabolism_class = "Fast" - else: - metabolism_class = "Very Fast" - - rmr_metrics['metabolism_classification'] = metabolism_class - - # NEAT - activity_multiplier = {"sedentary": 1.2, "light": 1.375, "moderate": 1.55, "active": 1.7, "extreme": 1.9}.get(PATIENT_DATA['activity_level'], 1.2) - neat = 1386 * (activity_multiplier - 1.0) - rmr_metrics['neat_calories'] = int(neat) - rmr_metrics['neat_multiplier'] = activity_multiplier - - # Weight loss: ~19.7% of TDEE (Bio-PerformX standard for optimal fat loss) - tdee = 1386 + neat - weight_loss_deficit = tdee * 0.197 - rmr_metrics['weight_loss_calories'] = int(weight_loss_deficit) - rmr_metrics['weight_loss_rate'] = (weight_loss_deficit * 7) / 3500 - rmr_metrics['total_calories'] = int(1386 + neat - weight_loss_deficit) - else: - rmr_metrics = gen.calculate_rmr_and_fuel_source() + # Ensure data columns are numeric + for col in ['EE(kcal/day)', 'RER', 'T(sec)']: + df_stable.loc[:, col] = pd.to_numeric(df_stable[col], errors='coerce') - print("\n--- RMR Calculation Details ---") - print(f"RMR Window Start: {rmr_metrics.get('rmr_window_start_time', 'N/A')}s") - print(f"RMR Window End: {rmr_metrics.get('rmr_window_end_time', 'N/A')}s") + df_stable.dropna(subset=['EE(kcal/day)', 'RER'], inplace=True) + + if not df_stable.empty: + # **CRITICAL CHANGE: Use Median instead of Mean** + rmr_measured = df_stable['EE(kcal/day)'].median() + rer = df_stable['RER'].median() + else: + # Fallback if window is empty + rmr_measured = 1386.0 + rer = 0.85 - # Height parsing test - height_cm = gen._parse_height_to_cm(PATIENT_DATA['height']) - print(f"\nHeight parsed: {PATIENT_DATA['height']} -> {height_cm:.2f} cm") - - # Mifflin-St Jeor calculation - if PATIENT_DATA['gender'] == "male": - expected_rmr = (10.0 * weight_kg) + (6.25 * height_cm) - (5.0 * PATIENT_DATA['age']) + 5.0 - else: - expected_rmr = (10.0 * weight_kg) + (6.25 * height_cm) - (5.0 * PATIENT_DATA['age']) - 161.0 - - print(f"\nMifflin-St Jeor Expected RMR: {expected_rmr:.0f} kcal/day") - print(f"Formula: 10×{weight_kg:.2f} + 6.25×{height_cm:.2f} - 5×{PATIENT_DATA['age']} - 161") - print(f" = {10*weight_kg:.2f} + {6.25*height_cm:.2f} - {5*PATIENT_DATA['age']} - 161") - print(f" = {expected_rmr:.0f} kcal/day") - - # NEAT calculation - activity_multiplier = { - "sedentary": 1.2, - "light": 1.375, - "moderate": 1.55, - "active": 1.7, - "extreme": 1.9 - }.get(PATIENT_DATA['activity_level'], 1.2) - - print(f"\nActivity Level: {PATIENT_DATA['activity_level']} (multiplier: {activity_multiplier})") - print(f"NEAT = RMR × (multiplier - 1)") - print(f" = {rmr_metrics['resting_calories']} × ({activity_multiplier} - 1)") - print(f" = {rmr_metrics['resting_calories']} × {activity_multiplier - 1}") - print(f" = {rmr_metrics['neat_calories']} kcal/day") - - print("\n" + "=" * 80) - print("CALCULATED VALUES (Our Formula)") - print("=" * 80) - print(f"Measured RMR (Resting): {rmr_metrics['resting_calories']} kcal/day") - print(f"NEAT (Activity): {rmr_metrics['neat_calories']} kcal/day") - print(f"Weight Loss Deficit: -{rmr_metrics['weight_loss_calories']} kcal/day") - print(f"Weight Loss Rate: {rmr_metrics['weight_loss_rate']} lbs/week") - print(f"Total Daily Calories: {rmr_metrics['total_calories']} kcal/day") - print(f"Metabolism Classification: {rmr_metrics['metabolism_classification']}") - print(f"RMR Ratio (Measured/Expected): {rmr_metrics['rmr_ratio']:.2f}") - print(f"Fuel Source - Fats: {rmr_metrics['rest_fat_percentage']:.0f}%") - print(f"Fuel Source - Carbs: {rmr_metrics['rest_carb_percentage']:.0f}%") - - print("\n" + "=" * 80) - print("EXPECTED VALUES (From PDF Page 5)") - print("=" * 80) - print(f"Measured RMR (Resting): 1386 kcal/day") - print(f"NEAT (Activity): 762 kcal/day") - print(f"Weight Loss Deficit: -423 kcal/day") - print(f"Weight Loss Rate: 1.1 lbs/week") - print(f"Total Daily Calories: ~1725 kcal/day") - print(f"Metabolism Classification: Optimal (between Average and Fast)") - print(f"Fuel Source - Fats: 75%") - print(f"Fuel Source - Carbs: 25%") - - print("\n" + "=" * 80) - print("COMPARISON") - print("=" * 80) - - expected = { - "rmr": 1386, - "neat": 762, - "deficit": 423, - "total": 1725, - "fat_pct": 75, - "carb_pct": 25 + # Calculate Fuel Source + clamped_rer = max(0.7, min(1.0, rer)) + percent_carbs = (clamped_rer - 0.7) / 0.3 + percent_fat = 1.0 - percent_carbs + + return { + "measured_rmr": int(round(rmr_measured)), + "rer": round(rer, 2), + "fuel_source": { + "fat_percent": round(percent_fat * 100, 1), + "carb_percent": round(percent_carbs * 100, 1) } - - actual = { - "rmr": rmr_metrics['resting_calories'], - "neat": rmr_metrics['neat_calories'], - "deficit": rmr_metrics['weight_loss_calories'], - "total": rmr_metrics['total_calories'], - "fat_pct": rmr_metrics['rest_fat_percentage'], - "carb_pct": rmr_metrics['rest_carb_percentage'] - } - - def compare(label, expected_val, actual_val, unit=""): - diff = actual_val - expected_val - pct_diff = (diff / expected_val * 100) if expected_val != 0 else 0 - status = "✓" if abs(pct_diff) < 5 else "✗" - print(f"{status} {label:30} Expected: {expected_val:6}{unit} Actual: {actual_val:6.0f}{unit} Diff: {diff:+6.0f} ({pct_diff:+.1f}%)") - - compare("RMR (Resting)", expected['rmr'], actual['rmr'], " kcal") - compare("NEAT (Activity)", expected['neat'], actual['neat'], " kcal") - compare("Weight Loss Deficit", expected['deficit'], actual['deficit'], " kcal") - compare("Total Daily Calories", expected['total'], actual['total'], " kcal") - compare("Fuel Source - Fats", expected['fat_pct'], actual['fat_pct'], "%") - compare("Fuel Source - Carbs", expected['carb_pct'], actual['carb_pct'], "%") - - # Overall assessment - rmr_match = abs(actual['rmr'] - expected['rmr']) / expected['rmr'] < 0.05 - neat_match = abs(actual['neat'] - expected['neat']) / expected['neat'] < 0.10 - total_match = abs(actual['total'] - expected['total']) / expected['total'] < 0.05 - - print("\n" + "=" * 80) - if rmr_match and neat_match and total_match: - print("✓ SUCCESS: Our formula produces values within 5-10% of the PDF!") - else: - print("✗ WARNING: Significant differences found. Check:") - if not rmr_match: - print(" - RMR calculation method (2-minute window selection)") - if not neat_match: - print(" - Activity level assumption (sedentary/light/moderate/active)") - if not total_match: - print(" - Weight loss deficit calculation") - print("=" * 80) - - except Exception as e: - print(f"\n✗ Error calculating metrics: {e}") - import traceback - traceback.print_exc() + } -if __name__ == "__main__": - main() +def assess_metabolic_health(measured_rmr, weight_kg, height_cm, age, sex): + """ + Calculates Predicted RMR (Mifflin-St Jeor) and compares to Measured RMR. + """ + # Mifflin-St Jeor Formula + if sex.lower() == 'male': + predicted_rmr = (10 * weight_kg) + (6.25 * height_cm) - (5 * age) + 5 + else: + predicted_rmr = (10 * weight_kg) + (6.25 * height_cm) - (5 * age) - 161 + + variance = ((measured_rmr - predicted_rmr) / predicted_rmr) * 100 + + # Interpretation + if variance > 10: + metabolism_type = "Fast" + elif variance < -10: + metabolism_type = "Slow" + else: + metabolism_type = "Normal" + + return { + "predicted_rmr_mifflin": int(round(predicted_rmr)), + "variance_percent": round(variance, 1), + "metabolism_type": metabolism_type + } + +def generate_nutrition_plan(measured_rmr, weight_kg, body_fat_percent, age, activity_level, weekly_weight_loss_goal_kg): + """ + Calculates TDEE, applies Deficit, and calculates Macros based on uploaded PDFs. + """ + # 1. TDEE (Maintenance Calories) + multiplier = ACTIVITY_MULTIPLIERS.get(activity_level, 1.2) + maintenance_calories = measured_rmr * multiplier + + # 2. Daily Calorie Target + daily_deficit = DEFICIT_TABLE.get(weekly_weight_loss_goal_kg, 0) + target_calories = maintenance_calories - daily_deficit + is_deficit = daily_deficit > 0 + + # 3. Protein Needs (Based on Lean Body Mass and age/deficit status) + lean_mass_kg = weight_kg * (1 - (body_fat_percent / 100)) + + protein_multiplier = 1.8 # default fallback + for (min_age, max_age), values in PROTEIN_GUIDELINES.items(): + if min_age <= age < max_age: + protein_multiplier = values['deficit'] if is_deficit else values['maintenance'] + break + + daily_protein_grams = lean_mass_kg * protein_multiplier + protein_calories = daily_protein_grams * 4 + + # 4. Remaining Macros (Fats and Carbs) + FAT_PERCENT_OF_TOTAL_CALORIES = 0.28 # Standard 25-30% fat allocation + + fat_calories = target_calories * FAT_PERCENT_OF_TOTAL_CALORIES + fat_grams = fat_calories / 9 + + carb_calories = target_calories - protein_calories - fat_calories + carb_grams = carb_calories / 4 + + if carb_calories < 0: + carb_calories = 0 + carb_grams = 0 + + return { + "tdee_maintenance": int(round(maintenance_calories)), + "daily_deficit": daily_deficit, + "target_calories": int(round(target_calories)), + "macros": { + "protein_g": int(round(daily_protein_grams)), + "fats_g": int(round(fat_grams)), + "carbs_g": int(round(carb_grams)) + }, + "caloric_breakdown": { + "protein_kcal": int(round(protein_calories)), + "fats_kcal": int(round(fat_calories)), + "carbs_kcal": int(round(carb_calories)) + } + } + +# --- EXECUTION EXAMPLE --- + +# 1. Run Analysis on the CSV +# Replace with your actual file path +csv_result = analyze_pnoe_data('/home/oluwasanmi/Documents/Work/MKD/report_generation/data/Pnoe_20250729_1550-Moran_Keirstyn.csv') + +# 2. Inputs for the Calculation (These would come from your UI/Form) +user_weight = 85.0 # kg +user_height = 180.0 # cm +user_age = 35 +user_sex = 'male' +user_body_fat = 20.0 # % +user_activity = 'Moderate' # From the PDF list +user_goal_loss = 0.5 # kg per week + +# 3. Assess Health +health_assessment = assess_metabolic_health( + measured_rmr=csv_result['measured_rmr'], + weight_kg=user_weight, + height_cm=user_height, + age=user_age, + sex=user_sex +) + +# 4. Get Nutrition Plan +nutrition_plan = generate_nutrition_plan( + measured_rmr=csv_result['measured_rmr'], + weight_kg=user_weight, + body_fat_percent=user_body_fat, + age=user_age, + activity_level=user_activity, + weekly_weight_loss_goal_kg=user_goal_loss +) + +# --- OUTPUT --- +print("--- METABOLIC REPORT ---") +print(f"Measured RMR: {csv_result['measured_rmr']} kcal/day") +print(f"Predicted RMR: {health_assessment['predicted_rmr_mifflin']} kcal/day") +print(f"Metabolism Status: {health_assessment['metabolism_type']} ({health_assessment['variance_percent']}%)") +print(f"Fuel Source: {csv_result['fuel_source']['fat_percent']}% Fat, {csv_result['fuel_source']['carb_percent']}% Carbs") +print("\n--- NUTRITION PLAN ---") +print(f"Goal: Lose {user_goal_loss} kg/week") +print(f"Daily Calorie Target: {nutrition_plan['target_calories']} kcal (Deficit: {nutrition_plan['daily_deficit']})") +print("\nDaily Macros:") +print(f"Protein: {nutrition_plan['macros']['protein_g']}g") +print(f"Fats: {nutrition_plan['macros']['fats_g']}g") +print(f"Carbs: {nutrition_plan['macros']['carbs_g']}g") \ No newline at end of file