CAP_TB.m

%% This is the main script containing the routines necessary for the use
% of the co-activation pattern analysis (CAP) toolbox known as TbCAPs
%
% Original scripts implemented and written by Thomas A. W. Bolton, from
% the Medical Image Processing Laboratory (MIP:Lab), EPFL, Switzerland
%
% For concerns, please write to thomas.arthur.bolton@gmail.com
%
% Version 1.0 (November 9th 2018): first usable version of the toolbox, and
% start of use by a few local members from the Lausanne/Geneva Universities
%
% Version 2.0 (January 10th 2020): first publicly released version of the 
% toolbox with extended functionalities





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%% SECTION 0: SETTING UP GUI %%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Handles the opening of the toolbox window (set by MATLAB)
function varargout = CAP_TB(varargin)

gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
                   'gui_Singleton',  gui_Singleton, ...
                   'gui_OpeningFcn', @CAP_TB_OpeningFcn, ...
                   'gui_OutputFcn',  @CAP_TB_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



function CAP_TB_OpeningFcn(hObject, eventdata, handles, varargin)

%%%%%%%%%%%%%%%%%%%%
% Path and other miscellaneous settings

% Adds the paths to the subfolders of the toolbox that will be important
% for the plotting and the analysis
addpath(genpath('./Plotting'));
addpath(genpath('./Analysis'));
addpath(genpath('./DefaultData'));

% Sets warnings off
warning('off');

% Choose default command line output for CAP_TB
handles.output = hObject;


%%%%%%%%%%%%%%%%%%%%
% Data loading

% TC will contain the time courses of the subjects from the different
% populations (cell array, each cell with size n_TP x n_masked_voxels)
handles.TC = {};

% FD contains the traces of framewise displacement for the subjects (n_TP x
% n_subj per cell of the array, one cell per dataset)
handles.FD = {};

% Information on the NIFTI files from which the data originate, used in
% order to plot brain slices in the interface
handles.brain_info = {};

% mask specifies the voxels that will be retained for the analyses
handles.mask = {};

% Number of datasets added to the interface. A dataset is defined as a
% population of subjects from the same experimental group (e.g., an 
% ensemble of subjects suffering from the same disorder)
handles.n_datasets = 0;

handles.ReferencePopulation = 1;

% Stores the number of subjects that have been loaded
handles.n_subjects = {};

% TP and VOX contain the number of time points (of frames) and of brain
% voxels that are present in the loaded datasets. Those values are
% initialized at -inf, and then take the values of the first file that is
% being loaded if that file looks reasonable dimensionally speaking. In the
% scripts below, it is assumed that all subject populations loaded have a
% similar number of time points and of voxels
handles.SubjSize.TP = -inf;
handles.SubjSize.VOX = -inf;

mask_string{1} = 'Grey matter';
mask_string{2} = 'Whole-brain';
mask_string{3} = 'White matter';
mask_string{4} = 'CSF';

set(handles.MaskPopup,'String',mask_string);
clear mask_string

handles.prefix = 'sw';

% Loads and sets the brain underlay used for plotting purposes
Underlay = load_nii('Underlay.nii');
Underlay_mat = [Underlay.hdr.hist.srow_x; Underlay.hdr.hist.srow_y; Underlay.hdr.hist.srow_z; 0 0 0 1];
Underlay_dim = Underlay.hdr.dime.dim;
Underlay_dim = Underlay_dim(2:4);
handles.Underlay_info.dim = Underlay_dim;
handles.Underlay_info.mat = Underlay_mat;
clear Underlay
clear Underlay_dim
clear Underlay_mat
load('brain.mat');
assignin('base','brain', brain);
handles.brain = brain;
clear brain

% Handles for the TR and whether it is a reasonable value; the latter
% boolean is used to plot some axes as a function of time instead of
% samples
handles.TR = -inf;
handles.isTROK = false;


%%%%%%%%%%%%%%%%%%%%
% Seed selection and seed maps

% Seed(s) used for the analysis
handles.seed = [];

% Because there can be more than one seed, we create a vector that will
% encompass the multiple information in several colors
handles.seed_display = [];

% Handle to verify whether the amount of seeds has been entered well, how
% many seeds there are, and the type of computation to run on the seeds
handles.isSeedOK = false;

% Number of different seeds
handles.n_seed = 1;

handles.SeedType = 'Average';

% One average map of correlation is computed across subjects and can be
% displayed as a sanity check
handles.AvgSeedMap = [];


%%%%%%%%%%%%%%%%%%%%
% Time points selection

% Motion threshold for scrubbing (in [mm])
handles.Tmot = 0.5;

% Threshold for frame selection in the analysis
handles.T = 0.5;

% Sets the right text header in front of the frame selection threshold box
% (threshold or retention percentage)
if get(handles.TRadio,'Value')
    set(handles.TText,'String','T [-]');
    handles.SelMode = 'Threshold';
else
    set(handles.TText,'String','P [%]');
    handles.SelMode = 'Percentage';
end

handles.is_seed_free = 0;

% Denotes the type of frames (activation, deactivation or both) to use for
% selecting time points. There can be at most three different seeds
handles.SignMatrix = [1 0; 1 0; 1 0];

% Activation and deactivation frames kept and that should enter the
% clustering stage
handles.Xonp = {};
handles.Xonn = {};

% Percentage of frames retained for CAP analysis (discarding both the
% baseline time points and the scrubbed time points)
handles.RetainedPercentage = {};

% Indices of the frames that have been retained (i.e., when do they occur in
% the full time course), of baseline frames, and of scrubbed frames
handles.FrameIndices = {};

handles.idx_sep_seeds = {};


%%%%%%%%%%%%%%%%%%%%
% CAP analysis

handles.is_consensus_clustering = 0;

handles.ConsensusQuality = [];
handles.Consensus = [];

% Max number of clusters to verify with consensus clustering
handles.Kmax = 12;

% Percentage of items to use for the consensus clustering folds
handles.PCC = 80;

% Number of times that clustering is run
handles.n_rep = 20;

% Percentage voxels to keep for clustering (positive - Pp - and negative -
% Pn - ones)
handles.Pp = 100;
handles.Pn = 100;

% Number of clusters to use in the analysis
handles.K = 5;

% Indices of the CAP to which frames from the reference population and from
% the other populations are assigned
handles.idx = {};

% Value of correlation of the control group frame that is the Tper-th least
% close to its CAP
handles.CorrDist = [];

% Contains the CAPs
handles.CAP = [];

handles.Disp = [];

% Contains the standard deviation for the CAPs
handles.STDCAP = [];

% Percentile threshold used in frame assignment
handles.percentile = 5;


%%%%%%%%%%%%%%%%%%%%
% Metrics

% Will contain the metrics
% State matrix (n_subjects x n_time points)
handles.TPM = {};

% State counts (raw and frac)
handles.Counts = {};

% Number of times entering a state
handles.Number = {};

% Average duration within a state
handles.Avg_Duration = {};

% Duration of all the excursions within a state
handles.Duration = {};

% New more recently introduced graph theoretical metrics
handles.From_Baseline = {};

handles.To_Baseline = {};

handles.Baseline_resilience = {};

handles.Resilience = {};

handles.Betweenness = {};

handles.kin = {};

handles.kout = {};

% Transition probabilities 
handles.TM = {};

% Cumulative sum of states
handles.TPMCum = {};

% Seed fractions
handles.sfrac = [];

% Number of each type of frame per subject
handles.SubjectEntries = {};

%%%%%%%%%%%%%%%%%%%%
% General utilities

% Log containing the different events summoned from the toolbox
handles.Log = {};

% Colors used in plotting of all populations
handles.PopColor{1} = [255,255,180; 219,224,252; 188,252,188; 230,230,230]/255;
handles.PopColor{2} = [130,48,48; 51,75,163; 59,113,86; 0, 0, 0]/255;

% Project title, by default 'Untitled'
handles.project_title = 'Untitled';

% Directory to which data is to be saved (initially loaded as ./SavedData)
handles.savedir = fullfile(pwd,'SavedData');
set(handles.SaveFolderText,'String',handles.savedir);

% Update handles structure
guidata(hObject, handles);



function varargout = CAP_TB_OutputFcn(hObject, eventdata, handles) 

% Get default command line output from handles structure
varargout{1} = handles.output;





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%% SECTION 1: LOADING %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Mask Button Click
% Executes when inputing a new mask file; either the user properly enters
% the data, and a mask is created accordingly, or a default is used
% otherwise
function MaskButton_Callback(hObject, eventdata, handles)

%     try
%         % Selects the folders where to look (should be the ones just before the
%         % 'anat' vs 'func' distinction)
%         ToMask = spm_select(Inf,'dir','Select what to compute mask from (root directories)...');
% 
%         % Iterating across these folders to generate our mask...
%         for i = 1:size(ToMask,1)
% 
%             % Current file path
%             tmp = ToMask(i,:);
% 
%             % We need to determine the header for our data at hand, and we
%             % do so if we are considering the first folder inputed
%             if i == 1
% 
%                 % Selects all the functional files that match our criteria
%                 % (prefix 'sw' meaning smoothed MNI space data)
%                 FFiles = cellstr(spm_select('List',fullfile(tmp,'func'),['^' handles.prefix '.*\.' 'nii' '$']));
% 
%                 % We read the header of the first one to get the data
%                 % resolution
%                 handles.brain_info{handles.n_datasets+1} = spm_vol(fullfile(tmp,'func',FFiles{1}));
% 
%                 % We initialise our mask as a 3D volume
%                 mask_final = logical(ones(handles.brain_info{handles.n_datasets+1}.dim));
%             end
% 
%             % Gets the grey matter data
%             SFile = cellstr(spm_select('List',fullfile(tmp,'anat'),['^' 'wc1' '.*\.' 'nii' '$']));
%             tmp_GM = spm_vol(fullfile(tmp,'anat',SFile{1}));
%             tmp_GMvol = spm_read_vols(tmp_GM);
% 
%             % Converts into functional resolution
%             tmp_GMvol2 = CAP_V2V(tmp_GMvol,tmp_GM.dim,tmp_GM.mat,handles.brain_info{handles.n_datasets+1}.dim,handles.brain_info{handles.n_datasets+1}.mat);
% 
%             % Binarises
%             tmp_GMvol2 = logical(tmp_GMvol2);  
% 
%             % We will, every time, only keep the voxels that are present
%             % across all subjects
%             mask_final = mask_final & tmp_GMvol2;
%         end
% 
%         % Filling in the mask variable for the dataset at hand as a 1D
%         % logical vector
%         handles.mask{handles.n_datasets+1} = mask_final(:);
%         
%         % The button is turned to blue and data stored
%         handles.Log = CAP_AddToLog(handles.Log,'New mask generated for the analysis',{sum(handles.mask{handles.n_datasets+1}),size(ToMask,1)},{'Number of voxels','Number of subjects computed from'});
%         set(hObject,'BackgroundColor', [101,140,196]/255);
%         
%         set(handles.DataButton,'Enable','on');
%         set(hObject,'Enable','off');    
        
    % If there is a problem, we instead ask the user 
        
    ToMask = spm_select(Inf,'dir','Please select a directory with functional volumes of any subject...');

    % Current file path
    tmp = ToMask(1,:);

    % Selects all the functional files that match our criteria
    % (prefix 'sw' meaning MNI space data)
    FFiles = cellstr(spm_select('List',fullfile(tmp),['^' handles.prefix '.*\.' 'nii' '$']));

    % We read the header of the first one to get the data
    % resolution
    try
        handles.brain_info{handles.n_datasets+1} = spm_vol(fullfile(tmp,FFiles{1}));

        switch get(handles.MaskPopup,'Value')
            
            %GM
            case 1
               a = spm_vol(fullfile('.','DefaultData','Default_mask.nii'));
            % Whole-brain
            case 2
               a = spm_vol(fullfile('.','DefaultData','BrainMask.nii'));
            % White matter
            case 3
               a = spm_vol(fullfile('.','DefaultData','WhiteMask.nii'));
            % CSF
            case 4
               a = spm_vol(fullfile('.','DefaultData','CerebroMask.nii'));
        end
        
        b = spm_read_vols(a);
        b(b < 0.9) = 0;
        b(b >= 0.9) = 1;

        maskf = CAP_V2V(b,a.dim,a.mat,handles.brain_info{handles.n_datasets+1}.dim,handles.brain_info{handles.n_datasets+1}.mat);

        % Filling accordingly
        handles.mask{handles.n_datasets+1} = logical(maskf(:));

        tmp = get(handles.MaskPopup,'String');
        handles.Log = CAP_AddToLog(handles.Log,'New default mask generated',{tmp{get(handles.MaskPopup,'Value')},sum(handles.mask{handles.n_datasets+1})},{'Type of mask','Number of voxels'});
        set(hObject,'BackgroundColor', [101,140,196]/255);

        set(handles.DataButton,'Enable','on');
        set(hObject,'Enable','off');

    % If we enter here, it means even the default mask generation
    % failed, in which case we want to clear everything and have the
    % toolbox restarted
    catch
        errordlg('Error in attempting to create default mask!');
        handles = ClearDataButton_Callback(hObject, eventdata, handles);
    end
    
% Update handles structure
guidata(hObject, handles);



%% Data Button Click
% Executes when adding a subject population (clicking on 'A2. Load data')
function DataButton_Callback(hObject, eventdata, handles)
    
    % The user selects the data of interest for the group that should be
    % constructed
    Data_OI = spm_select(Inf,'dir','Select the directories containing the functional data to analyse within the assessed group...');
    
    % Number of subjects (or runs) considered
    handles.n_subjects{handles.n_datasets+1} = size(Data_OI,1);
    
    try
        % We now want to update the FD and TC variables by going through all
        % the subjects to add to the considered group...
        for i = 1:size(Data_OI,1)
            
            disp(['Currently preparing the data from run ',num2str(i),'...']);

            % As before, the "sw" prefix is looked for
            FFiles = cellstr(spm_select('List',fullfile(Data_OI(i,:)),['^' handles.prefix '.*\.' 'nii' '$']));

            % Functional files are read one after the other to build
            % tmp_data
            tmp_data = [];

            for t = 1:length(FFiles)

                tmp1 = spm_vol(fullfile(Data_OI(i,:),FFiles{t}));
                tmp2 = spm_read_vols(tmp1);
                tmp3 = tmp2(:);

                tmp_data = [tmp_data;tmp3(handles.mask{1})'];
            end

            % Z-scoring is performed within the toolbox
            % tmp_data = detrend(tmp_data);
            % tmp_data = zscore(tmp_data);
            tmp_data = (tmp_data-repmat(mean(tmp_data),size(tmp_data,1),1)) ./ repmat(std(tmp_data),size(tmp_data,1),1);
            tmp_data(isnan(tmp_data)) = 0;
            
            % The ready-to-analyse data is put in TC
            handles.TC{handles.n_datasets+1}{i} = tmp_data;
            clear tmp_data

            try
                % Look for the text file with motion parameters (should be the
                % first text file found)
                MFile = cellstr(spm_select('List',fullfile(Data_OI(i,:)),['.*\.' 'txt' '$']));

                % Computes framewise displacement and fills the FD matrix
                % accordingly
                handles.FD{handles.n_datasets+1}(:,i) = CAP_ComputeFD(fullfile(Data_OI(i,:),MFile{1}));
            catch
                handles.FD{handles.n_datasets+1}(:,i) = zeros(length(FFiles),1);
                handles.Log = CAP_AddToLog(handles.Log,'Could not process motion text file; assuming zero movement...');
            end
        end

        % Some commands are run only for the first dataset that we add; we 
        % compute and store the number of voxels and the number of time
        % points, as well as the number of subjects
        if handles.n_datasets == 0
                handles.SubjSize.VOX = size(handles.TC{1}{1},2);
                handles.SubjSize.TP = size(handles.TC{1}{1},1);
        end

        % Sets the text label about data dimensions
        set(handles.Dimensionality_Text, 'String', [num2str(handles.SubjSize.TP),...
            ' frames x ',num2str(handles.SubjSize.VOX),' voxels (',...
            strjoin(arrayfun(@(x) num2str(x),cell2mat(handles.n_subjects),...
            'UniformOutput',false),'+'),')']);

        % We can now enable the seed selection
        set(handles.SeedButton,'Enable','on');
        set(handles.SeedFreeButton,'Enable','on');
        set(handles.TMotText,'Visible','on');
        set(handles.TMotEdit,'Visible','on');
%         set(handles.TText,'Visible','on');
%         set(handles.TEdit,'Visible','on');
%         set(handles.PRadio,'Visible','on');
%         set(handles.TRadio,'Visible','on');
%         set(handles.uibuttongroup7,'Visible','on');

        % Also, we can now color the button in green
        set(hObject,'BackgroundColor', [101,140,196]/255);

        % If we are loading the first dataset, we convert the underlay
        % to the resolution of the functional data for plotting
        if handles.n_datasets == 0

            % The brain variable now contains a good resolution
            % underlay that can directly be overlapped with the
            % functional data
            handles.brain = CAP_V2V(handles.brain,handles.Underlay_info.dim,...
                handles.Underlay_info.mat,handles.brain_info{1}.dim,handles.brain_info{1}.mat);
            
        else
            % Also creates the brain_info and mask for the new pop
            handles.mask{handles.n_datasets+1} = handles.mask{1};
            handles.brain_info{handles.n_datasets+1} = handles.brain_info{1};

            set(handles.CAP_TP,'Visible','on');
            set(handles.Percentile_Edit,'Visible','on');
            
            % If we are loading one more dataset on top of the
            % first one, then we clear the subsequent locations of the
            % toolbox
            handles = ClearSection2(eventdata,handles);
            handles = ClearSection3(eventdata,handles);
            handles = ClearSection4(eventdata,handles);

            % We then want to enable the assignment of frames
            set(handles.AssignButton,'Enable','on');
            set(handles.SeedButton,'Enable','on');
            set(handles.SeedFreeButton,'Enable','on');
            set(handles.TMotText,'Visible','on');
            set(handles.TMotEdit,'Visible','on');
        end
        
        % We we are loading our final population, then we disable the
        % option to enter more still
        if handles.n_datasets == 3
            set(handles.DataButton,'Enable','off');
        end

        handles.Log = CAP_AddToLog(handles.Log,'Data correctly loaded',...
            {handles.n_datasets+1},{'Population index'});
        
        % We increment handles.n_datasets
        handles.n_datasets = handles.n_datasets + 1;
        
    catch
        errordlg('Could not load subject population!');
    end
    
% Update handles structure
guidata(hObject, handles);



%% TR Textbox Interaction
% Executes when we go to the TR field to add the TR of the experiment
function TR_Entry_Callback(hObject, eventdata, handles)

    % If the TR takes a reasonable value, then we validate it; we enable values
    % larger than 0
    if (~isempty(str2double(get(hObject,'String')))) && ...
            (str2double(get(hObject,'String')) > 0) 

        handles.TR = str2double(get(hObject,'String'));    
        set(hObject,'BackgroundColor', [101,140,196]/255);
        handles.isTROK = true;

        handles.Log = CAP_AddToLog(handles.Log,'Correct value of TR entered',{handles.TR},{'TR'});

    % Else, the TR value is not accepted
    else 
        set(hObject,'BackgroundColor', [204,146,146]/255);
        handles.isTROK = false;
    end

guidata(hObject, handles); 

% Executes during creation of the TR textbox
function handles = TR_Entry_CreateFcn(hObject, eventdata, handles)

    set(hObject,'Enable','off');
    set(hObject,'String','Click to enter...');
    set(hObject,'FontAngle','italic');

    if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
        set(hObject,'BackgroundColor','r');
    end

guidata(hObject, handles); 

% Executes when clicking on the TR text space
function TR_Entry_ButtonDownFcn(hObject, eventdata, handles)

    set(hObject,'Enable','on');
    set(hObject,'String','');
    set(hObject,'FontAngle','normal');
    uicontrol(hObject);

guidata(hObject, handles); 

function PrefixText_Callback(hObject, eventdata, handles)

    if (~isempty(get(hObject,'String')))
        handles.prefix = get(hObject,'String');    
        set(hObject,'BackgroundColor', [101,140,196]/255);

        handles.Log = CAP_AddToLog(handles.Log,'Prefix for data loading set',{handles.prefix},{'Prefix'});

    % Else, the TR value is not accepted
    else 
        set(hObject,'BackgroundColor', [204,146,146]/255);
    end
guidata(hObject, handles);

function handles = PrefixText_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
    set(hObject,'String','Click to enter...');
    set(hObject,'FontAngle','italic');

    if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
        set(hObject,'BackgroundColor','r');
    end

guidata(hObject, handles); 

function PrefixText_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
    set(hObject,'String','');
    set(hObject,'FontAngle','normal');
    uicontrol(hObject);

guidata(hObject, handles);

% --- Executes on selection change in MaskPopup.
function MaskPopup_Callback(hObject, eventdata, handles)

    tmp = get(hObject,'String');
    handles.Log = CAP_AddToLog(handles.Log,'Modified the type of mask to use',{tmp{get(hObject,'Value')}},{'Mask type'});

guidata(hObject, handles);


% --- Executes during object creation, after setting all properties.
function MaskPopup_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

guidata(hObject, handles);


%% Data saving and loading
% The functions below are summoned when the user wishes to save his/her
% data into a MATLAB structure, or to load previously processed data and 
% attempt clustering computations and CAP generation
function SaveFolderButton_Callback(hObject, eventdata, handles)

% Selection of a directory
[dirname]=uigetdir('*.*','Please select a save directory');
handles.savedir = dirname;

% If the user has indeed chosen a directory, we set it as the new save
% folder
if ~isequal(dirname,0)
    set(handles.SaveFolderText,'String',handles.savedir);
    set(hObject,'BackgroundColor', [101,140,196]/255);
    
    handles.Log = CAP_AddToLog(handles.Log,'Save folder changed',...
    {handles.savedir},...
    {'Save folder'});
else
    errordlg('Please select a directory !');
end

guidata(hObject,handles);

% Upon clicking on the 'SAVE' button, the data will be saved entirely under 
% a file name partly chosen by the user and partly depending on the present 
% date and time
function SaveButton_Callback(hObject, eventdata, handles)

% General information on the project
OverallInfo.ProjectTitle = handles.project_title;
OverallInfo.NumberTimePoints = handles.SubjSize.TP;
OverallInfo.NumberVoxels = handles.SubjSize.VOX;
OverallInfo.NumberSubjects = handles.n_subjects;
OverallInfo.TR = handles.TR;

Parameters.Inputs.DataHeader = handles.brain_info;
Parameters.Inputs.Mask = handles.mask;
Parameters.Inputs.Seeds = handles.seed;
Parameters.SpatioTemporalSelection.IsSeedFree = handles.is_seed_free;
Parameters.SpatioTemporalSelection.NumberSeeds = handles.n_seed;
Parameters.SpatioTemporalSelection.TypeEventRetainedPerSeed = handles.SignMatrix;
Parameters.SpatioTemporalSelection.SeedType = handles.SeedType;
Parameters.SpatioTemporalSelection.MotionThreshold = handles.Tmot;
Parameters.SpatioTemporalSelection.SelectionMode = handles.SelMode;
Parameters.SpatioTemporalSelection.FrameSelectionParameter = handles.T;
Parameters.KMeansClustering.IsConsensusRun = handles.is_consensus_clustering;
Parameters.KMeansClustering.MaxClusterNumber = handles.Kmax;
Parameters.KMeansClustering.PercentageDataPerFold = handles.PCC;
Parameters.KMeansClustering.NumberRepetitions = handles.n_rep;
Parameters.KMeansClustering.NumberClusters = handles.K;
Parameters.KMeansClustering.PercentagePositiveValuedVoxelsClustered = handles.Pp;
Parameters.KMeansClustering.PercentageNegativeValuedVoxelsClustered = handles.Pn;

Outputs.SpatioTemporalSelection.RetainedFramesPerSeed = handles.idx_sep_seeds;
Outputs.SpatioTemporalSelection.PercentageRetainedFrames = handles.RetainedPercentage;
Outputs.SpatioTemporalSelection.AverageCorrelationMap = handles.AvgSeedMap;
Outputs.KMeansClustering.ConsensusQuality = handles.ConsensusQuality;
Outputs.KMeansClustering.CoActivationPatternsDispersion = handles.Disp;
Outputs.KMeansClustering.CoActivationPatterns = handles.CAP;
Outputs.KMeansClustering.CoActivationPatternsZScored = CAP_Zscore(handles.CAP);
Outputs.KMeansClustering.CoActivationPatternsSTD = handles.STDCAP;
Outputs.KMeansClustering.AssignmentsToCAPs = handles.idx;
Outputs.Metrics.CAPExpressionIndices = handles.TPM;
Outputs.Metrics.Occurrences = handles.Counts;
Outputs.Metrics.NumberEntries = handles.Number;
Outputs.Metrics.AverageExpressionDuration = handles.Avg_Duration;
Outputs.Metrics.AllExpressionDurations = handles.Duration;
Outputs.Metrics.TransitionProbabilities = handles.TM;
Outputs.Metrics.FractionCAPFramesPerSeedCombination = handles.sfrac;
Outputs.Metrics.CAPEntriesFromBaseline = handles.From_Baseline;
Outputs.Metrics.CAPExitsToBaseline = handles.To_Baseline;
Outputs.Metrics.CAPResilience = handles.Resilience;
Outputs.Metrics.BaselineResilience = handles.Baseline_resilience;
Outputs.Metrics.BetweennessCentrality = handles.Betweenness;
Outputs.Metrics.CAPInDegree = handles.kin;
Outputs.Metrics.CAPOutDegree = handles.kout;
Outputs.Metrics.SubjectCounts = handles.SubjectEntries;
         
HeavyOutputs.SpatioTemporalSelection.ClusteredFrames = handles.Xonp;
HeavyOutputs.KMeansClustering.Consensus = handles.Consensus;

fancy_name = [handles.project_title];

% Saves NIFTI files storing the CAPs in MNI space
CAPToNIFTI(handles.CAP,...
   handles.mask{handles.ReferencePopulation},handles.brain_info{handles.ReferencePopulation},...
   handles.savedir,['CAP_NIFTI_',fancy_name]);

CAPToNIFTI(CAP_Zscore(handles.CAP),...
   handles.mask{handles.ReferencePopulation},handles.brain_info{handles.ReferencePopulation},...
   handles.savedir,['CAP_NIFTI_ZScored_',fancy_name]);

% Saves the different variables from the program
if get(handles.SaveCheckbox,'Value')
    save(fullfile(handles.savedir,fancy_name),'OverallInfo','Parameters','Outputs','HeavyOutputs','-v7.3');
else
    save(fullfile(handles.savedir,fancy_name),'OverallInfo','Parameters','Outputs','-v7.3');
end

% Adds the save process to the log
handles.Log = CAP_AddToLog(handles.Log,'Data saved');

% Writes a log .txt file with what has been done so far
file_ID = fopen(fullfile(handles.savedir,[fancy_name,'.txt']),'wt');

for i = 1:length(handles.Log)
    for j = 1:length(handles.Log{i})
        fprintf(file_ID,[handles.Log{i}{j},'\n']);
    end
    fprintf(file_ID,'\n');
end

fclose(file_ID);

% Clears the structure now that it has been saved
clear Outputs
clear HeavyOutputs
clear Parameters
clear OverallInfo

guidata(hObject,handles);

function SaveCheckbox_Callback(hObject, eventdata, handles)

guidata(hObject,handles);

% Executes when pressing on the 'CLEAR' button for data loading; supposed
% to set everything back to normal (when the window opened)
function handles = ClearDataButton_Callback(hObject, eventdata, handles)
     
    handles = ClearSection1(eventdata,handles);
    handles = ClearSection2(eventdata,handles);
    handles = ClearSection3(eventdata,handles);
    handles = ClearSection4(eventdata,handles);
    
    % Loads and sets the brain underlay used for plotting purposes
    Underlay = load_nii('Underlay.nii');
    Underlay_mat = [Underlay.hdr.hist.srow_x; Underlay.hdr.hist.srow_y; Underlay.hdr.hist.srow_z; 0 0 0 1];
    Underlay_dim = Underlay.hdr.dime.dim;
    Underlay_dim = Underlay_dim(2:4);
    handles.Underlay_info.dim = Underlay_dim;
    handles.Underlay_info.mat = Underlay_mat;
    clear Underlay
    clear Underlay_dim
    clear Underlay_mat
    load('brain.mat');
    assignin('base','brain', brain);
    handles.brain = brain;
    clear brain

    handles.Log = CAP_AddToLog(handles.Log,'Data cleared');

guidata(hObject, handles); 

% Clears the content of section 1 only
function handles = ClearSection1(eventdata, handles)

% Makes 'A. Load data' red again
set(handles.DataButton,'BackgroundColor',[204,146,146]/255);
set(handles.DataButton,'Enable','off');

% Resets the mask button
set(handles.MaskButton,'BackgroundColor',[204,146,146]/255);
set(handles.MaskButton,'Enable','on');

% Same for Save folder button
set(handles.SaveFolderButton,'BackgroundColor',[204,146,146]/255);

% Resets the time point and voxel parameters
handles.SubjSize.TP = -inf;
handles.SubjSize.VOX = -inf;

set(handles.MaskPopup,'Value',1);

handles.prefix = 'sw';
handles = PrefixText_CreateFcn(handles.PrefixText, eventdata, handles);

% Resets the TR
handles.TR = -inf;
handles.isTROK = false;

% Resets the reference population
handles.ReferencePopulation = 1;

handles = ProjectTitleText_CreateFcn(handles.ProjectTitleText,eventdata,handles);

% Also resets the number of subjects variable and associated text
set(handles.Dimensionality_Text, 'String','_ frames x _ voxels (_)');
handles.n_subjects = {};

% Resets the number of datasets entered to 0
handles.n_datasets = 0;

% Empties the data, motion, brain information and mask variables
handles.TC = {};
handles.FD = {};
handles.mask = {};
handles.brain_info = {};

% Resets the text related to motion and data files
handles.SubjNames = {};
handles.MotName = {};

% Resets the title and save folder information
handles.Log = {};

% Project title, by default 'Untitled'
handles.project_title = 'Untitled';

set(handles.SaveCheckbox,'Value',0);

% Directory to which data is to be saved (initially loaded as ./SavedData)
handles.savedir = fullfile(pwd,'SavedData');
set(handles.SaveFolderText,'String',handles.savedir);

%%%%%%%%%% Putting the loading part (bottom) back to normal %%%%%%%%%%%

% We also want to set the TR textbox back to its initial state
handles = TR_Entry_CreateFcn(handles.TR_Entry, eventdata, handles);

% Clears the content of section 2 only
function handles = ClearSection2(eventdata, handles)

% Stores the type of frames to retain for each seed
handles.SignMatrix = [1 0; 1 0; 1 0];

% Puts back the seed buttons information to original state
handles.seed = [];
set(handles.SeedButton,'BackgroundColor',[204,146,146]/255);
set(handles.SeedButton,'Enable','off');
set(handles.SeedFreeButton,'Enable','off');

set(handles.PlotSeedButton,'Enable','off');
set(handles.PlotSeedButton,'Visible','off');

% Seed label entries set invisible
set(handles.S_SEED1,'Visible','off');
set(handles.S_SEED2,'Visible','off');
set(handles.S_SEED3,'Visible','off');

handles.is_seed_free = 0;

% Removes graph display for the seed
cla(handles.SeedGraphX);
cla(handles.SeedGraphZ);
set(handles.SeedGraphX,'Visible','off');
set(handles.SeedGraphZ,'Visible','off');
set(handles.SliderX,'Visible','off');
set(handles.SliderZ,'Visible','off');
set(handles.XCoordText,'Visible','off');
set(handles.ZCoordText,'Visible','off');

%%%%%%%%%%%% Putting the seed map part back to normal %%%%%%%%%%%%%%%%%%%

% Resets the variable containing the seed maps of the subjects
handles.AvgSeedMap = [];

% Not clickable anymore
set(handles.SeedMapPushButton,'Enable','off');
set(handles.SeedMapPushButton,'Visible','off');

% Resets colorbar display
handles = ResetGraphDisplay(handles.ColorbarSeed,handles);

% Makes the slider and the text linked to slider of the seed map threshold
% back to invisible
set(handles.TSeed_Slider,'Visible','off');
set(handles.TSeed,'Visible','off');

% Resets graphs with seed map plots
handles = ResetGraphDisplay(handles.SeedMapX,handles);
handles = ResetGraphDisplay(handles.SeedMapZ,handles);

% Resets associated sliders
set(handles.SeedMapSliderX,'Visible','off');
set(handles.SeedMapSliderZ,'Visible','off');

% Resets associated slider texts
set(handles.SeedMap_SliderX,'Visible','off');
set(handles.SeedMap_SliderZ,'Visible','off');

% Resets the circles plot
handles = ResetGraphDisplay(handles.FancyCircles,handles);

% Sets the associated text back to invisible
set(handles.SeedPlusText,'Visible','off');
set(handles.SeedMinusText,'Visible','off');
set(handles.Seed1Text,'Visible','off');
set(handles.Seed2Text,'Visible','off');
set(handles.Seed3Text,'Visible','off');

% Puts the seed boxes back to not visible
set(handles.CheckS1POS,'Visible','off');
set(handles.CheckS2POS,'Visible','off');
set(handles.CheckS3POS,'Visible','off');
set(handles.CheckS1NEG,'Visible','off');
set(handles.CheckS2NEG,'Visible','off');
set(handles.CheckS3NEG,'Visible','off');

set(handles.TPSelectionButton,'Enable','off');
set(handles.TPSelectionButton,'Visible','off');

set(handles.PRadio,'Visible','off');
set(handles.TRadio,'Visible','off');
set(handles.uibuttongroup7,'Visible','off');
set(handles.TText,'Visible','off');
set(handles.TMotText,'Visible','off');
set(handles.TEdit,'Visible','off');
set(handles.TMotEdit,'Visible','off');

% Resets the frame selection mode
handles.SelMode = 'Threshold';

% Invisible Seed type list
set(handles.SeedPopup,'Visible','off');

% Reinitializes motion and the motion box
handles.Tmot = 0.5;
handles = TMotEdit_CreateFcn(handles.TMotEdit,eventdata,handles);

% Reinitializes frame selection threshold and the linked box
handles.T = 0.5;
handles = TEdit_CreateFcn(handles.TEdit,eventdata,handles);

% Resets the frame and percentage retention variables
handles.Xonp = {};
handles.Xonn = {};
handles.RetainedPercentage = {};
handles.FrameIndices = {};

% Resets the variables indexing seed selection time points retained
handles.idx_sep_seeds = {};
handles.sfrac = [];

% Resets the violin plot with percentage retained frames
handles = ResetGraphDisplay(handles.TPViolin,handles);

% Clears the content of section 3 only
function handles = ClearSection3(eventdata, handles)

set(handles.ClusterButton,'Enable','off');
set(handles.CCButton,'Enable','off');
set(handles.AssignButton,'Enable','off');
set(handles.AssignButton,'Visible','off');
    
set(handles.CCPlot,'Visible','off');
cla(handles.CCPlot);

set(handles.CAP_TP,'Visible','off');
set(handles.Percentile_Edit,'Visible','off');

set(handles.CAP_Kmax,'Visible','off');
set(handles.CAP_PPC,'Visible','off');
set(handles.CAP_N,'Visible','off');
set(handles.CAP_K,'Visible','off');
set(handles.CAP_PP,'Visible','off');
set(handles.CAP_PN,'Visible','off');

set(handles.KRange_Edit,'Visible','off');
set(handles.PCC_Edit,'Visible','off');
set(handles.ClusterEdit,'Visible','off');
set(handles.ClusterRepEdit,'Visible','off');
set(handles.ClusterPpEdit,'Visible','off');
set(handles.ClusterPnEdit,'Visible','off');

set(handles.CAP_TP,'Visible','off');
set(handles.Percentile_Edit,'Visible','off');

% Resets the consensus clustering parameter input boxes
handles = KRange_Edit_CreateFcn(handles.KRange_Edit,eventdata,handles);
handles = PCC_Edit_CreateFcn(handles.PCC_Edit,eventdata,handles);

% Resets the parameter input boxes
handles = ClusterEdit_CreateFcn(handles.ClusterEdit,eventdata,handles);
handles = ClusterRepEdit_CreateFcn(handles.ClusterRepEdit,eventdata,handles);
handles = ClusterPpEdit_CreateFcn(handles.ClusterPpEdit,eventdata,handles);
handles = ClusterPnEdit_CreateFcn(handles.ClusterPnEdit,eventdata,handles);
handles = Percentile_Edit_CreateFcn(handles.Percentile_Edit,eventdata,handles);

% Resets the consensus clustering parameters themselves
handles.Kmax = 12;
handles.PCC = 80;

set(handles.CCButton,'Visible','off');
set(handles.ClusterButton,'Visible','off');

set(handles.PIE_S1,'Visible','off');
set(handles.PIE_S2,'Visible','off');
set(handles.PIE_S3,'Visible','off');
set(handles.PIE_S1S2,'Visible','off');
set(handles.PIE_S2S3,'Visible','off');
set(handles.PIE_S1S3,'Visible','off');
set(handles.PIE_S1S2S3,'Visible','off');

% Resets the parameters themselves
handles.K = 5;
handles.n_rep = 20;
handles.Pp = 100;
handles.Pn = 100;
handles.percentile = 5;

% Resets the CAP parameters (CAPs, standard deviation within CAPs and
% indices of the CAPs to which all retained frames were assigned)
handles.CAP = [];
handles.STDCAP = [];
handles.idx = {};

% Resets the graph display of the CAP colorbar
handles = ResetGraphDisplay(handles.ColorbarCAP,handles);

% Reset all graph displays for the CAPs
tmpX = {handles.CAP1X,handles.CAP2X,handles.CAP3X,handles.CAP4X,handles.CAP5X};
tmpY = {handles.CAP1Y,handles.CAP2Y,handles.CAP3Y,handles.CAP4Y,handles.CAP5Y};
tmpZ = {handles.CAP1Z,handles.CAP2Z,handles.CAP3Z,handles.CAP4Z,handles.CAP5Z};
tmpF = {handles.CAP1_Frames,handles.CAP2_Frames,handles.CAP3_Frames,handles.CAP4_Frames,handles.CAP5_Frames};


for i_CAP = 1:5
    set(tmpF{i_CAP},'Visible','off');
    handles = ResetGraphDisplay(tmpX{i_CAP},handles);
    handles = ResetGraphDisplay(tmpY{i_CAP},handles);
    handles = ResetGraphDisplay(tmpZ{i_CAP},handles);
end

% Resets the sliders and the textboxes for the CAPs
set(handles.CAP_SliderX,'Visible','off');
set(handles.CAP_SliderY,'Visible','off');
set(handles.CAP_SliderZ,'Visible','off');
set(handles.CAP_XC,'Visible','off');
set(handles.CAP_YC,'Visible','off');
set(handles.CAP_ZC,'Visible','off');

% Resets the slider and textbox for the CAPs visualization threshold
set(handles.TVIS_Slider,'Visible','off');
set(handles.TVIS,'Visible','off');

% Resets the pie charts
handles = ResetGraphDisplay(handles.pie1,handles);
handles = ResetGraphDisplay(handles.pie2,handles);
handles = ResetGraphDisplay(handles.pie3,handles);
handles = ResetGraphDisplay(handles.pie4,handles);
handles = ResetGraphDisplay(handles.pie5,handles);

handles = ResetGraphDisplay(handles.ColorbarSimMat,handles);
handles = ResetGraphDisplay(handles.CAP_Mat,handles);

% Clears the content of section 4 only
function handles = ClearSection4(eventdata, handles)

set(handles.MetricsButton,'Enable','off');
set(handles.MetricsButton,'Visible','off');

set(handles.SubjectMenuMetrics,'Value',1);

% Resets the metrics variables
handles.TPM = {};
handles.Counts = {};
handles.Number = {};
handles.Avg_Duration = {};
handles.Duration = {};
handles.TM = {};
handles.TPMCum = {};
handles.SubjectEntries = {};
handles.From_Baseline = {};
handles.To_Baseline = {};
handles.Resilience = {};
handles.Baseline_resilience = {};
handles.Betweenness = {};
handles.kin = {};
handles.kout = {};
handles.SubjectEntries = {};

% Set the sliding lists of subjects invisible again
set(handles.SubjectMenuMetrics,'Visible','off');
set(handles.StateMenu,'Visible','off');

% Resets the colorbars from the metrics part
handles = ResetGraphDisplay(handles.ColorbarTransMat,handles);

% Resets all the graphs from the metrics part
handles = ResetGraphDisplay(handles.TMGraph,handles);
handles = ResetGraphDisplay(handles.TM_Subject,handles);
handles = ResetGraphDisplay(handles.DynStates,handles);
handles = ResetGraphDisplay(handles.CumStates,handles);
handles = ResetGraphDisplay(handles.ViolinRawCounts,handles);
handles = ResetGraphDisplay(handles.ViolinNumberEntries,handles);
handles = ResetGraphDisplay(handles.ViolinResilience,handles);
handles = ResetGraphDisplay(handles.ViolinBetweennessCentrality,handles);
handles = ResetGraphDisplay(handles.ViolinInDegree,handles);
handles = ResetGraphDisplay(handles.ViolinOutDegree,handles);

% Removes all the labels linked to Metrics displays
set(handles.DS_Scrubbed,'Visible','off');
set(handles.DS_NotSelected,'Visible','off');
set(handles.DS_Unassigned,'Visible','off');

tmp = {handles.DS_CAP1,handles.DS_CAP2,handles.DS_CAP3,handles.DS_CAP4,...
    handles.DS_CAP5,handles.DS_CAP6,handles.DS_CAP7,handles.DS_CAP8,...
    handles.DS_CAP9,handles.DS_CAP10,handles.DS_CAP11,handles.DS_CAP12};

for i = 1:length(tmp)
    set(tmp{i},'Visible','off');
end

clear tmp

tmp = {handles.V_POP1,handles.V_POP2,handles.V_POP3,handles.V_POP4};

for i = 1:length(tmp)
    set(tmp{i},'Visible','off');
end

clear tmp

% The following functions enable to modify the text of the project title
function ProjectTitleText_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);

function handles = ProjectTitleText_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

guidata(hObject, handles);

function ProjectTitleText_Callback(hObject, eventdata, handles)

% If we have entered a valid string, then we name the project as such
if ~isempty((get(hObject,'String')))
    handles.project_title = get(hObject,'String');
    set(hObject,'BackgroundColor', [101,140,196]/255);
    
    handles.Log = CAP_AddToLog(handles.Log,'Valid project title entered',{handles.project_title},{'New project title'});
    
% If we haven't entered anything, the project is just named 'untitled'
else
    handles.project_title = 'Untitled';
    set(hObject,'BackgroundColor',[204,146,146]/255);
end

guidata(hObject, handles);





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%% SECTION 2: SPATIOTEMPORAL SELECTION %%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Seed selection
% Executes when clicking on 'B. Select a seed'
function SeedButton_Callback(hObject, eventdata, handles)

% We want to clear everything from and after this stage, since we will
% compute results with a new seed
handles = ClearSection2(eventdata,handles);
set(hObject,'Enable','on');

handles = ClearSection3(eventdata,handles);
handles = ClearSection4(eventdata,handles);

% Multiselection is on, so that as many as three files can be picked
[filename_seed,pathname_seed]=uigetfile({'*.*','All Files'},...
  'Select Seed File...','MultiSelect','on');

% If the user has indeed entered files
if ~isequal(filename_seed,0) || ~isequal(pathname_seed,0)
   
    % In the case in which only one seed file is entered ('char' type),
    % we convert into an array
    if strcmp(class(filename_seed),'char')
        filename_seed = {filename_seed};
    end
    
    % If we enter that statement, it means that we have only one seed type
    % across subjects (that is, no subject-specific data)
    if length(filename_seed) <= 3

        % Number of entered seeds
        handles.n_seed = length(filename_seed);

        for myindex = 1:length(filename_seed)

            disp(['Processing seed number ',num2str(myindex),'...']);
            
            File_seed = fullfile(pathname_seed, filename_seed{myindex});
            
            % The NIFTI file for the seed is read, converted into the
            % proper resolution, masked and made logical
            tmp_seedh = spm_vol(File_seed);
            tmp_seed = spm_read_vols(tmp_seedh);
            
            tmp_seed2 = CAP_V2V(tmp_seed,tmp_seedh.dim,...
            tmp_seedh.mat,handles.brain_info{1}.dim,handles.brain_info{1}.mat);
            
            tmp = tmp_seed2(:);
            tmp = logical(tmp(handles.mask{1}));
            
            % If the file is of suitable dimensions
            if islogical(tmp) && size(tmp,2) == 1 && size(tmp,1) == sum(handles.mask{1})

                % Then we put it in the handles, enable the plotting button, and
                % make the seed selection button green
                handles.seed(:,myindex) = tmp;
                
                handles.Log = CAP_AddToLog(handles.Log,'Seed chosen',{File_seed},{'Seed file'});
            else
                errordlg('The file you entered appears to be of wrong dimensions...');
                handles = ClearDataButton_Callback(handles.ClearDataButton, eventdata, handles);
            end

        end
                
        % If we survive all the above, we can see that the seed files are
        % good
        handles.isSeedOK = true;

        % We also enable to plot the seed results
        set(handles.PlotSeedButton,'Enable','on');
        set(handles.PlotSeedButton,'Visible','on');
        
        set(handles.SeedButton,'BackgroundColor', [101,140,196]/255);
        set(handles.SeedButton,'Enable', 'off');
        set(handles.SeedFreeButton,'Enable', 'off');

        % We can now go through the next parts of the analysis, so we
        % enable the related buttons
        set(handles.TPSelectionButton,'Enable','on');
        set(handles.SeedMapPushButton,'Enable','on');
        
        set(handles.TPSelectionButton,'Visible','on');
        set(handles.SeedMapPushButton,'Visible','on');
        
        % Makes other TP selection utilities visible
        set(handles.PRadio,'Visible','on');
        set(handles.TRadio,'Visible','on');
        set(handles.uibuttongroup7,'Visible','on');
        set(handles.TText,'Visible','on');
        set(handles.TMotText,'Visible','on');
        set(handles.TEdit,'Visible','on');
        set(handles.TMotEdit,'Visible','on');
        
        % We also see the displays for entering seed specifications
        set(handles.SeedPopup,'Visible','on');
        
        handles.Log = CAP_AddToLog(handles.Log,'Correct amount of seeds entered',{handles.n_seed},{'Seed amount'});
    
        handles.seed_display = zeros(length(handles.seed(:,1)),1);
        
        set(handles.CheckS1POS,'Visible','on');
        set(handles.CheckS1NEG,'Visible','on');
        CheckS1POS_Callback(handles.CheckS1POS,eventdata,handles);
        
        set(handles.Seed1Text,'Visible','on');
        
        set(handles.SeedPlusText,'Visible','on');
        set(handles.SeedMinusText,'Visible','on');
        
        % If there are more than one seed, then we allow the popup button to be
        % changed for a more complex seed use choice
        if handles.n_seed > 1
            set(handles.SeedPopup,'Enable','on');
            set(handles.SeedPopup,'Value',2);
            handles.SeedType = 'Union';
            
            % We also update the circles in the seed illustration
            rectangle('Position',[12 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
            rectangle('Position',[11 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
            
            % We fill seed_display with one scalar value across seed voxels
            % per seed (to have different colors plotted in the seed choice
            % graph
            useless_vector = [0.25,0.75,1];
            
            for se = 1:handles.n_seed
                handles.seed_display = handles.seed_display + useless_vector(se)*handles.seed(:,se);
            end
            
            set(handles.S_SEED1,'Visible','on');
            set(handles.S_SEED2,'Visible','on');
            
            set(handles.CheckS2POS,'Visible','on');
            set(handles.CheckS2NEG,'Visible','on');
            CheckS2POS_Callback(handles.CheckS2POS,eventdata,handles);
            
            set(handles.Seed2Text,'Visible','on');
        
            % Same for 3 seeds
            if handles.n_seed > 2
                set(handles.CheckS3POS,'Visible','on');
                set(handles.CheckS3NEG,'Visible','on');
                CheckS3POS_Callback(handles.CheckS3POS,eventdata,handles);
                
                set(handles.Seed3Text,'Visible','on');
                
                rectangle('Position',[32 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
                rectangle('Position',[31 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
                
                set(handles.S_SEED3,'Visible','on');
            end
         
        % Entered if we have just one seed
        else
            % We make the text legends visible and colours accordingly
            set(handles.S_SEED1,'Visible','on');
            set(handles.S_SEED1,'ForegroundColor',[103,0,31]/255);
            
            set(handles.SeedPopup,'Enable','off');
            set(handles.SeedPopup,'Value',1);
            handles.SeedType = 'Average';
            
            handles.seed_display = handles.seed;
            
            set(handles.CheckS1POS,'Visible','on');
            set(handles.CheckS1NEG,'Visible','on');
        end
        
        rectangle('Position',[0 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
        
        if handles.n_seed > 1
            rectangle('Position',[20 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
            
            if handles.n_seed > 2
                rectangle('Position',[40 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
            end
        end
    else
        errordlg('Problem with the amount of seed files entered !');
        handles = ClearDataButton_Callback(handles.ClearDataButton, eventdata, handles);
    end
    
    % Updates the limits of the plot
    switch handles.n_seed
        case 1
            set(handles.FancyCircles,'xlim',[-10 10]);
            set(handles.FancyCircles,'ylim',[-10 10]);
        case 2
            set(handles.FancyCircles,'xlim',[-10 30]);
            set(handles.FancyCircles,'ylim',[-10 30]);
        case 3
            set(handles.FancyCircles,'xlim',[-10 50]);
            set(handles.FancyCircles,'ylim',[-10 50]);
    end
    
else
    errordlg('You did not enter a seed file !');
    handles = ClearDataButton_Callback(handles.ClearDataButton, eventdata, handles);
end
        
guidata(hObject, handles);



%% Seed plotting and associated sliders
% Executes when clicking on 'Plot Seed'
function PlotSeedButton_Callback(hObject, eventdata, handles)

% Clears the present graph content
cla(handles.SeedGraphX);
cla(handles.SeedGraphZ);

% Plots the slices within the graph windows
handles.SeedGraphX = plot_slice(handles.seed_display,get(handles.TVIS_Slider,...
    'Value'),1,handles.mask{handles.ReferencePopulation},handles.brain,...
    handles.brain_info{handles.ReferencePopulation},'X',get(handles.SliderX,...
    'Value'),handles.SeedGraphX);

handles.SeedGraphZ = plot_slice(handles.seed_display,get(handles.TVIS_Slider,...
    'Value'),1,handles.mask{handles.ReferencePopulation},handles.brain,...
    handles.brain_info{handles.ReferencePopulation},'Z',get(handles.SliderZ,...
    'Value'),handles.SeedGraphZ);

% Sets the sliders to visible
set(handles.SliderX,'Visible','on');
set(handles.SliderZ,'Visible','on');

% Sets the text values at the ones of the sliders
set(handles.XCoordText,'String',['X: ',sprintf('%.2f',get(handles.SliderX,'Value'))]);
set(handles.ZCoordText,'String',['Z: ',sprintf('%.2f',get(handles.SliderZ,'Value'))]);

% Sets the visibility of the slider texts to on
set(handles.XCoordText,'Visible','on');
set(handles.ZCoordText,'Visible','on');

handles.Log = CAP_AddToLog(handles.Log,'Seed plots activated');

guidata(hObject, handles);

% Executes on slider movement.
function SliderX_Callback(hObject, eventdata, handles)

% Clears the content of the graph
cla(handles.SeedGraphX);

% Gets the MNI slice coordinate value associated to the new display
set(handles.XCoordText,'String',['X: ',sprintf('%.2f',get(hObject,'Value'))]);

% Slice plotting itself; 1.5 is the color past which the display saturates
handles.SeedGraphX = plot_slice(handles.seed_display,get(handles.TVIS_Slider,...
    'Value'),1,handles.mask{handles.ReferencePopulation},handles.brain,...
    handles.brain_info{handles.ReferencePopulation},'X',get(hObject,'Value'),...
    handles.SeedGraphX);

guidata(hObject, handles);

% Executes during object creation, after setting all properties.
function SliderX_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

guidata(hObject, handles); 

% Executes on slider movement.
function SliderZ_Callback(hObject, eventdata, handles)

cla(handles.SeedGraphZ);
set(handles.ZCoordText,'String',['Z: ',sprintf('%.2f',get(hObject,'Value'))]);
handles.SeedGraphZ = plot_slice(handles.seed_display,get(handles.TVIS_Slider,...
    'Value'),1,handles.mask{handles.ReferencePopulation},handles.brain,...
    handles.brain_info{handles.ReferencePopulation},'Z',get(hObject,'Value'),...
    handles.SeedGraphZ);

guidata(hObject, handles); 

% Executes during object creation, after setting all properties.
function SliderZ_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

guidata(hObject, handles); 



%% Seed Map Computation Button
% When pressing on this button, classical seed maps are computed for the
% population of subjects chosen as the reference one in the loading part.
% The first seed (seed 1) is used.
function SeedMapPushButton_Callback(hObject, eventdata, handles)

% Computes seed maps for each subject and for the population, using the
% data from the chosen reference population
[~,handles.AvgSeedMap] = CAP_Compute_SeedMap(handles.TC{handles.ReferencePopulation},handles.seed,1);

% Graphical displays

% Making the plots, texts and sliders visible
set(handles.SeedMapX,'Visible','on');
set(handles.SeedMapZ,'Visible','on');

set(handles.SeedMap_SliderX,'Visible','on');
set(handles.SeedMap_SliderZ,'Visible','on');
set(handles.SeedMapSliderX,'Visible','on');
set(handles.SeedMapSliderZ,'Visible','on');

set(handles.TSeed_Slider,'Visible','on');
set(handles.TSeed,'Visible','on');
set(handles.ColorbarSeed,'Visible','on');

% Writing down the text with current MNI coordinates
set(handles.SeedMap_SliderX,'String',['X: ',sprintf('%.2f',get(handles.SeedMapSliderX,'Value'))]);
set(handles.SeedMap_SliderZ,'String',['Z: ',sprintf('%.2f',get(handles.SeedMapSliderZ,'Value'))]);

% Clears previous plot contents (in case we want to re-plot after changing
% the seed)
cla(handles.SeedMapX);
cla(handles.SeedMapZ);

% Plots new slices
handles.SeedMapX = plot_slice(handles.AvgSeedMap,0.25,1,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},'X',get(handles.SeedMapSliderX,'Value'),handles.SeedMapX);
handles.SeedMapZ = plot_slice(handles.AvgSeedMap,0.25,1,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},'Z',get(handles.SeedMapSliderZ,'Value'),handles.SeedMapZ);

% Adds the colorbar for the seed maps (between -1 and 1)
handles.ColorbarSeed = Create_CAP_colorbar(-1,1,0.5,get(handles.TSeed_Slider,'Value'),'',handles.ColorbarSeed,'Horizontal','div','RdBu',1000);

handles.Log = CAP_AddToLog(handles.Log,'Seed maps displayed');

guidata(hObject,handles);

function SeedMapSliderX_Callback(hObject, eventdata, handles)

% Clears graphs
cla(handles.SeedMapX);

% Changes slider texts
set(handles.SeedMap_SliderX,'String',['X: ',sprintf('%.2f',get(hObject,'Value'))]);

% Plots new slices
handles.SeedMapX = plot_slice(handles.AvgSeedMap,get(handles.TSeed_Slider,'Value'),1,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},'X',get(hObject,'Value'),handles.SeedMapX);

guidata(hObject, handles);

function SeedMapSliderX_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

function SeedMapSliderZ_Callback(hObject, eventdata, handles)

cla(handles.SeedMapZ);

% Changes slider texts
set(handles.SeedMap_SliderZ,'String',['Z: ',sprintf('%.2f',get(hObject,'Value'))]);

% Plots new slices
handles.SeedMapZ = plot_slice(handles.AvgSeedMap,get(handles.TSeed_Slider,'Value'),1,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},'Z',get(hObject,'Value'),handles.SeedMapZ);

guidata(hObject, handles);

function SeedMapSliderZ_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

function TSeed_Slider_Callback(hObject, eventdata, handles)

% Clears previous plot contents
cla(handles.SeedMapX);
cla(handles.SeedMapZ);

% Plots new slices (average seed maps)
handles.SeedMapX = plot_slice(handles.AvgSeedMap,get(hObject,'Value'),1,...
    handles.mask{handles.ReferencePopulation},handles.brain,...
    handles.brain_info{handles.ReferencePopulation},'X',...
    get(handles.SeedMapSliderX,'Value'),handles.SeedMapX);

handles.SeedMapZ = plot_slice(handles.AvgSeedMap,get(hObject,'Value'),1,...
    handles.mask{handles.ReferencePopulation},handles.brain,...
    handles.brain_info{handles.ReferencePopulation},'Z',...
    get(handles.SeedMapSliderZ,'Value'),handles.SeedMapZ);

% Modifies the text
set(handles.TSeed,'String',['Tv: ',sprintf('%.2f',get(hObject,'Value'))]);

% Clears and replots the colorbar
cla(handles.ColorbarSeed);
handles.ColorbarSeed = Create_CAP_colorbar(-1,1,0.5,get(hObject,'Value'),'',handles.ColorbarSeed,'Horizontal','div','RdBu',1000);

guidata(hObject,handles);

function TSeed_Slider_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end




%% (De)activation frame selection specifications
% The functions below control what happens when we click on the S1, S2 and
% S3 buttons to decide the type of frames to select. It also adjusts the
% displays accordingly
function CheckS1POS_Callback(hObject, eventdata, handles)

if get(hObject,'Value')
    set(handles.CheckS1NEG,'Value',0);
else
    set(handles.CheckS1POS,'Value',1);
end

handles.SignMatrix(1,:) = [1 0];

rectangle('Position',[0 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);

% Modifies the axis parameters to have a big enough seed display
axis(handles.FancyCircles,'square');

switch handles.n_seed
    case 1
        set(handles.FancyCircles,'xlim',[-10 10]);
        set(handles.FancyCircles,'ylim',[-10 10]);
    case 2
        set(handles.FancyCircles,'xlim',[-10 30]);
        set(handles.FancyCircles,'ylim',[-10 30]);
    case 3
        set(handles.FancyCircles,'xlim',[-10 50]);
        set(handles.FancyCircles,'ylim',[-10 50]);
end

handles.Log = CAP_AddToLog(handles.Log,'Selecting activations for seed 1');

guidata(hObject,handles);

function CheckS1NEG_Callback(hObject, eventdata, handles)

if get(hObject,'Value')
    handles.SignMatrix(1,:) = [0 1];
    set(handles.CheckS1POS,'Value',0);
    rectangle('Position',[0 0 10 10],'Curvature',[1 1],'FaceColor',[51,75,163]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    handles.Log = CAP_AddToLog(handles.Log,'Selecting deactivations for seed 1');
else
    handles.SignMatrix(1,:) = [1 0];
    set(handles.CheckS1POS,'Value',1);
    rectangle('Position',[0 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    handles.Log = CAP_AddToLog(handles.Log,'Selecting activations for seed 1');
end

% Modifies the axis parameters to have a big enough seed display
axis(handles.FancyCircles,'square');

switch handles.n_seed
    case 1
        set(handles.FancyCircles,'xlim',[-10 10]);
        set(handles.FancyCircles,'ylim',[-10 10]);
    case 2
        set(handles.FancyCircles,'xlim',[-10 30]);
        set(handles.FancyCircles,'ylim',[-10 30]);
    case 3
        set(handles.FancyCircles,'xlim',[-10 50]);
        set(handles.FancyCircles,'ylim',[-10 50]);
end

guidata(hObject,handles);

function CheckS2POS_Callback(hObject, eventdata, handles)

if get(hObject,'Value')
    set(handles.CheckS2NEG,'Value',0);
else
    set(handles.CheckS2POS,'Value',1);
end

handles.SignMatrix(2,:) = [1 0];
rectangle('Position',[20 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);

% Modifies the axis parameters to have a big enough seed display
axis(handles.FancyCircles,'square');

switch handles.n_seed
    case 1
        set(handles.FancyCircles,'xlim',[-10 10]);
        set(handles.FancyCircles,'ylim',[-10 10]);
    case 2
        set(handles.FancyCircles,'xlim',[-10 30]);
        set(handles.FancyCircles,'ylim',[-10 30]);
    case 3
        set(handles.FancyCircles,'xlim',[-10 50]);
        set(handles.FancyCircles,'ylim',[-10 50]);
end

handles.Log = CAP_AddToLog(handles.Log,'Selecting activations for seed 2');

guidata(hObject,handles);

function CheckS2NEG_Callback(hObject, eventdata, handles)

if get(hObject,'Value')
    handles.SignMatrix(2,:) = [0 1];
    set(handles.CheckS2POS,'Value',0);
    rectangle('Position',[20 0 10 10],'Curvature',[1 1],'FaceColor',[51,75,163]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    handles.Log = CAP_AddToLog(handles.Log,'Selecting deactivations for seed 2');
else
    handles.SignMatrix(2,:) = [1 0];
    set(handles.CheckS2POS,'Value',1);
    rectangle('Position',[20 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    handles.Log = CAP_AddToLog(handles.Log,'Selecting activations for seed 2');
end

% Modifies the axis parameters to have a big enough seed display
axis(handles.FancyCircles,'square');

switch handles.n_seed
    case 1
        set(handles.FancyCircles,'xlim',[-10 10]);
        set(handles.FancyCircles,'ylim',[-10 10]);
    case 2
        set(handles.FancyCircles,'xlim',[-10 30]);
        set(handles.FancyCircles,'ylim',[-10 30]);
    case 3
        set(handles.FancyCircles,'xlim',[-10 50]);
        set(handles.FancyCircles,'ylim',[-10 50]);
end

guidata(hObject,handles);

function CheckS3POS_Callback(hObject, eventdata, handles)

if get(hObject,'Value')
    set(handles.CheckS3NEG,'Value',0);
else
    set(handles.CheckS3POS,'Value',1);
end

handles.SignMatrix(3,:) = [1 0];

rectangle('Position',[40 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);

% Modifies the axis parameters to have a big enough seed display
axis(handles.FancyCircles,'square');

switch handles.n_seed
    case 1
        set(handles.FancyCircles,'xlim',[-10 10]);
        set(handles.FancyCircles,'ylim',[-10 10]);
    case 2
        set(handles.FancyCircles,'xlim',[-10 30]);
        set(handles.FancyCircles,'ylim',[-10 30]);
    case 3
        set(handles.FancyCircles,'xlim',[-10 50]);
        set(handles.FancyCircles,'ylim',[-10 50]);
end

handles.Log = CAP_AddToLog(handles.Log,'Selecting activations for seed 3');

guidata(hObject,handles);

function CheckS3NEG_Callback(hObject, eventdata, handles)

if get(hObject,'Value')
    handles.SignMatrix(3,:) = [0 1];
    set(handles.CheckS3POS,'Value',0);
    rectangle('Position',[40 0 10 10],'Curvature',[1 1],'FaceColor',[51,75,163]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    handles.Log = CAP_AddToLog(handles.Log,'Selecting deactivations for seed 3');
else
    handles.SignMatrix(3,:) = [1 0];
    set(handles.CheckS3POS,'Value',1);
    rectangle('Position',[40 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    handles.Log = CAP_AddToLog(handles.Log,'Selecting activations for seed 3');
end

% Modifies the axis parameters to have a big enough seed display
axis(handles.FancyCircles,'square');

switch handles.n_seed
    case 1
        set(handles.FancyCircles,'xlim',[-10 10]);
        set(handles.FancyCircles,'ylim',[-10 10]);
    case 2
        set(handles.FancyCircles,'xlim',[-10 30]);
        set(handles.FancyCircles,'ylim',[-10 30]);
    case 3
        set(handles.FancyCircles,'xlim',[-10 50]);
        set(handles.FancyCircles,'ylim',[-10 50]);
end

guidata(hObject,handles);



%% Type of seed combination selection
% The functions below control how to determine which seed selection scheme
% should be run
function SeedPopup_Callback(hObject, eventdata, handles)

% Clears and makes the circles display reflecting seed types invisible
handles = ResetGraphDisplay(handles.FancyCircles,handles);

% We consider the value selected by the user for the first seed between
% '+' or '-', and update the FancyCircles plot accordingly
if get(handles.CheckS1POS,'Value')
    rectangle('Position',[0 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
elseif get(handles.CheckS1NEG,'Value')
    rectangle('Position',[0 0 10 10],'Curvature',[1 1],'FaceColor',[51,75,163]/255,'EdgeColor','none','Parent',handles.FancyCircles);
end

% The same is done for the other seeds, if more than one has been loaded
% (or if more than two have been loaded)
if handles.n_seed > 1

    if get(handles.CheckS2POS,'Value')
        rectangle('Position',[20 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    elseif get(handles.CheckS2NEG,'Value')
        rectangle('Position',[20 0 10 10],'Curvature',[1 1],'FaceColor',[51,75,163]/255,'EdgeColor','none','Parent',handles.FancyCircles);
    end
    
    if handles.n_seed > 2
        
        if get(handles.CheckS3POS,'Value')
            rectangle('Position',[40 0 10 10],'Curvature',[1 1],'FaceColor',[150,48,48]/255,'EdgeColor','none','Parent',handles.FancyCircles);
        elseif get(handles.CheckS3NEG,'Value')
            rectangle('Position',[40 0 10 10],'Curvature',[1 1],'FaceColor',[51,75,163]/255,'EdgeColor','none','Parent',handles.FancyCircles);
        end
    end
end

% The second step in the plotting is to add the "arrows" that link circles
% differently depending on whether we consider a Union or an Intersection
switch get(hObject,'Value')
    
    % If we have the "average" pick
    case 1
        % If the user selects "average" but the number of seeds entered
        % exceeds 1, then by default we revert back to the "union" case,
        % since the user should enter one averaged seed file to have an
        % averaged seed output
        if handles.n_seed > 1
            set(hObject,'Value',2);
            handles.SeedType = 'Union';
            rectangle('Position',[12 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
            rectangle('Position',[11 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
            if handles.n_seed > 2
                rectangle('Position',[32 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
                rectangle('Position',[31 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
            end
        else
            handles.SeedType = 'Average';
        end
        
    % If we have the union pick
    case 2
        handles.SeedType = 'Union';
        rectangle('Position',[12 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
        rectangle('Position',[11 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
        if handles.n_seed > 2
            rectangle('Position',[32 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
            rectangle('Position',[31 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
        end
        
    % If we have the intersection pick
    case 3
        handles.SeedType = 'Intersection';
        rectangle('Position',[12 10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
        rectangle('Position',[11 9 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
        if handles.n_seed > 2
            rectangle('Position',[32 10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
            rectangle('Position',[31 9 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
        end
        
    % If we have the "union - intersection" pick (only frames when we have
    % individual activations without shared activations
    case 4
        handles.SeedType = 'Unisection';
        rectangle('Position',[12 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
        rectangle('Position',[11 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
        rectangle('Position',[12 10 6 8],'Curvature',[0.8 0.8],'EdgeColor','r','Parent',handles.FancyCircles);
        rectangle('Position',[11 9 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
        
        if handles.n_seed > 2
            rectangle('Position',[32 -10 6 8],'Curvature',[0.8 0.8],'Parent',handles.FancyCircles);
            rectangle('Position',[31 -5 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
            rectangle('Position',[32 10 6 8],'Curvature',[0.8 0.8],'EdgeColor','r','Parent',handles.FancyCircles);
            rectangle('Position',[31 9 8 4],'Curvature',[0.8 0.8],'EdgeColor','none','FaceColor','w','Parent',handles.FancyCircles);
        end
end

% Modifies the axis parameters to have a big enough seed display
axis(handles.FancyCircles,'square');

switch handles.n_seed
    case 1
        set(handles.FancyCircles,'xlim',[-10 10]);
        set(handles.FancyCircles,'ylim',[-10 10]);
    case 2
        set(handles.FancyCircles,'xlim',[-10 30]);
        set(handles.FancyCircles,'ylim',[-10 30]);
    case 3
        set(handles.FancyCircles,'xlim',[-10 50]);
        set(handles.FancyCircles,'ylim',[-10 50]);
end

handles.Log = CAP_AddToLog(handles.Log,'Seed union status changed',{handles.SeedType},{'Status'});

guidata(hObject, handles);

function SeedPopup_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

guidata(hObject, handles);



%% Motion parameter entry
% In the following, we have the functions controling the motion threshold
% (Power's FD) value
function TMotEdit_Callback(hObject, eventdata, handles)

% If we enter a reasonable value, it is taken as a new threshold
if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 0) && (str2double(get(hObject,'String')) <= 3)
    handles.Tmot = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);
    
    handles.Log = CAP_AddToLog(handles.Log,'Valid motion threshold value entered',{handles.Tmot},{'Motion threshold value'});
    
% If we set something wrong again, we set the threshold value back to the
% default of 0.5
else
    set(hObject,'BackgroundColor', [203,146,146]/255);
    handles.Tmot = 0.5;
end

guidata(hObject, handles); 

% When clicking on the motion button
function handles = TMotEdit_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject, handles); 

% When the object is created
function handles = TMotEdit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','r');
end

guidata(hObject, handles); 



%% Frame selection parameter entry
% What comes below describes the control of the frame selection threshold
% value entered by the user
function TEdit_Callback(hObject, eventdata, handles)

% If we enter a reasonable value, it is taken as the new threshold
if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 0) && (str2double(get(hObject,'String')) <= 100)
    handles.T = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);
    
    switch handles.SelMode
        case 'Threshold'
            handles.Log = CAP_AddToLog(handles.Log,'Valid (de)activation threshold entered',{handles.T},{'Threshold value'});
        case 'Percentage'
            handles.Log = CAP_AddToLog(handles.Log,'Valid percentage of frames to retain entered',{handles.T},{'Percentage value'});
        otherwise
            errordlg('You are pretty good at making this toolbox derail...');
    end
    
% If we set something wrong again, we set the threshold value back to the
% default of 0.5
else
    set(hObject,'BackgroundColor',[203,146,146]/255);
    handles.T = 0.5;
end

guidata(hObject, handles); 

% When the object is created
function handles = TEdit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end
guidata(hObject, handles); 

% When clicking on it
function TEdit_ButtonDownFcn(hObject,eventdata,handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);

% If we select threshold, we update the Selmode accordingly
function TRadio_Callback(hObject, eventdata, handles)

set(handles.TText,'String','T [-]');
handles.SelMode = 'Threshold';

% Resets the text box where we can enter the information
handles = TEdit_CreateFcn(handles.TEdit, eventdata, handles);
handles.T = 0.5;

handles.Log = CAP_AddToLog(handles.Log,'Changed time points selection scheme',{handles.SelMode},{'Selected mode'});

guidata(hObject,handles);

% Same for percentage
function PRadio_Callback(hObject, eventdata, handles)

set(handles.TText,'String','P [%]');
handles.SelMode = 'Percentage';

% Resets the text box where we can enter the information
handles = TEdit_CreateFcn(handles.TEdit, eventdata, handles);
handles.T = 20;

handles.Log = CAP_AddToLog(handles.Log,'Changed time points selection scheme',{handles.SelMode},{'Selected mode'});

guidata(hObject,handles);



%% Time points selection control
% When clicking on the select time points button, the frames matching the
% provided thresholds for scrubbing and for frame retention are selected.
% Both activation and deactivation frames are selected. This is performed
% on all the loaded populations of subjects
function TPSelectionButton_Callback(hObject, eventdata, handles)

handles = ClearSection3(eventdata,handles);
handles = ClearSection4(eventdata,handles);

% Clears the current plot display (for the case of having already computed
% something before with other parameters)
cla(handles.TPViolin);

% Performs the analysis to extract frames of activity for all loaded
% populations (done for each dataset)
for n_ds = 1:handles.n_datasets
    % Xonp and Xonn contain the frames (deactivation frames have been
    % switched in sign, so that deactivation is positive)
    [handles.Xonp{n_ds},p,Indices,...
        handles.idx_sep_seeds{n_ds}] = CAP_find_activity(handles.TC{n_ds},...
        handles.seed,handles.T,handles.FD{n_ds},handles.Tmot,...
        handles.SelMode,handles.SeedType,handles.SignMatrix);
    
    % Percentage of retained frames across subjects
    handles.RetainedPercentage{n_ds} = p(3,:);

    % Indices of the frames that have been retained (used later for metrics
    % computations)
    handles.FrameIndices{n_ds} = Indices; 
end

% Enables to go to the next step of the analysis and cluster the extracted
% frames
set(handles.ClusterButton,'Enable','on');
set(handles.CCButton,'Enable','on');

set(handles.ClusterButton,'Visible','on');
set(handles.CCButton,'Visible','on');

% Sets related displays to visible
set(handles.CAP_Kmax,'Visible','on');
set(handles.CAP_PPC,'Visible','on');
set(handles.CAP_N,'Visible','on');
set(handles.CAP_K,'Visible','on');
set(handles.CAP_PP,'Visible','on');
set(handles.CAP_PN,'Visible','on');

set(handles.KRange_Edit,'Visible','on');
set(handles.PCC_Edit,'Visible','on');
set(handles.ClusterEdit,'Visible','on');
set(handles.ClusterRepEdit,'Visible','on');
set(handles.ClusterPpEdit,'Visible','on');
set(handles.ClusterPnEdit,'Visible','on');

if handles.n_datasets > 1
    set(handles.CAP_TP,'Visible','on');
    set(handles.Percentile_Edit,'Visible','on');
end

tmp_toplot = ConcatMat(handles.RetainedPercentage,handles.n_datasets,1,handles.n_subjects,'FD');

% Displays the violin plot of subject scrubbing percentage for the
% reference population
[~,~,handles.TPViolin] = MakeViolin(tmp_toplot,handles.TPViolin,{' '},'Frames ret. [%]',handles.PopColor,handles.n_datasets,1);
set(handles.TPViolin,'Visible','on');

clear tmp_toplot

handles.Log = CAP_AddToLog(handles.Log,'Time points selected',{['1 to ',num2str(handles.n_datasets)],handles.SelMode,handles.T,handles.Tmot},{'Datasets indices','Selection mode','(De)activation threshold','Motion threshold'});

guidata(hObject, handles);



%% Seed-free analysis
% If the user presses this button, it should override the seed selection
% process, and directly go to the computation of CAPs
function SeedFreeButton_Callback(hObject, eventdata, handles)
    
    % Everything that may have been done from the seed section is not
    % relevant anymore, and thus cleared
    handles = ClearSection3(eventdata,handles);
    handles = ClearSection4(eventdata,handles);
    
    set(handles.TMotEdit,'Visible','on');
    set(handles.TMotText,'Visible','on');
    
    set(handles.SeedFreeButton,'Enable','on');
    
    handles.is_seed_free = 1;
    handles.SeedType = 'SeedFree';
    
    % Performs the analysis to extract frames of activity for all loaded
    % populations (done for each dataset)
    for n_ds = 1:handles.n_datasets
        % Xonp and Xonn contain the frames (deactivation frames have been
        % switched in sign, so that deactivation is positive)
        [handles.Xonp{n_ds},p,Indices] = CAP_find_activity_SeedFree(handles.TC{n_ds},...
            handles.FD{n_ds},handles.Tmot);

        % Percentage of retained frames across subjects
        handles.RetainedPercentage{n_ds} = p(3,:);

        % Indices of the frames that have been retained (used later for metrics
        % computations)
        handles.FrameIndices{n_ds} = Indices; 
    end

    % Enables to go to the next step of the analysis and cluster the extracted
    % frames
    set(handles.ClusterButton,'Enable','on');
    set(handles.CCButton,'Enable','on');

    set(handles.ClusterButton,'Visible','on');
    set(handles.CCButton,'Visible','on');

    % Sets related displays to visible
    set(handles.CAP_Kmax,'Visible','on');
    set(handles.CAP_PPC,'Visible','on');
    set(handles.CAP_N,'Visible','on');
    set(handles.CAP_K,'Visible','on');
    set(handles.CAP_PP,'Visible','on');
    set(handles.CAP_PN,'Visible','on');

    set(handles.KRange_Edit,'Visible','on');
    set(handles.PCC_Edit,'Visible','on');
    set(handles.ClusterEdit,'Visible','on');
    set(handles.ClusterRepEdit,'Visible','on');
    set(handles.ClusterPpEdit,'Visible','on');
    set(handles.ClusterPnEdit,'Visible','on');
    
    if handles.n_datasets > 1
        set(handles.CAP_TP,'Visible','on');
        set(handles.Percentile_Edit,'Visible','on');
    end
    
    tmp_toplot = ConcatMat(handles.RetainedPercentage,handles.n_datasets,1,handles.n_subjects,'FD');

    % Displays the violin plot of subject scrubbing percentage for the
    % reference population
    handles = ResetGraphDisplay(handles.TPViolin,handles);
    [~,~,handles.TPViolin] = MakeViolin(tmp_toplot,handles.TPViolin,{' '},'Frames ret. [%]',handles.PopColor,handles.n_datasets,1);
    set(handles.TPViolin,'Visible','on');

    clear tmp_toplot

    handles.Log = CAP_AddToLog(handles.Log,'Time points selected (seed-free analysis)',{['1 to ',num2str(handles.n_datasets)],handles.Tmot},{'Datasets indices','Motion threshold'});

guidata(hObject, handles);





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%% SECTION 2: SPATIOTEMPORAL SELECTION %%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Consensus clustering functions to compute optimal K
% The functions below enable to determine the optimal values of cluster
% number into which to disentangle the CAPs data
function CCButton_Callback(hObject, eventdata, handles)

    handles = ClearSection4(eventdata,handles);

    % Computes the consensus results
    [handles.Consensus] = CAP_ConsensusClustering(handles.Xonp{handles.ReferencePopulation},2:handles.Kmax,'items',handles.PCC/100,handles.n_rep,'correlation');

    % Calculates the quality metrics
    [~,Lorena] = ComputeClusteringQuality(handles.Consensus,2:handles.Kmax);
    
    handles.is_consensus_clustering = 1;
    handles.ConsensusQuality = 1-Lorena;
    
    set(handles.CCPlot,'Visible','on');
    tmp_plot = bar(2:handles.Kmax,1-Lorena,'Parent',handles.CCPlot);
    xlabel(get(tmp_plot(1),'Parent'),'Cluster number K');
    ylabel(get(tmp_plot(1),'Parent'),'Stability');
    xlim(get(tmp_plot(1),'Parent'),[2-0.6,handles.Kmax+0.6]);
    ylim(get(tmp_plot(1),'Parent'),[0,1]);
    set(get(tmp_plot(1),'Parent'),'Box','off');
    custom_cm = cbrewer('seq','Reds',25);
    colormap(handles.CCPlot,custom_cm(6:25,:));
    
    handles.Log = CAP_AddToLog(handles.Log,'Consensus clustering ran');
    
guidata(hObject,handles);

function KRange_Edit_Callback(hObject, eventdata, handles)

if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 1) && (str2double(get(hObject,'String')) <= 50)
    handles.Kmax = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);

    handles.Log = CAP_AddToLog(handles.Log,'Valid number of Kmax chosen',{handles.Kmax},{'Max cluster number'});
else
    set(hObject,'BackgroundColor',[204,146,146]/255);
    handles.Kmax = 12;
end

guidata(hObject, handles);

function handles = KRange_Edit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

guidata(hObject, handles);

function KRange_Edit_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);

function PCC_Edit_Callback(hObject, eventdata, handles)

if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 50) && (str2double(get(hObject,'String')) <= 100)
    handles.PCC = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);

    handles.Log = CAP_AddToLog(handles.Log,'Valid percentage of items chosen',{handles.PCC},{'Percentage items to cluster'});
else
    set(hObject,'BackgroundColor',[204,146,146]/255);
    handles.PCC = 80;
end

guidata(hObject, handles);

function handles = PCC_Edit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

guidata(hObject, handles);

function PCC_Edit_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);



%% Editing of all the CAP generation parameters
% Number of clusters
function ClusterEdit_Callback(hObject, eventdata, handles)

if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 1) && (str2double(get(hObject,'String')) <= 50)
    handles.K = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);

    handles.Log = CAP_AddToLog(handles.Log,'Valid number of clusters chosen',{handles.K},{'Number of clusters'});
    
else
    set(hObject,'BackgroundColor',[204,146,146]/255);
    handles.K = 5;
end

guidata(hObject, handles);

function handles = ClusterEdit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

guidata(hObject, handles);

function ClusterEdit_ButtonDownFcn(hObject,eventdata,handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);

% Number of k-means repetitions
function ClusterRepEdit_Callback(hObject, eventdata, handles)

if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 0) && (str2double(get(hObject,'String')) <= 50)
    handles.n_rep = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);

    handles.Log = CAP_AddToLog(handles.Log,'Valid number of replicates chosen',{handles.n_rep},{'Number of replicates'});
    
else
    set(hObject,'BackgroundColor',[204,146,146]/255);
    handles.n_rep = 20;
end

guidata(hObject, handles);

function handles = ClusterRepEdit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

guidata(hObject, handles);

function ClusterRepEdit_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);

% Percentage of positive-valued voxels to keep
function ClusterPpEdit_Callback(hObject, eventdata, handles)

if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 0) && (str2double(get(hObject,'String')) <= 100)
    handles.Pp = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);

    handles.Log = CAP_AddToLog(handles.Log,'Valid percentage positive voxels chosen',{handles.Pp},{'Percentage positive voxels'}); 
else
    set(hObject,'BackgroundColor',[204,146,146]/255);
    handles.Pp = 20;
end

guidata(hObject, handles);

function handles = ClusterPpEdit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

guidata(hObject, handles);

function ClusterPpEdit_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);

% Percentage of negative-valued voxels to keep
function ClusterPnEdit_Callback(hObject, eventdata, handles)

if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) > 0) && (str2double(get(hObject,'String')) <= 100)
    handles.Pn = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);
    
    handles.Log = CAP_AddToLog(handles.Log,'Valid percentage negative voxels chosen',{handles.Pn},{'Percentage negative voxels'});
else
    set(hObject,'BackgroundColor',[204,146,146]/255);
    handles.Pn = 20;
end

guidata(hObject, handles);

function handles = ClusterPnEdit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

guidata(hObject, handles);

function ClusterPnEdit_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject,handles);



%% Clustering control
% When pressing on the 'Cluster' button, we want to run clustering for the
% specified mode (Activation frames, Deactivation frames, or both types of
% frames together), using the previously declared parameters

% Upon clicking on 'Cluster'
function ClusterButton_Callback(hObject, eventdata, handles)

set(handles.PIE_S1,'Visible','off');
set(handles.PIE_S2,'Visible','off');
set(handles.PIE_S3,'Visible','off');
set(handles.PIE_S1S2,'Visible','off');
set(handles.PIE_S2S3,'Visible','off');
set(handles.PIE_S1S3,'Visible','off');
set(handles.PIE_S1S2S3,'Visible','off');

% Resets the CAP parameters (CAPs, standard deviation within CAPs and
% indices of the CAPs to which all retained frames were assigned)
handles.CAP = [];
handles.STDCAP = [];

% Resets the graph display of the CAP colorbar
handles = ResetGraphDisplay(handles.ColorbarCAP,handles);

% Reset all graph displays for the CAPs
tmpX = {handles.CAP1X,handles.CAP2X,handles.CAP3X,handles.CAP4X,handles.CAP5X};
tmpY = {handles.CAP1Y,handles.CAP2Y,handles.CAP3Y,handles.CAP4Y,handles.CAP5Y};
tmpZ = {handles.CAP1Z,handles.CAP2Z,handles.CAP3Z,handles.CAP4Z,handles.CAP5Z};
tmpF = {handles.CAP1_Frames,handles.CAP2_Frames,handles.CAP3_Frames,handles.CAP4_Frames,handles.CAP5_Frames};

for i_CAP = 1:5
    set(tmpF{i_CAP},'Visible','off');
    handles = ResetGraphDisplay(tmpX{i_CAP},handles);
    handles = ResetGraphDisplay(tmpY{i_CAP},handles);
    handles = ResetGraphDisplay(tmpZ{i_CAP},handles);
end

% Resets the sliders and the textboxes for the CAPs
set(handles.CAP_SliderX,'Visible','off');
set(handles.CAP_SliderY,'Visible','off');
set(handles.CAP_SliderZ,'Visible','off');
set(handles.CAP_XC,'Visible','off');
set(handles.CAP_YC,'Visible','off');
set(handles.CAP_ZC,'Visible','off');

% Resets the slider and textbox for the CAPs visualization threshold
set(handles.TVIS_Slider,'Visible','off');
set(handles.TVIS,'Visible','off');

% Resets the pie charts
handles = ResetGraphDisplay(handles.pie1,handles);
handles = ResetGraphDisplay(handles.pie2,handles);
handles = ResetGraphDisplay(handles.pie3,handles);
handles = ResetGraphDisplay(handles.pie4,handles);
handles = ResetGraphDisplay(handles.pie5,handles);

handles = ResetGraphDisplay(handles.ColorbarSimMat,handles);
handles = ResetGraphDisplay(handles.CAP_Mat,handles);

handles = ClearSection4(eventdata,handles);

% We perform clustering
if handles.is_seed_free == 0
    [handles.CAP,handles.Disp,handles.STDCAP,handles.idx{handles.ReferencePopulation},...
        handles.CorrDist,handles.sfrac] = Run_Clustering(cell2mat(handles.Xonp{handles.ReferencePopulation}),...
        handles.K,handles.mask{handles.ReferencePopulation},handles.brain_info{handles.ReferencePopulation},...
        handles.Pp,handles.Pn,handles.n_rep,handles.idx_sep_seeds{handles.ReferencePopulation},handles.SeedType);
else
    [handles.CAP,handles.Disp,handles.STDCAP,handles.idx{handles.ReferencePopulation},...
        handles.CorrDist,handles.sfrac] = Run_Clustering(cell2mat(handles.Xonp{handles.ReferencePopulation}),...
        handles.K,handles.mask{handles.ReferencePopulation},handles.brain_info{handles.ReferencePopulation},...
        handles.Pp,handles.Pn,handles.n_rep,1,handles.SeedType);
end

% Makes the sliders visible, and the related text too (CAP MNI coordinates)
set(handles.CAP_SliderX,'Visible','on');
set(handles.CAP_SliderY,'Visible','on');
set(handles.CAP_SliderZ,'Visible','on');
set(handles.CAP_XC,'Visible','on');
set(handles.CAP_YC,'Visible','on');
set(handles.CAP_ZC,'Visible','on');
set(handles.CAP_XC,'String',['X: ',sprintf('%.2f',get(handles.CAP_SliderX,'Value'))]);
set(handles.CAP_YC,'String',['Y: ',sprintf('%.2f',get(handles.CAP_SliderY,'Value'))]);
set(handles.CAP_ZC,'String',['Z: ',sprintf('%.2f',get(handles.CAP_SliderZ,'Value'))]);

% Computation of the similarity
SimMat = corr(handles.CAP',handles.CAP');
SimMat(isnan(SimMat))=0;

% Graph set visible, and plotting
handles = ResetGraphDisplay(handles.CAP_Mat,handles);
set(handles.CAP_Mat,'Visible','on');
imagesc(SimMat,'Parent',handles.CAP_Mat);

tmp_cb2 = cbrewer('div','RdBu',1000);
tmp_cb2(tmp_cb2 < 0) = 0;

colormap(handles.CAP_Mat,flipud(tmp_cb2));

% Correlation ranges from -1 to 1, so this is what we make the graph
% colorbar vary within. We also make the graph square and remove the axes
caxis(handles.CAP_Mat,[-1 1]);
axis(handles.CAP_Mat,'square','on');
axis(handles.CAP_Mat,'off');

% Addition of the colorbar just below
set(handles.ColorbarSimMat,'Visible','on');
handles.ColorbarSimMat = Create_CAP_colorbar(-1,1,0.5,0,'',...
    handles.ColorbarSimMat,'Vertical','div','RdBu',1000);

% If using the 'Union' option...
if strcmp(handles.SeedType,'Union')
    
    % Custom colormap
    custom_cm = 1/255*[211,36,36;11,170,65;51,75,163;255,255,180;186,59,204;58,221,221;242,242,242];
    
    % Graph displays are stored in a common tmp_sfrac cell array
    tmp_sfrac = {handles.pie1,handles.pie2,handles.pie3,handles.pie4,...
        handles.pie5};
    
    % The pie charts for each cluster are created
    for cc = 1:min([handles.K,5])
        
        % Pie charts
        set(tmp_sfrac{cc},'Visible','on');
        for tt = 1:size(handles.sfrac,3)
            lab{tt} = '';
        end
        
        pie(tmp_sfrac{cc},realmin*ones(size(handles.sfrac,3),1)+squeeze(mean(handles.sfrac(:,cc,:),1)),lab);
        caxis(tmp_sfrac{cc},[1,7]);
        
        switch handles.n_seed
            case 1
                errordlg('You managed the impossible, congratulations!');
            case 2
                colormap(tmp_sfrac{cc},(custom_cm));
                set(handles.PIE_S1,'Visible','on');
                set(handles.PIE_S2,'Visible','on');
                set(handles.PIE_S1S2,'Visible','on');
                set(handles.PIE_S1S2,'ForeGroundColor',[51,75,163]/255);
            case 3
                colormap(tmp_sfrac{cc},(custom_cm));
                set(handles.PIE_S1,'Visible','on');
                set(handles.PIE_S2,'Visible','on');
                set(handles.PIE_S3,'Visible','on');
                set(handles.PIE_S2S3,'Visible','on');
                set(handles.PIE_S1S2,'Visible','on');
                set(handles.PIE_S1S2,'ForeGroundColor',[243,243,139]/255);
                set(handles.PIE_S1S3,'Visible','on');
                set(handles.PIE_S1S2S3,'Visible','on');
        end
    end
end

% Same for the slider for the visualization threshold
set(handles.TVIS,'Visible','on');
set(handles.TVIS_Slider,'Visible','on'); 
set(handles.TVIS,'String',['Tv: ',sprintf('%.2f',get(handles.TVIS_Slider,'Value'))]);

% Makes the colorbar for the CAPs visible
handles.ColorbarCAP = Create_CAP_colorbar(-1.5,1.5,0.5,get(handles.TVIS_Slider,'Value'),'',handles.ColorbarCAP,'Horizontal','div','RdBu',1000);
set(handles.ColorbarCAP,'Visible','on');

% Concatenates all CAP information into metavariables for easier subsequent
% changes
tmpX = {handles.CAP1X,handles.CAP2X,handles.CAP3X,handles.CAP4X,handles.CAP5X};
tmpY = {handles.CAP1Y,handles.CAP2Y,handles.CAP3Y,handles.CAP4Y,handles.CAP5Y};
tmpZ = {handles.CAP1Z,handles.CAP2Z,handles.CAP3Z,handles.CAP4Z,handles.CAP5Z};
tmpF = {handles.CAP1_Frames,handles.CAP2_Frames,handles.CAP3_Frames,handles.CAP4_Frames,handles.CAP5_Frames};

% For each CAP...
for i_CAP = 1:min([handles.K,5])
    
    % Clears the display for each dimension
    cla(tmpX{i_CAP});
    cla(tmpY{i_CAP});
    cla(tmpZ{i_CAP});
    
    % Plots the new slice for each dimension
    tmpX{i_CAP} = plot_slice(handles.CAP(i_CAP,:),...
        get(handles.TVIS_Slider,'Value'),1.5,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},...
        'X',get(handles.CAP_SliderX,'Value'),tmpX{i_CAP});

    tmpY{i_CAP} = plot_slice(handles.CAP(i_CAP,:),...
        get(handles.TVIS_Slider,'Value'),1.5,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},...
        'Y',get(handles.CAP_SliderY,'Value'),tmpY{i_CAP});
    
    tmpZ{i_CAP} = plot_slice(handles.CAP(i_CAP,:),...
        get(handles.TVIS_Slider,'Value'),1.5,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},...
        'Z',get(handles.CAP_SliderZ,'Value'),tmpZ{i_CAP});

    % Sets the frame percentage text visible and at the right value (number
    % of frames from a CAP/total frame number, and then percentage that it
    % stands for)
    set(tmpF{i_CAP},'Visible','on');
    set(tmpF{i_CAP},'String',{[num2str(sum(handles.idx{handles.ReferencePopulation}==i_CAP)),'/',...
        num2str(size(handles.idx{handles.ReferencePopulation},1))],[sprintf('%.2f',...
        sum(handles.idx{handles.ReferencePopulation}==i_CAP)/size(handles.idx{handles.ReferencePopulation},1)*100),' [%]']});
end

% Fills that subject menu with the subjects from the reference population
handles = FillSubjectList(handles.SubjectMenuMetrics,handles);

% Also enables and fills the state menu
handles = FillStateList(handles.StateMenu,handles);

% Enables the Metrics button for the next part of the analysis if we
% only deal with one dataset
if handles.n_datasets == 1
    set(handles.MetricsButton,'Enable','on');
    set(handles.MetricsButton,'Visible','on');

% Else, we enable the assignment before enabling the metrics computation
elseif handles.n_datasets > 1
    set(handles.AssignButton,'Enable','on');
    set(handles.AssignButton,'Visible','on');
    
    set(handles.CAP_TP,'Visible','on');
    set(handles.Percentile_Edit,'Visible','on');
end

handles.Log = CAP_AddToLog(handles.Log,'Clustering performed',...
    {handles.ReferencePopulation,handles.K,handles.n_rep,handles.Pp,...
    handles.Pn},{'Reference group index',...
    'Number of clusters','Number of replicates',...
    'Percentage positive voxels','Percentage negative voxels'});

% If we have already assignment results, then we redo it straight away to
% update the associated results
if length(handles.idx) > 1
    AssignButton_Callback(hObject, eventdata, handles);
end

guidata(hObject, handles);



%% Frame assignment control
% This button is only enabled after clustering has been performed on the
% reference population. It assigns frames from the other populations to the
% computed CAPs
function AssignButton_Callback(hObject, eventdata, handles)

handles = ClearSection4(eventdata,handles);

tmp_notref = [];
tmp_computedTPsel = [];

% For each non-reference dataset...
for n_ds = 1:handles.n_datasets
    if n_ds ~= handles.ReferencePopulation
        
        tmp_notref = [tmp_notref,n_ds];
        
        % Attempts to access the frames for a given dataset; if it fails, it
        % means we must compute activity. If it works, we do nothing because
        % activity has already been computed
        try
            justtotest = handles.Xonp{n_ds};
        catch

            [handles.Xonp{n_ds},p,handles.FrameIndices{n_ds},handles.idx_sep_seeds{n_ds}] = ...
                CAP_find_activity(handles.TC{n_ds},handles.seed,handles.T,handles.FD{n_ds},handles.Tmot,handles.SelMode,handles.SeedType);

            handles.RetainedPercentage{n_ds} = p(4:5,:);
            
            tmp_computedTPsel = [tmp_computedTPsel,n_ds];
        end

        try
            handles.idx{n_ds} = CAP_AssignFrames(handles.CAP,cell2mat(handles.Xonp{n_ds}),handles.CorrDist,handles.percentile)';
        catch
            errordlg('You computed CAPs with a different CAP type compared to the one used now; please use the same CAP type !');
        end
    end
end

% We then enable the computation of metrics
set(handles.MetricsButton,'Enable','on');
set(handles.MetricsButton,'Visible','on');

handles.Log = CAP_AddToLog(handles.Log,'Frame assignment performed',...
    {num2str(tmp_notref)},{'Group indices for which frames were assigned'});

guidata(hObject, handles);

% This asks for the percentile to use in frame assignment (i.e. the
% threshold of correlation below which frames are left unassigned)
function Percentile_Edit_Callback(hObject, eventdata, handles)

if ~isempty(str2double(get(hObject,'String'))) && (str2double(get(hObject,'String')) <= 100)
    handles.percentile = str2double(get(hObject,'String'));
    set(hObject,'BackgroundColor', [101,140,196]/255);

    handles.Log = CAP_AddToLog(handles.Log,'Valid percentile chosen',{handles.percentile},{'Percentile'});
    
else
    set(hObject,'BackgroundColor',[204,146,146]/255);
    handles.percentile = 5;
end

guidata(hObject, handles);

function handles = Percentile_Edit_CreateFcn(hObject, eventdata, handles)

set(hObject,'Enable','off');
set(hObject,'String','Click to enter...');
set(hObject,'FontAngle','italic');

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

function Percentile_Edit_ButtonDownFcn(hObject, eventdata, handles)

set(hObject,'Enable','on');
set(hObject,'String','');
set(hObject,'FontAngle','normal');
uicontrol(hObject);

guidata(hObject, handles);



%% Sliders for CAP visualization (MNI coordinates)
% When changing along a slider, we want to update the graphs and the text of
% the MNI coordinate below the slider
function CAP_SliderX_Callback(hObject, eventdata, handles)

set(handles.CAP_XC,'String',['X: ',sprintf('%.2f',get(hObject,'Value'))]);
tmp_struct = {handles.CAP1X,handles.CAP2X,handles.CAP3X,handles.CAP4X,handles.CAP5X};

for i_CAP = 1:min([handles.K,5])
    cla(tmp_struct{i_CAP});  
    tmp_struct{i_CAP} = plot_slice(handles.CAP(i_CAP,:),get(handles.TVIS_Slider,'Value'),...
        1.5,handles.mask{handles.ReferencePopulation},handles.brain,...
        handles.brain_info{handles.ReferencePopulation},'X',get(hObject,'Value'),tmp_struct{i_CAP});
end

guidata(hObject, handles); 

function CAP_SliderX_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

guidata(hObject,handles);

% Y dimension slider
function CAP_SliderY_Callback(hObject, eventdata, handles)

set(handles.CAP_YC,'String',['Y: ',sprintf('%.2f',get(hObject,'Value'))]);
tmp_struct = {handles.CAP1Y,handles.CAP2Y,handles.CAP3Y,handles.CAP4Y,handles.CAP5Y};

for i_CAP = 1:min([handles.K,5])
    cla(tmp_struct{i_CAP});
    tmp_struct{i_CAP} = plot_slice(handles.CAP(i_CAP,:),get(handles.TVIS_Slider,'Value'),...
        1.5,handles.mask{handles.ReferencePopulation},handles.brain,...
        handles.brain_info{handles.ReferencePopulation},'Y',get(hObject,'Value'),tmp_struct{i_CAP});
end

guidata(hObject,handles);

function CAP_SliderY_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

guidata(hObject,handles);

% Z dimension slider
function CAP_SliderZ_Callback(hObject, eventdata, handles)

set(handles.CAP_ZC,'String',['Z: ',sprintf('%.2f',get(hObject,'Value'))]);
tmp_struct = {handles.CAP1Z,handles.CAP2Z,handles.CAP3Z,handles.CAP4Z,handles.CAP5Z};

for i_CAP = 1:min([handles.K,5])
   
    cla(tmp_struct{i_CAP});
    tmp_struct{i_CAP} = plot_slice(handles.CAP(i_CAP,:),get(handles.TVIS_Slider,'Value'),...
        1.5,handles.mask{handles.ReferencePopulation},handles.brain,handles.brain_info{handles.ReferencePopulation},'Z',get(hObject,'Value'),tmp_struct{i_CAP});
end

guidata(hObject,handles);

function CAP_SliderZ_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

guidata(hObject,handles);



%% Sliders for threshold visualization (CAP analysis)
% Again, we want to update the slices and the text if we change those
% sliders
function TVIS_Slider_Callback(hObject, eventdata, handles)

% The text is changed
set(handles.TVIS,'String',['Tv: ',sprintf('%.2f',get(hObject,'Value'))]);

% The colorbar graph is modified to suit the new threshold value
cla(handles.ColorbarCAP);
handles.ColorbarCAP = Create_CAP_colorbar(-1.5,1.5,0.5,get(hObject,'Value'),'',handles.ColorbarCAP,'Horizontal','div','RdBu',1000);

% The brain slices are replotted
tmpX = {handles.CAP1X,handles.CAP2X,handles.CAP3X,handles.CAP4X,handles.CAP5X};
tmpY = {handles.CAP1Y,handles.CAP2Y,handles.CAP3Y,handles.CAP4Y,handles.CAP5Y};
tmpZ = {handles.CAP1Z,handles.CAP2Z,handles.CAP3Z,handles.CAP4Z,handles.CAP5Z};

for i_CAP = 1:min([handles.K,5])
    
    cla(tmpX{i_CAP});
    cla(tmpY{i_CAP});
    cla(tmpZ{i_CAP});
    
    tmpX{i_CAP} = plot_slice(handles.CAP(i_CAP,:),get(hObject,'Value'),1.5,...
        handles.mask{handles.ReferencePopulation},handles.brain,...
        handles.brain_info{handles.ReferencePopulation},'X',get(handles.CAP_SliderX,'Value'),tmpX{i_CAP});
    
    tmpY{i_CAP} = plot_slice(handles.CAP(i_CAP,:),get(hObject,'Value'),1.5,...
        handles.mask{handles.ReferencePopulation},handles.brain,...
        handles.brain_info{handles.ReferencePopulation},'Y',get(handles.CAP_SliderY,'Value'),tmpY{i_CAP});
    
    tmpZ{i_CAP} = plot_slice(handles.CAP(i_CAP,:),get(hObject,'Value'),1.5,...
        handles.mask{handles.ReferencePopulation},handles.brain,...
        handles.brain_info{handles.ReferencePopulation},'Z',get(handles.CAP_SliderZ,'Value'),tmpZ{i_CAP});
end

guidata(hObject,handles);

function TVIS_Slider_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%% SECTION 4: METRICS COMPUTATION %%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Metrics computation control
% When pressing on the 'Compute metrics' button, the different metrics for
% CAP analysis are computed
function MetricsButton_Callback(hObject, eventdata, handles)

% All the metrics are computed for all the datasets
for n_ds = 1:handles.n_datasets
    
    try
        [handles.TPM{n_ds},handles.Counts{n_ds},...
            handles.Number{n_ds},handles.Avg_Duration{n_ds},...
            handles.Duration{n_ds},handles.TM{n_ds},...
            handles.From_Baseline{n_ds},handles.To_Baseline{n_ds},...
            handles.Baseline_resilience{n_ds},handles.Resilience{n_ds},...
            handles.Betweenness{n_ds},handles.kin{n_ds},handles.kout{n_ds},...
            handles.SubjectEntries{n_ds}] =...
            Compute_Metrics_simpler(handles.idx{n_ds},handles.FrameIndices{n_ds}.kept.active,...
            handles.FrameIndices{n_ds}.scrubbedandactive,...
            handles.K,handles.TR);
    catch
        errordlg('You tried computing metrics using parameter values different from the ones that were employed to generate CAPs; please check !');
    end
end

handles.Log = CAP_AddToLog(handles.Log,'Metrics computed',...
    {handles.n_datasets,handles.K,handles.TR},...
    {'Number of datasets','Number of clusters','TR'});

tmp_cb = cbrewer('seq','Greys',1000);

% 2. Transition matrix for all subjects together

tmp_toplot = squeeze(mean(handles.TM{handles.ReferencePopulation},3));
tmp_toplot = tmp_toplot(3:end-1,3:end-1);

% Make graph visible and plotting
handles = ResetGraphDisplay(handles.TMGraph,handles);
set(handles.TMGraph,'Visible','on');
imagesc(tmp_toplot,'Parent',handles.TMGraph);

colormap(handles.TMGraph,flipud(tmp_cb));

clear tmp_toplot

% Arbitrary setting of probability scale from 0 to 0.03
caxis(handles.TMGraph,[0 0.03]);
axis(handles.TMGraph,'square','on');
axis(handles.TMGraph,'off');

% 3. Transition matrix for one subject
tmp_toplot = squeeze(handles.TM{handles.ReferencePopulation}(:,:,get(handles.SubjectMenuMetrics,'Value')));
tmp_toplot = tmp_toplot(3:end-1,3:end-1);

% makes graph visible and plots the information given by the Subject popup
handles = ResetGraphDisplay(handles.TM_Subject,handles);
set(handles.TM_Subject,'Visible','on');
imagesc(tmp_toplot,...
    'Parent',handles.TM_Subject);

colormap(handles.TM_Subject,flipud(tmp_cb));

clear tmp_toplot

% Same setting for the axes as for the average graph
caxis(handles.TM_Subject,[0 0.03]);
axis(handles.TM_Subject,'square','on');
axis(handles.TM_Subject,'off');

% We then create the colorbar for both cases
set(handles.ColorbarTransMat,'Visible','on');
handles.ColorbarTransMat = Create_CAP_colorbar(0,0.03,0.01,0,'',...
    handles.ColorbarTransMat,'Vertical','seq','Greys',1000);

% Makes the subject menu visible
set(handles.SubjectMenuMetrics,'Visible','on');

% 4. Dynamic state plotting

% Makes the graph visible
handles = ResetGraphDisplay(handles.DynStates,handles);
set(handles.DynStates,'Visible','on');

% Concatenates information from the different datasets
tmp_toplot = [];

for i = 1:handles.n_datasets
    tmp_toplot = [tmp_toplot; handles.TPM{i}; 0*ones(5,handles.SubjSize.TP)];
end
tmp_toplot = tmp_toplot(1:end-5,:);

custom_cm = cbrewer('qual','Set1',handles.K+1);
custom_cm = [0.05,0.05,0.05;1,1,1;custom_cm];

% If the TR has been properly entered, the x-axis is time; else, it depicts
% time index. In any case, we plot the states
if handles.isTROK
    imagesc(tmp_toplot,'Parent',handles.DynStates);
    colormap(handles.DynStates,(custom_cm));
    xlabel(handles.DynStates,'Time [s]');
else
    imagesc(tmp_toplot,'Parent',handles.DynStates);
    colormap(handles.DynStates,(custom_cm));
    xlabel(handles.DynStates,'Time index [-]');
end

ylabel(handles.DynStates,'Subjects [-]');
axis(handles.DynStates,'off');
caxis(handles.DynStates,[-1,handles.K+1]);

clear tmp_toplot

% 5. Cumulative state distributions

% Makes the graph visible
handles = ResetGraphDisplay(handles.CumStates,handles);
set(handles.CumStates,'Visible','on');

for i = 1:handles.n_datasets
    % Cumulative distribution for the state that we want to be displayed (i.e.
    % the state from the popup menu)
    handles.TPMCum{i} = cumsum(handles.TPM{i} == get(handles.StateMenu,'Value'),2);

    % Average of the considered state across subjects
    tmp_TPMCum{i} = mean(handles.TPMCum{i},1);
end
    
% Similarly as above, we plot time if we have a valid TR; else, we plot
% 'time index'
if handles.isTROK == false

    for i = 1:handles.n_datasets
        % We first plot each subject curve
        for j = 1:size(handles.TPMCum{i},1)
            plot(1:size(handles.TPM{i},2),handles.TPMCum{i}(j,:),'Color',handles.PopColor{1}(i,:),...
                'Parent',handles.CumStates);
            hold(handles.CumStates,'on');
        end
    end

    for i = 1:handles.n_datasets
        % Then, we plot a bold average across subjects
        plot(1:size(handles.TPM{i},2),tmp_TPMCum{i},'Color',handles.PopColor{2}(i,:),...
            'LineWidth',2,'Parent',handles.CumStates); 
        xlabel(handles.CumStates,'Time index [-]','FontSize',10);
        xlim(handles.CumStates,[1,size(handles.TPM{i},2)]);
    end
else
    for i = 1:handles.n_datasets
        for j = 1:size(handles.TPMCum{i},1)
            plot(((1:size(handles.TPM{i},2))-1)*handles.TR,...
                handles.TPMCum{i}(j,:),...
                'Color',handles.PopColor{1}(i,:),'Parent',handles.CumStates);
            hold(handles.CumStates,'on');
        end
    end

    for i = 1:handles.n_datasets
        plot(((1:size(handles.TPM{i},2))-1)*handles.TR,...
            tmp_TPMCum{i},...
            'LineWidth',2,'Color',handles.PopColor{2}(i,:),'Parent',handles.CumStates);
        xlabel(handles.CumStates,'Time [s]','FontSize',10);
        xlim(handles.CumStates,[0,(size(handles.TPM{i},2)-1)*handles.TR]);
    end
end


ylabel(handles.CumStates,'Cumul. sum [-]','FontSize',10);
set(handles.CumStates,'Box','off');

% Makes the state menu visible
set(handles.StateMenu,'Visible','on');

% 6. Violin plots

% We build the legend used to plot the violins
% leg_viol = cell(handles.K);
for i = 1:handles.K
    leg_viol{i} = num2str(i);
end

% Makes graphs ready
handles = ResetGraphDisplay(handles.ViolinRawCounts,handles);
set(handles.ViolinRawCounts,'Visible','on');

handles = ResetGraphDisplay(handles.ViolinNumberEntries,handles);
set(handles.ViolinNumberEntries,'Visible','on');

handles = ResetGraphDisplay(handles.ViolinResilience,handles);
set(handles.ViolinResilience,'Visible','on');

handles = ResetGraphDisplay(handles.ViolinBetweennessCentrality,handles);
set(handles.ViolinBetweennessCentrality,'Visible','on');

handles = ResetGraphDisplay(handles.ViolinInDegree,handles);
set(handles.ViolinInDegree,'Visible','on');

handles = ResetGraphDisplay(handles.ViolinOutDegree,handles);
set(handles.ViolinOutDegree,'Visible','on');


% Concatenates the values from the different populations
tmp_toplot = ConcatMat(handles.Counts,handles.n_datasets,handles.K,handles.n_subjects,'Raw counts');

try
    % Plots the raw count values
    [~,~,handles.ViolinRawCounts] = MakeViolin(tmp_toplot,...
        handles.ViolinRawCounts,leg_viol,'Raw counts [-]',handles.PopColor,handles.n_datasets,handles.K);
catch
    set(handles.ViolinRawCounts,'Visible','off');
end
clear tmp_toplot


tmp_toplot = ConcatMat(handles.Number,handles.n_datasets,handles.K,handles.n_subjects,'Number');

try
    % Plots the raw count values
    [~,~,handles.ViolinNumberEntries] = MakeViolin(tmp_toplot,...
        handles.ViolinNumberEntries,leg_viol,'Entries [-]',handles.PopColor,handles.n_datasets,handles.K);
catch
    set(handles.ViolinNumberEntries,'Visible','off');
end
clear tmp_toplot


% Concatenates the values from the different populations
tmp_toplot = ConcatMat(handles.Resilience,handles.n_datasets,handles.K,handles.n_subjects,'Resilience');

try
    % Plots the raw count values
    [~,~,handles.ViolinResilience] = MakeViolin(tmp_toplot,...
        handles.ViolinResilience,leg_viol,'Resilience [-]',handles.PopColor,handles.n_datasets,handles.K);
catch
    set(handles.ViolinResilience,'Visible','off');
end

clear tmp_toplot

tmp_toplot = ConcatMat(handles.kin,handles.n_datasets,handles.K,handles.n_subjects,'kin');

try
    % Plots the normalized count values
    [~,~,handles.ViolinInDegree] = MakeViolin(tmp_toplot,...
        handles.ViolinInDegree,leg_viol,'kin [-]',handles.PopColor,handles.n_datasets,handles.K);
catch
    set(handles.ViolinInDegree,'Visible','off');
end

clear tmp_toplot

tmp_toplot = ConcatMat(handles.kout,handles.n_datasets,handles.K,handles.n_subjects,'kout');

try
    % Plots the number of times a state is entered
    [~,~,handles.ViolinOutDegree] = MakeViolin(tmp_toplot,...
        handles.ViolinOutDegree,leg_viol,'kout [-]',handles.PopColor,handles.n_datasets,handles.K);
catch
    set(handles.ViolinOutDegree,'Visible','off');
end

clear tmp_toplot

    
tmp_toplot = ConcatMat(handles.Betweenness,handles.n_datasets,handles.K,handles.n_subjects,'Betweenness');

try
    [~,~,handles.ViolinBetweennessCentrality] = MakeViolin(tmp_toplot,...
        handles.ViolinBetweennessCentrality,leg_viol,'Betweenness [-]',handles.PopColor,handles.n_datasets,handles.K);
catch
    set(handles.ViolinBetweennessCentrality,'Visible','off');
end
    
clear tmp_toplot
   

% Makes the displays visible
set(handles.DS_Scrubbed,'Visible','on');
set(handles.DS_Scrubbed,'ForegroundColor',custom_cm(1,:));

set(handles.DS_NotSelected,'Visible','on');
set(handles.DS_NotSelected,'ForegroundColor',[0.9,0.9,0.9]);

set(handles.DS_Unassigned,'Visible','on');
set(handles.DS_Unassigned,'ForegroundColor',custom_cm(handles.K+3,:));

tmp = {handles.DS_CAP1,handles.DS_CAP2,handles.DS_CAP3,handles.DS_CAP4,...
    handles.DS_CAP5,handles.DS_CAP6,handles.DS_CAP7,handles.DS_CAP8,...
    handles.DS_CAP9,handles.DS_CAP10,handles.DS_CAP11,handles.DS_CAP12};

for i = 1:handles.K
    set(tmp{i},'Visible','on');
    set(tmp{i},'ForegroundColor',custom_cm(2+i,:));
end

clear tmp

tmp = {handles.V_POP1,handles.V_POP2,handles.V_POP3,handles.V_POP4};

for i = 1:handles.n_datasets
    set(tmp{i},'Visible','on');
end

clear tmp
 
guidata(hObject,handles);



%% Subject popup menu control (metrics computation)
% When a new subject is chosen, the display of the transition matrix graph
% is changed

function SubjectMenuMetrics_Callback(hObject, eventdata, handles)

% In the case when we have something to plot...
try
    % ... we reset the graph display, make the graph visible, and plot
    % again
    handles = ResetGraphDisplay(handles.TM_Subject,handles);
    set(handles.TM_Subject,'Visible','on');
    
    tmp_toplot = squeeze(handles.TM{handles.ReferencePopulation}(:,:,get(handles.SubjectMenuMetrics,'Value')));
    tmp_toplot = tmp_toplot(3:end-1,3:end-1);
    
    imagesc(tmp_toplot,'Parent',handles.TM_Subject);
    caxis(handles.TM_Subject,[0 0.03]);
    axis(handles.TM_Subject,'square','on');
    axis(handles.TM_Subject,'off');
    
    tmp_cb = cbrewer('seq','Greys',1000);
    colormap(handles.TM_Subject,flipud(tmp_cb));
    
    clear tmp_toplot
    
    handles.Log = CAP_AddToLog(handles.Log,'Subject index changed (metrics)',...
    {get(hObject,'Value')},...
    {'Subject index'});

catch
    errordlg('Please recompute metrics for the presently considered population !');
end

guidata(hObject,handles);

function SubjectMenuMetrics_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end



%% State menu popup control
% When we change our state of interest, we will change the display of the
% cumulative state being displayed
function StateMenu_Callback(hObject, eventdata, handles)

handles = ResetGraphDisplay(handles.CumStates,handles);
set(handles.CumStates,'Visible','on');

% In the case of a non-null matrix...
if ~isempty(handles.TPM)
    
    for i = 1:handles.n_datasets
        % Cumulative distribution for the state that we want to be displayed (i.e.
        % the state from the popup menu)
        handles.TPMCum{i} = cumsum(handles.TPM{i} == get(handles.StateMenu,'Value'),2);

        % Average of the considered state across subjects
        tmp_TPMCum{i} = mean(handles.TPMCum{i},1);
    end

    % Similarly as above, we plot time if we have a valid TR; else, we plot
    % 'time index'
    if handles.isTROK == false

        for i = 1:handles.n_datasets
            % We first plot each subject curve
            for j = 1:size(handles.TPMCum{i},1)
                plot(handles.TPMCum{i}(j,:),'Color',handles.PopColor{1}(i,:),...
                    'Parent',handles.CumStates);
                hold(handles.CumStates,'on');
            end
        end

        for i = 1:handles.n_datasets
            % Then, we plot a bold average across subjects
            plot(tmp_TPMCum{i},'Color',handles.PopColor{2}(i,:),...
                'LineWidth',2,'Parent',handles.CumStates); 
            xlabel(handles.CumStates,'Time index [-]','FontSize',8);
        end
    else
        for i = 1:handles.n_datasets
            for j = 1:size(handles.TPMCum{i},1)
                plot(((1:size(handles.TPM{i},2))-1)*handles.TR,...
                    handles.TPMCum{i}(j,:),...
                    'Color',handles.PopColor{1}(i,:),'Parent',handles.CumStates);
                hold(handles.CumStates,'on');
            end
        end

        for i = 1:handles.n_datasets
            plot(((1:size(handles.TPM{i},2))-1)*handles.TR,...
                tmp_TPMCum{i},...
                'LineWidth',2,'Color',handles.PopColor{2}(i,:),'Parent',handles.CumStates);
            xlabel(handles.CumStates,'Time [s]','FontSize',8);
        end
    end


ylabel(handles.CumStates,'Cumul. sum [-]','FontSize',8);
set(handles.CumStates,'Box','off');
    
end

guidata(hObject,handles);

function StateMenu_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%% SECTION 5: MISCELLANEOUS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% General utilities
% Resets the display of a graph object
function handles = ResetGraphDisplay(Graph,handles)

cla(Graph);
set(Graph,'Visible','off');

% Fills the entries of a pop-up menu with 'Subject _' entries from the
% reference population
function handles = FillSubjectList(ToFill,handles)

tmp_string = {};

for ns = 1:handles.n_subjects{handles.ReferencePopulation}
    tmp_string{ns} = ['Subject ',num2str(ns)];
end

set(ToFill,'String',tmp_string);

clear tmp_string

% Fills the entries of a pop-up menu with the different population entries
function handles = FillPopulationList(ToFill,handles)

tmp_string = {};

for ns = 1:handles.n_datasets
    tmp_string{ns} = [handles.SubjNames{ns}];
end

set(ToFill,'String',tmp_string);

clear tmp_string

% Fills the entries of a pop-up menu with the different population entries
function handles = FillStateList(ToFill,handles)

tmp_string = {};

for ns = 1:handles.K
    tmp_string{ns} = ['State ',num2str(ns)];
end

set(ToFill,'String',tmp_string);

clear tmp_string

% Removes NaN-containing lines from a matrix (used for the plotting of
% duration violin plots)
function M2 = DiscardNaN(M)

% We initialize the output matrix as a void one
M2 = [];

% For each row, we count the amount of NaN entries; if not equal to zero,
% then we discard the line
for i = 1:size(M,1)
    if sum(isnan(M(i,:))) > 0
    else
        M2 = [M2;M(i,:)];
    end
end

% Concatenates populations appropriately for Violin plotting
function M2 = ConcatMat(M,n_pop,n_states,n_subjects,type)

% Creates the data matrix (nan values are used to have the same amount of
% data for each group)
M2 = nan(n_pop*n_states,max(cell2mat(n_subjects)));

for i = 1:n_pop
    
    switch type
        case 'Raw counts'
            
            tmp = M{i}.raw.state(:,1:n_states)';
            
            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'Normalized counts'

            tmp = M{i}.frac.state(:,1:n_states)';

            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'Number'

            tmp = M{i}(:,3:3+n_states-1)';

            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'Duration'
            tmp = DiscardNaN(M{i}(:,3:3+n_states-1))';
            
            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'Betweenness'
            
            tmp = M{i}';
            
            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'kin'
            
            tmp = M{i}';
            
            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'kout'
            
            tmp = M{i}';
            
            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'Resilience'
            
            tmp = M{i}';
            
            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
            
            clear tmp
            
        case 'FD'
            tmp = M{i};
            
            for j = 1:n_states
                M2(i+(j-1)*n_pop,1:size(tmp,2)) = tmp(j,:);
            end
    end
end