preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%%\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import resample\n",
    "from scipy.interpolate import interp1d\n",
    "import xml.etree.ElementTree as ET\n",
    "import data_import as di #from pycoontrol ulitity functions\n",
    "import alignment_code as ac\n",
    "import pynapple as nap\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pre_or_post= \"post\"\n",
    "name = \"wt3\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Load the F.npy file\n",
    "fluorescence = np.load(fr'J:\\My Drive\\0-Main\\1_STRESS\\{name}\\{pre_or_post}\\F.npy')\n",
    "\n",
    "# Load the iscell.npy file\n",
    "iscell = np.load(fr'J:\\My Drive\\0-Main\\1_STRESS\\{name}\\{pre_or_post}\\iscell.npy')\n",
    "\n",
    "\n",
    "\n",
    "Fofiscell = fluorescence[iscell[:, 0] == 1, :]\n",
    "\n",
    "raw_filtered_fluorescence = Fofiscell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df3=ac.correct_align_and_add_orientations_folder(folder_path=fr\"J:\\My Drive\\0-Main\\1_STRESS\\{name}\\{pre_or_post}\", window_size=1, video_fps=20, method='percentile', stable_frames=300, step_size=10, sliding_size=5400, percentile_s=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df3.to_csv(fr'J:\\My Drive\\0-Main\\1_STRESS\\{name}\\{pre_or_post}\\dFF_{name}_{pre_or_post}.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import io\n",
    "\n",
    "st = np.load(fr'J:\\My Drive\\0-Main\\1_STRESS\\{name}\\{pre_or_post}\\stat.npy', allow_pickle=True)\n",
    "n_rois = st.shape[0]\n",
    "# Image size in pixels\n",
    "# What if motion correction changed the image size? \n",
    "height = 512\n",
    "width = 512\n",
    "spatial_footprints = np.zeros((n_rois, height, width))\n",
    "\n",
    "for i in range(n_rois):\n",
    "    spatial_footprints[i, st[i]['ypix'], st[i]['xpix']] = st[i]['lam']\n",
    "\n",
    "io.savemat(fr'J:\\My Drive\\0-Main\\1_STRESS\\{name}\\{pre_or_post}\\spatial_footprints.mat', {'array': spatial_footprints})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#trasnpose the raw_filtered_fluorescence\n",
    "raw_filtered_fluorescence = raw_filtered_fluorescence.T\n",
    "\n",
    "#conver to df\n",
    "raw = pd.DataFrame(raw_filtered_fluorescence)\n",
    "\n",
    "#plot the trace of the frist row in the np array raw_filtered_fluorescence\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#convert the column names that are digits from string to int, igore the column anmes that are not digits\n",
    "df3 = df3.rename(columns=lambda x: int(x) if x.isdigit() else x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Load the data\n",
    "data_path = r'G:/My Drive/0-Main/stress_p/pre/wt2/aligned_dff1.csv'\n",
    "data = pd.read_csv(data_path)\n",
    "\n",
    "# Setup variables\n",
    "pre = 2   # Pre-event time in seconds, assuming data sampled at 10 Hz\n",
    "post = 8  # Post-event time in seconds, assuming data sampled at 10 Hz\n",
    "degrees = [0, 45, 90, 135, 180, 225, 270, 315]  # Degree orientations\n",
    "neuron_columns = [str(i) for i in range(data.shape[1] - 9)]  # Assuming the last 9 columns are non-neuron data\n",
    "#vertical line at x = 0\n",
    "plt.axvline(x=0, color='k', linestyle='--')\n",
    "# Close any existing plots\n",
    "plt.close('all')\n",
    "\n",
    "for neuron in neuron_columns:\n",
    "    fig, axes = plt.subplots(2, 4, sharey=True, figsize=(16, 8))\n",
    "    max_mean_dFF = -float('inf')\n",
    "\n",
    "    for i, degree in enumerate(degrees):\n",
    "        degree_column = f'degrees_{degree}'\n",
    "        degree_indices = data[degree_column].to_numpy().nonzero()[0]  # Corrected to get indices where degree is marked\n",
    "        dFF_data = []\n",
    "\n",
    "        for index in degree_indices:\n",
    "            start_index = max(0, index - pre * 10)  # Adjust pre and post frames according to actual data rate\n",
    "            end_index = index + post * 10\n",
    "            dFF_deg = data[neuron][start_index:end_index]\n",
    "            if len(dFF_deg) > 0:  # Check if the slice is non-empty\n",
    "                dFF_data.append(dFF_deg.values)\n",
    "\n",
    "        # Only process if there is data to avoid errors\n",
    "        if dFF_data:\n",
    "            dFFnp = np.vstack(dFF_data)  # Stack list of Series for calculations\n",
    "            mean_dFF = np.mean(dFFnp, axis=0)\n",
    "            sem_dFF = np.std(dFFnp, axis=0) / np.sqrt(dFFnp.shape[0])\n",
    "            max_degree_value = np.max(mean_dFF)\n",
    "\n",
    "            # Update max mean delta F/F if this degree has a higher value\n",
    "            if max_degree_value > max_mean_dFF:\n",
    "                max_mean_dFF = max_degree_value\n",
    "\n",
    "            # Plotting\n",
    "            row = i // 4\n",
    "            col = i % 4\n",
    "            ax = axes[row, col]\n",
    "            time_axis = np.linspace(-pre, post, len(mean_dFF))\n",
    "            ax.plot(time_axis, mean_dFF, label=f'Mean of trials for Deg {degree}', linewidth=3.0)\n",
    "            ax.fill_between(time_axis, mean_dFF + sem_dFF, mean_dFF - sem_dFF, alpha=0.2)\n",
    "            ax.set_xlabel('Time (seconds)')\n",
    "            ax.set_title(f'Deg {degree} (Max: {max_degree_value:.2f})')\n",
    "\n",
    "    # Customize and show plot\n",
    "    axes[0, 0].set_ylabel('Delta F/F')\n",
    "    fig.suptitle(f'Neuron {neuron}')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df30 = df30.drop(156, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = pd.read_csv(\"aligned_dff.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = ac.fetch_stimuli_data(df30, 1, 10, exclude_stimuli=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "baseline = ac.fetch_stimuli_data(df30, 1, 0, exclude_stimuli=False, transpose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stimuli = ac.fetch_stimuli_data(df30, 0.5, 1, exclude_stimuli=False, transpose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_dff_response(ax, dff, window_start_time, window_end_time, aspect=\"auto\", vmin=None, vmax=None, yticklabels=[], skipticks=1, xlabel=\"Time (s)\", ylabel=\"ROI\", cbar=True, cbar_label=None):\n",
    "    if len(dff) == 0:\n",
    "        print(\"Input data has length 0; Nothing to display\")\n",
    "        return\n",
    "\n",
    "    img = ax.imshow(dff, aspect=aspect, extent=[window_start_time, window_end_time, 0, len(dff)], vmin=vmin, vmax=vmax)\n",
    "    if cbar:\n",
    "        fig.colorbar(img, shrink=0.5, label=cbar_label)\n",
    "\n",
    "    ax.plot([0,0],[0, len(dff)], \":\", color=\"white\", linewidth=1.0)\n",
    "\n",
    "    if len(yticklabels) != 0:\n",
    "        ax.set_yticks(range(len(yticklabels)))\n",
    "        ax.set_yticklabels(yticklabels, fontsize=8)\n",
    "\n",
    "        n_ticks = len(yticklabels[::skipticks])\n",
    "        ax.yaxis.set_major_locator(plt.MaxNLocator(n_ticks))\n",
    "\n",
    "    ax.set_xlabel(xlabel)\n",
    "    ax.set_ylabel(ylabel)\n",
    "\n",
    "\n",
    "# \n",
    "def show_many_responses(windows, rows, cols, window_idxs=None, title=None, subplot_title=\"\", xlabel=None, ylabel=None, cbar_label=None, vmin=0, vmax=100):\n",
    "    if window_idxs is None:\n",
    "        window_idxs = range(len(windows))\n",
    "    windows = windows[window_idxs]\n",
    "    \n",
    "    # handle case with no input data\n",
    "    if len(windows) == 0:\n",
    "        print(\"Input data has length 0; Nothing to display\")\n",
    "        return\n",
    "    # handle cases when there aren't enough windows for number of rows\n",
    "    if len(windows) < rows*cols:\n",
    "        rows = (len(windows) // cols) + 1\n",
    "\n",
    "    fig, axes = plt.subplots(rows, cols, figsize=(2*cols+2, 2*rows+2), layout=\"constrained\")\n",
    "    # handle case when there's only one row\n",
    "    if len(axes.shape) == 1:\n",
    "        axes = axes.reshape((1, axes.shape[0]))\n",
    "    \n",
    "    for i in range(rows*cols):\n",
    "        ax_row = int(i // cols)\n",
    "        ax_col = i % cols\n",
    "        ax = axes[ax_row][ax_col]\n",
    "        \n",
    "        if i > len(windows)-1:\n",
    "            ax.set_visible(False)\n",
    "            continue\n",
    "\n",
    "        window = windows[i]\n",
    "        show_dff_response(ax, window, window_start_time, window_end_time, xlabel=xlabel, ylabel=ylabel, cbar=False, vmin=vmin, vmax=vmax)\n",
    "        ax.set_title(f\"{subplot_title} {window_idxs[i]}\")\n",
    "        if ax_row != rows-1:\n",
    "            ax.get_xaxis().set_visible(False)\n",
    "        if ax_col != 0:\n",
    "            ax.get_yaxis().set_visible(False)\n",
    "\n",
    "    fig.suptitle(title)\n",
    "    norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)\n",
    "    colorbar = fig.colorbar(mpl.cm.ScalarMappable(norm=norm), ax=axes, shrink=1.5/rows, label=cbar_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assuming df_3[\"degrees_0\"] is your data\n",
    "data = df[\"degrees_180\"]\n",
    "data = stimuli[\"degrees_180\"]\n",
    "\n",
    "# Calculate the mean across trials (axis=0)\n",
    "mean_window = np.mean(data, axis=0)\n",
    "\n",
    "print(mean_window.shape)\n",
    "# Define the window start and end times\n",
    "# These should be adjusted based on your specific experiment\n",
    "window_start_time = 0\n",
    "window_end_time = mean_window.shape[1]  # assuming timepoints is the second dimension\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "show_dff_response(ax, mean_window, window_start_time, window_end_time, vmin=0, vmax=100, cbar_label=\"$\\Delta$F/F (%)\")\n",
    "ax.set_title(\"Mean Response Window\")\n",
    "ax.set_xlabel(\"time (s)\")\n",
    "ax.set_ylabel(\"ROI (neuron)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "#select the neurons from 20 to 50 the neurons are in the second dimension\n",
    "stimuli_0 = data[:, 75:, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#I want to plot the 5 trials of the (5, 275, 328) nparray stimuli_0 in 5 heatmps\n",
    "fig, axes = plt.subplots(1, 5, figsize=(20, 10))\n",
    "\n",
    "for i, ax in enumerate(axes):\n",
    "    show_dff_response(ax, stimuli_0[i], -0.5, 1, vmin=0, vmax=150, cbar_label=\"$\\Delta$F/F (%)\")\n",
    "    ax.set_title(f\"Trial {i}\")\n",
    "    ax.set_xlabel(\"Time (s)\")\n",
    "    ax.set_ylabel(\"ROI (neuron)\")\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import zscore\n",
    "\n",
    "roi_indices = []\n",
    "new_trials = []\n",
    "\n",
    "stimuli_all0 = stimuli[\"degrees_0\"]\n",
    "baseline_all0 = baseline[\"degrees_0\"]\n",
    "\n",
    "# Calculate the z-scores for the baseline\n",
    "baseline_z_scores = np.apply_along_axis(zscore, 2, baseline_all0, ddof=1)\n",
    "\n",
    "# Iterate over the ROIs and trials\n",
    "for roi in range(stimuli_all0.shape[1]):\n",
    "    for trial in range(stimuli_all0.shape[0]):\n",
    "        # Check if the maximum value in the stimuli is greater than 3 standard deviations\n",
    "        if np.max(stimuli_all0[trial, roi, :]) > 3 * np.std(baseline_z_scores[trial, roi, :]):\n",
    "            roi_indices.append(roi)\n",
    "            new_trials.append(stimuli_all0[trial, roi, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(roi_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stimuli_0[i].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#locomotion Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Assuming 'data' is your 5xNxM numpy array\n",
    "data = df_3[\"degrees_45\"]  # Replace this with your actual data\n",
    "\n",
    "# Select a specific ROI (e.g., the first one)\n",
    "roi_index = 120\n",
    "roi_data = data[0, roi_index, :]\n",
    "\n",
    "# Calculate the mean response across trials\n",
    "#mean_response = roi_data.mean(axis=0)\n",
    "\n",
    "# Plot the mean response\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(roi_data)\n",
    "plt.title('Mean Response of ROI {}'.format(roi_index))\n",
    "plt.xlabel('Timepoints')\n",
    "plt.ylabel('Response')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#i want to select a specific roi and plot the mean response of that roi\n",
    "\n",
    "# Assuming df_3[\"degrees_0\"] is your data\n",
    "data = df_3[\"degrees_0\"]\n",
    "\n",
    "# Calculate the mean across trials (axis=0)\n",
    "mean_window = np.mean(data, axis=0)\n",
    "\n",
    "print(mean_window.shape)\n",
    "# Define the window start and end times\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot the trace of a single trial\n",
    "plt.figure(figsize=(6, 2))\n",
    "plt.plot(df_3[\"degrees_0\"][2], linewidth=5)\n",
    "plt.xlabel(\"Time (s)\")\n",
    "plt.ylabel(\"Fluorescence\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_2[\"degrees_0\"].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(df_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(df_1[\"degrees_90\"][1].columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_0[\"degrees_45\"][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to perform operations on a DataFrame\n",
    "def perform_operations(df):\n",
    "    # Select columns for calculation\n",
    "    cols = [col for col in df.columns if col != 'Unnamed: 0']\n",
    "\n",
    "    # Calculate the sum for each row\n",
    "    df['row_sum'] = df[cols].apply(lambda row: row.sum(), axis=1)\n",
    "\n",
    "    # Calculate the mean for each row\n",
    "    df['row_mean'] = df[cols].apply(lambda row: row.mean(), axis=1)\n",
    "\n",
    "    # Calculate the median for each row\n",
    "    df['row_median'] = df[cols].apply(lambda row: row.median(), axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "# Save the dictionary to a pickle file\n",
    "with open('output.pkl', 'wb') as f:\n",
    "    pickle.dump(df_1, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(df_0[\"degrees_45\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(df_0[\"degrees_45\"])  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_1[\"degrees_45\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_list = [df.reset_index(drop=True) for df in df_1[\"degrees_45\"]]\n",
    "# Concatenate the DataFrames along the row axis\n",
    "\n",
    "concat_df = pd.concat(df_list)\n",
    "\n",
    "# Calculate the mean of each cell across all DataFrames\n",
    "mean_df = concat_df.mean(level=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot one of the columns in mean_df\n",
    "plt.plot(mean_df[\"9\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_0[\"degrees_180\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "end = len(df_0[\"degrees_45\"])  \n",
    "\n",
    "for i in range(end):\n",
    "    print(df_0[\"degrees_45\"][i].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(df_0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raster = ac.plot_raster_plotly(df30)\n",
    "#raster.write_html(folder_path+r\"\\Figures\\raster.html\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "heatmap = ac.plot_orientation_heatmap_plotly(df30, response_type='mean')\n",
    "heatmap.write_html(folder_path+r\"\\Figures\\heatmap.html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "heatmap = ac.plot_orientation_heatmap_plotly(df30, response_type='peak')\n",
    "heatmap.write_html(folder_path+r\"\\Figures\\heatmap_peak.html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "polar = ac.plotly_polar_tuning_curve_grid(df30)\n",
    "polar.write_html(folder_path+r\"\\Figures\\polar.html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import plotly.graph_objs as go\n",
    "from plotly.subplots import make_subplots\n",
    "import random\n",
    "\n",
    "def plot_neuron_stimulus_response_plotly_faceted(df, neuron_number=None):\n",
    "    \"\"\"\n",
    "    Plots the response of a specified or randomly selected neuron to various stimuli in the DataFrame,\n",
    "    in a facet grid layout, accurately marking the onset of the stimulus, using Plotly for interactive plots.\n",
    "\n",
    "    Parameters:\n",
    "    df (pandas.DataFrame): The DataFrame containing neuron activity and stimuli information.\n",
    "    neuron_number (int, optional): The number of the neuron to plot. If None, a neuron is randomly selected.\n",
    "    \"\"\"\n",
    "    # Identify the stimulus columns, ensuring column names are treated as strings\n",
    "    stimulus_columns = [col for col in df.columns if 'degrees_' in str(col)]\n",
    "\n",
    "    # Number of frames before and after the stimulus\n",
    "    frames_before = 30\n",
    "    frames_after = 90\n",
    "\n",
    "    # Selecting a neuron, ensuring column names are treated as strings\n",
    "    neuron_columns = [col for col in df.columns if str(col).isdigit()]\n",
    "    selected_neuron = neuron_number if neuron_number is not None else random.choice(neuron_columns)\n",
    "\n",
    "    # Creating a figure for the plots with subplots\n",
    "    rows = len(stimulus_columns)\n",
    "    fig = make_subplots(rows=rows, cols=1, subplot_titles=stimulus_columns)\n",
    "\n",
    "    # Plotting the tracing for each stimulus with accurate onset points\n",
    "    for i, stimulus in enumerate(stimulus_columns, start=1):\n",
    "        # Find indices where the stimulus was presented\n",
    "        stimulus_indices = df.index[df[stimulus] == 1].tolist()\n",
    "\n",
    "        # Identifying the start of each stimulus occurrence\n",
    "        starts = [stimulus_indices[0]]\n",
    "        for j in range(1, len(stimulus_indices)):\n",
    "            if stimulus_indices[j] - 1 != stimulus_indices[j - 1]:\n",
    "                starts.append(stimulus_indices[j])\n",
    "\n",
    "        # Randomly select one of the occurrences of the stimulus being presented\n",
    "        selected_start_index = random.choice(starts)\n",
    "\n",
    "        # Calculate the actual start and end points for plotting\n",
    "        plot_start = max(selected_start_index - frames_before, 0)\n",
    "        plot_end = min(selected_start_index + frames_after, len(df))\n",
    "        rows = df.loc[plot_start:plot_end, selected_neuron]\n",
    "\n",
    "        # Adjust the x-axis to align with the DataFrame's index\n",
    "        adjusted_onset_index = selected_start_index - plot_start\n",
    "\n",
    "        # Add trace for this neuron and stimulus in the appropriate subplot\n",
    "        fig.add_trace(go.Scatter(x=rows.index, y=rows, mode='lines', name=f'Stimulus: {stimulus}'), row=i, col=1)\n",
    "\n",
    "        # Marking the stimulus onset in the subplot\n",
    "        fig.add_shape(type='line', x0=rows.index[adjusted_onset_index], y0=min(rows), x1=rows.index[adjusted_onset_index], y1=max(rows),\n",
    "                      line=dict(color='Red', width=2, dash='dashdot'),\n",
    "                      row=i, col=1)\n",
    "\n",
    "    # Update layout\n",
    "    fig.update_layout(height=2000, width=800, title_text=f'Tracing of Neuron {selected_neuron} with Orientation Onset')\n",
    "    fig.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tracing30 = ac.plot_neuron_stimulus_response_plotly_faceted(df30, 5)\n",
    "tracing30.write_html(folder_path+r\"\\Figures\\tracing30.html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tracing15 = ac.plot_neuron_stimulus_response_plotly_faceted(df15, 5)\n",
    "tracing15.write_html(folder_path+r\"\\Figures\\tracing15.html\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "bg",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}