function varargout = Neural_Ensemble_Analysis(varargin)
% NEURAL_ENSEMBLE_ANALYSIS MATLAB code for Neural_Ensemble_Analysis.fig
% NEURAL_ENSEMBLE_ANALYSIS, by itself, creates a new NEURAL_ENSEMBLE_ANALYSIS
% or raises the existing singleton*.
%
% H = NEURAL_ENSEMBLE_ANALYSIS returns the handle to a new NEURAL_ENSEMBLE_ANALYSIS
% or the handle to the existing singleton*.
%
% NEURAL_ENSEMBLE_ANALYSIS('CALLBACK',hObject,eventData,handles,...) calls the local
% function namedAfter CALLBACK in NEURAL_ENSEMBLE_ANALYSIS.M with the given input arguments.
%
% NEURAL_ENSEMBLE_ANALYSIS('Property','Value',...) creates a new NEURAL_ENSEMBLE_ANALYSIS
% or raises the existing singleton*.
% Starting from the left, property value pairs are
% applied to the GUI before Neural_Ensemble_Analysis_OpeningFcn gets called. An
% unrecognized property name or invalid value makes property application
% stop. All inputs are passed to Neural_Ensemble_Analysis_OpeningFcn via varargin.
%
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
% instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES
% Edit the above text to modify the response to help Neural_Ensemble_Analysis
% Last Modified by GUIDE v2.5 14-Feb-2020 12:43:13
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @Neural_Ensemble_Analysis_OpeningFcn, ...
'gui_OutputFcn', @Neural_Ensemble_Analysis_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
end
function Neural_Ensemble_Analysis_OpeningFcn(hObject, eventdata, handles, varargin)
handles.output = hObject;
guidata(hObject, handles);
btnRefreshWorkspace_Callback(hObject, eventdata, handles);
end
function varargout = Neural_Ensemble_Analysis_OutputFcn(~, ~, handles)
varargout{1} = handles.output;
end
%% --- Functions ---
%% Read analysis variable
function Read_Analysis(handles,experiment)
% Raster
% samples per second
samples_per_second=experiment.Raster.SamplesPerSecond;
set(handles.txtSamplesPerSecond,'string',num2str(samples_per_second));
% Coactivity
% Smooth filter
set(handles.txtSmoothFilter,'string',num2str(experiment.Coactivity.SmoothFilter));
% Coactivity Threshold
set(handles.txtCoactivityThreshold,'string',num2str(...
experiment.Coactivity.CoactivityThreshold));
% Z-score
set(handles.chkZscore,'value',experiment.Coactivity.ZScore);
% Remove oscillations
set(handles.chkRemoveOscillations,'value',experiment.Coactivity.RemoveOscillations);
% Peaks
set(handles.chkJoin,'value',experiment.Peaks.Join);
set(handles.chkFixedWidth,'value',experiment.Peaks.FixedWidth);
set(handles.rdbSpikes,'value',experiment.Peaks.UseSpikes);
set(handles.rdbFrequencies,'value',~experiment.Peaks.UseSpikes);
set(handles.chkDividePeaks,'value',experiment.Peaks.DividePeaks);
set(handles.txtFixedWidth,'string',num2str(...
experiment.Peaks.FixedWidthWindow*1000/samples_per_second));
set(handles.txtDividePeaks,'string',num2str(...
experiment.Peaks.DivisionWindow*1000/samples_per_second));
set(handles.chkDetectPeaksOrValleys,'value',experiment.Peaks.DetectPeaksOrValleys)
if(experiment.Peaks.DetectPeaks)
set(handles.popPeaksValleys,'value',1);
elseif(experiment.Peaks.DetectValleys)
set(handles.popPeaksValleys,'value',2);
else
set(handles.popPeaksValleys,'value',3);
set(handles.popStimuli,'enable','on');
end
% Evaluate analysis computed to enable buttons
if(experiment.Peaks.DividePeaks)
set(handles.txtDividePeaks,'enable','on')
set(handles.btnPlotSequenceByPeak,'enable','on')
end
% Method for create vectors
set(handles.popNetworkMethod,'enable','off');
switch(experiment.Peaks.VectorMethod)
case 'sum'
num=1;
case 'binary'
num=2;
case 'average'
num=3;
case 'network'
num=4;
set(handles.popNetworkMethod,'enable','on');
otherwise
num=1;
end
set(handles.popVectorMethod,'Value',num);
% Method for create networks
switch(experiment.Peaks.NetworkMethod)
case 'coactivity'
num=1;
case 'jaccard'
num=2;
case 'pearson'
num=3;
otherwise
num=1;
end
set(handles.popNetworkMethod,'Value',num);
% Similarity method
switch(experiment.Clustering.SimilarityMethod)
case 'euclidean'
num=1;
case 'jaccard'
num=2;
case 'cosine'
num=3;
case 'correlation'
num=4;
case 'hamming'
num=5;
case 'seuclidean'
num=6;
case 'cityblock'
num=7;
case 'minkowski'
num=8;
case 'chebychev'
num=9;
case 'mahalanobis'
num=10;
case 'spearman'
num=11;
otherwise
num=1;
end
set(handles.popSimilarityMethod,'Value',num);
% Linkage method
switch(experiment.Clustering.LinkageMethod)
case 'ward'
num=1;
case 'centroid'
num=2;
case 'median'
num=3;
case 'single'
num=4;
case 'complete'
num=5;
case 'average'
num=6;
case 'weighted'
num=7;
otherwise
num=1;
end
set(handles.popLinkageMethod,'Value',num);
% Clustering
groups=experiment.Clustering.Groups;
set(handles.txtGroups,'string',num2str(groups));
if(isfield(experiment.Clustering,'GroupsToPlot'))
groups_to_plot_double = experiment.Clustering.GroupsToPlot;
groups_to_plot=[];
for i=1:length(groups_to_plot_double)
groups_to_plot=[groups_to_plot num2str(groups_to_plot_double(i)) ','];
end
else
groups_to_plot=[];
for i=1:(groups-1)
groups_to_plot=[groups_to_plot num2str(i) ','];
end
groups_to_plot=[groups_to_plot num2str(groups)];
end
set(handles.txtGroupsToPlot,'string',groups_to_plot);
% Plots
% Similarity method
try
switch(experiment.Plot.CurrentSorting)
case 'no sorting'
num=1;
case 'activity'
num=2;
case 'activation'
num=3;
case 'jaccard correlation'
num=4;
case 'linear correlation'
num=5;
otherwise
by_group = strsplit(experiment.Plot.CurrentSorting,' ');
group = str2num(by_group{2});
num = 5 + group;
end
catch
num = 1;
end
set(handles.popSortingNeurons,'Value',num);
% Evaluate analysis computed to enable buttons
set(handles.btnDunnTest,'enable','on')
set(handles.btnSaveBySeconds,'enable','on')
% Vectors
% Normalized Instant Frequencies
if(isfield(experiment.Raster,'Frequencies'))
set(handles.btnGetFrequencies,'ForeGroundColor',[0 0.5 0])
set(handles.btnPlotFrequencies,'enable','on')
set(handles.rdbFrequencies,'enable','on')
end
if(experiment.Peaks.DetectPeaksOrValleys)
% Enable
set(handles.popPeaksValleys,'enable','on')
set(handles.txtCoactivityThreshold,'enable','on')
set(handles.btnShuffleTest,'enable','on')
set(handles.chkFixedWidth,'enable','on')
if(get(handles.chkFixedWidth,'value'))
set(handles.txtFixedWidth,'enable','on')
end
else
% Disable
set(handles.popPeaksValleys,'enable','off')
set(handles.txtCoactivityThreshold,'enable','off')
set(handles.btnShuffleTest,'enable','off')
set(handles.chkFixedWidth,'enable','off')
% Set values
set(handles.chkFixedWidth,'value',true)
end
% Coactivity
if(isfield(experiment.Coactivity,'Coactivity'))
set(handles.btnGetCoactivity,'ForeGroundColor',[0 0.5 0])
set(handles.btnPlotCoactivity,'enable','on')
set(handles.btnGetVectors,'enable','on')
set(handles.popSortingNeurons,'string',{'no sorting','activity','activation',...
'jaccard correlation','linear correlation'})
end
% Peaks
if(isfield(experiment.Peaks,'Vectors'))
set(handles.btnGetVectors,'ForeGroundColor',[0 0.5 0])
set(handles.btnGetSimilarity,'enable','on')
if(experiment.Peaks.DetectStimuli)
set(handles.btnGetNetworksByStimuli,'enable','on')
end
end
% Similarity
if(isfield(experiment.Clustering,'Similarity'))
set(handles.btnGetSimilarity,'ForeGroundColor',[0 0.5 0])
set(handles.btnPlotSimilarity,'enable','on')
set(handles.btnGetClusters,'enable','on')
set(handles.btnDunnTest,'enable','on')
end
% Clustering
if(isfield(experiment.Clustering,'GroupIndices'))
set(handles.btnGetClusters,'ForeGroundColor',[0 0.5 0])
set(handles.btnPlotPeaks,'enable','on')
set(handles.btnPlotRasterPeaks,'enable','on')
set(handles.btnPlotSequence,'enable','on')
set(handles.btnEnsembleLength,'enable','on')
set(handles.btnGetNetworks,'enable','on')
% Enable options on sorting raster/frequencies
labels={'no sorting','activity','activation','jaccard correlation',...
'linear correlation'};
for i=1:groups
labels{end+1}=['group ' num2str(i)];
end
set(handles.popSortingNeurons,'string',labels);
if(get(handles.popNetworkMethod,'value'))
set(handles.btnGetNetworks,'enable','on')
end
end
% Network
if(isfield(experiment,'Network'))
if(isfield(experiment.Network,'Network'))
set(handles.btnGetNetworks,'ForeGroundColor',[0 0.5 0])
set(handles.btnPlotNetworks,'enable','on')
set(handles.btnPlotStructure,'enable','on')
% Set structure sorting
labels = get(handles.popSortingNeurons,'string');
labels{end+1} = 'structure';
set(handles.popSortingNeurons,'string',labels);
end
if(isfield(experiment.Network,'Stimulus'))
set(handles.btnGetNetworksByStimuli,'ForeGroundColor',[0 0.5 0])
set(handles.btnPlotStimulusNetworks,'enable','on')
end
if(isfield(experiment.Network,'WholeNetwork'))
set(handles.btnGetNetworkRaster,'ForeGroundColor',[0 0.5 0])
set(handles.btnPlotWholeNetwork,'enable','on')
end
end
end
%% Read experiment
function experiment=Read_Experiment(handles)
data_num=get(handles.popWorkspace,'Value');
data_strings=get(handles.popWorkspace,'String');
name=data_strings{data_num};
if evalin('base',['exist(''' name '_analysis'')'])
experiment=evalin('base',[name '_analysis']);
else
experiment=[];
end
end
%% Write experiment data
function Write_Experiment(handles,experiment)
data_num=get(handles.popWorkspace,'Value');
data_strings=get(handles.popWorkspace,'String');
name=data_strings{data_num};
assignin('base',[name '_analysis'],experiment);
end
%% Refresh workspace data
function btnRefreshWorkspace_Callback(~, ~, handles)
data_strings = evalin('base','who');
set(handles.popWorkspace,'String',[{'select raster'};data_strings])
set(handles.popWorkspace,'Value',1)
set(handles.popStimuli,'String',[{'select source'};{'relevant coactivity'};data_strings])
set(handles.popStimuli,'Value',1)
set(handles.lblRaster,'String','...')
set(handles.lblRaster,'ForegroundColor','black')
Disable_Buttons(handles,'Raster')
end
%% User number entry control
function user_entry = User_Number_Entry(hObject,default,minimum,maximum,multiple,negative)
if(nargin==4)
multiple=false;
negative=false;
elseif(nargin==5)
negative=false;
end
user_entry = str2double(get(hObject,'string'));
neg=false;
% verify if the data is a number m?ltiplo
if ~isnan(user_entry)
user_entry=floor(user_entry);
if(user_entry<0)
neg=true;
user_entry=-user_entry;
end
% verify if the data is between the limits
if(user_entry>maximum)
user_entry=maximum;
elseif(user_entry<minimum)
user_entry=minimum;
end
else
user_entry=default;
end
if(multiple)
times=round(user_entry/minimum);
user_entry=minimum*times;
end
if(negative && neg)
user_entry=-user_entry;
end
set(hObject,'string',num2str(user_entry));
end
%% User number double entry control (one decimal point)
function user_entry = User_Double_Entry(hObject,default,minimum,maximum)
user_entry = str2double(get(hObject,'string'));
if ~isnan(user_entry)
user_entry=floor(user_entry*10)/10;
if(user_entry>maximum)
user_entry=maximum;
elseif(user_entry<minimum)
user_entry=minimum;
end
else
user_entry=default;
end
set(hObject,'string',num2str(user_entry));
end
%% User number double entry control (one decimal point)
function user_entry = User_Double_Entry_2(hObject,default,minimum,maximum)
user_entry = str2double(get(hObject,'string'));
if ~isnan(user_entry)
user_entry=floor(user_entry*100)/100;
if(user_entry>maximum)
user_entry=maximum;
elseif(user_entry<minimum)
user_entry=minimum;
end
else
user_entry=default;
end
set(hObject,'string',num2str(user_entry));
end
%% Set current GUI parameters
function experiment = Set_Current_Parameters(handles, experiment)
% Samples per second
samples_per_second = str2double(get(handles.txtSamplesPerSecond,'string'));
samples_per_minute = 60*samples_per_second;
% Coactivity
% Smooth filter
smooth_filter = str2double(get(handles.txtSmoothFilter,'string'));
smooth_window=smooth_filter*samples_per_second/1000;
% Z-score
z_score= get(handles.chkZscore,'value');
zscore_window=0;
only_mean=false;
% Remove oscillations
remove_oscillations= get(handles.chkRemoveOscillations,'value');
% Peaks
detect_peaks_or_valleys=get(handles.chkDetectPeaksOrValleys,'value');
detect_peaks=get(handles.popPeaksValleys,'value')==1;
if(detect_peaks_or_valleys)
coactivity_threshold = str2double(get(handles.txtCoactivityThreshold,'string'));
else
coactivity_threshold = [];
end
join=get(handles.chkJoin,'value');
fixed_width=get(handles.chkFixedWidth,'value');
use_spikes=get(handles.rdbSpikes,'value');
divide_peaks=get(handles.chkDividePeaks,'value');
fixed_width_window=str2num(get(handles.txtFixedWidth,'string'))...
*samples_per_second/1000;
division_window=str2num(get(handles.txtDividePeaks,'string'))...
*samples_per_second/1000;
% Method for create vectors
data_num=get(handles.popVectorMethod,'Value');
data_strings=get(handles.popVectorMethod,'String');
vector_method=data_strings{data_num};
% Method for create networks
data_num=get(handles.popNetworkMethod,'Value');
data_strings=get(handles.popNetworkMethod,'String');
network_method=data_strings{data_num};
% Similarity method
data_num=get(handles.popSimilarityMethod,'Value');
data_strings=get(handles.popSimilarityMethod,'String');
similarity_method=data_strings{data_num};
% Linkage method
data_num=get(handles.popLinkageMethod,'Value');
data_strings=get(handles.popLinkageMethod,'String');
linkage_method=data_strings{data_num};
% Clustering
groups=str2double(get(handles.txtGroups,'string'));
groups_to_plot=1:groups;
% Write experiment
experiment.Raster.SamplesPerSecond=samples_per_second;
experiment.Raster.SamplesPerMinute=samples_per_minute;
experiment.Coactivity.SmoothFilter=smooth_filter;
experiment.Coactivity.SmoothWindow=smooth_window;
experiment.Coactivity.CoactivityThreshold=coactivity_threshold;
experiment.Coactivity.ZScore=z_score;
experiment.Coactivity.RemoveOscillations=remove_oscillations;
experiment.Coactivity.ZScoreWindow=zscore_window;
experiment.Coactivity.ZScoreOnlyMean=only_mean;
experiment.Peaks.DetectPeaksOrValleys=detect_peaks_or_valleys;
experiment.Peaks.DetectPeaks=detect_peaks;
experiment.Peaks.DetectValleys=~detect_peaks;
experiment.Peaks.FixedWidth=fixed_width;
experiment.Peaks.FixedWidthWindow=fixed_width_window;
experiment.Peaks.DivisionWindow=division_window;
experiment.Peaks.Join=join;
experiment.Peaks.UseSpikes=use_spikes;
experiment.Peaks.DividePeaks=divide_peaks;
experiment.Peaks.VectorMethod=vector_method;
experiment.Peaks.NetworkMethod=network_method;
experiment.Clustering.SimilarityMethod=similarity_method;
experiment.Clustering.LinkageMethod=linkage_method;
experiment.Clustering.Groups=groups;
experiment.Clustering.GroupsToPlot=groups_to_plot;
end
%% Disable buttons
function Disable_Buttons(handles,from)
switch(from)
case 'Raster'
% Raster
set(handles.btnGetFrequencies,'enable','off')
set(handles.btnGetFrequencies,'ForeGroundColor','black')
set(handles.btnPlotRaster,'enable','off')
set(handles.btnPlotFrequencies,'enable','off')
set(handles.btnPlotFrequencies,'ForeGroundColor','black')
set(handles.txtSamplesPerSecond,'enable','off')
set(handles.btnSaveBySeconds,'enable','off')
% Coactivity
set(handles.btnGetCoactivity,'enable','off')
set(handles.btnGetCoactivity,'ForeGroundColor','black')
set(handles.btnPlotCoactivity,'enable','off')
set(handles.txtSmoothFilter,'enable','off')
set(handles.chkZscore,'enable','off')
set(handles.chkRemoveOscillations,'enable','off')
set(handles.popSortingNeurons,'value',1)
set(handles.popSortingNeurons,'string',{'no sorting','activity','activation'})
% Peaks
set(handles.chkDetectPeaksOrValleys,'enable','off')
set(handles.popPeaksValleys,'enable','off')
set(handles.popStimuli,'enable','off')
set(handles.txtCoactivityThreshold,'enable','off')
set(handles.btnShuffleTest,'enable','off')
set(handles.btnShuffleTest,'ForeGroundColor','black')
set(handles.rdbSpikes,'enable','off')
set(handles.rdbFrequencies,'enable','off')
set(handles.rdbSpikes,'value',true)
set(handles.rdbFrequencies,'value',false)
set(handles.chkFixedWidth,'enable','off')
set(handles.txtFixedWidth,'enable','off')
set(handles.chkJoin,'enable','off')
set(handles.chkDividePeaks,'enable','off')
set(handles.txtDividePeaks,'enable','off')
set(handles.popVectorMethod,'enable','off')
set(handles.popNetworkMethod,'enable','off')
set(handles.btnGetVectors,'enable','off')
set(handles.btnGetVectors,'ForeGroundColor','black')
% Similarity
set(handles.btnGetSimilarity,'enable','off')
set(handles.btnGetSimilarity,'ForeGroundColor','black')
set(handles.btnPlotSimilarity,'enable','off')
set(handles.popSimilarityMethod,'enable','off')
set(handles.popLinkageMethod,'enable','off')
% Clustering
set(handles.btnGetClusters,'enable','off')
set(handles.btnGetClusters,'ForeGroundColor','black')
set(handles.txtGroups,'enable','off')
set(handles.txtGroupsToPlot,'enable','off')
set(handles.btnPlotPeaks,'enable','off')
set(handles.btnPlotRasterPeaks,'enable','off')
set(handles.btnPlotSequence,'enable','off')
set(handles.btnEnsembleLength,'enable','off')
set(handles.btnPlotSequenceByPeak,'enable','off')
% Network
set(handles.btnGetNetworkRaster,'enable','off')
set(handles.btnPlotWholeNetwork,'enable','off')
set(handles.btnGetNetworks,'enable','off')
set(handles.btnGetNetworksByStimuli,'enable','off')
set(handles.btnGetNetworks,'ForeGroundColor','black')
set(handles.btnPlotNetworks,'enable','off')
set(handles.btnPlotStructure,'ForeGroundColor','black')
set(handles.btnPlotStructure,'enable','off')
set(handles.btnPlotStimulusNetworks,'enable','off')
case 'Peaks'
% Peaks
set(handles.btnGetVectors,'enable','off')
set(handles.btnGetVectors,'ForeGroundColor','black')
% Similarity
set(handles.btnGetSimilarity,'enable','off')
set(handles.btnGetSimilarity,'ForeGroundColor','black')
set(handles.btnPlotSimilarity,'enable','off')
% Clustering
set(handles.btnGetClusters,'enable','off')
set(handles.btnGetClusters,'ForeGroundColor','black')
set(handles.btnPlotPeaks,'enable','off')
set(handles.btnPlotRasterPeaks,'enable','off')
set(handles.btnPlotSequence,'enable','off')
set(handles.btnEnsembleLength,'enable','off')
set(handles.btnGetNetworks,'enable','off')
% Network
set(handles.btnGetNetworks,'enable','off')
set(handles.btnGetNetworks,'ForeGroundColor','black')
set(handles.btnGetNetworksByStimuli,'enable','off')
set(handles.btnGetNetworksByStimuli,'ForeGroundColor','black')
set(handles.btnPlotNetworks,'enable','off')
set(handles.btnPlotStimulusNetworks,'enable','off')
set(handles.btnPlotStructure,'ForeGroundColor','black')
set(handles.btnPlotStructure,'enable','off')
case 'Similarity'
% Similarity
set(handles.btnGetSimilarity,'enable','off')
set(handles.btnGetSimilarity,'ForeGroundColor','black')
set(handles.btnPlotSimilarity,'enable','off')
% Clustering
set(handles.btnGetClusters,'enable','off')
set(handles.btnGetClusters,'ForeGroundColor','black')
set(handles.btnPlotPeaks,'enable','off')
set(handles.btnPlotRasterPeaks,'enable','off')
set(handles.btnPlotSequence,'enable','off')
set(handles.btnEnsembleLength,'enable','off')
set(handles.btnGetNetworks,'enable','off')
% Network
set(handles.btnGetNetworks,'enable','off')
set(handles.btnGetNetworks,'ForeGroundColor','black')
set(handles.btnGetNetworksByStimuli,'enable','off')
set(handles.btnGetNetworksByStimuli,'ForeGroundColor','black')
set(handles.btnPlotNetworks,'enable','off')
set(handles.btnPlotStimulusNetworks,'enable','off')
set(handles.btnPlotStructure,'ForeGroundColor','black')
set(handles.btnPlotStructure,'enable','off')
case 'Clustering'
% Clustering
set(handles.btnGetClusters,'enable','off')
set(handles.btnGetClusters,'ForeGroundColor','black')
set(handles.btnPlotPeaks,'enable','off')
set(handles.btnPlotRasterPeaks,'enable','off')
set(handles.btnPlotSequence,'enable','off')
set(handles.btnEnsembleLength,'enable','off')
set(handles.btnGetNetworks,'enable','off')
% Network
set(handles.btnGetNetworks,'enable','off')
set(handles.btnGetNetworks,'ForeGroundColor','black')
set(handles.btnPlotNetworks,'enable','off')
set(handles.btnPlotStimulusNetworks,'enable','off')
set(handles.btnPlotStructure,'ForeGroundColor','black')
set(handles.btnPlotStructure,'enable','off')
case 'Network'
% Network
set(handles.btnGetNetworks,'enable','off')
set(handles.btnGetNetworks,'ForeGroundColor','black')
set(handles.btnPlotNetworks,'enable','off')
set(handles.btnPlotStimulusNetworks,'enable','off')
set(handles.btnPlotStructure,'ForeGroundColor','black')
set(handles.btnPlotStructure,'enable','off')
end
end
%% Enable buttons
function Enable_Buttons(handles,next)
switch(next)
case 'Raster'
% Raster
set(handles.btnGetFrequencies,'enable','on')
set(handles.btnGetFrequencies,'ForeGroundColor','black')
set(handles.btnPlotRaster,'enable','on')
set(handles.btnPlotRaster,'ForeGroundColor','black')
set(handles.txtSamplesPerSecond,'enable','on')
set(handles.popSortingNeurons,'enable','on')
% Coactivity
set(handles.btnGetCoactivity,'enable','on')
set(handles.btnGetCoactivity,'ForeGroundColor','black')
set(handles.txtSmoothFilter,'enable','on')
set(handles.chkZscore,'enable','on')
set(handles.chkRemoveOscillations,'enable','on')
% Peaks
set(handles.chkDetectPeaksOrValleys,'enable','on')
if(get(handles.chkDetectPeaksOrValleys,'value'))
set(handles.popPeaksValleys,'enable','on')
set(handles.txtCoactivityThreshold,'enable','on')
set(handles.btnShuffleTest,'enable','on')
set(handles.btnShuffleTest,'ForeGroundColor','black')
set(handles.chkFixedWidth,'enable','on')
if(get(handles.popPeaksValleys,'value')==3)
set(handles.popStimuli,'enable','on')
end
else
set(handles.chkFixedWidth,'value',true)
end
set(handles.rdbSpikes,'enable','on')
if(get(handles.chkFixedWidth,'value'))
set(handles.txtFixedWidth,'enable','on')
end
set(handles.chkJoin,'enable','on')
if(get(handles.chkJoin,'value'))
set(handles.chkDividePeaks,'enable','on')
if(get(handles.chkDividePeaks,'value'))
set(handles.txtDividePeaks,'enable','on')
end
end
set(handles.popVectorMethod,'enable','on')
if(get(handles.popVectorMethod,'value')==4)
set(handles.popNetworkMethod,'enable','on')
end
set(handles.btnSaveBySeconds,'enable','on')
% Similarity
set(handles.popSimilarityMethod,'enable','on')
set(handles.popLinkageMethod,'enable','on')
% Groups
set(handles.txtGroups,'enable','on')
set(handles.txtGroupsToPlot,'enable','on')
% Network
set(handles.btnGetNetworkRaster,'enable','on')
set(handles.btnGetNetworkRaster,'ForeGroundColor','black')
case 'Frequencies'
set(handles.btnPlotFrequencies,'enable','on')
set(handles.rdbFrequencies,'enable','on')
case 'Peaks'
set(handles.btnPlotCoactivity,'enable','on')
set(handles.btnGetVectors,'enable','on')
set(handles.btnGetVectors,'ForeGroundColor','black')
case 'Similarity'
set(handles.btnGetSimilarity,'enable','on')
set(handles.btnGetSimilarity,'ForeGroundColor','black')
case 'Clustering'
set(handles.btnPlotSimilarity,'enable','on')
set(handles.btnGetClusters,'enable','on')
set(handles.btnGetClusters,'ForeGroundColor','black')
set(handles.btnDunnTest,'enable','on')
case 'Network'
set(handles.btnGetNetworks,'enable','on')
set(handles.btnGetNetworks,'ForeGroundColor','black')
case 'PlotNetwork'
set(handles.btnPlotNetworks,'enable','on')
set(handles.btnGetNetworks,'ForeGroundColor','black')
set(handles.btnPlotStructure,'enable','on')
set(handles.btnPlotStructure,'ForeGroundColor','black')
case 'PlotNetworkByStimulus'
set(handles.btnPlotStimulusNetworks,'enable','on')
set(handles.btnPlotStimulusNetworks,'ForeGroundColor','black')
case 'PlotStates'
set(handles.btnPlotPeaks,'enable','on')
set(handles.btnPlotRasterPeaks,'enable','on')
set(handles.btnPlotSequence,'enable','on')
set(handles.btnEnsembleLength,'enable','on')
if(get(handles.popVectorMethod,'value')==4)
set(handles.btnGetNetworks,'enable','on')
end
end
end
%% --- Analysis ---
%% Get frequencies
function btnGetFrequencies_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
tic
% Read experiment
experiment=Read_Experiment(handles);
raster=experiment.Raster.Raster;
samples_per_second=experiment.Raster.SamplesPerSecond;
% Get frequencies
%frequencies = Get_Normalized_Instant_Freq(raster,samples_per_second,'zscore');
bin=200*samples_per_second/1000;step=20*samples_per_second/1000;
frequencies = Get_Zscore_From_Raster(raster,bin,step);
set(handles.btnPlotFrequencies,'enable','on')
% Write experiment
experiment.Raster.Frequencies=frequencies;
Write_Experiment(handles,experiment);
% Enable buttons
Enable_Buttons(handles,'Frequencies')
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
time=toc; disp(['Done in ' num2str(time) ' s.'])
end
%% Shuffle test
function btnShuffleTest_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
prompt = {'Enter number of iterations:','Enter significance level',...
'Enter shuffle type (1=Time shift; 2=Frames; 3=Time; 4=ISI; 5=Cell; 6=Exchange)',...
'Interval (0=[0-maximum value of coactivity];1=[0-number of cells]'};
title = 'Enter parameters';
dims = [1 50; 1 50; 1 50; 1 50];
default_input = {'10','0.01','1','0'};
answer = inputdlg(prompt,title,dims,default_input);
if(~isempty(answer))
iterations=str2num(answer{1});
if(isempty(iterations))
iterations=10;
elseif(iterations<2)
iterations=2;
end
alpha=str2num(answer{2});
if(isempty(alpha))
alpha=0.05;
elseif(alpha>1 && alpha<0)
alpha=0.05;
end
shuffle_method=str2num(answer{3});
if(isempty(shuffle_method))
shuffle_method=1;
end
switch(shuffle_method)
case 1
shuffle_method='time_shift';
case 2
shuffle_method='frames';
case 3
shuffle_method='time';
case 4
shuffle_method='isi';
case 5
shuffle_method='cell';
case 6
shuffle_method='exchange';
otherwise
shuffle_method='time_shift';
end
interval_by_cell=str2num(answer{4});
if(isempty(interval_by_cell))
interval_by_cell=1;
end
% Read experiment
experiment=Read_Experiment(handles);
raster=experiment.Raster.Raster;
name=experiment.Raster.Name;
smooth_window=experiment.Coactivity.SmoothWindow;
z_score=experiment.Coactivity.ZScore;
zscore_window=experiment.Coactivity.ZScoreWindow;
only_mean=experiment.Coactivity.ZScoreOnlyMean;
remove_oscillations=experiment.Coactivity.RemoveOscillations;
% Process
plot=false;
coactivity_threshold_shuffeld_test = Shuffle_Test(raster,smooth_window,...
iterations,shuffle_method,alpha,interval_by_cell,remove_oscillations,...
z_score,only_mean,zscore_window,plot);
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Shuffle test (' shuffle_method ') - ' name]);
end
% Write experiment
experiment.Coactivity.ShuffleMethod=shuffle_method;
experiment.Coactivity.CoactivityThresholdShuffleTest=...
coactivity_threshold_shuffeld_test;
experiment.Coactivity.AlphaShuffleTest=alpha;
Write_Experiment(handles,experiment);
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Get coactivity
function btnGetCoactivity_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
tic
% Read experiment
experiment=Read_Experiment(handles);
raster=experiment.Raster.Raster;
smooth_window=experiment.Coactivity.SmoothWindow;
z_score=experiment.Coactivity.ZScore;
zscore_window=experiment.Coactivity.ZScoreWindow;
only_mean=experiment.Coactivity.ZScoreOnlyMean;
remove_oscillations=experiment.Coactivity.RemoveOscillations;
% Get coactivity
coactivity = Get_And_Filter_Coactivity(raster,smooth_window);
% Remove Oscillations
if(remove_oscillations)
percentage = 0.1;
[coactivity,removed]= Remove_Oscillations(coactivity,percentage);
experiment.Coactivity.CoactivityRemoved=removed;
end
% Z-score
if(z_score)
coactivity=Z_Score_Coactivity(coactivity,zscore_window,only_mean);
end
% Write experiment
experiment.Coactivity.Coactivity=coactivity;
experiment.Plot.Correlation = [];
experiment.Plot.JaccardCorrelation = [];
experiment.Plot.CorrelationState = [];
Write_Experiment(handles,experiment);
% Refresh coactivity threshold
txtCoactivityThreshold_Callback(handles.txtCoactivityThreshold,[],handles);
% Enable options on sorting raster/frequencies
set(handles.popSortingNeurons,'string',{'no sorting','activity','activation',...
'jaccard correlation','linear correlation'})
set(handles.popSortingNeurons,'value',1)
% Disable/Enable buttons
Disable_Buttons(handles,'Peaks')
Enable_Buttons(handles,'Peaks')
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
time=toc; disp(['Done in ' num2str(time) ' s.'])
end
%% Get neural vectors
function btnGetVectors_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
tic
% Read experiment
experiment=Read_Experiment(handles);
coactivity=experiment.Coactivity.Coactivity;
coactivity_threshold=experiment.Coactivity.CoactivityThreshold;
vector_method=experiment.Peaks.VectorMethod;
network_method=experiment.Peaks.NetworkMethod;
fixed_width=experiment.Peaks.FixedWidth;
join=experiment.Peaks.Join;
divide_peaks=experiment.Peaks.DividePeaks;
use_spikes=experiment.Peaks.UseSpikes;
fixed_width_window=experiment.Peaks.FixedWidthWindow;
division_window=experiment.Peaks.DivisionWindow;
samples_per_second=experiment.Raster.SamplesPerSecond;
detect_peaks_or_valleys=experiment.Peaks.DetectPeaksOrValleys;
if join
% Ask for minimum
prompt = {['Enter the minimum time width in ms to consider peak'...
' (0 = without restriction):']};
title = 'Enter parameters';
dims = [1 50];
default_input = {'0'};
answer = inputdlg(prompt,title,dims,default_input);
if(~isempty(answer))
minimum_width = str2num(answer{1})/1000*samples_per_second;
if(isempty(minimum_width))
minimum_width = 0;
elseif(minimum_width<1)
minimum_width = 0;
end
else
minimum_width = 0;
end
else
minimum_width = 0;
end
if use_spikes
data = experiment.Raster.Raster;
else
data = experiment.Raster.Frequencies;
end
if fixed_width
width = fixed_width_window;
else
width = 0;
end
if detect_peaks_or_valleys
ignore_ini_fin = false;
if get(handles.popPeaksValleys,'value')==3
external = experiment.Peaks.External;
detect_peaks = true;
[vector_indices,vector_widths,vector_amplitudes,vector_ini_fin] = ...
Find_Peaks_Or_Valleys(external,coactivity_threshold,join,detect_peaks,...
minimum_width,width,ignore_ini_fin);
experiment.Peaks.DetectPeaks = false;
experiment.Peaks.DetectValleys = false;
experiment.Peaks.DetectStimuli = true;
else
% Find peaks indexes
detect_peaks = get(handles.popPeaksValleys,'value')==1;
[vector_indices,vector_widths,vector_amplitudes,vector_ini_fin] = ...
Find_Peaks_Or_Valleys(coactivity,coactivity_threshold,join,detect_peaks,...
minimum_width,width,ignore_ini_fin);
experiment.Peaks.DetectPeaks = detect_peaks;
experiment.Peaks.DetectValleys = ~detect_peaks;
experiment.Peaks.DetectStimuli = false;
end
% Write experiment
experiment.Peaks.Widths = vector_widths;
experiment.Peaks.Amplitudes = vector_amplitudes;
experiment.Peaks.IniFin = vector_ini_fin;
else
% Create vector indices
samples=experiment.Raster.Samples;
n=ceil(samples/width);
vector_indices=zeros(samples,1);
for i=1:n
ini=(i-1)*width+1;
fin=i*width;
if(fin>samples)
fin=samples;
end
vector_indices(ini:fin)=i;
end
% Write experiment
experiment.Peaks.DetectPeaks = false;
experiment.Peaks.DetectValleys = false;
experiment.Peaks.DetectStimuli = false;
end
if divide_peaks
vector_indices = Divide_Peaks(vector_indices, division_window);
end
if max(vector_indices)>0
% Create a matrix with all vector peaks
bin_network = 5; % bin_network = 25;
vectors=Get_Peak_Vectors(data,vector_indices,vector_method,network_method,bin_network);
count=size(vectors,1);
% Create raster with only peaks
raster_peaks = data(:,vector_indices>0);
raster_no_peaks = data(:,~vector_indices);
% Write experiment
experiment.Peaks.Indices=vector_indices;
experiment.Peaks.Vectors=vectors;
experiment.Peaks.Count=count;
experiment.Peaks.RasterPeaks=raster_peaks;
experiment.Peaks.RasterNoPeaks=raster_no_peaks;
Write_Experiment(handles,experiment);
% Disable/Enable buttons
Disable_Buttons(handles,'Similarity')
Enable_Buttons(handles,'Similarity')
if(get(handles.popPeaksValleys,'value')==3)
set(handles.btnGetNetworksByStimuli,'enable','on')
else
set(handles.btnGetNetworksByStimuli,'enable','off')
end
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
else
warning('No vectors created')
% Color red
set(hObject,'ForeGroundColor',[0.5 0 0])
end
time=toc; disp(['Done in ' num2str(time) ' s.'])
end
%% Get similarity
function btnGetSimilarity_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
tic
% Read experiment
experiment = Read_Experiment(handles);
vectors = experiment.Peaks.Vectors;
similarityMethod = experiment.Clustering.SimilarityMethod;
linkageMethod = experiment.Clustering.LinkageMethod;
% Get similarity
similarity = Get_Peaks_Similarity(vectors,similarityMethod);
if ~isempty(similarity)
tree = linkage(squareform(1-similarity,'tovector'),linkageMethod);
%tree = linkage(vectors,linkageMethod,similarityMethod);
else
tree = [];
end
% Write experiment
experiment.Clustering.Similarity = similarity;
experiment.Clustering.Tree = tree;
Write_Experiment(handles,experiment);
% Enable buttons
Enable_Buttons(handles,'Clustering')
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
time=toc; disp(['Done in ' num2str(time) ' s.'])
end
%% Groups test
function btnDunnTest_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
prompt = {'Enter test type (1=Contrast; 2=Dunn; 3=Davies)'};
title = 'Enter parameters';
dims = [1 50];
default_input = {'1'};
answer = inputdlg(prompt,title,dims,default_input);
if(~isempty(answer))
test_method=str2num(answer{1});
if(isempty(test_method))
test_method=1;
end
switch(test_method)
case 1
test_method='contrast';
case 2
test_method='dunn';
case 3
test_method='davies';
otherwise
test_method='contrast';
end
% Read experiment
experiment=Read_Experiment(handles);
name=experiment.Raster.Name;
tree=experiment.Clustering.Tree;
similarity=experiment.Clustering.Similarity;
groups=experiment.Clustering.Groups;
if(groups>30)
groups=2:ceil(groups/10):groups;
else
groups=2:30;
end
% Process
obj = Set_Figure(['Clustering test (' name ')'],[0 0 600 300]);
groups_test = Cluster_Test(tree,similarity,test_method,'hierarchical',...
groups,obj); % 'Connectivity', 'Davies', 'Contrast'
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Clustering test (' test_method ') - ' name]);
end
% Write experiment
experiment.Clustering.GroupsTest = groups_test;
Write_Experiment(handles,experiment);
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Get clusters
function btnGetClusters_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
tic
% Read experiment
experiment = Read_Experiment(handles);
raster = experiment.Raster.Raster;
indices = experiment.Peaks.Indices;
tree = experiment.Clustering.Tree;
groups = experiment.Clustering.Groups;
% Process
% Get clusters
sequence = cluster(tree,'maxclust',groups);
% Get Sequences
[sequence_sorted,sorted_indices] = Get_Peaks_Sequence_Sorted(sequence);
% Get raster from states
for i = 1:groups
peaks = find(sequence_sorted==i);
n_peaks = length(peaks);
rasterState = [];
indicesState = [];
for j = 1:n_peaks
indicesPeak = find(indices==peaks(j));
peak = raster(:,indicesPeak);
rasterState = [rasterState peak];
indicesState = [indicesState indicesPeak'];
end
rasterStates{i} = rasterState;
indicesStates{i} = indicesState;
end
% Write experiment
experiment.Clustering.GroupIndices = sequence;
experiment.Clustering.SortedIndices = sorted_indices;
experiment.Clustering.SequenceSorted = sequence_sorted;
experiment.Clustering.RasterStates = rasterStates;
experiment.Clustering.IndicesStates = indicesStates;
experiment.Plot.CorrelationState = [];
Write_Experiment(handles,experiment);
% Enable options on sorting raster/frequencies
labels={'no sorting','activity','activation','jaccard correlation','linear correlation'};
for i=1:groups
labels{end+1}=['group ' num2str(i)];
end
set(handles.popSortingNeurons,'string',labels);
set(handles.popSortingNeurons,'value',1);
% Enable buttons
Enable_Buttons(handles,'PlotStates')
Enable_Buttons(handles,'Network')
if(experiment.Peaks.DividePeaks)
set(handles.btnPlotSequenceByPeak,'enable','on')
end
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
time=toc; disp(['Done in ' num2str(time) ' s.'])
end
%% Get network
function btnGetNetworkRaster_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
tic
% Read experiment
experiment = Read_Experiment(handles);
raster = experiment.Raster.Raster;
bin = 1;
iterations = 1000;
alpha = 0.05;
network_method = experiment.Peaks.NetworkMethod;
shuffle_method = 'time_shift';
single_th = true;
% Get significant network
[whole_network,whole_coactivity] = Get_Significant_Network_From_Raster(...
raster,bin,iterations,alpha,network_method,shuffle_method,single_th);
% Write experiment
experiment.Network.WholeCoactivity = whole_coactivity;
experiment.Network.WholeNetwork = whole_network;
Write_Experiment(handles,experiment);
% Enable buttons
set(handles.btnPlotWholeNetwork,'enable','on')
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
time=toc; disp(['Done in ' num2str(time) ' s.'])
end
%% Get networks by groups
function btnGetNetworks_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
n = experiment.Raster.Neurons;
groups = experiment.Clustering.Groups;
% clear current networks
experiment.Network.State = {};
experiment.Network.StateSignificant = {};
with_th = true;
if(with_th)
bin = 1;
iterations = 10;
alpha = 0.05;
network_method = experiment.Peaks.NetworkMethod;
shuffle_method = 'time_shift';
single_th = true;
groups_to_plot = experiment.Clustering.GroupsToPlot;
%
%correlation = experiment.Plot.Correlation;
% sequence_sorted = experiment.Clustering.SequenceSorted;
% indices = experiment.Peaks.Indices;
% raster = experiment.Raster.Raster;
% Get significant networks of each state
for i=1:groups
if(ismember(i,groups_to_plot))
% Get state raster
raster_state = experiment.Clustering.RasterStates{i};
% compute correlation
try
correlation = experiment.Plot.CorrelationState(i,:);
catch
indices = experiment.Peaks.Indices;
sequence = experiment.Clustering.SequenceSorted;
raster = experiment.Raster.Raster;
correlation = Ensemble_Correlation(raster,indices,sequence,i);
% Write in experiment
experiment.Plot.CorrelationState(i,:) = correlation;
end
% Get significant network
% [state_network_th,state_network] = Get_Significant_Network_From_Raster(...
% raster_state,bin,iterations,alpha,network_method,shuffle_method,single_th);
[state_network_th,state_network] = ...
Get_Significant_Network_From_Raster_And_Correlation(raster_state,...
correlation,bin,iterations,alpha,network_method,shuffle_method,single_th);
% Minimum two coactivations
%state_network_th(state_network < 2) = 0;
% Write in experiment
experiment.Network.State{i}=state_network;
experiment.Network.StateSignificant{i}=state_network_th;
end
end
%}
% Get core network
% raster_peaks = experiment.Peaks.RasterPeaks;
% [core_network_th,core_network] = Get_Significant_Network_From_Raster(raster_peaks,...
% bin,iterations,alpha,network_method,shuffle_method,single_th);
% Network of all networks = union of states and core network = intersection
core_network = ones(n);
network = zeros(n);
for i=1:groups
if(ismember(i,groups_to_plot))
state_network_th = experiment.Network.StateSignificant{i};
network = network + state_network_th;
core_network = core_network .* state_network_th;
end
end
core_network_th = core_network;
network_th = logical(network);
else
networks = experiment.Peaks.Vectors;
sequence = experiment.Clustering.SequenceSorted;
% Get significant networks of each state
for i=1:groups
if(ismember(i,groups_to_plot))
% Get significant network
if(sum(sequence==i)==1)
state_network = squareform(networks(sequence==i,:)>0);
else
state_network = squareform(mean(networks(sequence==i,:)>0));
end
state_network_th = state_network==1;
% Write in experiment
experiment.Network.State{i}=state_network;
experiment.Network.StateSignificant{i}=state_network_th;
end
end
% Network of whole raster = intersection of states
core_network = squareform(mean(networks>0));
core_network_th = core_network==1;
% Network of all networks = union of states
network = zeros(n);
for i=1:groups
if(ismember(i,groups_to_plot))
state_network_th = experiment.Network.StateSignificant{i};
network = network + state_network_th;
end
end
network_th = logical(network);
end
% Get structure
[~,xyColors,isSpecial,id,structure] = Get_XY_Ensembles(experiment.Network.StateSignificant);
structureSorted = structure(:,id);
% Set structure sorting
labels = get(handles.popSortingNeurons,'string');
n = length(labels);
if ~strcmp(labels{n},'structure') && ~strcmp(labels{n-1},'structure')
labels{n+1} = 'structure';
set(handles.popSortingNeurons,'string',labels);
end
name = strrep(experiment.Raster.Name,'_','-');
save = get(handles.chkSavePlot,'value');
Plot_Ensemble_Structure(structureSorted,name,save)
% Write experiment
experiment.Network.Network = network;
experiment.Network.Significant = network_th;
experiment.Network.CoreNetwork = core_network;
experiment.Network.CoreSignificant = core_network_th;
experiment.Network.Structure = structure;
experiment.Network.StructureSorted = structureSorted;
experiment.Network.IDstructure = id;
experiment.Network.ColorsStructure = xyColors;
experiment.Network.IsSpecial = isSpecial;
Write_Experiment(handles,experiment);
% Enable buttons
Enable_Buttons(handles,'PlotNetwork')
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
end
%% Get networks by stimuli
function btnGetNetworksByStimuli_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
n = experiment.Raster.Neurons;
stimuli = experiment.Peaks.Stimuli;
raster = experiment.Raster.Raster;
groups = sum(unique(stimuli)>0);
stimuli_sequence = zeros(size(stimuli));
j=1;
for i = unique(stimuli)'
if(i)
stimuli_sequence(stimuli==i)=j;
j=j+1;
end
end
stimuli_sequence = Delete_Consecutive_Coactivation(stimuli_sequence');
stimuli_sequence = Get_Peaks_Sequence_Sorted(stimuli_sequence);
stimuli_sequence = stimuli_sequence(stimuli_sequence>0);
idx = Get_Peak_Or_Valley_Indices(stimuli,0.0001,true);
is = find(idx~=[0; idx(1:numel(idx)-1)+1]); % index of same peak
% number of total peaks
count = numel(is);
if count
for j = 1:count-1
indices(idx(is(j)):idx(is(j+1)-1),1)=j; % set #peak
end
indices(idx(is(count)):max(idx),1)=count;
end
% clear current networks
experiment.Network.Stimulus = {};
experiment.Network.StimulusSignificant = {};
bin = 1; %bin = 25;
iterations = 1000;
alpha = 0.05;
network_method = experiment.Peaks.NetworkMethod;
shuffle_method = 'time_shift';
single_th = true;
% Get significant networks of each stimulus
for i=1:groups
% Get state raster
peaks = find(stimuli_sequence==i);
n_peaks = length(peaks);
raster_state = [];
idx_stim = [];
for j = 1:n_peaks
peak = indices==peaks(j);
raster_peak = raster(:,peak);
raster_state = [raster_state raster_peak];
idx_stim = [idx_stim; find(peak)];
end
% compute correlation
try
correlation = experiment.Plot.CorrelationStimulus(i,:);
catch
% compute correlation
for j = 1:n
D(j) = pdist([idx_stim';raster_state(j,:)],'correlation');
end
correlation = 1-D;
correlation(isnan(correlation)) = 0;
correlation(correlation<0) = 0;
experiment.Plot.CorrelationStimulus(i,:)=correlation;
end
tic
% Get significant network
[state_network_th,state_network] = Get_Significant_Network_From_Raster_And_Correlation(...
raster_state,correlation,bin,iterations,alpha,network_method,shuffle_method,single_th);
% Write in experiment
experiment.Network.Stimulus{i}=state_network;
experiment.Network.StimulusSignificant{i}=state_network_th;
toc
end
%}
% Network of all networks = union of states and core network = intersection
core_network = ones(n);
network = zeros(n);
for i=1:groups
state_network_th = experiment.Network.StimulusSignificant{i};
network = network + state_network_th;
core_network = core_network .* state_network_th;
end
core_network_th = core_network;
network_th = logical(network);
% Write experiment
experiment.Network.UnionStimulus = network;
experiment.Network.UnionSignificantStimulus = network_th;
experiment.Network.IntersectionStimulus = core_network;
experiment.Network.IntersectionSignificantStimulus = core_network_th;
Write_Experiment(handles,experiment);
% Enable buttons
Enable_Buttons(handles,'PlotNetworkByStimulus')
% Color green
set(hObject,'ForeGroundColor',[0 0.5 0])
end
%% --- Callbacks ---
%% Raster
function popWorkspace_Callback(hObject,~,handles)
% Get data
data_num=get(hObject,'Value');
set(handles.lblRaster,'String','...')
Disable_Buttons(handles,'Raster');
if data_num>1
data_strings=get(hObject,'String');
name=data_strings{data_num};
% Check if exist
if evalin('base',['exist(''' name ''',''var'')'])
raster=evalin('base',name);
% Evaluate data
set(handles.lblRaster,'ForegroundColor',[0 0.5 0])
[cells,samples]=size(raster);
if (samples>1 && cells>1 && length(size(raster))==2)
% Data with less than 500 samples or more than 500 cells
if (samples<cells)
set(handles.lblRaster,'ForegroundColor','red')
info = 'Maybe the raster should be transposed';
else
info = '';
end
info = {info,sprintf('%d neurons, %d samples',cells,samples)};
% Read experiment
experiment=Read_Experiment(handles);
% Enable controls
Enable_Buttons(handles,'Raster')
if(isempty(experiment))
% Set current parameters
experiment = Set_Current_Parameters(handles,experiment);
% Outputs
experiment.Raster.Raster = raster;
experiment.Raster.Activity = sum(raster,2);
experiment.Raster.Name = name;
experiment.Raster.Neurons = cells;
experiment.Raster.Samples = samples;
experiment.Plot.CurrentIndices = 1:cells;
% Write experiment
Write_Experiment(handles,experiment);
else
% Read analysis variable
Read_Analysis(handles,experiment);
end
else
info={'Raster should have 2 dimensions'};
set(handles.lblRaster,'ForegroundColor','red')
Disable_Buttons(handles,'Raster');
end
else
info='Variable data does not exist!';
btnRefreshWorkspace_Callback([],[],handles)
Disable_Buttons(handles,'Raster');
end
set(handles.lblRaster,'String',info)
end
end
function txtSamplesPerSecond_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
smooth_filter=experiment.Coactivity.SmoothFilter;
% Process
samples_per_second = User_Double_Entry_2(hObject,1,1,50000);
samples_per_minute = 60*samples_per_second;
smooth_window=smooth_filter*samples_per_second/1000;
fixed_width_window=str2num(get(handles.txtFixedWidth,'string'))...
*samples_per_second/1000;
division_window=str2num(get(handles.txtDividePeaks,'string'))...
*samples_per_second/1000;
% Write experiment
experiment.Raster.SamplesPerSecond=samples_per_second;
experiment.Raster.SamplesPerMinute=samples_per_minute;
experiment.Coactivity.SmoothWindow=smooth_window;
experiment.Peaks.FixedWidthWindow=fixed_width_window;
experiment.Peaks.DivisionWindow=division_window;
Write_Experiment(handles,experiment);
% Disable buttons and alert
Disable_Buttons(handles,'Peaks');
set(handles.rdbFrequencies,'enable','off')
set(handles.rdbFrequencies,'value',false)
set(handles.rdbSpikes,'value',true)
rdbSpikes_Callback([],[],handles)
txtSmoothFilter_Callback(handles.txtSmoothFilter,[],handles)
txtFixedWidth_Callback(handles.txtFixedWidth,[],handles)
set(handles.btnGetFrequencies,'ForegroundColor','black')
set(handles.btnGetCoactivity,'ForegroundColor','black')
end
%% Coactivity
function txtSmoothFilter_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
samples_per_second=experiment.Raster.SamplesPerSecond;
samples=experiment.Raster.Samples;
% Process
default = round(5000/samples_per_second);
minimum = round(1000/samples_per_second);
maximum = round(samples*1000/samples_per_second);
multiple=true;
smooth_filter=User_Number_Entry(hObject,default,minimum,maximum,multiple);
smooth_window=smooth_filter*samples_per_second/1000;
% Write experiment
experiment.Coactivity.SmoothFilter=smooth_filter;
experiment.Coactivity.SmoothWindow=smooth_window;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Peaks')
set(handles.btnGetCoactivity,'ForegroundColor','black')
end
function chkZscore_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
samples_per_second=experiment.Raster.SamplesPerSecond;
samples=experiment.Raster.Samples;
% Process
z_score = get(hObject,'value');
coactivity_threshold=1.5;
set(handles.txtCoactivityThreshold,'string','1.5')
if(z_score)
prompt = {'Z-score (0) or only substract mean (1):',['Enter the seconds of'...
' window for computation (0=all raster):']};
title = 'Enter parameters';
dims = [1 50; 1 50];
default_input = {'0','0'};
answer = inputdlg(prompt,title,dims,default_input);
if(~isempty(answer))
only_mean=str2num(answer{1});
if(isempty(only_mean))
only_mean=false;
else
only_mean=logical(only_mean);
end
zscore_window=str2num(answer{2});
if(isempty(zscore_window))
zscore_window=0;
elseif(zscore_window>samples_per_second*samples)
zscore_window=0;
else
zscore_window=round(zscore_window*samples_per_second);
end
experiment.Coactivity.ZScoreWindow=zscore_window;
experiment.Coactivity.ZScoreOnlyMean=only_mean;
end
end
% Write experiment
experiment.Coactivity.ZScore=z_score;
experiment.Coactivity.CoactivityThreshold=coactivity_threshold;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Peaks')
set(handles.btnGetCoactivity,'ForegroundColor','black')
end
function chkRemoveOscillations_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
% Process
remove_oscillations = get(hObject,'value');
% Write experiment
experiment.Coactivity.RemoveOscillations=remove_oscillations;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Peaks')
set(handles.btnGetCoactivity,'ForegroundColor','black')
end
%% Neural vectors
% Selection
function chkDetectPeaksOrValleys_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
% Process
detect_peaks_or_valleys=get(hObject,'value');
% Enable/Disable
if(detect_peaks_or_valleys)
% Enable
set(handles.popPeaksValleys,'enable','on')
set(handles.txtCoactivityThreshold,'enable','on')
set(handles.btnShuffleTest,'enable','on')
set(handles.chkFixedWidth,'enable','on')
if(get(handles.chkFixedWidth,'value'))
set(handles.txtFixedWidth,'enable','on')
end
% Set values
coactivity_threshold=str2double(get(handles.txtCoactivityThreshold,'string'));
experiment.Coactivity.CoactivityThreshold=coactivity_threshold;
else
% Disable
set(handles.popPeaksValleys,'enable','off')
set(handles.txtCoactivityThreshold,'enable','off')
set(handles.btnShuffleTest,'enable','off')
set(handles.chkFixedWidth,'enable','off')
set(handles.txtFixedWidth,'enable','on')
% Set values
set(handles.chkFixedWidth,'value',true)
experiment.Peaks.FixedWidth=true;
experiment.Coactivity.CoactivityThreshold=[];
end
% Write experiment
experiment.Peaks.DetectPeaksOrValleys=detect_peaks_or_valleys;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Peaks or valleys
function popPeaksValleys_Callback(hObject,~,handles)
% Enable Stimuli signal if selected
if(get(hObject,'value')==3)
set(handles.popStimuli,'enable','on')
else
set(handles.popStimuli,'enable','off')
end
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Stimuli
function popStimuli_Callback(hObject,~,handles)
set(hObject,'ForegroundColor','black')
% Read experiment
experiment = Read_Experiment(handles);
% Get data
data_num = get(hObject,'Value');
if data_num>1
if data_num == 2
if ~isfield(experiment,'Network')
disp('Computing functional connectivity...')
btnGetNetworkRaster_Callback(handles.btnGetNetworkRaster,[],handles);
disp('Done!')
else
if ~isfield(experiment.Network,'WholeNetwork')
disp('Computing functional connectivity...')
btnGetNetworkRaster_Callback(handles.btnGetNetworkRaster,[],handles);
disp('Done!')
end
end
% Update experiment
experiment = Read_Experiment(handles);
raster = experiment.Raster.Raster;
network = experiment.Network.WholeNetwork;
% Get relevant coactivity peaks based on functional connectivity
tic
if ~isfield(experiment.Peaks,'nonNoisyRaster')
disp('Get relevant coactivity based on functional conectivity...')
[relevant,nonNoisyRaster,~,fraction,spikesRemoved] =...
Get_Relevant_Coactivations(raster,network,1-0.5);
experiment.Peaks.External = relevant;
experiment.Peaks.FractionRelevant = fraction;
experiment.Raster.NonNoisyRaster = nonNoisyRaster;
experiment.Raster.SpikesRemoved = spikesRemoved;
end
time = toc; disp(['Done in ' num2str(time) ' s.'])
% Set threshold to 0.5
set(handles.txtCoactivityThreshold,'string','0.5')
else
data_strings = get(hObject,'String');
name=data_strings{data_num};
% Check if exist
if evalin('base',['exist(''' name ''',''var'')'])
external=evalin('base',name);
% Evaluate data
set(handles.lblRaster,'ForegroundColor',[0 0.5 0])
if(isvector(external))
if(length(external)~=experiment.Raster.Samples)
set(hObject,'ForegroundColor','red')
end
else
set(hObject,'ForegroundColor','red')
end
else
btnRefreshWorkspace_Callback([],[],handles)
Disable_Buttons(handles,'Raster');
end
experiment.Peaks.External = external;
end
% Write experiment
Write_Experiment(handles,experiment);
end
% Update the threshold
txtCoactivityThreshold_Callback(handles.txtCoactivityThreshold,[],handles)
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Coactivity Threshold
function txtCoactivityThreshold_Callback(hObject,~,handles)
% Read experiment
experiment = Read_Experiment(handles);
z_score = experiment.Coactivity.ZScore;
coactivity = experiment.Coactivity.Coactivity;
% Process
if z_score
maximum = max(floor(coactivity*10)/10);
else
maximum = experiment.Raster.Neurons;
end
coactivity_threshold = User_Double_Entry(hObject,0,0,maximum);
% Write experiment
experiment.Coactivity.CoactivityThreshold=coactivity_threshold;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Use spikes
function rdbSpikes_Callback(~,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
% Process
if(~get(handles.rdbSpikes,'value'))
set(handles.rdbSpikes,'value',true)
end
set(handles.rdbFrequencies,'value',false)
use_spikes=true;
% Write experiment
experiment.Peaks.UseSpikes=use_spikes;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Use frequencies
function rdbFrequencies_Callback(~,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
% Process
if(~get(handles.rdbFrequencies,'value'))
set(handles.rdbFrequencies,'value',true)
end
set(handles.rdbSpikes,'value',false)
use_spikes=false;
% Write experiment
experiment.Peaks.UseSpikes=use_spikes;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Fixed width
function chkFixedWidth_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
% Process
fixed_width=get(hObject,'value');
if(fixed_width)
set(handles.txtFixedWidth,'enable','on')
else
set(handles.txtFixedWidth,'enable','off')
end
% Write experiment
experiment.Peaks.FixedWidth=fixed_width;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Define fixed with
function txtFixedWidth_Callback(hObject,~,handles)
% Read experiment
experiment = Read_Experiment(handles);
samples = experiment.Raster.Samples;
samples_per_second = experiment.Raster.SamplesPerSecond;
detect_peaks_or_valleys = experiment.Peaks.DetectPeaksOrValleys;
% Process
minimum = round(1000/samples_per_second);
maximum = round(samples*1000/samples_per_second);
default = minimum;
multiple = true;
fixed_width_window = round(User_Number_Entry(hObject,default,minimum,maximum,multiple,...
detect_peaks_or_valleys)*samples_per_second/1000);
% Write experiment
experiment.Peaks.FixedWidthWindow=fixed_width_window;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Join peaks
function chkJoin_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
% Process
join=get(hObject,'value');
if(join)
set(handles.chkDividePeaks,'enable','on')
if(get(handles.chkDividePeaks,'value'))
set(handles.txtDividePeaks,'enable','on')
end
else
set(handles.chkDividePeaks,'enable','off')
set(handles.txtDividePeaks,'enable','off')
end
% Write experiment
experiment.Peaks.Join=join;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Divide Peaks
function chkDividePeaks_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
% Process
divide_peaks=get(hObject,'value');
if(divide_peaks)
set(handles.txtDividePeaks,'enable','on')
else
set(handles.txtDividePeaks,'enable','off')
set(handles.btnPlotSequenceByPeak,'enable','off')
end
% Write experiment
experiment.Peaks.DividePeaks=divide_peaks;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Define division time
function txtDividePeaks_Callback(hObject,~,handles)
% Read experiment
experiment=Read_Experiment(handles);
samples_per_second=experiment.Raster.SamplesPerSecond;
fixed_width_window=experiment.Peaks.FixedWidthWindow;
% Process
minimum=1000/samples_per_second;
maximum=abs(fixed_width_window)*1000/samples_per_second;
multiple=true;
division_window=User_Number_Entry(hObject,minimum,minimum,maximum,...
multiple)*samples_per_second/1000;
% Write experiment
experiment.Peaks.DivisionWindow=division_window;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Vector method
function popVectorMethod_Callback(hObject,~,handles)
% Get data
data_num=get(hObject,'Value');
data_strings=get(hObject,'String');
vector_method=data_strings{data_num};
% Disable/enable button
if(data_num<4)
set(handles.popNetworkMethod,'enable','off')
else
set(handles.popNetworkMethod,'enable','on')
end
% Read experiment
experiment=Read_Experiment(handles);
% Write experiment
experiment.Peaks.VectorMethod=vector_method;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
% Network method
function popNetworkMethod_Callback(hObject,~,handles)
% Get data
data_num=get(hObject,'Value');
data_strings=get(hObject,'String');
network_method=data_strings{data_num};
% Read experiment
experiment=Read_Experiment(handles);
% Write experiment
experiment.Peaks.NetworkMethod=network_method;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Similarity')
set(handles.btnGetVectors,'ForegroundColor','black')
end
%% Similarity
% Similarity method
function popSimilarityMethod_Callback(hObject,~,handles)
% Get data
data_num=get(hObject,'Value');
data_strings=get(hObject,'String');
similarity_method=data_strings{data_num};
% Read experiment
experiment=Read_Experiment(handles);
% Write experiment
experiment.Clustering.SimilarityMethod=similarity_method;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Clustering')
set(handles.btnGetSimilarity,'ForegroundColor','black')
end
% Linkage method
function popLinkageMethod_Callback(hObject,~,handles)
% Get data
data_num=get(hObject,'Value');
data_strings=get(hObject,'String');
linkage_method=data_strings{data_num};
% Read experiment
experiment=Read_Experiment(handles);
% Write experiment
experiment.Clustering.LinkageMethod=linkage_method;
Write_Experiment(handles,experiment);
% Disable buttons
Disable_Buttons(handles,'Clustering')
set(handles.btnGetSimilarity,'ForegroundColor','black')
end
%% Clustering
% Groups
function txtGroups_Callback(hObject,~,handles)
% Read experiment
experiment = Read_Experiment(handles);
count = experiment.Peaks.Count;
% Process
groups = User_Number_Entry(hObject,5,2,count);
groups_string = [];
for i=1:(groups-1)
groups_string = [groups_string num2str(i) ','];
end
groups_string = [groups_string num2str(groups)];
set(handles.txtGroupsToPlot,'string',groups_string)
groups_to_plot = 1:groups;
% Write experiment
experiment.Clustering.Groups = groups;
experiment.Clustering.GroupsToPlot = groups_to_plot;
Write_Experiment(handles,experiment);
% Disable buttons
set(handles.btnGetClusters,'ForegroundColor','black')
end
%% Plots
% Sort neurons
function popSortingNeurons_Callback(hObject, ~, handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment=Read_Experiment(handles);
raster = experiment.Raster.Raster;
neurons = experiment.Raster.Neurons;
% Process
data_num=get(hObject,'Value');
data_strings=get(hObject,'String');
sorting_method=data_strings{data_num};
% Select sorting method
switch(sorting_method)
case 'no sorting'
cell_indices = 1:neurons;
case 'activity'
activity=experiment.Raster.Activity;
[~,cell_indices]=sort(activity,'descend');
case 'activation'
[~,cell_indices] = Sort_Raster(raster);
case 'jaccard correlation'
if(get(handles.popPeaksValleys,'value')==3)
disp('Computing correlation...')
tic
stimuli = experiment.Peaks.External;
[~,cell_indices,D] = Sort_Raster_By_Distance(raster,stimuli,'jaccard');
experiment.Plot.JaccardCorrelation = 1-D;
toc
else
coactivity=experiment.Coactivity.Coactivity;
try
correlation = experiment.Plot.JaccardCorrelation(1,:);
[~, cell_indices]=sort(correlation,'descend');
catch
disp('Computing correlation...')
tic
[~,cell_indices,D] = Sort_Raster_By_Distance(raster,coactivity,'jaccard');
experiment.Plot.JaccardCorrelation = 1-D;
toc
end
end
case 'linear correlation'
if(get(handles.popPeaksValleys,'value')==3)
stimuli = experiment.Peaks.External;
disp('Computing correlation...')
tic
[~,cell_indices,D] = Sort_Raster_By_Distance(raster,stimuli,'correlation');
correlation = 1-D;
correlation(isnan(correlation)) = 0;
correlation(correlation<0) = 0;
toc
else
try
correlation = experiment.Plot.Correlation(1,:);
[~, cell_indices]=sort(correlation,'descend');
catch
disp('Computing correlation...')
tic
coactivity = experiment.Coactivity.Coactivity;
[~,cell_indices,D] = Sort_Raster_By_Distance(raster,coactivity,'correlation');
correlation = 1-D;
correlation(isnan(correlation)) = 0;
correlation(correlation<0) = 0;
toc
end
end
experiment.Plot.Correlation = correlation;
case 'structure'
cell_indices = experiment.Network.IDstructure;
case 'structure by stimulus'
cell_indices = experiment.Plot.IDstructureStimulus;
otherwise
by_group=strsplit(sorting_method,' ');
group=str2num(by_group{2});
try
correlation = experiment.Plot.CorrelationState(group,:);
[~, cell_indices]=sort(correlation,'descend');
catch
[correlation,cell_indices] = Compute_Correlation_by_State(experiment,group);
experiment.Plot.CorrelationState(group,:)=correlation;
end
end
% Write experiment
experiment.Plot.CurrentIndices = cell_indices;
experiment.Plot.CurrentSorting = sorting_method;
Write_Experiment(handles,experiment);
% Color green
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Compute correlation by state
function [correlation,cell_indices] = Compute_Correlation_by_State(experiment,group)
disp('Computing correlation...')
tic
% if experiment.Peaks.DetectStimuli
% signal = experiment.Peaks.External;
% else
% signal = experiment.Coactivity.Coactivity;
% end
indices = experiment.Peaks.Indices;
groupSequence = experiment.Clustering.SequenceSorted;
neurons = experiment.Raster.Neurons;
raster = experiment.Raster.Raster;
[correlation,cell_indices] = Ensemble_Correlation(raster,indices,groupSequence,group);
%{
% find indices of group peaks
idGroup = find(groupSequence==group)';
idIndices = zeros(size(indices));
for i = idGroup
idIndices(indices==i) = 1;
end
%signal = signal.*idIndices; % old
signal = idIndices; % correlation with binary
% compute correlation
for i=1:neurons
D(i) = pdist([signal';raster(i,:)],'correlation');
end
correlation = 1-D;
correlation(isnan(correlation)) = 0;
correlation(correlation<0) = 0;
% sort
[~, cell_indices] = sort(correlation,'descend');
%}
toc
end
% Groups to plot
function txtGroupsToPlot_Callback(hObject,~, handles)
% Read experiment
experiment=Read_Experiment(handles);
groups=experiment.Clustering.Groups;
% Process
% default
default_entry=[];
for i=1:(groups-1)
default_entry=[default_entry num2str(i) ','];
end
default_entry=[default_entry num2str(groups)];
default_groups_to_plot=[1:groups];
% validate user entry
user_entry = get(hObject,'string');
if ~isnan(user_entry)
cell_groups=strsplit(user_entry,',');
n=length(cell_groups);
groups_to_plot=[];
for i=1:n
group_num=str2num(cell_groups{i});
if(isempty(group_num))
user_entry=default_entry;
groups_to_plot=default_groups_to_plot;
break;
end
groups_to_plot=[groups_to_plot group_num];
end
else
user_entry=default_entry;
groups_to_plot=default_groups_to_plot;
end
set(hObject,'string',num2str(user_entry));
% Write experiment
experiment.Clustering.GroupsToPlot=groups_to_plot;
Write_Experiment(handles,experiment);
end
%% --- Plots ---
%% Plot raster
function btnPlotRaster_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
raster = experiment.Raster.Raster;
name = experiment.Raster.Name;
try
cell_indices = experiment.Plot.CurrentIndices;
current_sorting = experiment.Plot.CurrentSorting;
catch
neurons = experiment.Raster.Neurons;
cell_indices = 1:neurons;
current_sorting = 'no sorting';
% Write experiment
experiment.Plot.CurrentIndices = cell_indices;
experiment.Plot.CurrentSorting = current_sorting;
Write_Experiment(handles,experiment);
end
% Plot raster
plot_spikes=true;
Plot_Raster(raster(cell_indices,:),name,plot_spikes)
if (strcmp(current_sorting,'no sorting'))
ylabel('neurons')
else
ylabel({'neurons sorted by'; current_sorting})
end
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Raster - ' name]);
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot frequencies
function btnPlotFrequencies_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
frequencies = experiment.Raster.Frequencies;
name = experiment.Raster.Name;
try
cell_indices = experiment.Plot.CurrentIndices;
current_sorting = experiment.Plot.CurrentSorting;
catch
neurons = experiment.Raster.Neurons;
cell_indices = 1:neurons;
current_sorting = 'no sorting';
% Write experiment
experiment.Plot.CurrentIndices = cell_indices;
experiment.Plot.CurrentSorting = current_sorting;
Write_Experiment(handles,experiment);
end
% Plot frequencies
plot_spikes=false;
Plot_Raster(frequencies(cell_indices,:),name,plot_spikes)
if (strcmp(current_sorting,'no sorting'))
ylabel('neurons')
else
ylabel({'neurons sorted by'; current_sorting})
end
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Frequencies - ' name]);
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot coactivity
function btnPlotCoactivity_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment=Read_Experiment(handles);
coactivity_threshold=experiment.Coactivity.CoactivityThreshold;
name=experiment.Raster.Name;
samples_per_second=experiment.Raster.SamplesPerSecond;
smooth_coactivity=experiment.Coactivity.Coactivity;
if(get(handles.popPeaksValleys,'value')==3)
coactivity_threshold = [];
end
% Plot coactivity
Plot_Coactivity(smooth_coactivity,name,coactivity_threshold,samples_per_second)
if(experiment.Coactivity.ZScore)
ylabel({'coactivity';'(z-score)'})
end
if (experiment.Coactivity.SmoothFilter>1000/samples_per_second)
if(experiment.Coactivity.RemoveOscillations)
title(['smooth filter (' num2str(experiment.Coactivity.SmoothFilter)...
' ms) - slow oscillations removed']);
else
title(['smooth filter (' num2str(experiment.Coactivity.SmoothFilter) ' ms)']);
end
elseif(experiment.Coactivity.RemoveOscillations)
title('slow oscillations removed');
else
title('');
end
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Coactivity - ' name]);
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot similarity
function btnPlotSimilarity_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment=Read_Experiment(handles);
similarity=experiment.Clustering.Similarity;
name=experiment.Raster.Name;
tree=experiment.Clustering.Tree;
similarity_method=experiment.Clustering.SimilarityMethod;
linkage_method=experiment.Clustering.LinkageMethod;
raster = experiment.Peaks.RasterPeaks;
id = 1:size(similarity,1);
if isfield(experiment,'Plot')
if isfield(experiment.Plot,'CurrentIndices')
id = experiment.Plot.CurrentIndices;
end
end
% Plot Similarity
indices = Plot_Similarity(similarity,name,tree,similarity_method,linkage_method);
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Similarity - ' name]);
end
% Plot raster
states = [];
if isfield(experiment.Clustering,'SequenceSorted')
states = experiment.Clustering.SequenceSorted;
states = states(indices);
end
Plot_Raster_And_Similarity(raster(id,indices),similarity(indices,indices),name,...
similarity_method,states)
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Raster and Similarity - ' name]);
end
% Write experiment
experiment.Clustering.IndicesSimilarity = indices;
Write_Experiment(handles,experiment);
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot peaks
function btnPlotPeaks_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
name = experiment.Raster.Name;
samples_per_second = experiment.Raster.SamplesPerSecond;
raster = experiment.Raster.Raster;
coactivity = experiment.Coactivity.Coactivity;
coactivity_threshold = experiment.Coactivity.CoactivityThreshold;
peak_indices = experiment.Peaks.Indices;
sequence = experiment.Clustering.SequenceSorted;
groups_to_plot = experiment.Clustering.GroupsToPlot;
groups = experiment.Clustering.Groups;
save = get(handles.chkSavePlot,'value');
if(get(handles.popPeaksValleys,'value')==3)
coactivity_threshold = [];
end
% noise_group
noise_group=setdiff(1:groups,groups_to_plot);
% Plot Peaks
peak_number=false;
try
cell_indices = experiment.Plot.CurrentIndices;
catch
neurons = experiment.Raster.Neurons;
cell_indices = 1:neurons;
current_sorting = 'no sorting';
% Write experiment
experiment.Plot.CurrentIndices = cell_indices;
experiment.Plot.CurrentSorting = current_sorting;
Write_Experiment(handles,experiment);
end
rasterColor = Plot_Peaks_On_Raster(raster(cell_indices,:),peak_indices,sequence,name);
if save
Save_Figure(['Peaks on raster - ' name]);
end
Plot_Coactivity(coactivity,name,coactivity_threshold,samples_per_second);
Plot_Peaks_On_Coactivity(coactivity,peak_indices,sequence,...
noise_group,peak_number)
if(experiment.Coactivity.ZScore)
ylabel({'coactivity';'(z-score)'})
end
if (experiment.Coactivity.SmoothFilter>1000/samples_per_second)
if(experiment.Coactivity.RemoveOscillations)
title(['smooth filter (' num2str(experiment.Coactivity.SmoothFilter)...
' ms) - slow oscillations removed']);
else
title(['smooth filter (' num2str(experiment.Coactivity.SmoothFilter) ' ms)']);
end
elseif(experiment.Coactivity.RemoveOscillations)
title('slow oscillations removed');
end
% Save
if save
Save_Figure(['Coactivity Peaks - ' name]);
end
% Write experiment
experiment.Plot.RasterColor = rasterColor;
Write_Experiment(handles,experiment);
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot raster peaks
function btnPlotRasterPeaks_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Ask for division
prompt = {'Enter the seconds to divide the ensembles: (0=no division)'};
title = 'Enter parameters';
dims = [1 50];
default_input = {'0'};
answer = inputdlg(prompt,title,dims,default_input);
if ~isempty(answer)
winSeconds = str2num(answer{1});
if isempty(winSeconds)
winSeconds = 0;
end
% Read experiment
experiment = Read_Experiment(handles);
name = experiment.Raster.Name;
indices = experiment.Peaks.Indices;
idSort = experiment.Plot.CurrentIndices;
raster = experiment.Peaks.RasterPeaks(idSort,:);
sequence = experiment.Clustering.SequenceSorted;
samplesPerSecond = experiment.Raster.SamplesPerSecond;
peaks = experiment.Peaks.Count;
neurons = experiment.Raster.Neurons;
samples = experiment.Raster.Samples;
% Plot raster
sequenceSingle = [];
for i = 1:peaks
sequenceSingle = [sequenceSingle repmat(sequence(i),1,nnz(indices==i))];
end
Plot_Raster_Ensembles(raster,sequenceSingle,name)
% Get the number of peak as limit
if winSeconds && winSeconds<(samples/samplesPerSecond)
frameLimit = ceil(winSeconds*samplesPerSecond);
nWin = ceil(round(samples/frameLimit,1))-1;
for i = 1:nWin
peakLimit = indices(find(indices(frameLimit*i+1:end)>0,1,'first')+frameLimit*i);
Plot_Raster_Limit(neurons,sequence,peakLimit)
end
% Write experiment
experiment.Plot.PeakLimit = peakLimit;
Write_Experiment(handles,experiment);
end
% Set label
Set_Label_Time(size(raster,2),samplesPerSecond)
% Save
if get(handles.chkSavePlot,'value')
Save_Figure(['Raster Peaks - ' name]);
end
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot sequence
function btnPlotSequence_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Ask for division
prompt = {'Enter the seconds of windows to divide the raster: (0=all sequence)'};
title = 'Enter parameters';
dims = [1 50];
default_input = {'0'};
answer = inputdlg(prompt,title,dims,default_input);
if ~isempty(answer)
window_sec = str2num(answer{1});
if isempty(window_sec)
window_sec = 0;
end
% Read experiment
experiment=Read_Experiment(handles);
name=experiment.Raster.Name;
groups_to_plot=experiment.Clustering.GroupsToPlot;
sequence=experiment.Clustering.SequenceSorted;
groups=experiment.Clustering.Groups;
% noise_group
noise_group=setdiff(1:groups,groups_to_plot);
if(window_sec==0)
% Plot Sequence
count_states = Plot_States_Sequence(sequence,noise_group,name);
% Write experiment
experiment.Plot.CountStates = count_states;
Write_Experiment(handles,experiment);
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Sequence - ' name]);
end
else
% read indices
indices=experiment.Peaks.Indices;
samples=experiment.Raster.Samples;
samples_per_second=experiment.Raster.SamplesPerSecond;
window = ceil(window_sec*samples_per_second);
n_seqs=ceil(samples/window);
indices_seq=zeros(length(sequence),1);
for i=1:n_seqs
if(i*window>samples)
idx=find(indices(((i-1)*window+1):end)>0,1,'first');
ini=indices((i-1)*window+idx);
fin=max(indices(((i-1)*window+1):end));
else
idx=find(indices(((i-1)*window+1):i*window)>0,1,'first');
ini=indices((i-1)*window+idx);
fin=max(indices(((i-1)*window+1):i*window));
end
% Plot Sequence
if ~isempty(ini)
count_states{i} = Plot_States_Sequence(sequence(ini:fin),noise_group,...
[name ' (' num2str(i) '-' num2str(n_seqs) ')'],...
Read_Colors(max(sequence)));
if(i==1)
Hold_Axes('States count');
ylims = get(gca,'ylim');
else
Hold_Axes('States count');
if ylims(2)> max(count_states{i})
ylim(ylims)
end
end
% Save
if(get(handles.chkSavePlot,'value'))
Save_Figure(['Sequence - ' name '_' num2str(i) '-' num2str(n_seqs)]);
end
end
indices_seq(ini:fin)=i;
end
% Write experiment
experiment.Plot.CountStates = count_states;
experiment.Plot.SecondsForSequences = window_sec;
experiment.Plot.IndicesForSequences = indices_seq;
Write_Experiment(handles,experiment);
end
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot sequence by peak
function btnPlotSequenceByPeak_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment=Read_Experiment(handles);
name=experiment.Raster.Name;
division_window=experiment.Peaks.DivisionWindow;
fixed_width_window=abs(experiment.Peaks.FixedWidthWindow);
sequence=experiment.Clustering.SequenceSorted;
samples_per_second=experiment.Raster.SamplesPerSecond;
% Peak width
width=ceil(fixed_width_window/division_window);
% Plot save
save_plot=get(handles.chkSavePlot,'value');
% Plot states by width
division_ms=division_window*1000/samples_per_second;
% Plot state sequences
sequences=Plot_States_By_Width(sequence,width,name,save_plot);
Plot_Sequences(sequences,division_ms,save_plot,'Sequences');
% Plot graphs from sequencies
%adjacency_vectors=Plot_Sequence_Graph_By_Width(sequence,width,name,save_plot);
%Plot_Sequences(double(adjacency_vectors>0),division_ms,save_plot,'Adjacencies',...
%flipud(gray(max(adjacency_vectors(:)))));
%Plot_Sequences(adjacency_vectors,division_ms,save_plot,'Adjacencies',...
%flipud(gray(max(adjacency_vectors(:)))));
% Write experiment
experiment.Plot.Sequences=sequences;
%experiment.Plot.AdjacencyVectors=adjacency_vectors;
Write_Experiment(handles,experiment);
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot ensemble length histogram
function btnEnsembleLength_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
prompt = {'Enter the seconds of windows to divide the raster: (0=all)'};
title = 'Enter parameters';
dims = [1 50];
default_input = {'0'};
answer = inputdlg(prompt,title,dims,default_input);
if ~isempty(answer)
windowSec = str2num(answer{1});
if isempty(windowSec)
windowSec = 0;
end
% Read experiment
experiment = Read_Experiment(handles);
indices = experiment.Peaks.Indices;
sequence = experiment.Clustering.SequenceSorted;
name = strrep(experiment.Raster.Name,'_','-');
fps = experiment.Raster.SamplesPerSecond;
% Get the number of window to plot
step = floor(windowSec*fps);
nWin = ceil(length(indices)/step);
if windowSec
for i = 1:nWin
fin = step*i;
if fin>length(indices)
fin = length(indices);
end
id = indices((step*(i-1)+1):fin);
ini = id(find(id>0,1,'first'));
fin = id(find(id>0,1,'last'));
seq = sequence(ini:fin);
% Get widths
widths{i} = Plot_Ensembles_Length(id,seq,[name '(' num2str(i)...
'/' num2str(nWin) ')'],fps);
if get(handles.chkSavePlot,'value')
Save_Figure([name '(' num2str(i) '_' num2str(nWin) ')'])
end
end
else
% Get widths
widths = Plot_Ensembles_Length(indices,sequence,name,fps);
if get(handles.chkSavePlot,'value')
Save_Figure([name ' (ensemble lenght)'])
end
end
% Write experiment
experiment.Plot.EnsembleWidths = widths;
Write_Experiment(handles,experiment);
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot whole network
function btnPlotWholeNetwork_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
name = strrep(experiment.Raster.Name,'_','-');
n = experiment.Raster.Neurons;
coactivity = experiment.Network.WholeCoactivity;
network = experiment.Network.WholeNetwork;
try
cell_indices = experiment.Plot.CurrentIndices;
catch
neurons = experiment.Raster.Neurons;
cell_indices = 1:neurons;
current_sorting = 'no sorting';
% Write experiment
experiment.Plot.CurrentIndices = cell_indices;
experiment.Plot.CurrentSorting = current_sorting;
Write_Experiment(handles,experiment);
end
% Plot network
save_plot=get(handles.chkSavePlot,'value');
xy = 'force'; % 'circle'
xyColor = [0.8 0.8 0.8];
network_plot = coactivity.*network;
Plot_Adjacencies_And_Network(coactivity(cell_indices,cell_indices),...
network_plot(cell_indices,cell_indices),['Whole raster - ' name],...
xy,xyColor,[],save_plot)
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot networks by groups
function btnPlotNetworks_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
name = strrep(experiment.Raster.Name,'_','-');
network_th = experiment.Network.Significant;
save_plot=get(handles.chkSavePlot,'value');
structure = experiment.Network.StructureSorted;
id = experiment.Network.IDstructure;
xyColors = experiment.Network.ColorsStructure;
isSpecial = experiment.Network.IsSpecial;
% Plot
Plot_Ensembles(network_th(id,id),[],xyColors,isSpecial,structure,name,save_plot);
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot structure
function btnPlotStructure_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
structure = experiment.Network.StructureSorted;
name = strrep(experiment.Raster.Name,'_','-');
save = get(handles.chkSavePlot,'value');
% Plot
Plot_Ensemble_Structure(structure,name,save)
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%% Plot networks by stimulus
function btnPlotStimulusNetworks_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
name = strrep(experiment.Raster.Name,'_','-');
network_th = experiment.Network.UnionSignificantStimulus;
save_plot = get(handles.chkSavePlot,'value');
% plot networks
[~, xy_colors, id, structure] = Get_XY_Ensembles(experiment.Network.StimulusSignificant);
Plot_Ensembles(network_th(id,id),[],xy_colors,structure,name,save_plot);
% Set structure sorting
labels = get(handles.popSortingNeurons,'string');
n = length(labels);
if ~strcmp(labels{n},'structure by stimulus') && ~strcmp(labels{n-1},'structure by stimulus')
labels{n+1} = 'structure by stimulus';
set(handles.popSortingNeurons,'string',labels);
end
% Write experiment
experiment.Plot.IDstructureStimulus = id;
experiment.Plot.StructureStimulus = structure;
experiment.Plot.ColorsStructureStimulus = xy_colors;
Write_Experiment(handles,experiment);
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
% Plot random
%{
function btnPlotRandomNetworks_Callback(hObject, ~, handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Read experiment
experiment = Read_Experiment(handles);
name = strrep(experiment.Raster.Name,'_','-');
width = experiment.Peaks.FixedWidthWindow;
n = experiment.Raster.Neurons;
vector_method = experiment.Peaks.VectorMethod;
network_method = experiment.Peaks.NetworkMethod;
groups = experiment.Clustering.Groups;
raster_states = experiment.Clustering.RasterStates;
if(isfield(experiment,'Plot'))
cell_indices = experiment.Plot.CellIndices;
else
cell_indices = 1:experiment.Raster.Neurons;
end
shuffled_joined = zeros(n);
shuffled_core = ones(n);
for i = 1:groups
raster_state = raster_states{i};
samples=size(raster_state,2);
raster_shuffled = shuffle(raster_state,'time_shift');
% Get vectors from state
n=ceil(samples/width);
vector_indices=zeros(samples,1);
for j=1:n
ini=(j-1)*width+1;
fin=j*width;
if(fin>samples)
fin=samples;
end
vector_indices(ini:fin)=j;
end
% Create a matrix with all vector peaks
shuffled_networks=Get_Peak_Vectors(raster_shuffled,vector_indices,...
vector_method,network_method);
state_shuffled = squareform(mean(shuffled_networks>0));
state_shuffled_th = state_shuffled==1;
% Get
shuffled_joined = shuffled_joined + state_shuffled_th;
shuffled_core = shuffled_core.*state_shuffled_th;
% Write in experiment
experiment.Network.StateShuffled{i}=state_shuffled;
experiment.Network.StateSignificantShuffled{i}=state_shuffled_th;
end
shuffled_joined_th = logical(shuffled_joined);
% Get coordinates of network
xy = Get_Force_XY(shuffled_joined);
xy = xy(cell_indices,:);
% Plot networks
save_plot=get(handles.chkSavePlot,'value');
edge_color = [0.5 0.5 0.5];
node_color = [0.8 0.8 0.8];
Plot_Adjacencies_And_Network(shuffled_joined(cell_indices,cell_indices),...
shuffled_joined_th(cell_indices,cell_indices),...
['Shuffled all networks (union) - ' name],...
xy,node_color,edge_color,save_plot)
lims_x = get(gca,'xlim');
lims_y = get(gca,'ylim');
% Plot core network
Plot_Adjacencies_And_Network(shuffled_core(cell_indices,cell_indices),...
shuffled_core(cell_indices,cell_indices),...
['Shuffled core network (intersection) - ' name],...
xy,node_color,edge_color,save_plot)
xlim(lims_x)
ylim(lims_y)
% Plot network of each state
colors = Read_Colors(groups);
for i=1:groups
state_shuffled = experiment.Network.StateShuffled{i};
state_shuffled_th = experiment.Network.StateSignificantShuffled{i};
Plot_Adjacencies_And_Network(state_shuffled(cell_indices,cell_indices),...
state_shuffled_th(cell_indices,cell_indices),...
['Shuffled state ' num2str(i) ' network - ' name],...
xy,colors(i,:),edge_color,save_plot)
xlim(lims_x)
ylim(lims_y)
end
% Write experiment
experiment.Network.NetworkShuffled=shuffled_joined;
experiment.Network.ShuffledSignificant=shuffled_joined_th;
experiment.Network.ShuffledCoreSignificant=shuffled_core;
Write_Experiment(handles,experiment);
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end
%}
%% --- Save ---
%% Save raster by x seconds
function btnSaveBySeconds_Callback(hObject,~,handles)
% Color yellow
set(hObject,'ForeGroundColor',[0.5 0.5 0]); pause(0.1); pause on
% Ask for division
prompt = {'Enter the seconds of windows to divide the raster:'};
title = 'Enter parameters';
dims = [1 50];
default_input = {'60'};
answer = inputdlg(prompt,title,dims,default_input);
if ~isempty(answer)
window_sec=str2num(answer{1});
if isempty(window_sec)
window_sec=60;
end
% Read experiment
experiment=Read_Experiment(handles);
name=experiment.Raster.Name;
samples_per_second=experiment.Raster.SamplesPerSecond;
samples=experiment.Raster.Samples;
final_sec=samples/samples_per_second;
use_spikes=experiment.Peaks.UseSpikes;
% Check if raster was ploted
h=findobj('name',['Raster (' name ')']);
if isempty(h)
% Plot
if(use_spikes)
btnPlotRaster_Callback([],[],handles);
else
btnPlotFrequencies_Callback([],[],handles);
end
end
% Check if coactivity was ploted
h=findobj('name',['Coactivity (' name ')']);
i=findobj('tag',['CoactiveAxes' name]);
if (isempty(h) && isempty(i))
btnPlotPeaks_Callback([],[],handles);
end
% Save
if samples<2000
win = 1;
elseif samples<4000
win = 2;
elseif samples<10000
win = 5;
elseif samples<20000
win = 10;
elseif samples<500000
win = 20;
else
win = 50;
end
Hold_Axes(['CoactiveAxes' name]);
set(gca,'xtick',0:window_sec:final_sec)
set(gca,'xticklabel',0:window_sec:final_sec)
xlabel('time (s)')
for i=1:window_sec:final_sec
Hold_Axes(['RasterAxes' name]);
xlim([i-1 i+window_sec-1]*samples_per_second/win)
Hold_Axes(['CoactiveAxes' name]);
xlim([i-1 i+window_sec-1]*samples_per_second)
% Configure and save image
Save_Figure([name '_' num2str(i-1,'%.2f') '-' num2str(i+window_sec-1,'%.2f') 'sec']);
end
%Save_Raster_By_Windows(name,samples_per_second,window_sec/win,final_sec/win)
end
% Color black
set(hObject,'ForeGroundColor',[0 0 0])
end