[Master Index]
[Index for Toolbox]
dataplot_cb
(Toolbox/dataplot_cb.m in BrainStorm 2.0 (Alpha))
Function Synopsis
varargout = dataplot_cb(action,varargin)
Help Text
DATAPLOT_CB - : Callback switchyard for the DATAViewer Tool
function varargout = dataplot_cb(action,varargin)
Callback function for the DATAVIEWER tool
Cross-Reference Information
This function calls
This function is called by
Listing of function C:\BrainStorm_2001\Toolbox\dataplot_cb.m
function varargout = dataplot_cb(action,varargin)
%DATAPLOT_CB - : Callback switchyard for the DATAViewer Tool
% function varargout = dataplot_cb(action,varargin)
% Callback function for the DATAVIEWER tool
%<autobegin> ---------------------- 12-Oct-2004 12:01:11 -----------------------
% --------- Automatically Generated Comments Block Using AUTO_COMMENTS ---------
%
% CATEGORY: GUI and Related
%
% Alphabetical list of external functions (non-Matlab):
% publictoolbox\othertools\aviplayer.m
% publictoolbox\othertools\view3d.m
% toolbox\brainstorm_filt.m
% toolbox\bst_color_scheme.m
% toolbox\bst_imaging_display.m
% toolbox\bst_layout.m
% toolbox\bst_message_window.m
% toolbox\bst_mriviewer.m
% toolbox\bst_static_taskbar.m
% toolbox\bst_wavedata_display.m
% toolbox\bst_win_manager.m
% toolbox\dataplot_cb.m NOTE: Routine calls itself explicitly
% toolbox\file_selection_win.m
% toolbox\find_brainstorm_files.m
% toolbox\find_brainstorm_structure.m
% toolbox\findclosest.m
% toolbox\get_channel.m
% toolbox\get_user_directory.m
% toolbox\good_channel.m
% toolbox\load_brainstorm_file.m
% toolbox\makeuswait.m
% toolbox\manage_corticalscouts.m
% toolbox\meg4read.m
% toolbox\mutincomp.m
% toolbox\norcol.m
% toolbox\parametric_estimation.m
% toolbox\rap_music_parameters.m
% toolbox\save_fieldnames.m
% toolbox\set_sourceviewing_parameters.m
% toolbox\sourceimaging.m
% toolbox\togglebuttoncolor.m
% toolbox\windfind.m
% toolbox\zscore_gui.m
%
% Subfunctions in this file, in order of occurrence in file:
% initialize_SourceTimeViewing(handle)
% initialize_SourceSpatialViewing(handle)
% shorterfilename = shorter_filename(longfilename);
% slct_modal = get_selected_modalities;
%
% Group : Preference data and their calls in this file:
% 'BrainStorm' : 'UserCurrentData'
%
% setpref('BrainStorm','UserCurrentData',CurrentData);
%
% CurrentData = getpref('BrainStorm','CurrentData');
% cd(fullfile(getpref('BrainStorm','brainstormHomeDir'),'Custom'))
%
% Application data and their calls in this file:
% 'Methods'
% 'RotateState'
% 'TileType'
% 'ZoomState'
%
% setappdata(DATAPLOT,'RotateState',0);
% setappdata(DATAPLOT,'RotateState',1);
% setappdata(DATAPLOT,'TileType','D');
% setappdata(DATAPLOT,'ZoomState',0);
% setappdata(DATAPLOT,'ZoomState',1);
% setappdata(DataParam,'TileType','Tile')
% setappdata(chanwin,'TileType','Tile')
% setappdata(data.Measures.Display.Handles.Figures.ContactSheet,'TileType','T')
% setappdata(data.Results.Display.Handles.Figures.ContactSheet,'TileType','T')
% setappdata(data.Results.Display.Handles.Figures.Surfaces,'TileType','T')
% setappdata(data.Results.Display.Handles.Figures.TimeSeries,'TileType','T');
% setappdata(fig,'TileType','T')
% setappdata(figHandle,'TileType','T')
% setappdata(figcopy,'TileType','T')
% setappdata(h,'TileType','Tile')
% setappdata(handle,'Methods',Methods);
%
% Method = getappdata(hDataplot.SourceViewingTimeDisplay,'Methods');
% Methods = getappdata(gcbo,'Methods');
% RotateState = getappdata(DATAPLOT,'RotateState');
% ZoomState = getappdata(DATAPLOT,'ZoomState');
%
% Figure Files opened by this function:
% 'channel_select.fig'
% 'dataplot.fig'
% 'filterGUI.fig'
% 'lcmvbf.fig'
% 'listchan.fig'
% 'set_dataviewing_parameters.fig'
% 'sourceimaging.fig'
% 'tessellation_select.fig'
% 'tessellation_window.fig'
%
% Format of strings below: Type:Style:Tag, "String", CallBack Type and Call
% <automatic> callback is <Tag>_Callback by Matlab default
%
% Callbacks by figure channel_select.fig
% uicontrol:popupmenu:pChannelSets "Channel Sets" uses Callback for dataplot_cb channel_switch
% uicontrol:pushbutton:OPushbutton1 "Done" uses Callback for dataplot_cb channel_select_done
% uicontrol:pushbutton:pAdd ">" uses Callback for dataplot_cb channel_switch
% uicontrol:pushbutton:pRemove "<" uses Callback for dataplot_cb channel_switch
% uicontrol:pushbutton:QPushbutton1 "Close" uses Callback for close gcbf
%
% Callbacks by figure dataplot.fig
% figure::DATAPLOT "" uses DeleteFcn for clear global data
% uicontrol:edit:current_time "0" uses Callback for dataplot_cb set_current_time
% uicontrol:edit:step "''" uses Callback for dataplot_cb set_time_step
% uicontrol:edit:time_max "" uses Callback for dataplot_cb set_time_max
% uicontrol:edit:time_min "" uses Callback for dataplot_cb set_time_min
% uicontrol:popupmenu:ChangeUnits "MKS" uses Callback for
% dataplot_cb('ChangeUnits','reset'),dataplot_cb ChangeUnits
% uicontrol:popupmenu:DataViewingDataType "Original Data" uses Callback for
% dataplot_cb DataViewingDataType
% uicontrol:popupmenu:DataViewingSpatialDisplay "<No Scalp Topography>" uses Callback for
% dataplot_cb('DataViewingSpatialDisplay', 'reset'), dataplot_cb DataViewingSpatialDisplay
% uicontrol:popupmenu:DataViewingTimeDisplay "<No Time Display>" uses Callback for
% dataplot_cb DataViewingTimeDisplay
% uicontrol:popupmenu:SourceEstimationMethod "-------- IMAGING " uses Callback for
% dataplot_cb SourceImaging
% uicontrol:popupmenu:SourceViewingSpatialDisplay "<No Spatial Topography>" uses Callback for
% dataplot_cb SourceViewingSpatialDisplay
% uicontrol:popupmenu:SourceViewingTimeDisplay "<No Time Display>" uses Callback for
% dataplot_cb SourceViewingTimeDisplay
% uicontrol:pushbutton:HPlot "Plot" uses Callback for dataplot_cb('Plot','Measures')
% uicontrol:pushbutton:HPlotTimeSeries "Plot" uses Callback for sourceimaging('View')
% uicontrol:pushbutton:HSetDataViewing "Set-up" uses Callback for dataplot_cb SetDataViewing
% uicontrol:pushbutton:HSetSourceViewing "Set-up" uses Callback for dataplot_cb SetSourceViewing
% uicontrol:pushbutton:MSIndexSwitch "ms/index" uses Callback for dataplot_cb MSIndexSwitch
% uicontrol:pushbutton:NoiseModel "Noise Model" uses Callback for dataplot_cb CallDataSelector
% uicontrol:pushbutton:pushbutton35 "Filter" uses Callback for dataplot_cb create_filter_window
% uicontrol:pushbutton:pushbutton36 "Average" uses Callback for dataplot_cb GenerateAverage
% uicontrol:pushbutton:SourceModel "Source Model" uses Callback for
% dummy_dynamic_viewer('pushbutton11_Callback',gcbo,[],guidata(gcbo))
% uicontrol:slider:TimeSlider "" uses Callback for dataplot_cb mapping_slider
%
% Callbacks by figure filterGUI.fig
% uicontrol:checkbox:toggleFilter "Filter is ON" uses Callback for dataplot_cb ToggleFilter
% uicontrol:pushbutton:cancel "Cancel" uses Callback for close(gcf)
% uicontrol:pushbutton:Hok "Done" uses Callback for dataplot_cb data_filter
%
% Callbacks by figure lcmvbf.fig
% uicontrol:checkbox:TikhonovRegularization "" uses Callback for
% sourceimaging Tikhonov_regularization
% uicontrol:edit:cAutomaticParameterSetUp "10" uses Callback for sourceimaging changeLambda
% uicontrol:edit:data_start "" uses Callback for sourceimaging data_start
% uicontrol:edit:data_stop "" uses Callback for sourceimaging data_stop
% uicontrol:edit:noise_start "" uses Callback for sourceimaging noise_start
% uicontrol:edit:noise_stop "" uses Callback for sourceimaging noise_stop
% uicontrol:pushbutton:Go "Go" uses Callback for sourceimaging Go
% uicontrol:pushbutton:Quit "Quit" uses Callback for sourceimaging Quit
% uicontrol:radiobutton:cBrainStorm "Filter Output" uses Callback for
% sourceimaging output_format_currDensity
% uicontrol:radiobutton:noiseNormalization "Neural Index" uses Callback for
% sourceimaging output_format_index
% uicontrol:radiobutton:normalizedOut "Normalized Output" uses Callback for
% sourceimaging output_format_normalizedOut
% uicontrol:radiobutton:sourcePower "Source Power" uses Callback for
% sourceimaging output_format_sourcePower
%
% Callbacks by figure listchan.fig
% uicontrol:listbox:available "" uses CreateFcn for movegui center
% uicontrol:listbox:removed "" uses CreateFcn for movegui center
% uicontrol:pushbutton:Pushbutton1 ">" uses CreateFcn for movegui center
% uicontrol:pushbutton:Pushbutton1 ">" uses Callback for dataplot_cb channel_plot_remove
% uicontrol:pushbutton:Pushbutton1 "<" uses CreateFcn for movegui center
% uicontrol:pushbutton:Pushbutton1 "<" uses Callback for dataplot_cb channel_plot_restore
% uicontrol:pushbutton:Pushbutton1 "Cancel" uses CreateFcn for movegui center
% uicontrol:pushbutton:Pushbutton1 "Cancel" uses Callback for close gcbf
% uicontrol:pushbutton:Pushbutton1 "Apply" uses CreateFcn for movegui center
% uicontrol:pushbutton:Pushbutton1 "Apply" uses Callback for dataplot_cb listchan_refresh
% uicontrol:pushbutton:pushbutton1 "Select All" uses CreateFcn for movegui center
% uicontrol:pushbutton:pushbutton1 "Select All" uses Callback for dataplot_cb listchan_SelectAll
% uicontrol:pushbutton:pushbutton2 "Remove All" uses CreateFcn for movegui center
% uicontrol:pushbutton:pushbutton2 "Remove All" uses Callback for dataplot_cb listchan_RemoveAll
% uicontrol:text:StaticText1 "Available" uses CreateFcn for movegui center
% uicontrol:text:StaticText1 "Selected" uses CreateFcn for movegui center
% uicontrol:text:text1 "Number of Columns" uses CreateFcn for movegui center
%
% Callbacks by figure set_dataviewing_parameters.fig
% uicontrol:checkbox:cAbsoluteColormap "Absolute" uses Callback for dataplot_cb AbsoluteColormap
% uicontrol:checkbox:cColorbar "Show colorbar" uses Callback for dataplot_cb Colorbar
% uicontrol:checkbox:cContours "On" uses Callback for dataplot_cb ShowContours
% uicontrol:checkbox:cSensorLabels "Labels" uses Callback for dataplot_cb SensorLabels
% uicontrol:checkbox:cSensorMarkers "Markers" uses Callback for dataplot_cb SensorMarkers
% uicontrol:edit:ColumnLayout "4" uses Callback for dataplot_cb ChangeColumnLayout
% uicontrol:edit:eGainValue "1" uses Callback for dataplot_cb ApplyGain
% uicontrol:pushbutton:pushbutton1 "Select" uses Callback for dataplot_cb selectchannels
% uicontrol:pushbutton:pushbutton10 "Load" uses Callback for dataplot_cb aviplayer
% uicontrol:pushbutton:pushbutton11 "-" uses Callback for dataplot_cb ChangeColumnLayout
% uicontrol:pushbutton:pushbutton12 "+" uses Callback for dataplot_cb ChangeColumnLayout
% uicontrol:pushbutton:pushbutton13 "Edit" uses Callback for dataplot_cb NewColormap
% uicontrol:pushbutton:pushbutton14 "Load" uses Callback for dataplot_cb loadColormap
% uicontrol:pushbutton:pushbutton15 "Save" uses Callback for dataplot_cb saveColormap
% uicontrol:pushbutton:pushbutton5 "-" uses Callback for dataplot_cb ChangeGain
% uicontrol:pushbutton:pushbutton6 "+" uses Callback for dataplot_cb ChangeGain
% uicontrol:pushbutton:pushbutton8 "Movie" uses Callback for dataplot_cb GenerateMovie
% uicontrol:pushbutton:pushbutton9 "Contact sheet" uses Callback for dataplot_cb GenerateSlides
% uicontrol:pushbutton:Qpushbutton7 "Close" uses Callback for close(gcbf)
%
% Callbacks by figure sourceimaging.fig
% uicontrol:checkbox:cBrainStorm "BrainStorm Format" uses Callback for
% sourceimaging mutincomp_kernel
% uicontrol:checkbox:cKernel "Kernel only" uses Callback for sourceimaging mutincomp_kernel
% uicontrol:checkbox:FFNormalization "" uses Callback for sourceimaging FFNormalization
% uicontrol:checkbox:noiseNormalization "" uses Callback for sourceimaging noiseNormalization
% uicontrol:checkbox:TikhonovRegularization "" uses Callback for
% sourceimaging Tikhonov_regularization
% uicontrol:edit:cAutomaticParameterSetUp "10" uses Callback for sourceimaging changeLambda
% uicontrol:edit:data_start "" uses Callback for sourceimaging data_start
% uicontrol:edit:data_stop "" uses Callback for sourceimaging data_stop
% uicontrol:edit:noise_start "" uses Callback for sourceimaging noise_start
% uicontrol:edit:noise_stop "" uses Callback for sourceimaging noise_stop
% uicontrol:pushbutton:HGo "Go" uses Callback for sourceimaging Go
% uicontrol:pushbutton:Quit "Quit" uses Callback for sourceimaging Quit
%
% Callbacks by figure tessellation_select.fig
% Unable to open tessellation_select.fig
%
% Callbacks by figure tessellation_window.fig
% figure::tessellation_window "" uses CreateFcn for movegui northwest
%
% At Check-in: $Author: Mosher $ $Revision: 120 $ $Date: 10/12/04 10:23a $
%
% This software is part of BrainStorm Toolbox Version 2.0 (Alpha) 12-Oct-2004
%
% Principal Investigators and Developers:
% ** Richard M. Leahy, PhD, Signal & Image Processing Institute,
% University of Southern California, Los Angeles, CA
% ** John C. Mosher, PhD, Biophysics Group,
% Los Alamos National Laboratory, Los Alamos, NM
% ** Sylvain Baillet, PhD, Cognitive Neuroscience & Brain Imaging Laboratory,
% CNRS, Hopital de la Salpetriere, Paris, France
%
% See BrainStorm website at http://neuroimage.usc.edu for further information.
%
% Copyright (c) 2004 BrainStorm by the University of Southern California
% This software distributed under the terms of the GNU General Public License
% as published by the Free Software Foundation. Further details on the GPL
% license can be found at http://www.gnu.org/copyleft/gpl.html .
%
% FOR RESEARCH PURPOSES ONLY. THE SOFTWARE IS PROVIDED "AS IS," AND THE
% UNIVERSITY OF SOUTHERN CALIFORNIA AND ITS COLLABORATORS DO NOT MAKE ANY
% WARRANTY, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
% MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, NOR DO THEY ASSUME ANY
% LIABILITY OR RESPONSIBILITY FOR THE USE OF THIS SOFTWARE.
%<autoend> ------------------------ 12-Oct-2004 12:01:11 -----------------------
% /---Script Author--------------------------------------\
% | |
% | *** Sylvain Baillet, Ph.D. |
% | Cognitive Neuroscience & Brain Imaging Laboratory |
% | CNRS UPR640 - LENA |
% | Hopital de la Salpetriere, Paris, France |
% | sylvain.baillet@chups.jussieu.fr |
% \------------------------------------------------------/
%
% Date of creation: January 1999
%
% Script History---------------------------------------------------------------------------------------------------------------------------
% SB 2001-09 Revamping for compliancy with DataManager + major plastic surgery
% SB Oct 2001 Added Cortical Probes, Mapping of Curvature, Colormap Scaling of Activations
% SB|DS Nov 2001 Multiple fixings; added 0ms adjustment to data maximum peak (useful for epileptic data analysis about the maximum of the spike)
% SB 10-May-2002 User.CurrentData.DataFile is now a referential file name
% SB 28-May-2002 Call STUDY_EDITOR rather than STUDY_EDITOR_CB
% JCM 28-May-2002 added bst_color_scheme, still needs lots of fixing, Users.Current.Database now
% Users.Comment
% SB 03-Mar-03 Starting major update. . .
% JCM 09-Sep-2003 disabling old taskbar routines
% SB 20-Oct-2003 lots of fixes at USC
% SB 15-Dec 2003 Added visualisation of surface data on scalp tessellation
% Fixed movie generation (provided uses has codec Indeo5
% installed on computer)
% JCM 17-Jun-2004 Adding Names to the time series figures
% DP 28-Sep-2004 Fix a bug not to open many plot figures
% DP 20-Sep-2004 Update the menu options for imaging methods
% EK 1-Oct-2004 Visualization of results stored in kernel mode
% EK 2-Oct-2004 Functionality to LCMV is given
% EK 7-Oct-2004 Imaging methods that are NOT available are deleted from
% the GUI (dataplot.fig) and code is changed according to the new list
% Old list is available (commented) here for future
% reference.
% EK 7-Oct-2004 Minor change in result plotting. GUI file changed to call
% sourceimaging('View') instead of dataplot_cb('Plot','RESULTS')
% when PLOT button in Source Viewing section is pressed. Now the
% Data Time Series window is also opened. Consistent with viewing the
% results using an imaging method.
% -----------------------------------------------------------------------------------------------------------------------------------------
% SB - 01-Jul-2003 | Declare very-much used variables as global instead of storing things using guidata too much (make windows flicker under Matlab 6.1)
global DATAPLOT hDataplot data DefaultCheckChar
% DATAPLOT : handle to Viewer figure
% hDataPlot : handles to all objects in Viewer GUI
% data : large structure containing all display data and options
% DefaultCheckChar : usualyy a '*' to check selected items in pulldown menus
DefaultCheckChar = '*'; % SB 05-Jun-2003 | default character used for checked items in pulldown lists
% Labels of modalities for surface measures
% A cell array indicating to which modality the measures belong to :
% {'MEG','EEG','OTHER'}.
% This order is important as modalities are usually referred to by their index in ModalityLabel
ModalityLabel = {'MEG','EEG','OTHER'};
%-CALLBACK ACTION SWITCHYARD---------------------------------------------------------------------------------------------------------------
switch action
case 'create'
clear global data
Users = get_user_directory; % go and fetch information on current database
% Check for data loaded from DataManager, if exists
if ~isfield(Users,'CurrentData') % No data was loaded using DataManager - do nothing (old way)
errordlg('No data file was loaded from DataManager.')
return
end
% Warnings off to suppress the message:
% Warning: Figure file created with a newer version (7.0.0) of MATLAB
warning off, DATAPLOT = openfig('dataplot.fig','reuse');, warning on
BrainStormWindows = bst_win_manager(DATAPLOT,'DataViewer');
bst_color_scheme(DATAPLOT);
setappdata(DATAPLOT,'TileType','D');
bst_layout('align',DATAPLOT)
set(DATAPLOT,'Visible','on');
hDataplot = guihandles(DATAPLOT);
set([hDataplot.NoiseModelTag,hDataplot.tSourceModelTag],'String','default')
% Look for datafiles in current study folder
cd(Users.STUDIES);
[studypath,file,ext] = fileparts(Users.CurrentData.StudyFile);
cd(studypath)
% Define Misc. Viewing parameters ---------------------------------------------------------------------
% Load selected dataset from bst_static_taskbar
tmp = bst_static_taskbar('GET','DATA');
if ~isempty(tmp{1})
dataplot_cb('loadfile',tmp);
else
errordlg('Please select first a data file from pulldown list','No data file selected')
return
end
% Load selected result file from bst_static_taskbar
tmp = bst_static_taskbar('GET','RESULTS');
if ~isempty(tmp)
dataplot_cb('loadfile',tmp);
end
if ~isappdata(hDataplot.SourceViewingTimeDisplay,'Methods');
initialize_SourceTimeViewing(hDataplot.SourceViewingTimeDisplay); % Initialize pull-down menus
end
if ~isappdata(hDataplot.SourceViewingSpatialDisplay,'Methods');
initialize_SourceSpatialViewing(hDataplot.SourceViewingSpatialDisplay); % Initialize pull-down menus
end
% CBB: need to do the same with all pulldown in DATAPLOT
%----------------------------------------------------------------------------
case 'FileDisplayType' % Toggle file display type in listbox (scalp data and/or result files)
dataplot_cb('create') % refresh file list
%----------------------------------------------------------------------------
case 'GET' % Retrieve tag information
TAG = varargin{1};
switch(lower(TAG))
% [TimeSet, TimeIndices] = dataplot_cb('GET','TIME')
% Retrieve information about time window specified in the Viewer
% TimeSet: [start, step, stop] time instants in seconds
% TimeIndices: a subset of time indices from orginal data array
case 'time' % retrieve time start|step|stop and corresponding time indices
% data.Display.Time(1) = str2num(get(hDataplot.time_min,'String'))/1000;
% data.Display.Time(end) = str2num(get(hDataplot.time_max,'String'))/1000;
% data.Display.SamplingRate = str2num(get(hDataplot.step,'String'))/1000;
varargout{1} = [data.Display.Time(1) data.Display.SamplingRate data.Display.Time(end)];
varargout{2} = data.Display.TimeSamples;
case 'current_time' % retrieve current time in seconds
timeValue = get(hDataplot.TimeSlider,'Value');
timeVec = [data.Display.Time(1):data.Display.SamplingRate:data.Display.Time(end)];
timeValue = findclosest(timeValue,timeVec');
varargout{1} = timeVec(timeValue);
end
%----------------------------------------------------------------------------
case 'SET' % Set tag information
TAG = varargin{1};
switch(lower(TAG))
% [TimeSet, TimeIndices] = dataplot_cb('GET','TIME')
% Retrieve information about time window specified in the Viewer
% TimeSet: [start, step, stop] time instants in seconds
% TimeIndices: a subset of time indices from orginal data array
case 'time' % set current time
set(hDataplot.current_time,'string',num2str(1000*varargin{2},'%3.2f'));
% update display
dataplot_cb('set_current_time')
end
%----------------------------------------------------------------------------
case 'loadfile' % Load either a data ro a result file
makeuswait('start')
Users = get_user_directory;
datatype = 'mat'; % Assume we're loading only a BST matlab file with proper extension
% Read Study File %
cd(Users.STUDIES);
if (0) % Deprecated code nargin == 1 % Manual load
[studyfile,StudyPath] = uigetfile(['*brainstormstudy.',datatype], 'Enter file name for the study file');
if (studyfile)==0, return, end
cd(studypath)
[datafile,datapath] = uigetfile(['*data*.',datatype], 'Enter file name for data set');
if (datafile)==0, return, end
disp('Loading data...')
cd(datapath)
[path,file,ext] = fileparts(studyfile);
load(studyfile);
if ~isempty(path)
cd(path)
end
elseif nargin == 2 % Data and Study files are specified as arguments
datafile = varargin{1}{1};
%fname = varargin{1};
end
% Determine whether it is a surface data file or a result file
% if ~exist(datafile)
% bst_message_window('wrap',...
% sprintf('Can''t find the datfile called %s . . .',datafile))
% data.Results.Filename = {[]};
% return
% end
File_whos = whos('-file',fullfile(Users.STUDIES,datafile));
if(strmatch('Fsynth',{File_whos.name})) % result file
DataFlag = 0; % Just a flag: we're loading a result file
elseif (strmatch('F',{File_whos.name})) % data file
DataFlag = 1; % Just a flag: we're loading a data file
% Check for time and data array size integrity
if File_whos(strmatch('F',{File_whos.name})).size(2) ~= File_whos(strmatch('Time',{File_whos.name})).size(2)
errordlg(sprintf(...
'Time and Data arrays have incompatible sizes in file %s.',datafile),...
'Cannot load this file : file is corrupted')
makeuswait('stop')
return
end
else
errordlg('File does not follow BrainStorm file format.','Wrong file format')
return
end
% Fill out all data or result parameters necessary for subsequent viewing
if DataFlag % MEG/EEG surface data file
% Update display of type of data to plot
dataplot_cb('DataViewingDataType','reset')
set(hDataplot.DataViewingDataType,'enable','off','value',1)
bst_message_window('wrap',...
sprintf('Loading data file %s . . .',datafile))
data.Measures = load(datafile,'Time','ChannelFlag'); % Load time samples (in seconds)
data.Measures.Filename = {datafile};
% Fill out basic entries with information about measures
% -> Time Information
data.Measures.SamplingRate = data.Measures.Time(2) - data.Measures.Time(1);
data.Measures.NumberOfSamples = length(data.Measures.Time);
data.Measures.Time = [data.Measures.Time(1), data.Measures.Time(end)];
% Default time window for visualization if original data time window
data.Display.Time = data.Measures.Time;
data.Display.TimeSamples = [1:data.Measures.NumberOfSamples];
data.Display.SamplingRate = data.Measures.SamplingRate;
data.Display.NumberOfSamples = data.Measures.NumberOfSamples;
% A set of strings for display of basic time information in GUI
data.Measures.DataInfoString = {...
'Maximum time span',...
sprintf('From: %3.1f ms', 1000*data.Measures.Time(1)),...
sprintf('To: %3.1f ms', 1000*data.Measures.Time(end)),...
sprintf('%d samples',data.Measures.NumberOfSamples),...
sprintf('Sampling rate: %d Hz (%3.1f ms)',round(1/data.Measures.SamplingRate),data.Measures.SamplingRate*1000)...
};
% -> Time Information <- DONE
% -> Channel Information
% Fetch information about current study
StudySubject = find_brainstorm_structure(Users.CurrentData.StudyFile);
try
Channel = load_brainstorm_file(StudySubject.Channel);
data.Measures.Channel = Channel.Channel; clear Channel
catch
errordlg(...
sprintf('Please make sure that channel file is present and has proper name: %s',StudySubject.Channel),...
'Channel file not found'...
)
end
% Available channels in data file
data.Measures.Display.SelectedChannels{1} = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'MEG');
data.Measures.Display.SelectedChannels{2} = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'EEG');
data.Measures.Display.SelectedChannels{3} = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'Other');
% What does the user want to look at MEG? EEG? Both ? etc.
% Get this information from checkboxes in Static Taskbar
[val,enable,hMEG] = bst_static_taskbar('GET','MEG');
[val,enable,hEEG] = bst_static_taskbar('GET','EEG');
[val,enable,hOTHER] = bst_static_taskbar('GET','OTHER');
% Check whether user's choice is compatible with available channels
if isempty(data.Measures.Display.SelectedChannels{1})
set(hMEG,'enable','off')
else
set(hMEG,'enable','on')
end
if isempty(data.Measures.Display.SelectedChannels{2})
set(hEEG,'enable','off')
else
if ~isempty(data.Measures.Display.SelectedChannels{1})
set(hEEG,'enable','on') % Select MEG only by default
else
set(hEEG,'enable','on')
end
end
if isempty(data.Measures.Display.SelectedChannels{3})
set(hOTHER,'enable','off')
else
set(hOTHER,'enable','on')
end
% Is any already checked ?
chck = get_selected_modalities;
if isempty(chck) % None selected, select first available by default
tmpHandles = [hMEG,hEEG,hOTHER];
enbl = get(tmpHandles,'enable');
tmp = find(strcmp(enbl,'on'));
set(tmpHandles(tmp(1)),'value',1)
end
% -> Channel Infomation <- DONE
bst_message_window({'Loading data file -> DONE',' '})
elseif DataFlag == 0 % Load a result file generated by some source analysis
bst_message_window('wrap',...
sprintf('Loading result file %s . . .',datafile))
set(hDataplot.DataViewingDataType,'enable','on','value',1)
dataplot_cb('DataViewingDataType','set',1,1); % Default visualization is Original Data
% Results file name
data.Results.Filename = {datafile};
% -> Make time ranges of Measures and Results match for display purposes
% Load original Time range of which source analysis was computed
% This time range superseeds the original Measures time range for display
tmpTimeSamples = load(datafile,'Time'); % load vector of subset sample indices from original data time range
tmpTimeSamples = tmpTimeSamples.Time;
origTime = linspace(data.Measures.Time(1),data.Measures.Time(end),data.Measures.NumberOfSamples);
data.Results.Time = [origTime(tmpTimeSamples(1)),origTime(tmpTimeSamples(end))];
data.Display.Time = data.Results.Time;
data.Display.SamplingRate = origTime(tmpTimeSamples(2)) - origTime(tmpTimeSamples(1));
data.Display.NumberOfSamples = length(tmpTimeSamples);
clear tmpTimeSamples origTime
% Apply Results time range to entire display, including Measures data
set(hDataplot.time_min,'String',sprintf('%3.2f',1000*data.Display.Time(1)));
set(hDataplot.time_max,'String',sprintf('%3.2f',1000*data.Display.Time(end)));
set(hDataplot.step,'String',sprintf('%3.2f',1000*data.Display.SamplingRate));
set(hDataplot.current_time,'String',data.Display.Time(1)*1000);
% -> Make time ranges of Measures and Results match for display purposes <- DONE
dataplot_cb('set_time_max')
bst_message_window({'Loading result file -> DONE',' '})
end
% Update GUI objects in Viewer accordingly
set(hDataplot.time_min,'String',sprintf('%3.2f',1000*data.Display.Time(1)));
set(hDataplot.time_max,'String',sprintf('%3.2f',1000*data.Display.Time(end)));
set(hDataplot.step,'String',sprintf('%3.2f',1000*data.Display.SamplingRate));
set(hDataplot.TimeSlider,'Min',data.Display.Time(1),'Max',data.Display.Time(end),...
'SliderStep',[data.Display.SamplingRate/(data.Display.Time(end)-data.Display.Time(1)),.1],'Value',data.Display.Time(1))
set(hDataplot.current_time,'String',data.Display.Time(1)*1000);
set(hDataplot.nTimeSamples,'String',sprintf('%d samples',data.Display.NumberOfSamples));
makeuswait('stop')
%----------------------------------------------------------------------------
case 'LoadFromDataFileList' % Load from popup menu list in the DataViewer
% BrainStormWindows = bst_win_manager;
% DATAPLOT = BrainStormWindows.DataViewer;
% % hDataplot = guihandles(DATAPLOT);
iFile = get(hDataplot.DataFileList,'Value');
FileNames = get(hDataplot.DataFileList,'String');
dataplot_cb('loadfile',FileNames{iFile});
%----------------------------------------------------------------------------
case 'LoadPrevFile' % Load previous file in the popup menu list in the DataViewer
% % hDataplot = guihandles(DATAPLOT);
iFile = get(hDataplot.DataFileList,'Value');
FileNames = get(hDataplot.DataFileList,'String');
iFile = iFile - 1;
if iFile < 1
iFile = 1;
return
end
set(hDataplot.DataFileList,'Value',iFile)
CurrentData = getpref('BrainStorm','CurrentData');
CurrentData.DataFile = fullfile(...
fileparts(CurrentData.StudyFile),...
FileNames{iFile});
setpref('BrainStorm','UserCurrentData',CurrentData);
dataplot_cb('loadfile',FileNames{iFile});
%----------------------------------------------------------------------------
case 'LoadNextFile' % Load previous file in the popup menu list in the DataViewer
% % hDataplot = guihandles(DATAPLOT);
iFile = get(hDataplot.DataFileList,'Value');
FileNames = get(hDataplot.DataFileList,'String');
iFile = iFile + 1;
if iFile > length(FileNames)
iFile = length(FileNames);
return
end
set(hDataplot.DataFileList,'Value',iFile)
CurrentData = getpref('BrainStorm','CurrentData');
CurrentData.DataFile = fullfile(...
fileparts(CurrentData.StudyFile),...
FileNames{iFile});
setpref('BrainStorm','UserCurrentData',CurrentData);
dataplot_cb('loadfile',FileNames{iFile});
% dataplot_cb quicklook
%----------------------------------------------------------------------------
case 'SourceImaging' % Launch source imaging routines on seleceted data
Val = get(hDataplot.SourceEstimationMethod,'Val'); % what is the popup set to
% OLD LIST
% -------- IMAGING
% Min. Norm Imaging (LMMS)
% (Recursive LMMS)
% ST-MAP
% Recursice Tiling
% LCMV
% Cortical MUSIC
%
% -------- SCANNING
% LCMV
% RAP-MUSIC
% R-MUSIC
% SPTF
% --------
% NEW LIST
% -------- IMAGING
% Min. Norm Imaging (LMMS)
% Cortical LCMV Beamformer
% Cortical MUSIC
%
% -------- SCANNING
% RAP-MUSIC
% --------
% CODE FOR OLD LIST
% --------------------------------------------
% switch Val
% case {1, 8, 9, 14}
% % do nothing, comment lines in the popup
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
%
% case {2} % min norm imaging
% % JCM 09-Sep-2003 moving taskbar function to here
% set(DATAPLOT,'Pointer','watch')
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
% SrcImagingGUI = openfig('sourceimaging.fig','reuse');
% sourceimaging('create', SrcImagingGUI)
% set(DATAPLOT,'Pointer','arrow')
%
% case {3}%Recursive LMMS
% bst_message_window(sprintf('Recursive LMMS not implemented yet'));
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
%
% case {4}%ST MAP
% bst_message_window(sprintf('ST MAP not implemented yet'));
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
%
% case {5}%recursive tiling
% bst_message_window(sprintf('Recursive tiling not implemented yet'));
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
%
% case{6}%Cortical LCMV Beamformer
% % EK 2-Oct-2004 Functionality to LCMV is given
% set(DATAPLOT,'Pointer','watch')
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
% SrcImagingGUI = openfig('lcmvbf.fig','reuse');
% sourceimaging('create', SrcImagingGUI)
% set(DATAPLOT,'Pointer','arrow')
%
% case{7}%Cortical MUSIC
% bst_message_window(sprintf('Cortical MUSIC not implemented yet'));
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
%
% case 11 % RAP-MUSIC
%
% if ~isfield(data.Measures,'F') % call data display
% tmp = bst_static_taskbar('GET','DATA');
% if ~isempty(tmp{1})
% Users = get_user_directory;
% dataplot_cb('loadfile',tmp); %Users.CurrentData.StudyFile
% end
% dataplot_cb('Plot','measures');
% end
%
% if ~isfield(data.Measures,'NoiseModelParam') % Noise parameters were not defined - call data selector
% dataplot_cb('CallDataSelector')
% waitfor(findobj(0,'Name','Parametric Estimation Data Selector'))
% end
% hf = rap_music_parameters; % setup
% rap_music_parameters('load_parameters',hf,data.Measures.NoiseModelParam.StudySubject,data.Measures.NoiseModelParam);
%
% case 13 % Least-squares
% % get the GUI parameters
% GUI = start_gui_structure(h,eventdata,handles,varargin);
% StudySubject = getappdata(fig,'StudySubject');
% hf = least_squares_parameters_cb; % setup
%
% least_squares_parameters_cb(StudySubject,GUI,hf); %set up the popup
%
% otherwise
% bst_message_window(sprintf('Unknown source estimation method'));
% set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
% end
%
% %----------------------------------------------------------------------------
switch Val
case {1, 5, 6, 8}
% do nothing, comment lines in the popup
set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
case {2} % min norm imaging
% JCM 09-Sep-2003 moving taskbar function to here
set(DATAPLOT,'Pointer','watch')
set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
warning off, SrcImagingGUI = openfig('sourceimaging.fig','reuse');warning on
sourceimaging('create', SrcImagingGUI)
set(DATAPLOT,'Pointer','arrow')
case{3}%Cortical LCMV Beamformer
% EK 2-Oct-2004 Functionality to LCMV is given
set(DATAPLOT,'Pointer','watch')
set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
warning off, SrcImagingGUI = openfig('lcmvbf.fig','reuse');, warning on
sourceimaging('create', SrcImagingGUI)
set(DATAPLOT,'Pointer','arrow')
case{4}%Cortical MUSIC
bst_message_window(sprintf('Cortical MUSIC not implemented yet'));
set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
case 7 % RAP-MUSIC
set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
if ~isfield(data.Measures,'F') % call data display
tmp = bst_static_taskbar('GET','DATA');
if ~isempty(tmp{1})
Users = get_user_directory;
dataplot_cb('loadfile',tmp); %Users.CurrentData.StudyFile
end
dataplot_cb('Plot','measures');
end
if ~isfield(data.Measures,'NoiseModelParam') % Noise parameters were not defined - call data selector
dataplot_cb('CallDataSelector')
waitfor(findobj(0,'Name','Parametric Estimation Data Selector'))
end
hf = rap_music_parameters; % setup
rap_music_parameters('load_parameters',hf,data.Measures.NoiseModelParam.StudySubject,data.Measures.NoiseModelParam);
otherwise
bst_message_window(sprintf('Unknown source estimation method'));
set(hDataplot.SourceEstimationMethod,'Val',1); % reset back to teaser
end
%----------------------------------------------------------------------
case 'SelectChannelType' % Select MEG, EEG or Other Channels for display
% hDataplot = guihandles(DATAPLOT);
%data = guidata(DATAPLOT);
if get(gcbo,'Value')
flag = 1; % add channels to display
else
flag = 0; % remove channels from display
end
mod = strmatch(upper(get(gcbo,'Tag')),data.Label); % Which modalities were selected ?
if flag
data.Measures.Display.SelectedChannels{mod} = good_channel(data.Measures.Channel,[],data.Label{mod});
else
data.Measures.Display.SelectedChannels{mod} = [];
end
%----------------------------------------------------------------------------
case 'ChangeColumnLayout' % Changle the number of column of disply layout
handles = guihandles(gcbf);
ViewParam = openfig('set_dataviewing_parameters.fig','reuse');
hViewParam = guihandles(ViewParam);
data.Measures.Display.DisplayTypes(2) = str2num(get(handles.ColumnLayout,'String'));
switch(upper(get(gcbo,'String')))
case '+'
data.Measures.Display.DisplayTypes(2) = data.Measures.Display.DisplayTypes(2) + 1;
case '-'
data.Measures.Display.DisplayTypes(2) = max([data.Measures.Display.DisplayTypes(2)-1,1]);
end
set(hViewParam.ColumnLayout,'String',data.Measures.Display.DisplayTypes(2))
%----------------------------------------------------------------------------
case 'ChangeUnits' % Change display units of current waveforms
switch(get(gcbo,'Value'))
case 1
% Original time series units
case 2
% Move to Zscore time series
zscore_gui('create')
otherwise
return % not implemented yet
end
%----------------------------------------------------------------------------
case {'ChangeGain','ApplyGain'} % Change display gain of data
% % hDataplot = guihandles(DATAPLOT);
%%data = guidata(DATAPLOT);
%Label = {'MEG','EEG','OTHER'};
ViewParam = openfig('set_dataviewing_parameters.fig','reuse');
hViewParam = guihandles(ViewParam);
strr = get(hViewParam.GainDataType,'String');
% Which modality was selected from pulldown?
mod = get(hViewParam.GainDataType,'Value');
switch(action)
case 'ChangeGain'
if ~isempty(findstr('+',get(gcbo,'String')))
gain = 1.2; % increase display gain
else
gain = 0.8;
end
set(hViewParam.eGainValue,'String',num2str(gain))
case 'ApplyGain'
gain = str2num(get(hViewParam.eGainValue,'String'));
end
if data.Measures.Display.DisplayTypes(1) & mod <= length(data.Measures.Display.Handles.PlotOverlay)
lineHandles = [data.Measures.Display.Handles.PlotOverlay(mod).lines{:}];
lineHandles = lineHandles(:);
ydata = get(lineHandles,'ydata');
if isempty(ydata), return, end
ytick = get(get(data.Measures.Display.Handles.PlotOverlay(mod).lines{1}(1),'Parent'),'Ytick');
if length(ytick)>1
ytick = ytick(mod);
end
ydata = reshape([ydata{:}],length(ydata{1}),length(ydata))';
ydata = (ydata-ytick)* gain + ytick;
for k=1:size(ydata,1)
%set(data.Measures.Display.Handles.PlotOverlay(mod).lines(k),'ydata',ydata(k,:));
set(lineHandles(k),'ydata',ydata(k,:));
end
if mod == 1 % MEG
sstring = 'fT'; factor = 1e-15;
elseif mod == 2 % EEG
sstring = 'uV'; factor = 1e-6;
else
sstring = 'a.u.'; factor = 1;
end
set(data.Measures.Display.Handles.PlotOverlay(mod).YScale.Label,'String',...
sprintf('%3.1f %s',str2num(strrep(get(data.Measures.Display.Handles.PlotOverlay(mod).YScale.Label,'string'),sstring,''))/gain,sstring))
end
if data.Measures.Display.DisplayTypes(2) > 0
colLines = [data.Measures.Display.Handles.PlotColumn(mod).lines{:}];
ydata = get(colLines,'ydata');
if isempty(ydata), return, end
ydata = reshape([ydata{:}],length(ydata{1}),length(ydata))';
ydata = ydata* gain + (1-gain)*data.Measures.Display.Handles.PlotColumn(mod).ytick'*ones(1,size(ydata,2));
for k=1:size(ydata,1)
set(colLines(k),'ydata',ydata(k,:));
end
end
%----------------------------------------------------------------------------
case {'ShowContours','SensorMarkers','SensorLabels','Colorbar','AbsoluteColormap'} % Update parameters for spatial display
ViewParam = openfig('set_dataviewing_parameters.fig','reuse');
hViewParam = guihandles(ViewParam);
switch(action)
case 'ShowContours'
data.Measures.Display.Flags.ShowContours = get(hViewParam.cContours,'Value');
case 'SensorMarkers'
data.Measures.Display.Flags.SensorMarkers = get(hViewParam.cSensorMarkers,'Value');
case 'SensorLabels'
data.Measures.Display.Flags.SensorLabels = get(hViewParam.cSensorLabels,'Value');
case 'AbsoluteColormap'
data.Measures.Display.Flags.AbsoluteColormap = get(hViewParam.cAbsoluteColormap,'Value');
case 'Colorbar'
data.Measures.Display.Flags.Colorbar = get(hViewParam.cColorbar,'Value');
if isfield(data,'Results')
data.Results.Display.Flags.Colorbar = data.Measures.Display.Flags.Colorbar;
end
end
% Update display
set(gcbf,'pointer','watch')
dataplot_cb('mapping_slider')
set(gcbf,'pointer','arrow')
%----------------------------------------------------------------------------
case{'SourceViewingTimeDisplay'}
Method = getappdata(hDataplot.SourceViewingTimeDisplay,'Methods');
item = get(hDataplot.SourceViewingTimeDisplay,'Value');
eval(Method(item).callback)
%----------------------------------------------------------------------------
case {'DataViewingDataType','set_SourceViewingTimeDisplay','DataViewingTimeDisplay','DataViewingSpatialDisplay','SourceViewingSpatialDisplay'} % Original / Modeled / Residual data and type of time series visualization
switch(action)
case 'DataViewingDataType'
objtHandle = hDataplot.DataViewingDataType;
flag = 1;
reset = 0;
case 'DataViewingTimeDisplay'
objtHandle = hDataplot.DataViewingTimeDisplay;
flag = 0;
reset = 0;
case 'set_SourceViewingTimeDisplay'
objtHandle = hDataplot.SourceViewingTimeDisplay;
flag = 0;
reset = 0;
case 'DataViewingSpatialDisplay'
objtHandle = hDataplot.DataViewingSpatialDisplay;
flag = 0;
reset = 1;
case 'SourceViewingSpatialDisplay'
objtHandle = hDataplot.SourceViewingSpatialDisplay;
flag = 0;
reset = 1;
otherwise
error('Not a valid call.')
end
%if nargin == 1 % Reset selected items to 'unselected'
if reset == 1 & nargin == 1
dataplot_cb(action,'reset')
end
DataViewingTimeDisplay = get(objtHandle,'String'); % Available data types
DisplayType = get(objtHandle,'Value');
if nargin == 2
if strmatch(lower(varargin{1}),'reset') % reset all items in pulldown menu
for k = 1:length(DataViewingTimeDisplay)
DataViewingTimeDisplay{k} = strrep(DataViewingTimeDisplay{k},DefaultCheckChar,'');
end
set(objtHandle,'String',DataViewingTimeDisplay);
return
elseif strmatch(lower(varargin{1}),'get') % get values of checked items in pulldown menu
items = zeros(length(DataViewingTimeDisplay),1);
for k = 1:length(DataViewingTimeDisplay)
if ~isempty(findstr(DataViewingTimeDisplay{k},DefaultCheckChar))
items(k) = 1;
end
end
varargout{1} = items;
end
elseif nargin == 3 & strmatch(lower(varargin{1}),'set') % Set specified menu item
nitem = varargin{2}; % item menu location
value = varargin{3}; % 1 is check - 0 is uncheck
DataViewingTimeDisplay{k} = strrep(DataViewingTimeDisplay{k},DefaultCheckChar,'');
if value
DataViewingTimeDisplay{DisplayType} = sprintf('%s%s',DataViewingTimeDisplay{DisplayType},DefaultCheckChar);
end
set(objtHandle,'String',DataViewingTimeDisplay);
return
end
getFlag = 0; % Flag | see below
if nargin == 2 % User request special function
if strcmp(lower(varargin{1}),'get') % Get display properties without altering them
getFlag = 1;
end
end
if ~isempty(findstr(DataViewingTimeDisplay{DisplayType},DefaultCheckChar))% Unselect current display type
if ~getFlag
DataViewingTimeDisplay{DisplayType} = strrep(DataViewingTimeDisplay{DisplayType},DefaultCheckChar,'');
end
else
if ~getFlag
DataViewingTimeDisplay{DisplayType} = sprintf('%s%s',DataViewingTimeDisplay{DisplayType},DefaultCheckChar);
if flag == 0 & DisplayType == 1
for k = 1:length(DataViewingTimeDisplay)
DataViewingTimeDisplay{k} = strrep(DataViewingTimeDisplay{k},DefaultCheckChar,'');
end
end
end
end
set(objtHandle,'String',DataViewingTimeDisplay);
%----------------------------------------------------------------------------
case 'Plot' % Look at Measures and/or Results in all possible ways
makeuswait('start')
if nargin == 1
varargin{1}= 'measures'; % see surface data by default
end
% Zoom status of the window was previously stored as an application data
if isappdata(DATAPLOT,'ZoomState')
rmappdata(DATAPLOT,'ZoomState') % Reset - zoom is turned off
end
% Create/Find display figure depending on type of display; i.e. data or results
if strcmp(lower(varargin{1}),'measures') % Display surface measures (i.e. MEG, EEG, OTHER)
DataFlag = 1; % Just a flag meaning we're looking at measures, not results.
% Clean up previous figures
if isfield(data.Measures.Display,'Handles')
HandlesNames = fieldnames(data.Measures.Display.Handles);
for k = 1:length(HandlesNames)
if ishandle(getfield(data.Measures.Display.Handles,HandlesNames{k}))
delete(getfield(data.Measures.Display.Handles,HandlesNames{k})) % Delete all previous figures
end
end
data.Measures.Display = rmfield(data.Measures.Display,'Handles');
end
% Create new figure
% figHandle = openfig('timeseries.fig','reuse'); % Handle to time series window
% set(0,'CurrentFigure',figHandle)
% clf
% set(figHandle,'MenuBar','figure')
% set(figHandle,'Visible','on')
figHandle = findobj(0,'type', 'figure', 'tag','DataTimeSeries');
if isempty(figHandle)
figHandle = figure;
set(figHandle,'Visible','off','tag','DataTimeSeries','Name',sprintf('Data Time Series Figure %.0f',figHandle));
setappdata(figHandle,'TileType','T')
bst_color_scheme(figHandle);
set(figHandle,'menubar','figure');
bst_layout('align',figHandle,2,1,1);
set(figHandle,'Visible','on')
end
BrainStormWindows = bst_win_manager(figHandle,'DataTimeSeries');
data.Measures.Display.Handles.Figures.TimeSeries = figHandle;
clear figHandle
% -> Fill out display parameters
% What kind of displays are requested ?
whichDisplay = dataplot_cb('DataViewingTimeDisplay','get'); % None | Overlay | Column ?
data.Measures.Display.DisplayTypes(1) = whichDisplay(2); % Overlay
if whichDisplay(3) == 0 % no Column
data.Measures.Display.DisplayTypes(2) = 0;
else % Column layout required
if data.Measures.Display.DisplayTypes(2) > 1 % previous choice of number of columns somewhere
% use data.Measures.Display.DisplayTypes(2) ;
else
data.Measures.Display.DisplayTypes(2) = 1;
end
end
data.Measures.Display.DisplayTypes(3) = max([0,find(dataplot_cb('DataViewingSpatialDisplay','get'))]); % Spatial display
% Now find what kind of datatype to display (Original | Modeled | Residuals)
data.Measures.Display.TimeSeriesTypes = dataplot_cb('DataViewingDataType','get');
%data.Display = DisplayStruct;
% -> Fill out display parameters <- DONE
figHandle = data.Measures.Display.Handles.Figures.TimeSeries;
figure(figHandle)
%set(figHandle,'Pointer','watch')
delete(findobj(figHandle,'type','axes'))
set(figHandle,'Visible','on')
% % Remove all previous handles from Display substructure
% if isfield(data.Measures.Display,'Handles')
% data.Measures.Display = rmfield(data.Measures.Display,'Handles');
% end
% -> Which modalities need to be displayed ?
data.Measures.Display.Modality = get_selected_modalities;
if isempty(data.Measures.Display.Modality)
bst_message_window('wrap',...
{' ',...
'Please select either ''MEG'', ''EEG'' or ''Other'' for display in taskbar',...
' '});
errordlg(...
'Please select either ''MEG'', ''EEG'' or ''Other'' for display in Taskbar','No modality selected')
return
end
% -> Which modalities need to be displayed ? <- DONE
DisplayStruct = data.Measures.Display; %temporary structure to use shorter names in the following
% -> Get data filename to create labels on displays
fname = shorter_filename(data.Measures.Filename);
% -> Get data filename to create labels on displays <- DONE
% -> Fill out parameters before call to specific display subfunction
DefaultLabels = {'MEG','EEG','OTHER'}; % Default modality labels
OPTIONS = DisplayStruct;
if isfield(OPTIONS,'Flags') % User has already altered viewing preferences
flagNames = fieldnames(OPTIONS.Flags);
for k = 1:length(flagNames)
OPTIONS = setfield(OPTIONS,flagNames{k},getfield(OPTIONS.Flags,flagNames{k}));
end
end
OPTIONS.Modality = DisplayStruct.Modality;
OPTIONS.ModalityLabel = DefaultLabels(DisplayStruct.Modality); clear DefaultLabels
OPTIONS.SelectedChannels(OPTIONS.Modality) = data.Measures.Display.SelectedChannels(DisplayStruct.Modality);
OPTIONS.Channel = data.Measures.Channel;
tmpTime = linspace(data.Measures.Time(1),data.Measures.Time(end),data.Measures.NumberOfSamples); % Rebuild original time vector
data.Display.NumberOfSamples = data.Measures.NumberOfSamples;
data.Display.Time = data.Measures.Time;
data.Display.SamplingRate = tmpTime(2)-tmpTime(1);
% extract Display time samples in ms
OPTIONS.Time = tmpTime(data.Display.TimeSamples); clear tmpTime
OPTIONS.CurrentTime = dataplot_cb('GET','current_time');
if 0,%isfield(data.Measures,'Fmax')
OPTIONS.Fmax(:,OPTIONS.Modality) = data.Measures.Fmax;
end
%OPTIONS.DisplayTypes = data.Measures.Display.DisplayTypes;
% <- DONE
% Now specify data to display in specific cell arrays
% -> Check if user wants to see modeled data or residuals when no results a re available yet
if sum(data.Measures.Display.TimeSeriesTypes) > 1 & ~isfield(data,'Results')
errordlg('Please selected a Results file from list in taskbar')
return
end
% <- DONE
% Fill out arrays containing Original | Modeled | Residuals
% Make sure at least one of the above was selected
if isempty(find(DisplayStruct.TimeSeriesTypes))
% If not, selected Original timeseries by default
DisplayStruct.TimeSeriesTypes(1) = 1;
% Update pulldown menu by adding a 'checked' character
dataplot_cb('DataViewingDataType','set',1,1)
end
% Initialize diplay variables
OPTIONS.WaveLabel = cell(1);
% Fill out these cell arrays
if DisplayStruct.TimeSeriesTypes(1) == 1 % User wants to see Original data
if (1)%~isfield(data.Measures,'F') % Data were not loaded yet
% Load them by calling subfunction that also checks for possible subsampling
tmp2 = dataplot_cb('set_time_min'); clear tmp2 % CHEAT - Need argout otherwise plot is re-drawn
end
OPTIONS.WaveLabel = fname;
end
% If results are available, and if user needs it, load Modeled data and Residuals
if isfield(data,'Results') & ...
sum(data.Measures.Display.TimeSeriesTypes(2:3))>0
% Load synthetized data
Users = get_user_directory;
cd(Users.STUDIES)
Fsynth = load(data.Results.Filename{1},'Fsynth');
data.Results.Fsynth = Fsynth.Fsynth; clear Fsynth
% Is it MEG, EEG ?
Label = {'MEG','EEG','OTHER'};
DataFlag = load(data.Results.Filename{1},'OPTIONS'); %was DataFlag - CBB still is for RAP results file - see below
if isempty(fieldnames(DataFlag)) % CBB - we're loading a rap results file
load(data.Results.Filename{1},'DataFlag');
DataFlag.OPTIONS.DataType = find(ismember(Label,DataFlag));
end
data.Results.DataFlag = Label{DataFlag.OPTIONS.DataType}; clear DataFlag
if data.Measures.Display.TimeSeriesTypes(2) % User wants to see Modeled data
data.Measures.F{end+1} = zeros(length(data.Measures.Channel),length(data.Display.TimeSamples));
data.Measures.F{end}(good_channel(data.Measures.Channel,data.Measures.ChannelFlag,data.Results.DataFlag),:) = ...
data.Results.Fsynth; % CBB need to update plotselectedchannels accordingly
OPTIONS.WaveLabel{end+1} = ...
sprintf('Modeled Data; GOF = %3.1f%%',...
100*(1-mean(norcol(data.Measures.F{1}(good_channel(data.Measures.Channel,...
data.Measures.ChannelFlag,...
data.Results.DataFlag),:)...
- data.Results.Fsynth))/...
mean(norcol(data.Measures.F{1}(good_channel(data.Measures.Channel,data.Measures.ChannelFlag,data.Results.DataFlag),:))))); clear gof
end
[tmp,TimePlot] = dataplot_cb('GET','time'); % Get time samples
clear tmp
if data.Measures.Display.TimeSeriesTypes(3) == 1 % User wants to see residuals
data.Measures.F{end+1} = zeros(length(data.Measures.Channel),length(TimePlot));
data.Measures.F{end}(good_channel(data.Measures.Channel,data.Measures.ChannelFlag,data.Results.DataFlag),:) = data.Measures.F{1}(good_channel(data.Measures.Channel,data.Measures.ChannelFlag,data.Results.DataFlag),:)...
- data.Results.Fsynth; % CBB see above
OPTIONS.WaveLabel{end+1} = sprintf('Residual Data');
end
end
% -> Now call diplay function
%[PlotHandles,OPTIONS] = bst_wavedata_display('surface',data.Measures.F,OPTIONS); clear tmp;
figs = data.Measures.Display.Handles.Figures;
OPTIONS.DataType = 'surface';
% Colormap
if isfield(data.Measures.Display,'Colormap')
OPTIONS.Colormap = data.Measures.Display.Colormap;
end
[data.Measures.Display.Handles,OPTIONS] = bst_wavedata_display(data.Measures.F,OPTIONS); clear tmp;
if isempty(OPTIONS) % Display type not available yet
return
end
data.Measures.Display.Flags = struct('SensorMarkers',OPTIONS.SensorMarkers,...
'SensorLabels',OPTIONS.SensorLabels, 'ShowContours', OPTIONS.ShowContours,...
'AbsoluteColormap',OPTIONS.AbsoluteColormap, 'Colorbar',OPTIONS.Colorbar);
data.Measures.Display.Handles.Figures = figs;
% <- DONE
elseif strcmp(lower(varargin{1}),'results') % Display results
DataFlag = 0; % Just a flag, we're looking at Results, not Measures.
if ~isempty(findobj(0,'Tag','set_sourceviewingparameters'))
set_sourceviewing_parameters('create'); % Refresh viewing parameters
end
if ~isfield(data,'Results') % Nor results loaded
errordlg('Please pick a Results file from taskbar.','No Results in memory')
return
end
% Clean up previous figures
if isfield(data.Results,'Display')
if isfield(data.Results.Display,'Handles')
HandlesNames = fieldnames(data.Results.Display.Handles);
for k = 1:length(HandlesNames)
if ishandle(getfield(data.Results.Display.Handles,HandlesNames{k}))
delete(getfield(data.Results.Display.Handles,HandlesNames{k})) % Delete all previous figures
end
end
data.Results.Display = rmfield(data.Results.Display,'Handles');
end
DisplayStruct = data.Results.Display;
end
% -> Fill out display parameters
% What kind of displays are requested ?
whichDisplay = dataplot_cb('set_SourceViewingTimeDisplay','get'); % None | Overlay | Column ?
DisplayStruct.DisplayTypes(1) = whichDisplay(2); % Overlay
if whichDisplay(3) == 0 % no Column
DisplayStruct.DisplayTypes(2) = 0;
else % Column layout required
if length(DisplayStruct.DisplayTypes) > 1 % previous choice of number of columns somewhere
% use data.Measures.Display.DisplayTypes(2) ;
else
DisplayStruct.DisplayTypes(2) = 1;
end
end
% Cortical envolope ? MRI ?
DisplayStruct.DisplayTypes(3) = max([1,find(dataplot_cb('SourceViewingSpatialDisplay','get'))])-1; % Spatial display
% Fill out display parameters --------------DONE-------------------------------------------------------------
tmpLabel = {'MEG','EEG','Misc.'};
% -> Which modalities need to be displayed ?
data.Results.Display.Modality = get_selected_modalities;
if isempty(data.Results.Display.Modality)
bst_message_window('wrap',...
{' ',...
'Please select either ''MEG'', ''EEG'' or ''Other'' for display in DataPlot window',...
' '});
return
end
% -> Which modalities need to be displayed ? <- DONE
% -> Get Results filename and edit it for display as a label
fname = shorter_filename(data.Results.Filename);
% <- DONE
% We need to discriminate though between parametric source plots (a la MUSIC)
% and cortical source imaging (distributed models)
Users = get_user_directory;
File_whos = whos('-file',fullfile(Users.STUDIES,data.Results.Filename{1}));
if isempty(strmatch('TimeSeries',{File_whos.name})) % Does this file contain a variable named 'TimeSeries'
TimeSeries = []; % No: this is an Imaging results file
else
load(fullfile(Users.STUDIES,data.Results.Filename{1}),'TimeSeries') % | CBB - just one Results file at a time
end
switch ~isempty(TimeSeries)
case 1 % Parametric source results
% Create new figure
figHandle = findobj(0,'type','figure','tag','ResultsTimeSeries');
if isempty(figHandle)
figHandle = figure; % Handle to time series window, integer handle by default
set(figHandle,'visible','off')
setappdata(figHandle,'TileType','T')
set(figHandle,'Name',sprintf('Data Time Series Figure %.0f',figHandle)); % integer handle by default
bst_color_scheme(figHandle);
set(figHandle,'MenuBar','figure')
bst_layout('align',figHandle,2,1,2);
data.Results.Display.Handles.Figures.TimeSeries = figHandle;
set(figHandle,'visible','on','tag','ResultsTimeSeries')
end
DataType = 'source';
data.Results.TimeSeries = TimeSeries;
TimeSeries = num2cell(TimeSeries',2);
OPTIONS.Time = linspace(data.Display.Time(1),data.Display.Time(end),data.Display.NumberOfSamples);
%tmp.Time = tmp.Time(data.Results.Time);
for src = 1:length(TimeSeries)
SrcName{src} = sprintf('Source %d',src);
end
data.Results.DataFlag = load(fullfile(Users.STUDIES,data.Results.Filename{1}),'DataFlag'); % | CBB - just one Results file at a time
data.Results.DataFlag = data.Results.DataFlag.DataFlag;
OPTIONS.ModalityLabel = {data.Results.DataFlag};
OPTIONS.WaveLabel = SrcName;
OPTIONS.SelectedChannels = data.Measures.Display.SelectedChannels(data.Measures.Display.Modality);
%OPTIONS.Channel = data.Measures.Channel;
tmpLabel = {'MEG','EEG','Other'};
tmpChannel = good_channel(data.Measures.Channel,[],tmpLabel{data.Measures.Display.Modality});
[C,IA,IB] = intersect(tmpChannel,data.Measures.Display.SelectedChannels{data.Measures.Display.Modality});
data.Results.IndepTopo = load(fullfile(Users.STUDIES,data.Results.Filename{1}),'IndepTopo'); % | CBB - just one Results file at a time
data.Results.IndepTopo = data.Results.IndepTopo.IndepTopo;
OPTIONS.IndepTopo = data.Results.IndepTopo(IA,:);
OPTIONS.Channel = data.Measures.Channel(data.Measures.Display.SelectedChannels{data.Measures.Display.Modality});
% CBB: We are opening yet another time series figure already opened
% earlier. Redundant?
data.Results.Display.Handles.Figures.TimeSeries = figure;
setappdata(data.Results.Display.Handles.Figures.TimeSeries,'TileType','T');
set(data.Results.Display.Handles.Figures.TimeSeries, 'Name',...
sprintf('Data Time Series Figure %.0f',data.Results.Display.Handles.Figures.TimeSeries))
bst_color_scheme(data.Results.Display.Handles.Figures.TimeSeries);
set(data.Results.Display.Handles.Figures.TimeSeries,'menubar','figure');
bst_layout('align',data.Results.Display.Handles.Figures.TimeSeries,2,1,2)
figure(data.Results.Display.Handles.Figures.TimeSeries)
figs = data.Results.Display.Handles.Figures;
OPTIONS.DataType = 'source';
OPTIONS.DisplayTypes = data.Measures.Display.DisplayTypes;
% Colormap
if isfield(data.Measures.Display,'Colormap')
OPTIONS.Colormap = data.Measures.Display.Colormap;
end
[data.Results.Display.Handles,OPTIONS] = ...
bst_wavedata_display(TimeSeries,OPTIONS); clear tmp;
data.Results.Display.Handles.Figures = figs; clear figs
% See time series
% And now spatial display, e.g. Glass Brain
if DisplayStruct.DisplayTypes(3) == 3 % See parametric dipole models in brain
% Load selected tessellation file
[TessFile,h] = bst_static_taskbar('GET','TESS'); clear h
bst_message_window('wrap',{...
' ',...
sprintf('Loading %s tessellation file',TessFile)});
load(fullfile(Users.SUBJECTS,TessFile),'Comment')
data.Results.ImageGrid.iGrid = 1;
if length(Comment)>1 % Several surfaces in this tessellation file
[data.Results.ImageGrid.iGrid,OK] = listdlg('PromptString','Select an envelope from list:',...
'SelectionMode','single',...
'ListString',Comment);
if OK == 0
return
end
end
clear Comment
data.Results.Display.Handles.Figures.Surfaces = figure; set(data.Results.Display.Handles.Figures.Surfaces,'visible','off' ); drawnow
setappdata(data.Results.Display.Handles.Figures.Surfaces,'TileType','T')
bst_color_scheme(data.Results.Display.Handles.Figures.Surfaces);
bst_layout('align',data.Results.Display.Handles.Figures.Surfaces,1,2,1);
bst_layout('align',data.Results.Display.Handles.Figures.TimeSeries,2,2,4);
bst_layout('align',data.Measures.Display.Handles.Figures.TimeSeries,2,2,2)
data.Results.ImageGrid.GridLoc = {TessFile};
load(fullfile(Users.STUDIES,data.Results.Filename{1}),'SourceLoc','SourceOrientation','TimeSeries'); % | CBB - just one Results file at a time
OPTIONS.Dipoles.SourceLoc = SourceLoc;
OPTIONS.Dipoles.Orientation = SourceOrientation;
OPTIONS.Dipoles.TimeSeries = TimeSeries;
OPTIONS.Dipoles.Color = data.Results.Display.Handles.LineColor;
OPTIONS.Time = 1;
OPTIONS.currDensityTransparency = 1;
OPTIONS.timeValue = dataplot_cb('GET','current_time');
figure(data.Results.Display.Handles.Figures.Surfaces)
[PlotHandles2,dOPTIONS] = bst_imaging_display(...
data.Results.Display.Handles.Figures.Surfaces,...
data.Results.ImageGrid,...
0,OPTIONS);
set(data.Results.Display.Handles.Figures.Surfaces,'visible','on' ); drawnow
data.Results.Display.Handles.hPatch = PlotHandles2.hPatch;
data.Results.Display.Handles.hLights = PlotHandles2.hLights;
data.Results.Display.OPTIONS = dOPTIONS;
dataplot_cb SetSourceViewing % Call GUI for setting of viewing parameters
elseif DisplayStruct.DisplayTypes(3) == 2 % MRI
bst_mriviewer('LoadSourceMap_Callback','','','',data.Results.Filename{1});
bst_layout('align',data.Measures.Display.Handles.Figures.TimeSeries,2,2,2);
bst_layout('align',data.Results.Display.Handles.Figures.TimeSeries,2,2,4);
end
case 0 % Distributed cortical imaging
%delete(data.Results.Display.Handles.Figures) % Screen layout will be a bit different for this kind of source display
% dimitrios, avoid creating many figures
if isfield(data.Results.Display,'SurfaceName')
h = windfind(data.Results.Display.SurfaceName);
close(h);
end
data.Results = rmfield(data.Results,'Display');
data.Results.Display.Handles.Figures.Surfaces = figure;
set(data.Results.Display.Handles.Figures.Surfaces,'visible','off' ); drawnow
setappdata(data.Results.Display.Handles.Figures.Surfaces,'TileType','T')
bst_layout('align',data.Results.Display.Handles.Figures.Surfaces,1,2,1);
bst_layout('align',data.Measures.Display.Handles.Figures.TimeSeries,2,2,2)
figHandle=data.Results.Display.Handles.Figures.Surfaces;
bst_color_scheme(data.Results.Display.Handles.Figures.Surfaces);
set( data.Results.Display.Handles.Figures.Surfaces,'CurrentAxes',findobj( data.Results.Display.Handles.Figures,'Tag','MainAxis'),...
'Color','k', 'Colormap',gray,'visible','off');
view3d(data.Results.Display.Handles.Figures.Surfaces,'rot')
% Tessellation information
load(fullfile(Users.STUDIES,data.Results.Filename{1}),'HeadModelFile')
try
data.Results.ImageGrid = load(HeadModelFile,'GridLoc','iGrid'); clear HeadModelFile
catch
Users = get_user_directory;
try
data.Results.ImageGrid = load(fullfile(Users.STUDIES,data.Results.GUI.HeadModelFile),'GridLoc','iGrid');
catch
errordlg({'Result file has corrupted structure','Could not find GridLoc or iGrid information'})
delete(data.Results.Display.Handles.Figures.Surfaces)
return
end
end
OPTIONS.Time = 1; % time index to be displayed
OPTIONS.timeValue = dataplot_cb('GET','current_time');
end
if DisplayStruct.DisplayTypes(3) == 1 % See distributed cortical models
try
set(data.Results.Display.Handles.Figures.Surfaces,'Visible','on')
catch
% do nothing
end
data.Results.ImageGridAmp = load(fullfile(Users.STUDIES,data.Results.Filename{1}),'ImageGridAmp');
data.Results.ImageGridAmp = data.Results.ImageGridAmp.ImageGridAmp;
% CBB time downsampling & Kernel only
if isempty(data.Results.ImageGridAmp)
try
data.Results.ImagingKernel = load(fullfile(Users.STUDIES,data.Results.Filename{1}),'ImagingKernel');
data.Results.ImagingKernel = data.Results.ImagingKernel.ImagingKernel;
catch
errordlg('Results file does not contain cortical soutce maps.','Non-compliant results file')
return
end
if isempty(data.Results.ImagingKernel)
errordlg('Results file does not contain cortical source maps.','Non-compliant results file')
return
else %ESEN - get the reconstruction from Kernel mode
DataType = {'MEG','EEG'};
goodChannels = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,DataType{data.Measures.Display.Modality});
iKernel = data.Results.ImagingKernel;
f_good = data.Measures.F{1};f_good= f_good(goodChannels, :);
tmp = load(fullfile(Users.STUDIES,data.Results.Filename{1}),'OPTIONS');
if(~tmp.OPTIONS.NNormalization) %if not noise normalization
data.Results.ImageGridAmp =double(iKernel) * f_good;
else
tmpdatafile = load(fullfile(Users.STUDIES,data.Results.Filename{1}),'DataFile');
tmpF = load(tmpdatafile.DataFile,'F'); tmpF = tmpF.F;
tmpF = tmpF(goodChannels, :);
tmpFbaseline = tmpF(:,tmp.OPTIONS.NoiseSegmentIndices);
mean_Baseline= mean(tmpFbaseline,2)*ones(1,size(f_good,2));
data.Results.ImageGridAmp =double(iKernel) * (f_good - mean_Baseline);
end
% msgbox('Results visualization from results stored as linear kernel needs BrainStorm update'); % TBD !!!!
% return
end
end
[PlotHandles,OPTIONS] = bst_imaging_display(data.Results.Display.Handles.Figures.Surfaces,...
data.Results.ImageGrid,...
data.Results.ImageGridAmp,OPTIONS);
OPTIONS.hPatch = PlotHandles.hPatch;
PlotHandles.OPTIONS = OPTIONS; clear OPTIONS % to save OPTIONS in data.Results.Display structure
plotFieldNames = fieldnames(PlotHandles);
for k = 1:length(plotFieldNames)
DisplayStruct = setfield(DisplayStruct,plotFieldNames{k},getfield(PlotHandles,plotFieldNames{k}));
end
% Clean up storage structures
data.Results.Display = DisplayStruct;
data.Results.Display.Handles.Figures.Surfaces = DisplayStruct.hFigure;
data.Results.Display.Handles.hPatch = DisplayStruct.hPatch;
data.Results.Display.Handles.hLights = DisplayStruct.hLights;
data.Results.Display = rmfield(data.Results.Display,{'hPatch','hLights','hFigure'});
dataplot_cb SetSourceViewing % Viewing parameters
end
end
makeuswait('stop')
%----------------------------------------------------------------------------
case 'AddScalpSurface' % Add up Scalp surface display to cortical source visualization
set(findobj(0,'type','figure'),'pointer','watch')
DisplayStruct = data.Measures.Display; %temporary structure to use shorter names in the following
% -> Get data filename to create labels on displays
%fname = shorter_filename(data.Measures.Filename);
% -> Get data filename to create labels on displays <- DONE
% -> Fill out parameters before call to specific display subfunction
DefaultLabels = {'MEG','EEG','OTHER'}; % Default modality labels
OPTIONS = DisplayStruct;
OPTIONS.DisplayTypes = [0 0 4]; % Scalp surface display
if isfield(OPTIONS,'Flags') % User has already altered viewing preferences
flagNames = fieldnames(OPTIONS.Flags);
for k = 1:length(flagNames)
OPTIONS = setfield(OPTIONS,flagNames{k},getfield(OPTIONS.Flags,flagNames{k}));
end
end
OPTIONS.Modality = DisplayStruct.Modality;
OPTIONS.ModalityLabel = DefaultLabels(DisplayStruct.Modality); clear DefaultLabels
OPTIONS.SelectedChannels = data.Measures.Display.SelectedChannels(DisplayStruct.Modality);
OPTIONS.Channel = data.Measures.Channel;
tmpTime = linspace(data.Measures.Time(1),data.Measures.Time(end),data.Measures.NumberOfSamples); % Rebuild original time vector
% extract Display time samples in ms
OPTIONS.Time = tmpTime(data.Display.TimeSamples); clear tmpTime
OPTIONS.CurrentTime = dataplot_cb('GET','current_time');
if isfield(data.Measures,'Fmax')
OPTIONS.Fmax = data.Measures.Fmax;
end
% -> Now call diplay function
figure(data.Results.Display.Handles.Figures.Surfaces); hold on
OPTIONS.DataType = 'surface';
[htmp,OPTIONS] = bst_wavedata_display(data.Measures.F,OPTIONS); clear tmp;
data.Results.Display.Handles.TopoPlot = htmp.TopoPlot; clear tmp
if isfield(data.Results.Display.Handles.TopoPlot(OPTIONS.Modality),'hsens')
set(data.Results.Display.Handles.TopoPlot(OPTIONS.Modality).hsens{1},'Markeredgecolor',[.2 .2 .2]) % Figure color is 'white' - darken marker color
end
% Apply default transparency to scalp
set(data.Results.Display.Handles.TopoPlot(OPTIONS.Modality).surf{1},'FaceAlpha',.5)
set(data.Results.Display.Handles.TopoPlot(OPTIONS.Modality).timeText{1},'visible','off')
%data.Measures.Display.Handles.Figures = figs;
% <- DONE
set_sourceviewing_parameters('create'); % refresh pulldown list of surface patches
set(findobj(0,'type','figure'),'pointer','arrow')
%----------------------------------------------------------------------------
case 'CorticalScouts' % Create/Manage cortical scouts
manage_corticalscouts('create')
%----------------------------------------------------------------------------
case 'GetTimeWindowFromZoom' % Set viewing time window from zooming in/out of the overlay plot
XXlim = xlim;
if data.Measures.Display.DisplayTypes(1)
for k=1:length(data.Measures.Display.Handles.PlotOverlay)
set([data.Measures.Display.Handles.PlotOverlay(k).axes],'Xlim',XXlim,'buttondownfcn','dataplot_cb GetTimeWindowFromZoom')
set(get([data.Measures.Display.Handles.PlotOverlay(k).axes],'Children'),'buttondownfcn','dataplot_cb GetTimeWindowFromZoom')
end
end
if data.Measures.Display.DisplayTypes(2) > 1
for k=1:length(data.Measures.Display.Handles.PlotColumn)
set([data.Measures.Display.Handles.PlotColumn(k).axes],'Xlim',XXlim,'buttondownfcn','dataplot_cb GetTimeWindowFromZoom')
tmp = get([data.Measures.Display.Handles.PlotColumn(k).axes],'Children');
if iscell(tmp)
tmp = cat(1,tmp{:});
end
set(tmp,'buttondownfcn','dataplot_cb NameSelectedChannel')
set(tmp,'buttondownfcn','dataplot_cb GetTimeWindowFromZoom')
end
end
% Requested time window for display
set(hDataplot.time_min,'String',1000*XXlim(1));
set(hDataplot.time_max,'String',1000*XXlim(2));
% Display global data
data.Display.Time = XXlim;
% Set current time in the middle of new window
dataplot_cb('set_time_min');
dataplot_cb('SET','time', mean(XXlim));
% Check whether signal decomposition window is open
DataSelectorFig = findobj(0,'Name','Parametric Estimation Data Selector');
if isempty(DataSelectorFig), return, end
% Set axes time limits to viewer's limits
DShandles = guihandles(DataSelectorFig);
set([DShandles.AxisSignalSubspace,DShandles.AxisNoiseSubspace],'Xlim',1000*XXlim);
set([DShandles.EditMinTime],'string',sprintf('%3.2f ms',1000*XXlim(1)))
set([DShandles.EditMaxTime],'string',sprintf('%3.2f ms',1000*XXlim(2)))
%----------------------------------------------------------------------------
case 'ToggleWindowFromZoom' % Toggle axes zoom status
if ~isappdata(DATAPLOT,'ZoomState')
setappdata(DATAPLOT,'ZoomState',0);
end
ZoomState = getappdata(DATAPLOT,'ZoomState');
Axes = [];
if data.Measures.Display.DisplayTypes(1)
for k = 1:length(data.Measures.Display.Handles.PlotOverlay)
Axes = [Axes,data.Measures.Display.Handles.PlotOverlay(k).axes];
end
end
if data.Measures.Display.DisplayTypes(2) > 1
for k = 1:length(data.Measures.Display.Handles.PlotColumn)
data.Measures.Display.Handles.PlotColumn(k).axes = data.Measures.Display.Handles.PlotColumn(k).axes(data.Measures.Display.Handles.PlotColumn(k).axes~=0);
Axes = [Axes,data.Measures.Display.Handles.PlotColumn(k).axes'];
end
end
if ~ZoomState
bst_message_window('wrap',{...
' ',...
'Press and hold left mouse button to zoom in and out',...
'Press and hold middle mouse button to move the plot',...
'Double click to restore the original view'...
})
view3d zoom %zoom xon
set(gcbo,'Checked','on')
setappdata(DATAPLOT,'ZoomState',1);
for k = 1:length(Axes)
set(Axes(k),'buttondownfcn','dataplot_cb GetTimeWindowFromZoom','selected','on')
set(setdiff(get(Axes(k),'Children'),data.Measures.Display.Handles.TimeCursor),'buttondownfcn','dataplot_cb GetTimeWindowFromZoom')
end
else
view3d off %zoom off
set(gcbo,'Checked','off')
setappdata(DATAPLOT,'ZoomState',0);
for k = 1:length(Axes)
set(Axes(k),'buttondownfcn','','selected', 'off')
set(setdiff(get(Axes(k),'Children'),data.Measures.Display.Handles.TimeCursor),'buttondownfcn','dataplot_cb NameSelectedChannel')
end
end
%----------------------------------------------------------------------------
case 'ToggleRotate3D' % Toggle rotate3d status
if ~isappdata(DATAPLOT,'RotateState')
setappdata(DATAPLOT,'RotateState',0);
end
RotateState = getappdata(DATAPLOT,'RotateState');
%handles = guihandles(gcbf);
try % to rotat eonly surface maps
set(gcbf,'CurrentAxes',data.Measures.Display.Handles.TopoPlot.axes{:})
if ~RotateState
bst_message_window('wrap',{...
' ',...
'Press and hold left mouse button to rotate about screen XY axis',...
'Press and hold middle mouse button to rotate about screen z axis',...
'Double click to restore the original view'...
})
view3d rot%rotate3d on
set(gcbo,'Checked','on')
setappdata(DATAPLOT,'RotateState',1);
else
view3d off %rotate3d off
set(gcbo,'Checked','off')
setappdata(DATAPLOT,'RotateState',0);
end
catch
% do nothing
end
%----------------------------------------------------------------------------
case 'SetDataViewing' % set viewing parameters for data time and spatial displays
DataParam = openfig('set_dataviewing_parameters.fig','reuse');
setappdata(DataParam,'TileType','Tile')
bst_color_scheme(DataParam);
bst_layout('align',DataParam,2,2,4);
hDataParam = guihandles(DataParam);
% Number of columns
if ~isfield(data.Measures.Display,'Flags')
data.Measures.Display.DisplayTypes = dataplot_cb('DataViewingTimeDisplay','get'); % Time series
data.Measures.Display.DisplayTypes = data.Measures.Display.DisplayTypes(2:end); % Discard first item which is N/A
data.Measures.Display.DisplayTypes(3) = max([0,find(dataplot_cb('DataViewingSpatialDisplay','get'))]); % Spatial display
end
set(hDataParam.ColumnLayout,'String',data.Measures.Display.DisplayTypes(2));
% Were basic viewing Flags defined before ?
if ~isfield(data.Measures.Display,'Flags')
data.Measures.Display.Flags = struct(...
'Colorbar',1,'AbsoluteColormap',1,'SensorMarkers',1,'SensorLabels',0,'ShowContours',1);
end
set(hDataParam.cColorbar,'Value',data.Measures.Display.Flags.Colorbar);
set(hDataParam.cAbsoluteColormap,'Value',data.Measures.Display.Flags.AbsoluteColormap);
set(hDataParam.cSensorMarkers,'Value',data.Measures.Display.Flags.SensorMarkers);
set(hDataParam.cSensorLabels,'Value',data.Measures.Display.Flags.SensorLabels);
set(hDataParam.cContours,'Value',data.Measures.Display.Flags.ShowContours);
set(DataParam,'Visible','on')
%----------------------------------------------------------------------------
case 'SetSourceViewing' % set viewing parameters for source displays
set_sourceviewing_parameters('create')
%----------------------------------------------------------------------------
case 'MSIndexSwitch' % Switch between time expressed in milliseconds and indices of time samples
%%%%% SB 12-Jun-2003 - CBB - STILL NOT FINISHED - wait until next version...
switch(get(hDataplot.MsIndex,'String'))
case 'ms' % Time is displaid in ms -> switch to time indices
set(hDataplot.MsIndex,'String','time samples')
return % CBB - need to finish this ?
data.Indices = [1:data.NumberOfSamples];
timesamples = findclosest([data.Display.Time(1),data.Display.Time(1)+data.Display.SamplingRate,data.Display.Time(end)], 1000*data.TimePlot');
% Requested time window for display
set(hDataplot.time_min,'String',timesamples(1));
set(hDataplot.time_max,'String',timesamples(2));
set(hDataplot.step,'String',timesamples(2)-timesamples(1));
timesamples = findclosest([data.Display.Time(1),data.Display.Time(1)+data.Display.SamplingRate,data.Display.Time(end)], 1000*data.TimePlot');
case 'time samples' % Time is displaid in samples -> switch to milliseconds
set(hDataplot.MsIndex,'String','ms')
return % CBB - need to finish this ?
end
%----------------------------------------------------------------------------
case {'set_time_min','set_time_step','set_time_max'} % Set parameters of time window for display
Users = get_user_directory;
% User has changed values from time-related objects in GUI: get new values
% or a Results file has just been loaded and we need to restrict the Measures display
% to the time window of analysis from which the results were obtained
% Requested time window for display (range + step between samples)
TIME_MIN = str2num(get(hDataplot.time_min,'String'));
TIME_MAX = str2num(get(hDataplot.time_max,'String'));
STEP = str2num(get(hDataplot.step,'String'));
% -> Check whether these values stay within the original time window
if TIME_MAX > data.Measures.Time(end) * 1000
TIME_MAX = data.Measures.Time(end) * 1000;
set(hDataplot.time_max,'String',num2str(TIME_MAX,5))
end
if TIME_MIN < data.Measures.Time(1) * 1000
TIME_MIN = data.Measures.Time(1) * 1000;
set(hDataplot.time_min,'String',num2str(TIME_MIN,5))
end
% -> Check whether these values stay within the original time window <- DONE
% -> Subset of time samples for display
% Rebuild original time window of measures
tmp = linspace(data.Measures.Time(1),data.Measures.Time(2),data.Measures.NumberOfSamples);
% Find original time samples closest to requested time window
timesamples = findclosest([TIME_MIN,TIME_MIN+STEP,TIME_MAX], 1000*tmp');
% New valid values for time range and samplerate from original Measures time window
TIME_MIN = tmp(timesamples(1));
STEP = tmp(timesamples(2))-tmp(timesamples(1));
TIME_MAX = tmp(timesamples(end));
data.Display.TimeSamples = [timesamples(1):timesamples(2)-timesamples(1):timesamples(end)];
data.Display.Time = tmp([timesamples(1),timesamples(end)]);
data.Display.SamplingRate = STEP;
data.Display.NumberOfSamples = length(data.Display.TimeSamples);
clear tmp timesamples
% -> Subset of time samples for display <- DONE
% -> Update GUI objects accordingly
set(hDataplot.step,'String',sprintf('%3.2f',1000*STEP))
set(hDataplot.time_min,'String',sprintf('%3.2f',1000*data.Display.Time(1)))
set(hDataplot.time_max,'String',sprintf('%3.2f',1000*data.Display.Time(end)))
set(hDataplot.nTimeSamples,'String', sprintf('%d samples',length(data.Display.TimeSamples)))
set(hDataplot.TimeSlider,'Min',data.Display.Time(1),'Max',data.Display.Time(end),...
'Value',data.Display.Time(1),'SliderStep',[STEP/(data.Display.Time(end)-data.Display.Time(1)),.1])
clear TIME_MIN TIME_MAX STEP
% -> Update GUI objects accordingly <- DONE
% -> Extract accordingly a subset of columns from original Measures array
% for all selected data files
[fname,h] = bst_static_taskbar('GET','DATA'); % Get data file
if ~iscell(fname) % Single data set was selected
fname = {fname};
end
data.Measures.F = cell(length(fname),1); % Spatio-temporal array of measures
for ifname = 1:length(fname) % for each selected data filename
load(fullfile(Users.STUDIES,fname{ifname}),'F')
if ischar(F) % Data in native format
data.Measures.F{ifname} = meg4read(F,1,data.Display.TimeSamples,1) % Trial is 1 here and Verbose is set to 1 too.
else
data.Measures.F{ifname} = F(:,data.Display.TimeSamples);
end
clear F
for mod=1:3 % For each modality (MEG, EEG, OTHER), compute maximum across time and sensors
% (useful for subsequent display)
if ~isempty(data.Measures.Display.SelectedChannels{mod}) % Channels are available is this modality
data.Measures.Fmax(ifname,mod) = max(max(abs(...
data.Measures.F{ifname}(data.Measures.Display.SelectedChannels{mod},:))));
else
data.Measures.Fmax(ifname,mod) = 0;
end
end
end
% -> Extract accordingly a subset of columns from original Measures array
% for all selected data files <- DONE
if nargout == 0
dataplot_cb('Plot','measures'); % Update display of original data
else
varargout{1} = []; % trick to avoid plots to be redrawn | CBB (SB)
end
%----------------------------------------------------------------------------
case 'NameSelectedChannel' % Display Channel Name of selected time series
if ~strcmp(lower(get(gcbf,'SelectionType')),'normal') % Not a left-click button press - return
return
end
hobj = gcbo;
% Find which modality was selected
nSets = length(data.Measures.F);
iSelec = [];
iChanSelec = [];
for mod = data.Measures.Display.Modality % Explore all axes to find which was selected
for iSet = 1:nSets
if data.Measures.Display.DisplayTypes(1) % Overlay waveforms ?
Objects = [data.Measures.Display.Handles.PlotOverlay(mod).lines{iSet}];
iSelec = find(Objects == gcbo);
if ~isempty(iSelec)
modSelec = mod;
iSetSelec = iSet;
iChanSelec = iSelec;
break
end
end
if data.Measures.Display.DisplayTypes(2) > 1 % Column Layout
Objects = [data.Measures.Display.Handles.PlotColumn(mod).lines{iSet}];
iSelec = find(Objects == gcbo);
if ~isempty(iSelec)
modSelec = mod;
iSetSelec = iSet;
iChanSelec = iSelec;
break
end
end
if data.Measures.Display.DisplayTypes(3) > 1 % Surface plots
Objects = [data.Measures.Display.Handles.TopoPlot(mod).hsens{iSet}];
iSelec = find(Objects == gcbo);
if ~isempty(iSelec)
modSelec = mod;
iSetSelec = iSet;
iChanSelec = iSelec;
break
end
end
end
end
if isempty(iChanSelec), return, end
iChan = data.Measures.Display.SelectedChannels{modSelec}(iChanSelec);
% Was this channel selected before ?
if ~isfield(data.Measures.Display.Handles,'MouseSelectedChannels')
data.Measures.Display.Handles.MouseSelectedChannels = [];
end
if isempty(data.Measures.Display.Handles.MouseSelectedChannels) % this if series is to avoid warning signs in the command line...
flag = 0;
elseif ~isempty(find(data.Measures.Display.Handles.MouseSelectedChannels == iChan))
flag = 1;
else
flag = 0;
end
if flag
% Yes, remove it from selection
data.Measures.Display.Handles.MouseSelectedChannels = setdiff(data.Measures.Display.Handles.MouseSelectedChannels,iChan);
for iSet = 1:nSets
if data.Measures.Display.DisplayTypes(1)
set(data.Measures.Display.Handles.PlotOverlay(modSelec).lines{iSet}(iChanSelec),'linewidth',1,...
'Color',data.Measures.Display.Handles.LineColor{iSetSelec})
end
if data.Measures.Display.DisplayTypes(2) > 1
set(data.Measures.Display.Handles.PlotColumn(modSelec).lines{iSet}(iChanSelec),'linewidth',1,...
'Color',data.Measures.Display.Handles.LineColor{iSetSelec})
end
if data.Measures.Display.DisplayTypes(3) > 1 & data.Measures.Display.Flags.SensorMarkers
set(data.Measures.Display.Handles.TopoPlot(modSelec).hsens{iSet}(iChanSelec),'MarkerFaceColor','none')
end
end
else
data.Measures.Display.Handles.MouseSelectedChannels = [data.Measures.Display.Handles.MouseSelectedChannels,iChan];
for iSet = 1:nSets
if data.Measures.Display.DisplayTypes(1)
set(data.Measures.Display.Handles.PlotOverlay(modSelec).lines{iSet}(iChanSelec),'linewidth',2)
if nSets == 1
set(data.Measures.Display.Handles.PlotOverlay(modSelec).lines{iSet}(iChanSelec),'Color','r')
end
end
if data.Measures.Display.DisplayTypes(2) > 1
set(data.Measures.Display.Handles.PlotColumn(modSelec).lines{iSet}(iChanSelec),'linewidth',2)
if nSets == 1
set(data.Measures.Display.Handles.PlotColumn(modSelec).lines{iSet}(iChanSelec),'Color','r')
end
end
if data.Measures.Display.DisplayTypes(3) > 1 & data.Measures.Display.Flags.SensorMarkers
set(data.Measures.Display.Handles.TopoPlot(modSelec).hsens{iSet}(iChanSelec),'MarkerFaceColor','g')
end
end
end
% Context Menu
ChannelNames = uicontextmenu;
uimenu(ChannelNames,'Label',char(data.Measures.Channel(iChan).Name))
uimenu(ChannelNames,'Separator','on','Label','Display Selected Channel(s)','Callback','dataplot_cb DisplaySelectedChannels')
uimenu(ChannelNames,'Separator','on','Label','Change Waveforms Color','Callback','dataplot_cb ChangeWaveformsColor')
set(hobj,'UIcontextMenu',ChannelNames)
data.SelectedChannel.iChan = iChanSelec;
data.SelectedChannel.ModSelec = modSelec;
data.SelectedChannel.iSetSelec = iSetSelec;
%----------------------------------------------------------------------------
case 'CopyCurrentPlot' % Make a copyobj command on selected axes to export current plot to some other tile
% Create new figure
set(gcf,'Pointer','Watch')
figcopy = figure; % create new figure
set(figcopy,'Visible','off')
setappdata(figcopy,'TileType','T')
bst_color_scheme(figcopy);
bst_layout('align',figcopy,2,2,3);
% Find what is current axes
% (GCA command is not enough as we need extra information on colorbar and other stuff)
copyColorbar = [];
if data.Measures.Display.DisplayTypes(1)
figAxes = [data.Measures.Display.Handles.PlotOverlay(:).axes];
slctAxes = find(figAxes == gca);
if isempty(slctAxes)
if data.Measures.Display.DisplayTypes(2) > 1
figAxes = [data.Measures.Display.Handles.PlotColumn.axes(:)];
slctAxes = find(figAxes == gca);
end
if isempty(slctAxes) & data.Measures.Display.DisplayTypes(3) >1
figAxes = [];
for mod = data.Measures.Display.Modality
figAxes = [figAxes,data.Measures.Display.Handles.TopoPlot(mod).axes{:}];
end
slctAxes = find(figAxes == gca);
if data.Measures.Display.Flags.Colorbar
copyColorbar = [];
for mod = data.Measures.Display.Modality
copyColorbar = [copyColorbar,data.Measures.Display.Handles.TopoPlot(mod).Colorbar{:}];
end
copyColorbar = copyColorbar(slctAxes);
end
end
end
end
if isempty(slctAxes)
delete(figcopy)
set(gcf,'Pointer','Arrow')
return
end
C = copyobj(figAxes(slctAxes),figcopy);
set(C(1),'position',[0.1 0.1 0.8 0.8])
if ~isempty(copyColorbar) % This is a surface topography plot
newColorbar = colorbar('horiz','peer',C(1));
posSurfAxes = get(C(1),'Position');
posColBarAxes = get(newColorbar,'Position');
set(get(newColorbar,'Children'),'XData',get(get(copyColorbar,'Children'),'XData'))
set(newColorbar, 'XLim',get(copyColorbar,'XLim'),...
'Position',[posColBarAxes(1)*1.00014,posColBarAxes(2),posSurfAxes(3),posColBarAxes(4)],...
'YAxisLocation',get(copyColorbar,'YAxisLocation'),...
'YLim',get(copyColorbar,'YLim'),...
'Xtick',get(copyColorbar,'Xtick'),...
'Ytick',get(copyColorbar,'Ytick'),...
'XtickLabel',get(copyColorbar,'XtickLabel'),'YtickLabel',get(copyColorbar,'YtickLabel'))
end
if ~isfield(data.Measures.Display.Flags,'Colorbar')
data.Measures.Display.Flags.Colorbar = 0;
end
set(figcopy,'visible','on',...
'menubar','figure','NumberTitle','on','Name','Copy')
if isfield(data.Measures.Display.Handles,'Colormap')
set(figcopy,'visible','on','colormap',data.Measures.Display.Handles.Colormap,...
'menubar','figure','NumberTitle','on','Name','Copy')
end
set(gcf,'Pointer','Arrow')
%----------------------------------------------------------------------------
case 'ChangeWaveformsColor' % Change line color of time series
% Handles to all line objects in TimeSeries display window
Lines = [];
hsens = [];
hobj = [];
ncol = 0; nover = 0;
if ~isempty(data.SelectedChannel.iChan)
newcolor = uisetcolor('Pick a new color for selected waveform(s)');
if ~newcolor
return
end
% Now find the data set this time series belong to:
if data.Measures.Display.DisplayTypes(2) > 1
Lines = cat(1,data.Measures.Display.Handles.PlotColumn(data.SelectedChannel.ModSelec).lines{ data.SelectedChannel.iSetSelec });
end
if data.Measures.Display.DisplayTypes(1)
Lines = [Lines;cat(1,data.Measures.Display.Handles.PlotOverlay(data.SelectedChannel.ModSelec).lines{ data.SelectedChannel.iSetSelec })];
end
set(Lines,'Color',newcolor)
data.Measures.Display.Handles.LineColor{data.SelectedChannel.iSetSelec } = newcolor;
end
%----------------------------------------------------------------------------
case 'DisplaySelectedChannels'
% Display time series of selected channels using the above ''NameSelectedChannel' callback
if ~isempty(data.Measures.Display.Handles.MouseSelectedChannels) % Channels were actually selected by user's mouse
% Open new display figure
h = figure;
set(h,'visible','off')
setappdata(h,'TileType','Tile')
bst_color_scheme(h)
figure(h), hold on
for mod = data.Measures.Display.Modality
if~isempty(data.Measures.Display.SelectedChannels{mod}==data.Measures.Display.Handles.MouseSelectedChannels(1))
modselected = mod;
break
end
end
for iSet = 1:length(data.Measures.F)
if data.Measures.Display.DisplayTypes(1)
LineColor = get(data.Measures.Display.Handles.PlotOverlay(modselected).lines{iSet}(1),'color');
elseif data.Measures.Display.DisplayTypes(2) > 1
LineColor = get(data.Measures.Display.Handles.PlotColumn(modselected).lines{iSet}(1),'color');
end
tmpTime = linspace(data.Display.Time(1),data.Display.Time(end),data.Display.NumberOfSamples);
data.Measures.Display.Handles.PlotOverlaySelected.lines{iSet} = plot(tmpTime,...
data.Measures.F{iSet}(data.Measures.Display.Handles.MouseSelectedChannels,:)','color',LineColor);
end
data.Measures.Display.Handles.PlotOverlaySelected.axes = get(data.Measures.Display.Handles.PlotOverlaySelected.lines{1}(1),'Parent');
set(data.Measures.Display.Handles.PlotOverlaySelected.axes,'ygrid','on','xgrid','on','Box','on',...
'xColor',[.8 .8 .8], 'ycolor', [.8 .8 .8],'XMinorGrid','on',...
'Xlim',[data.Display.Time(1),data.Display.Time(end)],...
'ButtonDownFcn','dataplot_cb GetTimeWindowFromZoom',...
'Visible','on')
xlabel('Time (s)')
% Display Legend
[LEGH,OBJH,OUTH,OUTM] = legend(data.Measures.Channel(data.Measures.Display.Handles.MouseSelectedChannels).Name);
LegendMenu = uicontextmenu;
uimenu(LegendMenu,'Label','Hide/Show Legend','Callback','dataplot_cb HideShowMouseSelectedDisplayLegend')
uimenu(LegendMenu,'checked','off','Label','Zoom ON','Callback','dataplot_cb ToggleWindowFromZoom')
uimenu(LegendMenu,'checked','off','Label','Rotate','Callback','dataplot_cb ToggleRotate3D')
uimenu(LegendMenu,'Separator','on','Label','Copy Current Plot','Callback','dataplot_cb CopyCurrentPlot')
set([h;data.Measures.Display.Handles.PlotOverlaySelected.axes;LEGH;OBJH],'UIcontextMenu',LegendMenu)
set(findobj(OBJH,'type','text'),'Fontsize',7,'fontunits','points')
bst_layout('align',h,2,2,3)
set(h,'visible','on')
else
bst_message_window('wrap',...
'No channel selected - please click on overlay time series or sensor locations in scalp topography display')
end
%----------------------------------------------------------------------------
case 'HideShowMouseSelectedDisplayLegend' % Hide/Show legend for plot of selected channel time series
if ~isfield(data,'ShowMouseSelectedDisplayLegend') % Flag
data.ShowMouseSelectedDisplayLegend = 1;
end
switch(data.ShowMouseSelectedDisplayLegend)
case 1
legend(gca,'hide') %data.Measures.Display.Handles.PlotOverlaySelected.axes
data.ShowMouseSelectedDisplayLegend = 0;
case 0
legend(gca,'show')
data.ShowMouseSelectedDisplayLegend = 1;
end
%----------------------------------------------------------------------------
case 'MoveTimeCursor' % Move time cursor with mouse button pushed
if ~exist('hDataplot','var') % Trick to make cursor move a bit faster
global hDataplot data
% % hDataplot = guihandles(DATAPLOT);
%%data = guidata(DATAPLOT);
end
% Get handles from all text and time cursors (both Measures and Results plots)
TimeCursorHandles = [];
TextCursorHandles = [];
if isfield(data.Measures.Display.Handles,'TimeCursor')
TimeCursorHandles = data.Measures.Display.Handles.TimeCursor;%[data.Measures.Display.Handles.TimeCursor(ishandle(data.Measures.Display.Handles.TimeCursor)),data.Results.Display.TimeCursor(ishandle(data.Results.Display.TimeCursor))];
end
if isfield(data.Measures.Display.Handles,'TextCursor')
TextCursorHandles = data.Measures.Display.Handles.TextCursor; %[data.Measures.Display.Handles.TimeCursor(ishandle(data.Measures.Display.Handles.TimeCursor)),data.Results.Display.TimeCursor(ishandle(data.Results.Display.TimeCursor))];
end
if isfield(data,'Results')
if isfield(data.Results,'Display')
if isfield(data.Results.Display.Handles,'TimeCursor')
TimeCursorHandles = [TimeCursorHandles,data.Results.Display.Handles.TimeCursor];
end
if isfield(data.Results.Display.Handles,'TextCursor')
TextCursorHandles = [TextCursorHandles ,data.Results.Display.Handles.TextCursor];
end
% Scout display
if isfield(data.Results.Display,'Scouts')
if isfield(data.Results.Display.Scouts.Handles,'TimeCursor')
TimeCursorHandles = [TimeCursorHandles,data.Results.Display.Scouts.Handles.TimeCursor];
end
if isfield(data.Results.Display.Scouts.Handles,'TextCursor')
TextCursorHandles = [TextCursorHandles ,data.Results.Display.Scouts.Handles.TextCursor];
end
end
end
end
% House cleaning
TimeCursorHandles = TimeCursorHandles(ishandle(TimeCursorHandles));
TextCursorHandles = TextCursorHandles(ishandle(TextCursorHandles));
switch varargin{1}
case 'start',
set(gcbf,'WindowButtonMotionFcn','dataplot_cb MoveTimeCursor move')
set(gcbf,'WindowButtonUpFcn','dataplot_cb MoveTimeCursor stop')
set(DATAPLOT,'pointer','fleur')
case 'move'
set(DATAPLOT,'pointer','fleur')
set(TimeCursorHandles,'Selected','on')
XData = get(TimeCursorHandles,'Xdata');
X = get(gca,'CurrentPoint');
X = X(1,1);
% Check whether cursor is out of display time bounds
if X < data.Display.Time(1)
X = data.Display.Time(1);
end
if X > data.Display.Time(end)
X = data.Display.Time(end);
end
set(TimeCursorHandles,'Xdata',[X X])
postxt = get(TextCursorHandles,'Position');
if ~iscell(postxt)
postxt = {postxt};
end
for curs = 1:length(postxt)
if ~isempty(postxt{curs})
set(TextCursorHandles(curs),'Position',[X postxt{curs}(2)],'String',num2str(1000*X,'%3.1f'))
end
end
case 'stop'
set(gcbf,'WindowButtonMotionFcn','')
set(gcbf,'WindowButtonUpFcn','')
set(TimeCursorHandles,'selected','off')
set(DATAPLOT,'pointer','arrow')
X = get(data.Measures.Display.Handles.TimeCursor(1),'Xdata');
set(hDataplot.current_time,'String',num2str(1000*X(1),'%3.2f'))
set(hDataplot.TimeSlider,'Value',X(1));
dataplot_cb mapping_slider
end
%----------------------------------------------------------------------------
case 'mapping_slider' % Update of the current time sample using the slider or graphical timecursor
ctime = dataplot_cb('GET','current_time');
if isfield(data,'Results')
if isfield(data.Results,'Display')
setDisplayStruct = {data.Measures.Display,data.Results.Display};
if isfield(data.Results.Display,'Scouts')
setDisplayStruct = {data.Measures.Display,data.Results.Display.Scouts,data.Results.Display};
end
noResults = 0; % Just a flag - 0: there are some results to display
else
setDisplayStruct = {data.Measures.Display};
noResults = 1;
end
else
setDisplayStruct = {data.Measures.Display};
noResults = 1;
end
datatype = 0; % Flag : 1 is for surface data ; 2 is for result data
for struuct = 1:length(setDisplayStruct)
DisplayStruct = setDisplayStruct{struuct};
DisplayStruct = DisplayStruct.Handles;
datatype = datatype + 1;
if ~isfield(DisplayStruct,'TimeCursor')
break
end
if ~isempty(DisplayStruct.TimeCursor)
if ~ishandle(DisplayStruct.TimeCursor), return, end
set(DisplayStruct.TimeCursor,'Xdata',[ctime ctime])
end
if ~isfield(DisplayStruct,'TextCursor')
DisplayStruct.TextCursor = [];
end
if (isempty(DisplayStruct.TextCursor) & ~isempty(DisplayStruct.TimeCursor)) | ~ishandle(DisplayStruct.TimeCursor) | ~ishandle(DisplayStruct.TextCursor)
for k = 1%:length(data.Measures.Display.Handles.TimeCursor)
if k ==1 % Plot Overlay
DisplayStruct.TextCursor(k) = text(ctime,max(get(get(DisplayStruct.TimeCursor(k),'Parent'),'Ylim'))/1.1,num2str(1000*ctime,'%3.1f'),...
'Parent',get(DisplayStruct.TimeCursor(1),'Parent'));
else % Plot Columns
DisplayStruct.TextCursor(k) = text(ctime,txtpos(2),num2str(1000*ctime,'%3.1f'),'Units','Normal');
end
end
set(DisplayStruct.TextCursor ,'Horizontalalignment','right',...
'Fontweight','bold','color','k','fontsize',9,...
'Tag','data.TextCursor','erasemode','xor')
elseif ~isempty(DisplayStruct.TextCursor)
pos = get(DisplayStruct.TextCursor,'Position');
set(DisplayStruct.TextCursor,'Position',[[ctime],pos(2)],...
'String',sprintf('%3.1f',1000*ctime))
end
% Current time index
timeTmp = [data.Display.Time(1):data.Display.SamplingRate:data.Display.Time(end)]';
tindx = findclosest(ctime,timeTmp);
% Is there any spatial plot requested ?
TopoType = data.Measures.Display.DisplayTypes;
TopoType = TopoType(3);
if TopoType > 1 % Spatial topography plot of scalp data is requested
if datatype == 1
if data.Measures.Display.TimeSeriesTypes(1) == 1 % User wants to see original data
Disp.TimeSeries = data.Measures.F;
end
if 0%data.Measures.Display.TimeSeriesTypes(2) == 1 % User wants to see modeled data
Disp.TimeSeries{end+1} = zeros(length(data.Measures.Channel),length(data.Display.TimeSamples));
Disp.TimeSeries{end}(good_channel(data.Measures.Channel,...
data.Measures.ChannelFlag,data.Results.DataFlag),:) = data.Results.Fsynth; % CBB need to updat plotselectedchannels accordingly
end
if 0%data.Measures.Display.TimeSeriesTypes(3) == 1 % User wants to see residuals
Disp.TimeSeries{end+1} = zeros(length(data.Measures.Channel),length(data.Display.TimeSamples));
Disp.TimeSeries{end}(good_channel(data.Measures.Channel,...
data.Measures.ChannelFlag,data.Results.DataFlag),:) = ...
data.Measures.F{1}(good_channel(data.Measures.Channel,data.Measures.ChannelFlag,data.Results.DataFlag),:) ...
- data.Results.Fsynth;; % CBB see above
end
nSets = length(Disp.TimeSeries);
elseif datatype == 2
nSets = size(data.Results.TimeSeries,2);
end
if ~isfield(setDisplayStruct{struuct},'Modality') & struuct > 1
setDisplayStruct{struuct}.Modality = setDisplayStruct{struuct-1}.Modality;
elseif ~isfield(setDisplayStruct{struuct},'Modality') & struuct == 1
errordlg('Unvalid display structure.',mfilename)
return
end
for iSet = 1:nSets
for k = getfield(setDisplayStruct{struuct},'Modality')
switch(TopoType)
case 1 % Do nothing
case 2 % Spherical approximation of the scalp
if datatype == 1
CData = DisplayStruct.TopoPlot(k).Wmat{iSet} * Disp.TimeSeries{iSet}(data.Measures.Display.SelectedChannels{k},tindx);
CData = reshape(CData,sqrt(length(CData)),sqrt(length(CData)));
CData = CData * max(abs(Disp.TimeSeries{iSet}(data.Measures.Display.SelectedChannels{k},tindx)))/max(abs(CData(:))); % properly rescale to data amplitude
elseif datatype == 2
%F = zeros(length(data.Measures.Channel),size(data.Results.TimeSeries',2));
F = data.Results.IndepTopo(:,iSet)*data.Results.TimeSeries(tindx,iSet)';
CData = DisplayStruct.TopoPlot(k).Wmat{iSet} * F;
CData = reshape(CData,sqrt(length(CData)),sqrt(length(CData)));
CData = CData * max(abs(F))/max(abs(CData(:))); % properly rescale to data amplitude
end
set(DisplayStruct.TopoPlot(k).surf{iSet},'CData',CData);
case {3,6} % (2D) Sensor Cap
set(DisplayStruct.TopoPlot(k).surf{iSet},'FaceVertexCData', Disp.TimeSeries{iSet}(data.Measures.Display.SelectedChannels{k},tindx))
case 4 % Scalp surface interpolation
vertxcolor = DisplayStruct.TopoPlot(k).Wmat{iSet}*Disp.TimeSeries{iSet}(data.Measures.Display.SelectedChannels{k},tindx);
set(DisplayStruct.TopoPlot(k).surf{iSet},'FaceVertexCData',vertxcolor);
case 5 % 2D Disc
if datatype == 1
CData = DisplayStruct.TopoPlot(k).Wmat{iSet} * Disp.TimeSeries{iSet}(data.Measures.Display.SelectedChannels{k},tindx);
CData = reshape(CData,sqrt(length(CData)),sqrt(length(CData)));
CData = CData * max(abs(Disp.TimeSeries{iSet}(data.Measures.Display.SelectedChannels{k},tindx)))/max(abs(CData(:))); % properly rescale to data amplitude
elseif datatype == 2
F = data.Results.IndepTopo(:,iSet)*data.Results.TimeSeries(:,iSet)';
CData = DisplayStruct.TopoPlot(k).Wmat{iSet} * F(:,tindx);
CData = reshape(CData,sqrt(length(CData)),sqrt(length(CData)));
CData = CData * max(abs(F(:,tindx)))/max(abs(CData(:))); % properly rescale to data amplitude
end
set(DisplayStruct.TopoPlot(k).surf{iSet},'CData',CData)
if data.Measures.Display.Flags.ShowContours % Add contour plot
axes(DisplayStruct.TopoPlot(k).axes{iSet});
delete(DisplayStruct.TopoPlot(k).Contour{iSet}.H(ishandle(DisplayStruct.TopoPlot(k).Contour{iSet}.H))); % CBB - how is that I need to check for ishandle here ? (SB 15-Mar-2004)
[DisplayStruct.TopoPlot(k).Contour{iSet}.C,DisplayStruct.TopoPlot(k).Contour{iSet}.H] = contour(DisplayStruct.TopoPlot(k).Yo{iSet},DisplayStruct.TopoPlot(k).Xo{iSet},CData,'w-');
end
end
if iSet == 1
if datatype == 1
for kk = 1:length(Disp.TimeSeries)
for kkk = 1:3
if ~isempty(data.Measures.Display.SelectedChannels{kkk})
tmp.Fmax(kk,kkk) = max(max(abs(Disp.TimeSeries{kk}(data.Measures.Display.SelectedChannels{kkk},:))));
else
tmp.Fmax(kk,kkk) = 0;
end
end
end
maxData(k) = max(tmp.Fmax(:,k));
elseif datatype == 2
if iSet == 1 %&~OPTIONS.AbsoluteColormap
% Compute absolute maximum of surface topography for all sources
Topo_maxx = max(max(abs(data.Results.IndepTopo*data.Results.TimeSeries')));
end
maxData(k) = Topo_maxx;
end
end
% Colormapping : Absolute | Relative ?
CData = get(DisplayStruct.TopoPlot(k).surf{iSet},'CData');
if data.Measures.Display.Flags.AbsoluteColormap
tmp = max(abs(CData(:)));
set(DisplayStruct.TopoPlot(k).axes{iSet},'CLim',[-tmp tmp]); clear tmp
else
set(DisplayStruct.TopoPlot(k).axes{iSet},'CLim',[-maxData(k) maxData(k)]);
end
% Colorbar management
data.Measures.Display.Colormap = ...
get(data.Measures.Display.Handles.Figures.TimeSeries,'Colormap');
if ishandle(DisplayStruct.TopoPlot(k).Colorbar{iSet}) ...
& data.Measures.Display.Flags.Colorbar
% Store colormap and Clim (possibly edited using COLORMAPEDITOR)
tmp = get(DisplayStruct.TopoPlot(k).axes{iSet},'CLim');
if k == 1
tmp = tmp/1e-15; % fT
else
tmp = tmp/1e-6; % microV
end
m = num2str(tmp(2),2);
[m,e] = strtok(m,'e');
e = str2num(['1',e]);
m = str2num(m);
tmp2 = linspace(-m*e,m*e,3)';
tmp2(abs(tmp2)<0.001) = 0;
YtickLabel = num2str(tmp2,'%3.0f');
a = get(DisplayStruct.TopoPlot(k).Colorbar{iSet},'Children');
set(DisplayStruct.TopoPlot(k).Colorbar{iSet},'XTickLabel',YtickLabel,'Visible','on')
else
set(DisplayStruct.TopoPlot(k).Colorbar{iSet},'Visible','off');
end
end
% Is scalp surface superimposed to cortical surface ?
if isfield(data,'Results')
if isfield(data.Results,'Display')
if isfield(data.Results.Display.Handles,'TopoPlot')
if ishandle(data.Results.Display.Handles.TopoPlot(k).surf{iSet}) % If yes - then update facevertexcolor
%vertxcolor = data.Results.Display.Handles.TopoPlot(k).Wmat{iSet}*Disp.TimeSeries{iSet}(data.Measures.Display.SelectedChannels{k},tindx);
vertxcolor = data.Results.Display.Handles.TopoPlot(k).Wmat{iSet}*...
data.Results.IndepTopo(:,iSet)*data.Results.TimeSeries(tindx,iSet)';
switch(get(data.Results.Display.Handles.TopoPlot(k).surf{iSet},'Type'))
case 'surface'
vertxcolor = reshape(vertxcolor,sqrt(length(vertxcolor)),sqrt(length(vertxcolor)));
set(data.Results.Display.Handles.TopoPlot(k).surf{iSet},'CData',vertxcolor);
case 'patch'
set(data.Results.Display.Handles.TopoPlot(k).surf{iSet},'FaceVertexCData',vertxcolor);
end
end
end
end
end
% Update time display
set(DisplayStruct.TopoPlot(k).timeText{iSet},'string',sprintf('%3.1f ms',1000*timeTmp(tindx)))
end % For each dataset
end % if TopoType >1
set(hDataplot.current_time,'String',sprintf('%3.2f',1000*timeTmp(tindx)))
if datatype == 1
data.Measures.Display.Handles = DisplayStruct;
%rotate3d(data.Measures.Display.Handles.Figures.TimeSeries,'off')
view3d(data.Measures.Display.Handles.Figures.TimeSeries,'off')
elseif datatype == 2
if struuct == 3 % Cortical display
data.Results.Display.Handles = DisplayStruct;
view3d(data.Results.Display.Handles.Figures.Surfaces,'rot')
%rotate3d(data.Results.Display.Handles.Figures.Surfaces,'on')
elseif struuct == 2 % Scout time series
data.Results.Display.Scouts.Handles = DisplayStruct;
%rotate3d(data.Results.Display.Handles.Figures.TimeSeries,'off')
view3d(data.Results.Display.Handles.Figures.TimeSeries,'off')
end
end
end % For data and maybe result display
% Source Viewing Update
if noResults
% no results loaded yet
return
end
if ~isfield(data.Results.Display.Handles,'hPatch') % No cortical map displayed yet
return
end
if ishandle(data.Results.Display.Handles.hPatch) % surface handle for result display is valid
if isempty(data.Results.ImageGridAmp), return, end % CBB - make dipole size change over time
data.Results.Display.OPTIONS.Time = tindx;
data.Results.Display.OPTIONS.timeValue = dataplot_cb('GET','current_time');
data.Results.Display.OPTIONS.hPatch = data.Results.Display.Handles.hPatch;
data.Results.Display.OPTIONS.hLights = data.Results.Display.Handles.hLights;
[tmp,OPTIONS] = bst_imaging_display(data.Results.ImageGridAmp,data.Results.Display.OPTIONS); clear tmp
view3d(data.Results.Display.Handles.Figures.Surfaces,'rot') %rotate3d(data.Results.Display.Handles.Figures.Surfaces,'on')
end
% Source Viewing Update <- DONE
%----------------------------------------------------------------------
case 'NewColormap'
% Change properties of current colormap - from Matlab 6.5 only
try
colormapeditor;
catch
errordlg('Matlab 6.5 or greater is requested for colormap editing.','Older Matlab version')
return
end
%----------------------------------------------------------------------------
case 'saveColormap'
% Save current colormap to disk
% Move to Custom folder by default
cd(fullfile(getpref('BrainStorm','brainstormHomeDir'),'Custom'))
[FILENAME, PATHNAME, FILTERINDEX] = uiputfile('*.mat', 'Save colormap as...');
if (FILENAME)==0, return, end
Colormap = data.Measures.Display.Colormap;
save(fullfile(PATHNAME,FILENAME),'Colormap')
%----------------------------------------------------------------------------
case 'loadColormap'
% Save current colormap to disk
% Move to Custom folder by default
cd(fullfile(getpref('BrainStorm','brainstormHomeDir'),'Custom'))
[FILENAME, PATHNAME, FILTERINDEX] = uigetfile('*.mat', 'Load colormap file ...');
if (FILENAME) ==0, return, end
load(fullfile(PATHNAME,FILENAME),'Colormap')
if ~exist('Colormap','var'), errordlg('Not a valid BrainStorm colormap. Colormap arry needs to be saved under variable name : ''Colormap''.'), return, end
data.Measures.Display.Colormap = Colormap;
set(data.Measures.Display.Handles.Figures.TimeSeries,'Colormap',Colormap);
%----------------------------------------------------------------------------
case 'GenerateMovie' % Generate a movie of surface plots (Measures & Results) within specified time window
% Where to store the AVI movie file ?
Users = get_user_directory;
datafile=bst_static_taskbar('GET','DATA');
cd(fullfile(Users.STUDIES,fileparts(datafile{1})))
[moviefile, moviepath] = uiputfile('*.avi', 'Save Movie File as...');
if moviefile == 0, return, end
cd(moviepath)
% Is there a spatial Results display window opened ?
if isfield(data,'Results')
if ishandle(data.Results.Display.Handles.Figures.Surfaces) % Surface display
% Set of results figures to get frames from
resFigures = [data.Results.Display.Handles.Figures.Surfaces];
end
else
resFigures = [];
end
% Movie parameters
% Short input dialog
prompt={'Frame(s) per second: ','Quality [0,100]: '};
def={'1','100'};
dlgTitle='Enter movie parameters';
lineNo=1;
answer=inputdlg(prompt,dlgTitle,lineNo,def);
% Now generate movie
Movie = avifile(moviefile,'FPS',max([1,round(answer{1})]),'QUALITY',round(answer{2}),'compression','None');
if ~isempty(resFigures)
resMovieFile = strrep(moviefile,'.avi','_surf.avi');
resMovie = avifile(resMovieFile,'FPS',max([1,round(answer{1})]),'QUALITY',round(answer{2}),'compression','None');
bst_message_window(...
{'Cortical surface movie :',...
resMovieFile});
end
% Get time window
timeWin = dataplot_cb('GET','time'); % [start,step,stop]
timeWin = [data.Display.Time(1):data.Display.SamplingRate:data.Display.Time(2)];
% Find time samples in original data array
bst_message_window(...
{'Starting shooting of movie . . .',...
moviefile});
% Loop on all time samples
for n = timeWin
% Update and set current time
dataplot_cb('SET','time',n);
drawnow
if ishandle(data.Measures.Display.Handles.Figures.TimeSeries) % Measures display
Frame = getframe(data.Measures.Display.Handles.Figures.TimeSeries);
Movie = addframe(Movie,Frame);
end
if ~isempty(resFigures)
if ishandle(data.Results.Display.Handles.Figures.Surfaces)
Frame = getframe(data.Results.Display.Handles.Figures.Surfaces);
resMovie = addframe(resMovie,Frame);
end
end
end
Movie = close(Movie);
if exist('resMovie','var')
resMovie = close(resMovie);
% Play movie
aviplayer(fullfile(moviepath,resMoviefile));
end
% Play movie
aviplayer(fullfile(moviepath,moviefile));
bst_message_window(...
{'-> DONE ',...
' '});
%----------------------------------------------------------------------------
case 'aviplayer' % Load an .avi movie file and play it
aviplayer % Call third-party routine in PublicToolbox
%----------------------------------------------------------------------------
case 'GenerateSlides' % Generate a contact sheet of surface plots (Measures & Results) within specified time window
% Get selected time window
timeWin = dataplot_cb('GET','time');
timeWin = [timeWin(1):timeWin(2):timeWin(3)];
% Number of columns and rows on contact sheet.
ncol = ceil(sqrt(length(timeWin)));
nrow = ncol;
% Is there a spatial Results display window opened ?
if isfield(data,'Results')
if isfield(data.Results,'Display')
if ishandle(data.Results.Display.Handles.Figures.Surfaces) % Surface display
% Set of results figures to get frames from
resFigures = [data.Results.Display.Handles.Figures.Surfaces];
end
end
else
resFigures = [];
end
bst_message_window(...
{'Preparing contact sheet . . .'});
% Loop on all time samples
iplot = 0;
for n = timeWin
iplot = iplot+1;
% Update and set current time
dataplot_cb('SET','time',n);
drawnow
if ishandle(data.Measures.Display.Handles.Figures.TimeSeries) % Measures display
if n == timeWin(1) % Create figure
data.Measures.Display.Handles.Figures.ContactSheet = figure;
setappdata(data.Measures.Display.Handles.Figures.ContactSheet,'TileType','T')
bst_color_scheme(data.Measures.Display.Handles.Figures.ContactSheet);
bst_layout('align',data.Measures.Display.Handles.Figures.ContactSheet,2,2,1)
figAxes = data.Measures.Display.Handles.TopoPlot(data.Measures.Display.Modality(1)).axes{1}; % CBB | only one dataset and one modality
set( data.Measures.Display.Handles.Figures.ContactSheet,'visible','on','colormap',data.Measures.Display.Handles.Colormap,...
'menubar','figure','NumberTitle','on','Name','Copy')
end
figure(data.Measures.Display.Handles.Figures.ContactSheet)
cAxes = subplot(ncol,nrow,iplot); % Current axes
set(cAxes,'View',get(figAxes,'View'))
axis equal, axis vis3d
axis off
C = copyobj(figAxes,data.Measures.Display.Handles.Figures.ContactSheet);
child = get(C,'Children');
set(child,'parent',cAxes),
textObject = [];
textObject(1) = findobj(child','string','MEG');
textObject = [textObject,findobj(child','string','EEG')];
linesObject = findobj(child','Type','line');
delete(unique([textObject,linesObject'])) % CBB | pb is that it also deletes contour lines when present
delete(C)
end
if ~isempty(resFigures)
if ishandle(data.Results.Display.Handles.Figures.Surfaces)
if n == timeWin(1) % Create figure
data.Results.Display.Handles.Figures.ContactSheet = figure;
setappdata(data.Results.Display.Handles.Figures.ContactSheet,'TileType','T')
bst_color_scheme(data.Results.Display.Handles.Figures.ContactSheet);
bst_layout('align',data.Results.Display.Handles.Figures.ContactSheet,2,2,3)
resfigAxes = findobj(data.Results.Display.Handles.Figures.Surfaces,'Type','axes');
set( data.Results.Display.Handles.Figures.ContactSheet,'visible','on','colormap',data.Measures.Display.Handles.Colormap,...
'menubar','figure','NumberTitle','on','Name','Copy')
end
figure(data.Results.Display.Handles.Figures.ContactSheet)
cAxes = subplot(ncol,nrow,iplot); % Current axes
set(cAxes,'View',get(resfigAxes,'View'))
axis equal, axis vis3d
axis off
C = copyobj(resfigAxes,data.Results.Display.Handles.Figures.ContactSheet);
child = get(C,'Children');
set(child,'parent',cAxes),
delete(C)
linesObject = findobj(child','Type','line');
delete(linesObject') % CBB | pb is that it also deletes contour lines when present
end
end
end
set( data.Measures.Display.Handles.Figures.ContactSheet,'visible','on','colormap',data.Measures.Display.Handles.Colormap,...
'menubar','figure','NumberTitle','on','Name','Contact Sheet')
bst_message_window(...
{'-> DONE ',...
' '});
%----------------------------------------------------------------------------
case 'CallDataSelector' % just like it sounds....
% Define noise model (covariance statistics and signal vs. source subspaces)
figP = parametric_estimation;
figP_handles = guihandles(figP);
% decompose the data
parametric_estimation('Pushbutton_decompose_Callback',...
figP_handles.Pushbutton_decompose,[],figP_handles);
%parametric_estimation % Call John's routine
%----------------------------------------------------------------------------
case 'set_current_time'
ctime = str2num(get(hDataplot.current_time,'String'))/1000;
set(hDataplot.TimeSlider,'Value',ctime);
dataplot_cb mapping_slider
%----------------------------------------------------------------------------
case 'Residuals'
Visu = get(DATAPLOT,'Userdata');
tesselation_select_win = findobj(0,'Tag','tesselation_select');
if isempty(tesselation_select_win)
tesselation_select_win = open('tessellation_select.fig');
end
handles = guihandles(tesselation_select_win);
ResFiles = get(handles.ResultFiles,'String');
ResFile = ResFiles{get(handles.ResultFiles,'Value')};
[path,file,ext] = fileparts(Users.CurrentData.StudyFile);
ResFile = fullfile(Users.STUDIES,path,ResFile);
load(ResFile,'Fsynth','OPTIONS','ImageGridTime');
if ~exist('OPTIONS','var') % File is from older version (i.e. before MMII)
load(ResFile,'GUI')
OPTIONS = GUI; clear GUI
OPTIONS.SegmentIndices = OPTIONS.Segment;
OPTIONS = rmfield(OPTIONS,'Segment');
end
if ~isempty(find(Visu.Data.ChannelFlag == -1))%~isempty(find(Visu.Data.ChannelFlag == 0))
goodchannels = good_channel(Visu.Channel,Visu.Data.ChannelFlag,DataType{current}); % Discard bad channels
badchannels = setdiff(good_channel(Visu.Channel,ones(length(Visu.Channel),1),DataType{current}),goodchannels);
% goodchannels = setdiff(Visu.ChannelID{current},find(Visu.Data.ChannelFlag == -1)); % - min(Visu.ChannelID{current})+1; % Discard bad channels
%badchannels = intersect(Visu.ChannelID{current},find(Visu.Data.ChannelFlag == -1));% - min(Visu.ChannelID{current})+1;
else
goodchannels = Visu.ChannelID{current};% - min(Visu.ChannelID{current})+1;
badchannels = [];
end
%F = Visu.Data.F(goodchannels,[OPTIONS.SegmentIndices(1):OPTIONS.SegmentIndices(end)]); % Try next line instead
F = Visu.Data.F(goodchannels,OPTIONS.SegmentIndices);
Fsynth = Fsynth(goodchannels-goodchannels(1)+1,:);
res = 100*sqrt(norcol(F-Fsynth)./norcol(F)); % NORCOL computes the square of the columns of matrix
clear Results;
mean_res = mean(res);
std_res = std(res);
min_res = min(res);
max_res = max(res);
figres = figure; % Overlay Residuals and normalized global field power plots
%powF = norm(F,'fro');
GFP = sqrt(norcol(F));
GFP = 100*GFP/max(GFP);
%[haxes, hline1,hline2] = plotyy(1000*ImageGridTime,res,1000*ImageGridTime,100*(norcol(F))/powF);
[haxes, hline1,hline2] = plotyy(1000*ImageGridTime,res,1000*ImageGridTime,GFP);
hold on
axes(haxes(1))
set(haxes(1),'Ycolor','r')
set(hline1,'linewidth',2)
xlabel('Time (ms)');
ylabel('Residuals (%)');
axes(haxes(2))
set(haxes(2),'Ycolor','b')
xlabel('Time (ms)');
ylabel('GFP (normalized)');
grid on
set(hline1,'Color','r')
set(hline2,'Color','b')
grid on
fprintf(...
'Residuals\nAverage: %4.2f%%\nStd.:%4.2f%%\nMin.: %4.2f%%\nMax.: %4.2f%%\n',mean_res,std_res,min_res,max_res);
set(figres,'Name','Residuals / GFP')
set(get(figres,'CurrentAxes'),'XGrid','on','YGrid','on')
%----------------------------------------------------------------------------
case 'LoadResultFile' % Load selected Result File parameters for source visualization
tesselation_select_win = findobj(0,'Tag','tesselation_select');
if isempty(tesselation_select_win)
tesselation_select_win = open('tessellation_select.fig');
end
handles = guihandles(tesselation_select_win);
set(tesselation_select_win,'Pointer','watch'),drawnow
set(handles.ZScore,'Value',0)
togglebuttoncolor(handles.ZScore)
if nargin == 1
ResFiles = get(handles.ResultFiles,'String');
ResFile = ResFiles{get(handles.ResultFiles,'Value')};
else % A result file is specified
ResFile = varargin{1};
end
[path,file,ext] = fileparts(Users.CurrentData.StudyFile);
ResFile = fullfile(Users.STUDIES,path,ResFile);
Results = load(ResFile);
Results.ImageGridAmp = double(Results.ImageGridAmp); % Stored in single precision in MMII version
% Convert older Results structure to MMII
if isfield(Results,'GUI');
Results = setfield(Results,'OPTIONS',Results.GUI);
Results = rmfield(Results,'GUI');
end
set(handles.Refresh,'Userdata',ResFile)
if isfield(Results,'ZScore')
set(handles.Baseline,'Userdata',1) ; % Enforce Baseline application
if get(handles.Baseline,'Userdata') == 0 % This if switch should therefore be optional from now on: need to check this when updating the next dataplot
try
set(handles.Baseline,'String',num2str(1000*(Results.ZScore.BaselineTime),'%4.2f '));
if isfield(Results.ZScore,'BaselineFile')
disp(['ZScore available - baseline taken from file: ',strrep(Results.ZScore.BaselineFile,Users.STUDIES,'')])
else
disp(['ZScore available - baseline was set to: ', num2str(1000*Results.ZScore.BaselineTime,'%4,2f '),' ms'])
end
catch
set(handles.Baseline,'String','File');
end
elseif (get(handles.Baseline,'Userdata')) == 1
set(handles.Baseline,'String','File');
if isfield(Results.ZScore,'BaselineFile')
disp(['ZScore available - baseline taken from file: ',Results.ZScore.BaselineFile])
else
disp(['ZScore available - baseline was set to: ', num2str(1000*Results.ZScore.BaselineTime,'%4,2f '),' ms'])
end
end
end
%Load Associated Data File
cd(fullfile(Users.STUDIES,path))
ResFiletmp = strrep(ResFile,Users.STUDIES,'');
ResFiletmp = strrep(ResFiletmp,'.mat','');
Iunder = findstr(ResFiletmp,'_');
DataFile= [ResFiletmp(1:Iunder(end-1)-1),'.mat'];
if exist(DataFile,'file')
dataplot_cb('loadfile',[DataFile]);
end
set(handles.ResultFiles,'Userdata',Results); % Save in GUI for future use
nSources = length(Results.SourceLoc);
if nSources == 0 | ischar(Results.SourceLoc) % Probably an ImageGrid file
nSources = size(Results.ImageGridAmp,1);
BeginTime = Results.ImageGridTime(1)*1000;
EndTime = Results.ImageGridTime(end)*1000;
set(handles.CorticalMap,'enable','on') % Allo20w visualization of cortical current density maps
else
BeginTime = [];
EndTime = [];
set(handles.CorticalMap,'enable','off')
end
DATA = {'MEG','EEG'};
if ~isfield(Results,'ZScore')
ResultFileParamString= sprintf('%s\nNumber of Sources: %d\nTime window: %3.1f %3.1f msec',...
Results.Comment,nSources,BeginTime,EndTime);
else
if ~isempty(Results.ZScore.BaselineFile)
[tmp,tmpfile,ext] = fileparts(Results.ZScore.BaselineFile);
BaselineTime = load(Results.ZScore.BaselineFile,'ImageGridTime');
set(handles.LoadBaseline,'Userdata',Results.ZScore.BaselineFile)
Results.ZScore.BaselineTime = [BaselineTime.ImageGridTime(1) BaselineTime.ImageGridTime(end)]; clear BaselineTime
ResultFileParamString= sprintf(...
'%s-%s\nNumber of Sources: %d\nTime window: %3.1f %3.1f msec\nZScore done: baseline from file:\n%s\n%4.1f to %4.1f ms',...
Results.Comment,DATA{Results.OPTIONS.DataType},nSources,BeginTime,EndTime,tmpfile,1000*(Results.ZScore.BaselineTime));
else
ResultFileParamString= sprintf(...
'%s-%s\nNumber of Sources: %d\nTime window: %3.1f %3.1f msec\nZScore done: baseline set to\n%4.1f to %4.1f ms',...
Results.Comment,DATA{Results.OPTIONS.DataType},nSources,BeginTime,EndTime,1000*(Results.ZScore.BaselineTime));
end
end
set(handles.ResultFileParam,'String',ResultFileParamString)
% Find the corresponding tessellated envelope in the list
nsrc = size(Results.ImageGridAmp,1); % Number of cortical sources
% Is there a cortical surface available qith the same number of sources ?
Visu = get(DATAPLOT,'Userdata');
try % MMII procedure
load(Results.OPTIONS.GridLoc,'Vertices','Comment')
nmesh = max(size(Vertices));
Vals = [ones(nmesh,1),zeros(nmesh,7)];
set(handles.removed,'Userdata',Vals)
clear Vertices
iCortex = Results.OPTIONS.iGrid;
Visu.Tesselation = Results.OPTIONS.GridLoc;
set(DATAPLOT,'UserData',Visu)
catch % Older BsT Version
try
load(fullfile(Users.SUBJECTS,Visu.Tesselation),'Vertices','Comment')
catch
load(Visu.Tesselation,'Vertices','Comment')
end
for k = 1:length(Vertices)
nverts(k) = size(Vertices{k},2);
end
iCortex = find(nverts == nsrc);
if isempty(iCortex)
errordlg('No corresponding cortical surface was found among the available tessellated surfaces')
return
elseif length(iCortex)>1
msgbox('Several tessellated surfaces may be corresponding to this result file. Please select the proper one manually')
return
end
end
% Find the cortical surface is the list and mark it as selected
set(handles.removed,'String',Comment{iCortex})
set(handles.available,'String',Comment(setdiff(1:length(Comment),iCortex)))
set(handles.CorticalMap,'Value',1);
Green = [.66 1 .43];
Dark = [.4 .4 .4];
set(handles.CorticalMap,'Backgroundcolor',Green,'Foregroundcolor',Dark)
set(tesselation_select_win,'Pointer','arrow')
%----------------------------------------------------------------------------
case 'mesh_props' % Indicate Mesh Surface Properties with Radiobuttons
Visu = get(DATAPLOT,'Userdata');
% eval(['load ',Visu.Tesselation,' Comment'])
cd(Users.SUBJECTS)
load(Visu.Tesselation)
nmesh = max(size(Comment));
tesselation_select_win = findobj(0,'Tag','tesselation_select');
available = findobj(tesselation_select_win,'Tag','available');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(gcbo,'Value');
IDs = get(gcbo,'String');
mesh_names = IDs(removeID);
% current_surface = findobj(tesselation_select_win,'Tag','current_surface');
% set(current_surface,'String',mesh_names{1});
OPAQUE = findobj(gcbf,'Tag','Opaque');
TRANSPARENT = findobj(gcbf,'Tag','transparent');
RIGHT = findobj(tesselation_select_win,'Tag','right');
LEFT = findobj(tesselation_select_win,'Tag','left');
FRONT = findobj(tesselation_select_win,'Tag','front');
BACK = findobj(tesselation_select_win,'Tag','back');
TOP = findobj(tesselation_select_win,'Tag','top');
BOTTOM = findobj(tesselation_select_win,'Tag','bottom');
if length(removeID)>1
return
end
% Identification of the active mesh surfaces
for i = 1:length(removeID)
imesh(i) = find(strcmp(mesh_names{i},Comment));
end
if length(imesh)== 1
set(findobj(gcbf,'Tag','faces'),'string',[int2str(size(Faces{imesh},1)),' Faces'])
set(findobj(gcbf,'Tag','vertices'),'string',[int2str(size(Vertices{imesh},2)), ' Vertices'])
if ~strcmp(get(gcbo,'Tag'),'removed'); return, end
end
Vals = get(removed,'Userdata');
if isempty(Vals)
Vals = [ones(nmesh,1),zeros(nmesh,7)];
else
HANDLES = [OPAQUE TRANSPARENT RIGHT LEFT FRONT BACK TOP BOTTOM];
for k = 1:length(HANDLES)
set(HANDLES(k),'Value',Vals(imesh,k));
end
end
%----------------------------------------------------------------------------
case 'mesh_vals' % Indicate Mesh Surface Properties with Radiobuttons
Visu = get(DATAPLOT,'Userdata');
try
eval(['load ',Visu.Tesselation,' Comment'])
catch
cd(Users.SUBJECTS)
eval(['load ',Visu.Tesselation,' Comment'])
end
nmesh = max(size(Comment));
tesselation_select_win = findobj(0,'Tag','tesselation_select');
available = findobj(tesselation_select_win,'Tag','available');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(removed,'Value');
IDs = get(removed,'String');
if iscell(IDs)
mesh_names = IDs(removeID);
else
mesh_names = IDs;
end
current_surface = findobj(tesselation_select_win,'Tag','current_surface');
% set(current_surface,'String',mesh_names{1});
OPAQUE = findobj(gcbf,'Tag','Opaque');
TRANSPARENT = findobj(gcbf,'Tag','transparent');
RIGHT = findobj(tesselation_select_win,'Tag','right');
LEFT = findobj(tesselation_select_win,'Tag','left');
FRONT = findobj(tesselation_select_win,'Tag','front');
BACK = findobj(tesselation_select_win,'Tag','back');
TOP = findobj(tesselation_select_win,'Tag','top');
BOTTOM = findobj(tesselation_select_win,'Tag','bottom');
% Identification of the active mesh surfaces
if ~iscell(mesh_names)
imesh = find(strcmp(mesh_names,Comment));
else
for i = 1:length(removeID)
imesh(i) = find(strcmp(mesh_names{i},Comment));
end
end
Vals = get(removed,'Userdata');
if 0%isempty(Vals)
Vals = [ones(nmesh,1),zeros(nmesh,7)];
else
HANDLES = [OPAQUE TRANSPARENT RIGHT LEFT FRONT BACK TOP BOTTOM];
tmp = get(HANDLES,'Value');
Vals(imesh,:) = [tmp{:}];
end
set(removed,'Userdata',Vals)
%----------------------------------------------------------------------------
case 'ConcatenateTess' % Concatenate 2 selected envelopes into 1
tesselation_select_win = findobj(0,'Tag','tesselation_select');
Visu = get(DATAPLOT,'Userdata');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(removed,'Value');
IDs = get(removed,'String');
if isempty(IDs)
return
end
mesh_names = IDs(removeID);
eval(['load ',Visu.Tesselation,' Comment'])
nmesh = max(size(Comment));
% Identification of the active mesh surfaces
for i = 1:length(removeID)
imesh{i} = find(strcmp(mesh_names{i},Comment));
end
if length(imesh) >2
errordlg('Cannot concatenate more than 2 envelopes yet') % CHEAT - need to generalize this
return
end
load(Visu.Tesselation,'Faces','Vertices')
Vertices{end+1} = [Vertices{imesh{1}},Vertices{imesh{2}}] ;
Faces{end+1} = [Faces{imesh{1}}; Faces{imesh{2}}+size(Vertices{imesh{1}},2)];
Comment{end+1} = [Comment{imesh{1}},Comment{imesh{2}}] ;
save(Visu.Tesselation,'Faces','Vertices','Comment','-append')
dataplot_cb mesh_rendering
%----------------------------------------------------------------------------
case 'SwapFaces' % Swap vertex ordering for face definition as some pacthes normal may happen to be oriented inwards and therefore look dark in 3d
tesselation_select_win = findobj(0,'Tag','tesselation_select');
Visu = get(DATAPLOT,'Userdata');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(removed,'Value');
IDs = get(removed,'String');
if isempty(IDs)
return
end
mesh_names = IDs(removeID);
eval(['load ',Visu.Tesselation,' Comment'])
nmesh = max(size(Comment));
% Identification of the active mesh surfaces
for i = 1:length(removeID)
imesh{i} = find(strcmp(mesh_names{i},Comment));
end
if length(imesh) > 1
errordlg('Cannot swap vertices of more than 1 envelope yet') % CHEAT - need to generalize this
return
end
load(Visu.Tesselation,'Faces')
Faces{imesh{1}} = Faces{imesh{1}}(:,[2 1 3]);
save(Visu.Tesselation,'Faces','-append')
dataplot_cb mesh_rendering
%----------------------------------------------------------------------------
case 'RenameTess' % Edit the Comment (ie label) of selected envelope
tesselation_select_win = findobj(0,'Tag','tesselation_select');
Visu = get(DATAPLOT,'Userdata');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(removed,'Value');
IDs = get(removed,'String');
if isempty(IDs)
return
end
mesh_names = IDs(removeID);
eval(['load ',Visu.Tesselation,' Comment'])
nmesh = max(size(Comment));
% Identification of the active mesh surfaces
for i = 1:length(removeID)
imesh{i} = find(strcmp(mesh_names{i},Comment));
end
if length(imesh) > 1
errordlg('Cannot rename more than 1 envelope yet') % CHEAT - need to generalize this
return
end
newComment = inputdlg('Please enter a new label for the selected envelope');
if isempty(newComment)
return
end
Comment{imesh{1}} = newComment{:};
save(Visu.Tesselation,'Comment','-append')
dataplot_cb mesh_rendering
%----------------------------------------------------------------------------
case 'DownsizeTess'
tesselation_select_win = findobj(0,'Tag','tesselation_select');
Visu = get(DATAPLOT,'Userdata');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(removed,'Value');
IDs = get(removed,'String');
if isempty(IDs)
return
end
mesh_names = IDs(removeID);
eval(['load ',Visu.Tesselation,' Comment'])
nmesh = max(size(Comment));
% Identification of the active mesh surfaces
for i = 1:length(removeID)
imesh{i} = find(strcmp(mesh_names{i},Comment));
end
if length(imesh) > 1
errordlg('Cannot swap vertices of more than 1 envelope yet') % CHEAT - need to generalize this
return
end
load(Visu.Tesselation,'Faces','Vertices')
handles = guihandles(tesselation_select_win);
nfv.faces = Faces{imesh{1}};
nfv.vertices = Vertices{imesh{1}}';
set(tesselation_select_win,'Pointer','watch')
NFV = reducepatch(nfv, str2num(get(handles.DownsizeFactor,'String')));
clear nfv
Faces{end+1} = NFV.faces;
Vertices{end+1} = NFV.vertices';
clear NFV
Comment{end+1} = [Comment{imesh{1}},'_',get(handles.DownsizeFactor,'String')];
save(Visu.Tesselation,'Faces','Comment','Vertices', '-append')
dataplot_cb mesh_rendering
set(tesselation_select_win,'Pointer','arrow')
%----------------------------------------------------------------------------
case 'mesh_add' % Add a meshed surface to visualization
Visu = get(DATAPLOT,'Userdata');
load(Visu.Tesselation)
nmesh = max(size(Vertices));
tesselation_select_win = findobj(0,'Tag','tesselation_select');
available = findobj(tesselation_select_win,'Tag','available');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(available,'Value');
%Check if it's a double-click
old_available = get(available,'Userdata');
if isempty(old_available) | old_available ~= removeID % Single Click
set(available,'Userdata',removeID)
return
else
set(available,'Userdata',[])
end
IDs = get(available,'String');
if isempty(IDs), return, end
chan = 1:length(get(available,'String'));
set(available,'String', IDs(setdiff(chan,removeID)));
if isempty(get(removed,'String'))
set(removed,'String', IDs(removeID));
else
strtmp = (get(removed,'String'));
strtmp(end+1:end+length(IDs)) = IDs(removeID) ;
set(removed,'String', sort(unique(strtmp)));
end
set(available,'String', IDs(setdiff(chan,removeID)));
set(available,'Value',1,'Max',length(get(available,'String')))
set(removed,'Value',1,'Max',max([1,length(get(removed,'String'))]))
%----------------------------------------------------------------------------
case 'delete_tess'
% Update the tessellation file (SubjectTess) by deleting the selected surface tessellation
tesselation_select_win = findobj(0,'Tag','tesselation_select');
available = findobj(tesselation_select_win,'Tag','available');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(available,'Value');
availableID = get(removed,'Value');
IDs = get(removed,'String');
if isempty(IDs)
errordlg('Please select a Tessellation in the ''Active'' listbox')
return
end
mesh_names = IDs(availableID);
Visu = get(DATAPLOT,'Userdata');
eval(['load ',Visu.Tesselation,' Comment'])
nmesh = max(size(Comment));
% Identification of the active mesh surfaces
for i = 1:length(availableID)
imesh{i} = find(strcmp(mesh_names{i},Comment));
end
ButtonName=questdlg(['Are you sure you want to delete permanently ',[Comment{[imesh{:}]}],' from the subject tessellation file ?'], ...
'Warning', ...
'Yes','No','No');
switch ButtonName,
case 'No',
return
end
set(removed,'Value',1)
set(removed,'String',setdiff(get(removed,'String'),char(Comment{[imesh{:}]})))
load(Visu.Tesselation)
tmp = 1:length(Comment);
Comment = Comment(setdiff(tmp,[imesh{:}]));
Vertices = Vertices(setdiff(tmp,[imesh{:}]));
Faces= Faces(setdiff(tmp,[imesh{:}]));
save(Visu.Tesselation,'Faces','Vertices','Comment','-append')
%----------------------------------------------------------------------------
case 'mesh_lighting_props' % Set lighting to Flat/Gouraud/Phong
TessWin = findobj(0,'Tag','tessellation_window'); % Handle to the 3D display
SlidesWin = findobj(0,'Tag','subplot_tess_window'); % Handle to the Slides or Movie Window
if ~isempty(SlidesWin)
TessWin = SlidesWin;
end
if isempty(TessWin), return, end
TessSelect = findobj(0,'Tag','tesselation_select');
light_props = findobj(TessSelect,'Tag','light_props'); % Handle to the lighting properties pull-down menu
tmp = get(light_props,'String');
try
set(findobj(TessWin,'type','patch'),'edgelighting',tmp{get(light_props,'Value')},...
'facelighting',tmp{get(light_props,'Value')})
catch
if ~isempty(findstr(tmp{get(light_props,'Value')},'Flat'))
set(findobj(TessWin,'type','patch'),...
'facecolor','flat')
else
set(findobj(TessWin,'type','patch'),...
'facecolor','interp')
end
end
%----------------------------------------------------------------------------
case 'mesh_remove' % Remove a mesh surface from visualization
tesselation_select_win = findobj(0,'Tag','tesselation_select');
available = findobj(tesselation_select_win,'Tag','available');
removed = findobj(tesselation_select_win,'Tag','removed');
availableID = get(removed,'Value');
Faces = findobj(tesselation_select_win,'Tag','faces');
%Check if it's a double-click
old_removed = get(Faces,'Userdata');
if isempty(old_removed) | old_removed ~= availableID % Single Click
set(Faces ,'Userdata',availableID)
return
else
set(Faces ,'Userdata',[])
end
IDs = get(removed,'String');
if isempty(IDs), return, end
chan = [1:length(IDs)];
set(removed,'Max',max([1,length(setdiff(chan,availableID))]))
set(removed,'Value',1,'String',IDs(setdiff(chan,availableID)));
if isempty(get(available,'String'))
set(available,'String', [IDs(availableID)]);
else
strtmp = (get(available,'String'));
strtmp(end+1:end+length(IDs)) = IDs(availableID) ;
set(available,'String', sort(unique(strtmp)));
end
set(available,'Value',1,'Max',length(get(available,'String')))
%----------------------------------------------------------------------------
case 'change_color' % Changes the color of the current mesh surface
Visu = get(DATAPLOT,'Userdata');
eval(['load ',Visu.Tesselation,' Comment'])
tesselation_select_win = findobj(0,'Tag','tesselation_select');
available = findobj(tesselation_select_win,'Tag','available');
removed = findobj(tesselation_select_win,'Tag','removed');
removeID = get(removed,'Value');
IDs = get(removed,'String');
mesh_names = IDs(removeID);
for i = 1:length(removeID)
imesh(i) = find(strcmp(mesh_names{i},Comment));
end
previous = findobj(0,'Tag','tessellation_window');
if isempty(previous), return, end
for k = imesh
h = findobj(previous,'Tag',Comment{k});
corig = get(h,'Edgecolor');
if ischar(corig) % Edgecolor 'none'
corig = get(h,'FaceVertexCdata');
iok = find(isfinite(corig(:,1)));
corig = corig(iok,:);
corig = corig(1,:);
else
iok = [];
end
c = uisetcolor(corig, [Comment{k}, ' Color Change']);
if c == corig, return, end
ctet = get(h,'vertices');
vertexcolorh = get(h,'FaceVertexCData');
siz = size(vertexcolorh,2);
if size(vertexcolorh ,1) == 1
vertexcolorh = ones(size(ctet,1),1)*vertexcolorh;
end
if 0%size(ctet,1)~=length(iok)
vertexcolorh(tmp,:) = NaN * ones(length(tmp),siz);
end
vertexcolorh(iok,:) = ones(length(iok),1)*c ;
set(h,'FaceVertexCData',vertexcolorh,'Userdata',c)
if isempty(iok)
set(h,'edgecolor',c)
end
end
%--------------------------------------------------------------------------------------------------------------------
case 'saveas' % Save the new data set as...
Users = get_user_directory;
cd(Users.STUDIES)
[FILENAME, PATHNAME] = uiputfile('*data*mat', 'New File Name');
if FILENAME == 0, return, end
cd(PATHNAME)
Time = linspace(data.Display.Time(1),data.Display.Time(2),length(data.Display.TimeSamples));
Device = load(data.Measures.Filename{1},'Device');
[F,Device,ChannelFlag,Time,NoiseCov,SourceCov,Projector,Comment] = ...
deal(data.Measures.F{1},Device.Device,data.Measures.ChannelFlag,Time,[],[],[],' ');
save(FILENAME,'Device','ChannelFlag','F','Time','NoiseCov','SourceCov','Projector','Comment');
I = findstr(FILENAME,['_data']);
if isempty(I)
error('File name should contain ''_data'' string ')
return
end
% channelfile = FILENAME(1:I-1);
% channelfile = [channelfile,'_channel'];
% Channel = data.Measures.Channel;
% save (channelfile,'Channel')
%----------------------------------------------------------------------------
case 'create_filter_window'
fig = openfig('filterGUI.fig','reuse');
bst_color_scheme(fig);
setappdata(fig,'TileType','T')
bst_layout('align',fig,2,2,3);
BrainStormWindows = bst_win_manager(fig,'filterGUI');
%----------------------------------------------------------------------------
case 'ToggleFilter'
% Toggle filter parameter GUI on/off
handles = guihandles(gcbf);
switch(get(gcbo,'Value'))
case 1
set([handles.lowpass, handles.highpass],'enable','on')
case 0
set([handles.lowpass, handles.highpass],'enable','off')
end
%----------------------------------------------------------------------------
case 'data_filter' % Filter the data and update visualization
makeuswait('start')
filterGUI = findobj(0,'Tag','filterGUI');
handles = guihandles(filterGUI);
lpf = str2num(get(handles.lowpass,'string'));% Low Cut-off
hpf = str2num(get(handles.highpass,'string'));% High Cut-off
AVG = get(handles.avrgREF,'Value'); % Remove average
current = get_selected_modalities;
if isempty(current)
errordlg('Please select either MEG, EEG or Other from taskbar.','No data type selected')
makeuswait('stop')
return
end
DataType = {'MEG','EEG','Other'};
goodchannels = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,DataType{current}); % Discard bad channels
badchannels = setdiff(good_channel(data.Measures.Channel,'',DataType{current}),goodchannels);
srate = 1/data.Measures.SamplingRate;
new_waves = data.Measures.F{1}; % CBB - only one dataset here.
if get(handles.toggleFilter,'Value') % Filter is ON
tmp = brainstorm_filt(data.Measures.F{1}(goodchannels,:),srate,hpf,lpf);
new_waves(goodchannels,:) = tmp; clear tmp
end
if(1)
if AVG & current == 2 % if EEG, Remove average
new_waves(goodchannels,:) = new_waves(goodchannels,:) - repmat(mean(new_waves(goodchannels,:)),length(goodchannels),1);
end
else
if AVG == 1 % Remove average in time from each channel
AVG_MAX = Visu.Data.Time(end)*1000; % milliseconds
AVG_MIN = Visu.Data.Time(1)*1000;
prompt={'Enter the starting time (ms)','Enter the ending time (ms)'};
def={sprintf('%g',AVG_MIN),sprintf('%g',AVG_MAX)};
dlgTitle='Input the times to use for average removal';
answer = inputdlg(prompt,dlgTitle,1,def);
if(isempty(answer)),
disp('Cancelled')
return
else
AVG_MIN = sscanf(answer{1},'%g');
AVG_MAX = sscanf(answer{2},'%g');
end
AVG_MIN = min(find(Visu.Data.Time >= AVG_MIN/1000)); % convert to index
AVG_MAX = max(find(Visu.Data.Time <= AVG_MAX/1000));
if(isempty(AVG_MIN) | isempty(AVG_MAX)), % nothing
disp('Invalid time values')
return;
end
if(AVG_MAX < AVG_MIN), % bogus
disp('Inconsistent time values')
return;
end
tmp = mean(new_waves(goodchannels,AVG_MIN:AVG_MAX)')'; % mean in time for each channel
new_waves(goodchannels,:) = new_waves(goodchannels,:) - tmp(:,ones(1,size(new_waves,2)),:);
end
end
data.Measures.F{1}(goodchannels,:) = new_waves(goodchannels,:);
% Want to save data in file ?
Users = get_user_directory;
ButtonName=questdlg('Would you like to overwrite the orignal EEG segment in the current data file or save it under another name ?',...
'','Overwrite','Save as a new file','Save as a new file');
switch ButtonName
case 'Overwrite'
% Save it back to the original data set file
% Get current data file
[fname,h] = bst_static_taskbar('GET','DATA');
fname = fname{1};% CBB - only one file selected
cd(fullfile(Users.STUDIES,fileparts(fname)))
[path,file,ext] = fileparts(fname);
if file == 0, return, end
% Get original field names of datafile
oData = load(file);
% Replace by filtered values
oData.F = data.Measures.F{1};
oData.Time = linspace(data.Display.Time(1),data.Display.Time(2),data.Display.NumberOfSamples);
oData.ChannelFlag = data.Measures.ChannelFlag;
save_fieldnames(oData,file)
bst_message_window('wrap',...
sprintf('Overwrite original file %s -> done',file))
case 'Save as a new file'
% Save it to new datafile
[fname,h] = bst_static_taskbar('GET','DATA');
fname = fname{1};% CBB - only one file selected
cd(fullfile(Users.STUDIES,fileparts(fname)))
[path,file,ext] = fileparts(fname);
if file == 0, return, end
% Get original field names of datafile
oData = load(file);
file = sprintf('%s-f_L%dH%d',file,hpf,lpf);
% Replace by filtered values
oData.F = data.Measures.F{1};
oData.Time = linspace(data.Display.Time(1),data.Display.Time(2),data.Display.NumberOfSamples);
oData.ChannelFlag = data.Measures.ChannelFlag;
save_fieldnames(oData,file)
bst_message_window('wrap',...
sprintf('Filtered data saved in %s -> done',file))
[DataDir,DataPopup,Leader] = find_brainstorm_files('data',pwd,[]);
Users = get_user_directory;
for k=1:length(DataDir)
DataDir{k} = fullfile(strrep(Leader,[Users.STUDIES,filesep],''),DataDir{k});
end
% Refresh data file display
bst_static_taskbar('SET','DATA',DataDir);
ifile = strmatch(file,cellstr(DataPopup)); % where's the new file ?
% Find static taskbar
static_taskbar = findobj(0,'Tag','static_taskbar');
handles = guihandles(static_taskbar);
set(handles.popupmenu_DATA,'Value',ifile)
bst_static_taskbar('popupmenu_DATA_Callback',handles.popupmenu_DATA,[],guidata(handles.popupmenu_DATA))
case 'Don''t save; just try it' % deprecated case
% Do nothing
case 'Cancel'
return
end
makeuswait('stop')
dataplot_cb('loadfile',{fullfile(path,file)})
dataplot_cb('Plot')
%----------------------------------------------------------------------------
case 'show_fragment'
Visu = get(DATAPLOT,'Userdata');
tesselation_select_win = findobj(0,'Tag','tesselation_select');
available = findobj(tesselation_select_win,'Tag','available');
removed = findobj(tesselation_select_win,'Tag','removed');
availableID = get(removed,'Value');
IDs = get(removed,'String');
if isempty(IDs), return, end
chan = [1:length(IDs)];
load(Visu.Tesselation,'Clusters','Comment')
if ~exist('Clusters','var') % No fragmentation available for this tessellation file
return
end
% Identification of the active mesh surfaces
for i = 1:length(IDs)
imesh(i) = find(strcmp(IDs(i),Comment));
end
Vals = get(removed,'Userdata');
if isempty(Vals)
Vals = [ones(nmesh,1),zeros(nmesh,8)];
end
% Check for clusters for the current surface (highlighted surface name in the "selected text listbox")
FragmentMenu = findobj(gcbf,'Tag','FragmentMenu');
nsurf = imesh(availableID); % Selected surface
dataplot_cb mesh_props
if ~exist('Clusters','var') % Classes were not defined beforehand
set(FragmentMenu,'String','No Fragmentation','Value',1);
return
end
if isempty(Clusters{nsurf}) % No cluster available for surface 'nsurf'
set(FragmentMenu,'String','No Fragmentation','Value',1);
return
else
if isempty(Clusters{nsurf}.Seed)% No fragmentation availlable for this surface
set(FragmentMenu,'String','No Fragmentation');
else
sstring = {'No Fragmentation'};
for k = 1:length(Clusters{nsurf}.Seed)
sstring{k+1} = int2str(Clusters{nsurf}.Seed(k));
end
set(FragmentMenu,'String',sstring,'Value',2)
end
end
case 'listchan_create' % Selection of channel names for n-plot visualization
Visu = get(DATAPLOT,'Userdata');
if isempty(Visu)
errordlg('Please load a data set first')
return
end
0
str = {'MEG','EEG','OTHER'};
LISTCHAN = findobj(0,'Tag','listchan');
if isempty(LISTCHAN)
LISTCHAN = open('listchan.fig');
end
goodchannels = good_channel(Visu.Channel,Visu.Data.ChannelFlag,DataType{current}); % Discard bad channels
badchannels = setdiff(good_channel(Visu.Channel,ones(length(Visu.Channel),1),DataType{current}),goodchannels);
% goodchannels = setdiff(Visu.ChannelID{current},find(Visu.Data.ChannelFlag == -1)) - min(Visu.ChannelID{current})+1; % Discard bad channels
% badchannels = intersect(Visu.ChannelID{current},find(Visu.Data.ChannelFlag == -1)) - min(Visu.ChannelID{current})+1;
available = findobj(LISTCHAN,'Tag','available');
removed = findobj(LISTCHAN,'Tag','removed');
set(available,'String', {Visu.Channel(goodchannels).Name});
if ~isempty(badchannels)
set(removed,'String', {Visu.Channel(badchannels).Name});
else
set(removed,'String', '');
end
set(available,'Value',1,'Max',length(get(available,'String')))
set(removed,'Value',1,'Max',max([1,length(get(removed,'String'))]))
%----------------------------------------------------------------------------
case 'channel_plot_remove' % Remove Channels
channel_select_win = findobj(0,'Tag','listchan');
available = findobj(channel_select_win,'Tag','available');
removed = findobj(channel_select_win,'Tag','removed');
removeID = get(available,'Value');
IDs = get(available,'String');
chan = [1:length(IDs)];
set(available,'String', IDs(setdiff(chan,removeID)));
if isempty(get(removed,'String'))
set(removed,'String', [IDs(removeID)] );
else
strtmp = ([cellstr(get(removed,'String'));IDs(removeID)]);
strtmp = sort(strtmp);
set(removed,'String', cellstr(strtmp));
end
set(available,'Value',1,'Max',length(get(available,'String')))
set(removed,'Value',1,'Max',max([1,length(get(removed,'String'))]))
%----------------------------------------------------------------------------
case 'channel_plot_restore' % Restore Channels - Make them become available again
channel_select_win = findobj(0,'Tag','listchan');
available = findobj(channel_select_win,'Tag','available');
removed = findobj(channel_select_win,'Tag','removed');
availableID = get(removed,'Value');
IDs = get(removed,'String');
chan = [1:length(IDs)];
set(removed,'Max',max([1,length(setdiff(chan,availableID))]))
set(removed,'Value',1,'String',IDs(setdiff(chan,availableID)));
if isempty(get(available,'String'))
set(available,'String', [IDs(availableID)]);
else
strtmp = ([cellstr(get(available,'String'));IDs(availableID)]);
strtmp = sort(strtmp);
set(available,'String', cellstr(strtmp));
end
set(available,'Value',1,'Max',length(get(available,'String')))
%----------------------------------------------------------------------------
case 'listchan_SelectAll'
channel_select_win = findobj(0,'Tag','listchan');
available = findobj(channel_select_win,'Tag','available');
set(available,'Value',[1:get(available,'Max')])
dataplot_cb channel_plot_remove
%----------------------------------------------------------------------------
case 'listchan_RemoveAll'
channel_select_win = findobj(0,'Tag','listchan');
available = findobj(channel_select_win,'Tag','removed');
set(available,'Value',[1:get(available,'Max')])
dataplot_cb channel_plot_restore
%----------------------------------------------------------------------------
case 'listchan_refresh' % Update the channel information / plots
Visu = get(DATAPLOT,'Userdata');
str = {'MEG','EEG','OTHER'};
channel_select_win = findobj(0,'Tag','listchan');
removed = findobj(channel_select_win,'Tag','removed');
available = findobj(channel_select_win,'Tag','available');
handles = guihandles(channel_select_win);
ncol = str2num(get(handles.NumberOfColumns,'String')); % Number of columns in the layout
if isempty(get(removed,'String'))
errordlg('Please Select Channels for the Plot first')
return
end
[tmp,IDs] = intersect({Visu.Channel(Visu.ChannelID{current}).Name},get(removed,'String'));
% Get time window
data.Display.Time(1) = str2num(get(findobj(DATAPLOT,'Tag','time_min'),'String'));
data.Display.Time(end) = str2num(get(findobj(DATAPLOT,'Tag','time_max'),'String'));
if data.Display.Time(end) > Visu.Data.Time(end) * 1000
data.Display.Time(end) = Visu.Data.Time(end) * 1000;
set(findobj(DATAPLOT,'Tag','time_max'),'String',num2str(data.Display.Time(end),5))
end
if data.Display.Time(1) < Visu.Data.Time(1) * 1000
data.Display.Time(1) = Visu.Data.Time(1) * 1000;
set(findobj(DATAPLOT,'Tag','time_min'),'String',num2str(data.Display.Time(1),5))
end
delta_t = 1000*(Visu.Data.Time(2)-Visu.Data.Time(1));
samples = round(([data.Display.Time(1):delta_t:data.Display.Time(end)]-Visu.Data.Time(1)*1000)/delta_t)+1;
M = max(max(abs(Visu.Data.F(Visu.ChannelID{current}(IDs),samples))));
fignplot = findobj(0,'Tag','nplot_win'); % Figure of overlaping plots for the current modality
if isempty(fignplot)
fig = figure;
delete(findobj(fig,'type','axes'))
movegui(fig,'center')
set(fig,'Tag','nplot_win')
else
figure(fignplot)
clf
end
% Visualization
N = ceil(length(IDs)/ncol); % Maximum number of channels to visualize per column
delta = .95/(N+1); % Space between plots (in normalized units)
hold on
for col = 1:ncol % For each column of the layout
if col<ncol
try
IDscol = IDs((col-1)*N+1 : N*col); % Labels of channels to plot in each column
catch
errordlg('Please decrease the number of columns')
return
end
else
IDscol = IDs((col-1)*N+1 : end); % Labels of channels to plot in each column
end
if col>1
axes
end
i = 0;
for k = IDscol
i = i+1;
plotwaves = plot([data.Display.Time(1):delta_t:data.Display.Time(end)],Visu.Data.F(Visu.ChannelID{current}(k),samples)+(2*M*i));
hold on
end
set(gca,'units','normalized','ygrid','on','xgrid','on','Box','on',...
'Position',[(col-1)*0.96/ncol + 0.039, 0.035, 0.80/ncol, 0.96],...
'Yticklabel',{Visu.Channel(Visu.ChannelID{current}(IDscol)).Name},'Ytick',2*M*[1:length(IDscol)],...
'FontName','Helvetica','FontSize',7,'FontUnits','Points','Fontweight','light',...
'xColor',[.4 .4 .4], 'ycolor', [.05 .45 .80],'XMinorGrid','on',...
'Xlim',[data.Display.Time(1),data.Display.Time(end)],'Ylim',[0 2*M*(N+1)])
% set(gca,'Fontunits','normal')
liine = line([0 0],get(gca,'Ylim'),'linewidth',1);
set(liine,'color','r','Tag','cursor')
end
hold off
%--------------------------------------------------------------'--------------
case 'selectchannels' % Selection of Good/Bad Channels
chanwin = findobj(0,'type','figure','tag','channel_select');
if isempty(chanwin)
chanwin = openfig('channel_select.fig');
bst_color_scheme(chanwin);
setappdata(chanwin,'TileType','Tile')
bst_layout('align',chanwin,2,2,3);
end
hchanwin = guihandles(chanwin);
set(chanwin,'visible','on')
% Visualization %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
imeg = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'MEG');
ieeg = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'EEG');
iother = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'Other');
iall = [imeg,ieeg,iother];
Label = {'All','MEG','EEG','Other'};
set(hchanwin.pChannelSets,'String',Label,'Value',1);
% Available Channels
set(hchanwin.available,'String', {data.Measures.Channel(iall).Name});
set(hchanwin.available,'Value',1,'Max',max([1,length(iall)]));
% Bad or removed channels
% Create dummy channelflag array to show all bad (-1) channels
tmp.ChannelFlag = -ones(size(data.Measures.ChannelFlag));
tmp.ChannelFlag(data.Measures.ChannelFlag == -1) = 1;
ibad = [good_channel(data.Measures.Channel,tmp.ChannelFlag,'MEG'),...
good_channel(data.Measures.Channel,tmp.ChannelFlag,'EEG'),...
good_channel(data.Measures.Channel,tmp.ChannelFlag,'Other')];
tmp = data.Measures.ChannelFlag(iall);
iremoved = iall(tmp == 0);
channels.removed = [ibad,iremoved];
channels.available = [imeg,ieeg,iother];
set(hchanwin.removed,'String', sort({data.Measures.Channel(channels.removed).Name}));
set(hchanwin.removed,'Value',1,'Max',length(channels.removed));
set(hchanwin.removed,'Value',1,'Max',max([1,length(channels.removed)]))
% Store current selection of channels in channel_select GUI data
guidata(chanwin,channels);
%----------------------------------------------------------------------------
case 'channel_switch' % Remove Channels
chanwin = openfig('channel_select.fig','reuse');
hchanwin = guihandles(chanwin);
channels = guidata(chanwin);
switch(get(gcbo,'Tag')) % Which action button was pressed ?
case('pAdd')
ActionFlag = 0;
ChannelListFrom = hchanwin.removed;
ChannelListTo = hchanwin.available;
case('pRemove')
ActionFlag = 0;
ChannelListFrom = hchanwin.available;
ChannelListTo = hchanwin.removed;
case('pChannelSets') % Add some predefined channels set(s) to display
ActionFlag = 1;
ChannelListFrom = hchanwin.available;
ChannelListTo = hchanwin.removed;
% Visualization %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
imeg = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'MEG');
ieeg = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'EEG');
iother = good_channel(data.Measures.Channel,data.Measures.ChannelFlag,'Other');
ChanSetType = get(gcbo,'Value'); % Type of preselected channel set;
switch(ChanSetType)
case 1 % All Channels
ichans = [imeg,ieeg,iother];
case 2 % MEG
ichans = imeg;
case 3 % EEG
ichans = ieeg;
case 4 % Other
ichans = iother;
end
end
if ActionFlag == 0 % Manual channel selection
SelectedChannels = get(ChannelListFrom,'Value');
ChanNames = get(ChannelListFrom,'String');
if isempty(ChanNames)
return
end
chan = [1:length(ChanNames)];
set(ChannelListFrom,'String', ChanNames(setdiff(chan,SelectedChannels)));
if isempty(get(ChannelListTo,'String'))
set(ChannelListTo,'String', [ChanNames(SelectedChannels)] );
else
strtmp = ([cellstr(get(ChannelListTo,'String'));ChanNames(SelectedChannels)]);
strtmp = sort(strtmp);
set(ChannelListTo,'String', cellstr(strtmp));
end
set(ChannelListFrom,'Value',1,'Max',length(get(ChannelListFrom,'String')))
set(ChannelListTo,'Value',1,'Max',max([1,length(get(ChannelListTo,'String'))]))
elseif ActionFlag == 1 % Predefined display channel sets
set(ChannelListFrom,'String', {data.Measures.Channel(ichans).Name},...
'Value',1,'Max',max([1,length(ichans)]));
set(ChannelListTo,'String', {data.Measures.Channel(setdiff([imeg,ieeg,iother],ichans)).Name},...
'Value',1,'Max',max([1,length(setdiff([imeg,ieeg,iother],ichans))]));
end
[tmp,channels.removed] = intersect({data.Measures.Channel(:).Name},get(hchanwin.removed,'String'));
[tmp,channels.available] = intersect({data.Measures.Channel(:).Name},get(hchanwin.available,'String'));
guidata(chanwin,channels);
%----------------------------------------------------------------------------
case 'channel_select_done' % Update the channel information / plots
makeuswait('start')
Users = get_user_directory;
chanwin = openfig('channel_select.fig','reuse');
hchanwin = guihandles(chanwin);
channels = guidata(chanwin);
allchannels = [good_channel(data.Measures.Channel,[],'MEG'),...
good_channel(data.Measures.Channel,[],'EEG'),...
good_channel(data.Measures.Channel,[],'Other')];
% Apply proper flags to channel 1: selected | 0: discarded | -1: bad channels for display
if isempty(channels.removed)
data.Measures.ChannelFlag(allchannels) = 1;%ones(1,length(allchannels)); %Restore to Good Channel
else
data.Measures.ChannelFlag(channels.available) = 1; % Reinitialize to 1 before update
data.Measures.ChannelFlag(channels.removed) = -1; % CBB | Should be 0 instead
end
if get(hchanwin.ChannelSelectAllDataSets,'Value') % Apply this selection to all the data setsfrom this study
bst_message_window('Updating all data files from current study . . .')
cd(Users.STUDIES)
[path,file,ext] = fileparts(Users.CurrentData.StudyFile);
[DataDir,DataPopup,Leader] = find_brainstorm_files('data',fullfile(Users.STUDIES,path));
ndatafiles = 0;
clear ChannelFlag
for file = DataDir
cd(fullfile(Users.STUDIES,path))
if isempty(findstr(file{:},'results'))
load(file{:},'ChannelFlag')
end
if exist('ChannelFlag','var') % Skip this file
ndatafiles = ndatafiles+1
ChannelFlag = data.Measures.ChannelFlag;
save(file{:},'ChannelFlag','-append')
clear ChannelFlag
end
end
bst_message_window('wrap',...
{...
'Updating all data files from current study...-> DONE',...
sprintf('%d file(s) updated',ndatafiles)...
})
elseif get(hchanwin.ChannelSelectCurrentDataSet,'Value') % Apply this selection to current data file
cd(Users.STUDIES)
clear ChannelFlag
dataFile = bst_static_taskbar('GET','DATA');
dataFile = dataFile{1}; % CHEAT assume only first of selected file
bst_message_window('wrap',...
sprintf('Updating current data file: %s',dataFile))
load(dataFile,'ChannelFlag')
[path,file,ext] = fileparts(Users.CurrentData.StudyFile);
cd(path)
if exist('ChannelFlag','var') % Skip this file
ChannelFlag = data.Measures.ChannelFlag;
save(dataFile,'ChannelFlag','-append')
clear ChannelFlag
end
bst_message_window('-> DONE')
end
tmp = data.Measures.ChannelFlag;
tmp(tmp==0) = -1;
data.Measures.Display.SelectedChannels{1} = good_channel(data.Measures.Channel,tmp,'MEG');
data.Measures.Display.SelectedChannels{2} = good_channel(data.Measures.Channel,tmp,'EEG');
data.Measures.Display.SelectedChannels{3} = good_channel(data.Measures.Channel,tmp,'Other');
dataplot_cb('Plot','measures')
makeuswait('stop')
%----------------------------------------------------------------------------
case 'GenerateAverage' % Generate time-locked average of a selection of data files in current study folder
% File selection
% Current study folder
[fname,h] = bst_static_taskbar('GET','DATA');
fname = fname{1};
Users = get_user_directory;
path = fullfile(Users.STUDIES,fileparts(fname));
% File selection window - call Pantazis's routine
bst_message_window('Select files to be averaged from list')
selectedFiles = file_selection_win({'data'},path); % Fully-qualified cell array of filenames
if isempty(selectedFiles{1}), makeuswait('stop'), return, end
% Short input dialog about adjusting peak latency
prompt={'Allow time jitter of (ms): '};
def={'0'};
dlgTitle='Adjust time-locking factor';
lineNo = 1;
answer=inputdlg(prompt,dlgTitle,lineNo,def);
if isempty(answer), makeuswait('stop'), return , end
makeuswait('start')
bst_message_window('wrap',...
sprintf('Time-locked averaging of %d selected data files...', length(selectedFiles)))
ndatafiles = 0; % total number of files already read
for file = selectedFiles
if isempty(findstr(file{:},'results')) & isempty(findstr(file{:},'avr.mat'))
% Don't include average files or mistakenly selected results
% files
ndatafiles = ndatafiles+1;
bst_message_window('wrap',...
{...
sprintf('Step %d/%d -',ndatafiles,length(selectedFiles)),...
sprintf('Including %s into average', file{:})})
load(file{:},'F','Time')
[Channel,varargout] = get_channel(file{:}); % get Channel info
TimeOrig = Time; % Store original time vector
% Get selected modality
slct_modal = get_selected_modalities;
if length(slct_modal) > 1
errordlg('Only one modality needs to be selected in static taskbar for data averaging.')
return
elseif isempty(slct_modal)
errordlg('Please select either MEG, EEG or OTHER data subset')
return
end
% Get all channels from current data setand seletec modality (i.e. including BAD channels)
F = F(good_channel(Channel,[],ModalityLabel{slct_modal}),:);
% Corresponding number of samples
srate = Time(2)-Time(1); % Sampling rate of current file
% Get value for time-jitter factor
winPeak = str2num(answer{1});
winPeak = ceil(winPeak/(1000*srate*2)); % Allow search of possible jitter in terms of number of samples
% Find sample corresponding to time 0ms
zeroLat = findclosest(0,Time);
if winPeak > 0% Find maximum within jitter time window
% Extract data on the window of analysis:
tmpF = abs(F(:,zeroLat-winPeak:zeroLat+winPeak));
[mF ,mFindx] = max(tmpF);
[mF ,mFindx] = max(mF);
% New sample number for 0ms latency
zeroLat = zeroLat-winPeak+mFindx-1;
end
% Create new time vector
Time(1) = sign(Time(1))*(zeroLat-1)*srate;
Time = Time(1):srate:(Time(1)+(length(Time)-1)*srate);
data.Display.Time = [Time(1), Time(end)];
data.Display.SamplingRate = srate;
set(hDataplot.time_min,'String',num2str(Time(1)*1000,'%3.2f'));
set(hDataplot.time_max,'String',num2str(Time(end)*1000,'%3.2f'));
set(hDataplot.step,'String',num2str(srate*1000,'%3.2f'));
%Adjust time window
if ndatafiles == 1
srate = data.Display.SamplingRate;
zeroLat = round(abs(Time(1))/srate)+1;
zeroLatOld = zeroLat;
end
% Average files all together
if ndatafiles == 1
Fav = F;
iunder = findstr(file{:},'_'); % Generate average data file name
avFileName = file{:}(1:iunder(end));
avFileName = [avFileName,ModalityLabel{slct_modal},'avr.mat'];
Data = load(file{:});
else
% Find sample corresponding to time 0ms
zeroLat = round(abs(Time(1))/srate)+1;
if zeroLat < zeroLatOld
Fav = Fav(:,zeroLatOld-zeroLat+1:end);
Fav = Fav(:,1:min([size(F,2),size(Fav,2)]));
F = F(:,1:min([size(F,2),size(Fav,2)]));
zeroLatOld = zeroLat;
else
F = F(:,zeroLat-zeroLatOld+1:end);
Fav = Fav(:,1:min([size(F,2),size(Fav,2)]));
F = F(:,1:min([size(F,2),size(Fav,2)]));
zeroLat = zeroLatOld;
end
Fav = Fav+F;
end
% Find maximum latency of this running average
Time(1) = sign(Time(1))*(zeroLat-1)*srate;
Time = Time(1):srate:(Time(1)+(size(Fav,2)-1)*srate);
zeroLat = round(abs(Time(1))/srate)+1;
zeroLatOld = zeroLat;
end
end
srate = abs(TimeOrig(1)-TimeOrig(2));
% New time vector
Time(1) = sign(TimeOrig(1))*(zeroLat-1)*srate;
Time = Time(1):srate:(Time(1)+(size(Fav,2)-1)*srate);
% Save averaged data back to disk
Data.F = zeros(length(Channel),length(Time));
Data.F(good_channel(Channel,[],ModalityLabel{slct_modal}),:) = Fav/ndatafiles;
Data.Time = Time;
save_fieldnames(Data,avFileName);
[DataDir,DataPopup,Leader] = find_brainstorm_files('data',pwd,[]);
Users = get_user_directory;
for k=1:length(DataDir)
DataDir{k} = fullfile(strrep(Leader,[Users.STUDIES,filesep],''),DataDir{k});
end
% Refresh data file display
bst_static_taskbar('SET','DATA',DataDir);
ifile = strmatch(strrep(avFileName,[fileparts(avFileName),filesep],''),cellstr(DataPopup)); % where's the new file ?
% Find static taskbar
static_taskbar = findobj(0,'Tag','static_taskbar');
handles = guihandles(static_taskbar);
set(handles.popupmenu_DATA,'Value',ifile)
bst_static_taskbar('popupmenu_DATA_Callback',handles.popupmenu_DATA,[],guidata(handles.popupmenu_DATA))
bst_message_window('wrap',...
{'Time-locked averaging -> DONE',...
sprintf('%d files averaged',ndatafiles)}...
)
makeuswait('stop')
dataplot_cb('loadfile',{strrep(avFileName,[Users.STUDIES,filesep],'')})
dataplot_cb('Plot')
%----------------------------------------------------------------------------
case 'mapping_display_type' % Checkboxes Mutually incompatible
DATAPLOT = findobj(0,'Tag','mapping');
MEG = findobj(DATAPLOT,'Tag','single');
EEG = findobj(DATAPLOT,'Tag','slides');
OTHER = findobj(DATAPLOT,'Tag','movie');
mutincomp([MEG,EEG,OTHER])
h = findobj([MEG,EEG,OTHER],'Value',1);
if length(h)>1
set(h(2),'Value',0) % Just one modality at a time please !
end
%----------------------------------------------------------------------------
case 'quit'
close gcbf
%----------------------------------------------------------------------------
case 'see_sensors' % Visualize sensor locations using 3D spheres
TessWin = findobj(0,'Tag','tesselation_select');
hTessWin = guihandles(TessWin);
% mutincomp([hTessWin.Sensors3D,hTessWin.SensorsMarkers]);
previous = openfig('tessellation_window.fig','reuse');
if get(hTessWin.Sensors3D,'Value') == 0
if get(hTessWin.SensorsMarkers,'Value') == 1
sph= findobj(previous,'Tag','SENSORS');
delete(sph); set(previous,'Userdata',[]) % Redraw all sensors - to avoid mess with handles when resizing and coloring the sphere
dataplot_cb see_sensors_markers
return
else
sph= findobj(previous,'Tag','SENSORS');
delete(sph); set(previous,'Userdata',[]) % Redraw all sensors - to avoid mess with handles when resizing and coloring the sphere
return
end
end
Visu = get(DATAPLOT,'Userdata');
previous = openfig('tessellation_window.fig','reuse');
SIZE = sqrt(str2num(get(hTessWin.SensorSize,'String'))/10); % get sensor size
if isempty(SIZE), SIZE = 1; end
sph= findobj(previous,'Tag','SENSORS');
delete(sph); set(previous,'Userdata',[]) % Redraw all sensors - to avoid mess with handles when resizing and coloring the sphere
% Channels Locations:
if ~isempty(find(Visu.Data.ChannelFlag == -1))
goodchannels = good_channel(Visu.Channel,Visu.Data.ChannelFlag,DataType{current}); % Discard bad channels
badchannels = setdiff(good_channel(Visu.Channel,ones(length(Visu.Channel),1),DataType{current}),goodchannels);
else
goodchannels = Visu.ChannelID{current};
badchannels = [];
end
j = 0;
chanloc = [Visu.Channel(goodchannels).Loc];
chanloc = chanloc(:,1:2:end);
for chan = goodchannels %Visu.ChannelID{current}
j = j+1;
figure(previous)
hold on
if j == 1
maxx = max(abs(get(gca,'Xlim')/50))*SIZE;
[X,Y,Z] = sphere;
end
sph(j) = surf(maxx*X+chanloc(1,j),maxx*Y+chanloc(2,j),maxx*Z+chanloc(3,j),'Visible','off');
end
set(sph,'Userdata',SIZE,'Visible','on','facelighting','Gouraud','edgelighting','Gouraud','Tag','SENSORS','facecolor',[.1 .1 .9],'Edgecolor','none')
axis equal, axis vis3d
varargout{1} = sph;
%--------------------------------------------------------------------------------------------------------------------
case 'see_sensors_markers' % Visualize sensor locations using regular markers
TessWin = findobj(0,'Tag','tesselation_select');
hTessWin = guihandles(TessWin);
% mutincomp([hTessWin.Sensors3D,hTessWin.SensorsMarkers]);
previous = openfig('tessellation_window.fig','reuse');
if get(hTessWin.SensorsMarkers,'Value') == 0
if get(hTessWin.Sensors3D,'Value') == 1
sph= findobj(previous,'Tag','SENSORS');
delete(sph); set(previous,'Userdata',[]) % Redraw all sensors - to avoid mess with handles when resizing and coloring the sphere
dataplot_cb see_sensors
return
else
sph= findobj(previous,'Tag','SENSORS');
delete(sph); set(previous,'Userdata',[]) % Redraw all sensors - to avoid mess with handles when resizing and coloring the sphere
return
end
end
Visu = get(DATAPLOT,'Userdata');
SIZE = sqrt(str2num(get(hTessWin.SensorSize,'String'))); % get sensor size
if isempty(SIZE), SIZE = 1; end
sph= findobj(previous,'Tag','SENSORS');
delete(sph); set(previous,'Userdata',[]) % Redraw all sensors - to avoid mess with handles when resizing and coloring the sphere
% Channels Locations:
if ~isempty(find(Visu.Data.ChannelFlag == -1))
goodchannels = good_channel(Visu.Channel,Visu.Data.ChannelFlag,DataType{current}); % Discard bad channels
badchannels = setdiff(good_channel(Visu.Channel,ones(length(Visu.Channel),1),DataType{current}),goodchannels);
% % goodchannels = setdiff(Visu.ChannelID{current},find(Visu.Data.ChannelFlag == -1));% - min(Visu.ChannelID{current})+1; % Discard bad channels
% badchannels = intersect(Visu.ChannelID{current},find(Visu.Data.ChannelFlag == -1));% - min(Visu.ChannelID{current})+1;
else
goodchannels = Visu.ChannelID{current};
badchannels = [];
end
j = 0;
chanloc = [Visu.Channel(goodchannels).Loc];
chanloc = chanloc(:,1:2:end);
hold on
sph = scatter3(chanloc(1,:),chanloc(2,:),chanloc(3,:),'filled');
set(sph,'Userdata',SIZE,'Visible','on','Tag','SENSORS',...
'Markerfacecolor',[.1 .1 .9],'Markeredgecolor','k', 'MarkerSize',SIZE);
axis equal, axis vis3d
varargout{1} = sph;
%--------------------------------------------------------------------------------------------------------------------
case 'OrthoViews' % Toggle between visualization of selected envelopes along 4 orthogonal views and single-view mode
TessSelect = findobj(0,'Tag','tesselation_select');
hSelect = guihandles(TessSelect);
TAG = get(hSelect.OrthoViews,'Value');
TessWin = findobj(0,'Tag','tessellation_window');
if isempty(TessWin), set(gcbo,'Value',0), return, end
ha = findobj(TessWin,'Tag','MainAxes');
hp = findobj(get(ha,'Children'),'Type','patch');
haa(1) = findobj(TessWin,'Tag','axsub1');
haa(2) = findobj(TessWin,'Tag','axsub2');
haa(3) = findobj(TessWin,'Tag','axsub3');
haa(4) = findobj(TessWin,'Tag','axsub4');
haa_child = get(haa,'Children');
if ~isempty(haa_child{1})
hps{1} = findobj([haa_child{:}],'Type','patch');
else
hps{1} = [];
end
if isempty(TAG)|TAG == 1
if isempty(hps{1})
for k = 1:4
hps{k} = copyobj([hp(:)]',[haa(k)]);
end
axes(haa(1)), view(-180, 90), axis vis3d, axis equal, axis off,
copyobj(findobj(ha,'Type','light'),haa(1))
axes(haa(2)), view(-180, 0), axis vis3d, axis equal, axis off,
copyobj(findobj(ha,'Type','light'),haa(2))
axes(haa(3)), view(-90, 0), axis vis3d, axis equal, axis off,
copyobj(findobj(ha,'Type','light'),haa(3))
axes(haa(4)), view(0, 0), axis vis3d, axis equal, axis off,
copyobj(findobj(ha,'Type','light'),haa(4))
set(haa, 'Clim',get(ha,'Clim'))
else
set([hps{:}],'visible','on')
end
set(hp,'visible','off')
else
set([hps{:}],'visible','off')
set(hp,'visible','on')
set(TessWin,'CurrentAxes',get(hp(1),'Parent'))
end
dataplot_cb mapping_slider % Refersh time sample
%--------------------------------------------------------------------------------------------------------------------
case 'FreezeColormap' %...so that Colormap is adjusted to
TessWin = findobj(0,'Tag','tessellation_window');
TessSelect = findobj(0,'Tag','tesselation_select');
hSelect = guihandles(TessSelect);
figure(TessWin);
togglebuttoncolor(gcbo)
% Check if loaded Results match this surface (ie number of sources = number of vertices of selected cortical surface)
Results = get(hSelect.ResultFiles,'Userdata');
if isempty(Results), return, end
MAPPING = findobj(0,'Tag','mapping');
hMAPPING = guihandles(MAPPING);
srate = abs(Results.ImageGridTime(2)-Results.ImageGridTime(1));
ctime = round((get(hMAPPING.hDataplot.TimeSlider,'Value')/1000- Results.ImageGridTime(1))/srate)+1;
set(hSelect.FreezeColormap,'Userdata',ctime)
if get(hSelect.FreezeColormap,'Value')
set(hSelect.FreezeTime,'String',sprintf('Time: %4.1f ms',1000*Results.ImageGridTime(ctime)))
else
set(hSelect.FreezeTime,'String','')
end
if get(hSelect.FreezeColormap,'Value')
set(hSelect.Normalize,'Value',0);
set(TessSelect,'currentobject',hSelect.Normalize)
dataplot_cb NormalizeColormap
else
dataplot_cb mapping_slider
end
%dataplot_cb mapping_slider
%--------------------------------------------------------------------------------------------------------------------
case 'NormalizeColormap' % ...so that Colormapping is automatic (data maxima reach the maximum of the colormap)
TessWin = findobj(0,'Tag','tessellation_window');
TessSelect = findobj(0,'Tag','tesselation_select');
hSelect = guihandles(TessSelect);
figure(TessWin);
togglebuttoncolor(gcbo)
if get(hSelect.Normalize,'Value')
set(hSelect.FreezeColormap,'Value',0);
set(TessSelect,'currentobject',hSelect.FreezeColormap)
dataplot_cb FreezeColormap
end
dataplot_cb mapping_slider
%--------------------------------------------------------------------------------------------------------------------
case 'ScaleColormap' % let the user adjust the color scaling for greater saturation
hTessSelect = guihandles(gcbf);
%ScaleFactor = inputdlg('Enter Caxis Scaling Factor','BrainStorm Movie Maker',[1 50],{'1'});
%if isempty(ScaleFactor), return, end
if get(hTessSelect.ZScoreThresholdApply,'Value') & get(hTessSelect.ZScore,'Value')
ZScoreFlag = 1;
ScaleFactor = 100*get(hTessSelect.ZScoreThreshold,'Userdata');
else
ScaleFactor = str2num(get(hTessSelect.TruncateFactor,'String'));
ZScoreFlag = 0;
end
TessWin = findobj(0,'Tag','tessellation_window');
if isempty(TessWin), return, end
figure(TessWin)
ColorMap = get(TessWin,'Colormap');
ColorMapOld = get(hTessSelect.ScaleColormap,'Userdata');
if isempty(ColorMapOld),
ColorMapOld = ColorMap;
set(hTessSelect.ScaleColormap,'Userdata',ColorMapOld);
end
ColorMap = ColorMapOld;
if ScaleFactor > 0
ColorMap(1:round(ScaleFactor*end/100),:) = ...
repmat(min([.3,sum(ColorMap(round(ScaleFactor*end/100),:))])*[1 1 1],length(1:round(ScaleFactor*size(ColorMapOld,1)/100)),1);
else
ColorMap = ColorMapOld;
end
set(TessWin,'Colormap',ColorMap);
set(hTessSelect.ColorMAP,'Userdata',ColorMap)
dataplot_cb CorticalMap
%--------------------------------------------------------------------------------------------------------------------
%
% case 'Colorbar' % Add colorbar to the Surface Viewer window
% handles = guihandles(gcbf);
% ViewColorbar = get(handles.Colorbar,'Value'); % Add or remove colorbar
% TessWin = findobj(0,'Tag','tessellation_window');
%
% if isempty(TessWin), return, end
% if isempty(get(handles.Colorbar,'Userdata')) | (ViewColorbar == 1)
% figure(TessWin);
% Colorbar = colorbar('horiz');
% set(handles.Colorbar,'Userdata',Colorbar);
% set(Colorbar,'Xcolor',textcolor,'Ycolor',textcolor)
% elseif ~isempty(get(handles.Colorbar,'Userdata'))
% delete(get(handles.Colorbar,'Userdata'));
% set(handles.Colorbar,'Userdata',[])
% end
% figure(TessWin)
% view3d rot
% hTessSelect = guihandles(findobj(0,'Tag','tesselation_select'));
% if get(hTessSelect.Normalize,'Value') & ViewColorbar == 1% Normalized colorbar
% M=get(hTessSelect.Normalize,'Userdata');
% set(get(handles.Colorbar,'Userdata'),'XTickLabel',num2str(linspace(0,M,6)',1))
% end
%
% %--------------------------------------------------------------------------------------------------------------------
% case 'Colorbar_mapping' % Add colorbar to the Surface Viewer window
% handles = guihandles(gcbf);
% ViewColorbar = get(handles.Colorbar,'Value'); % Add or remove colorbar
% for k = 1:length(current)
% TessWin = findobj(0,'Tag',['map_single',int2str(current(k))]);
%
% if isempty(TessWin), return, end
% if (ViewColorbar == 1)
% figure(TessWin);
% axes(get(TessWin,'CurrentAxes'));
% Colorbar{k} = colorbar('horiz');
% set(handles.Colorbar,'Userdata',Colorbar);
% set(Colorbar{k},'Xcolor',textcolor,'Ycolor',textcolor)
% elseif ~isempty(get(handles.Colorbar,'Userdata'))
% Colorbar = get(handles.Colorbar,'Userdata');
% if isempty(Colorbar)
% return
% end
% delete([Colorbar{:}]);
% set(handles.Colorbar,'Userdata',[])
% end
% end
%
%--------------------------------------------------------------------------------------------------------------------
case 'QuitTessSelect' % Bye
delete(findobj(0,'tag','tesselation_select'));
delete(findobj(0,'tag','tessellation_window'));
%----------------------------------------------------------------------------
case 'mutincomp_cmapping' % Mutually icompatible checkboxes
mapping_win = findobj(0,'Tag','mapping');
MEG = findobj(mapping_win ,'Tag','ABSOLUTE');
EEG = findobj(mapping_win ,'Tag','RELATIVE');
mutincomp([MEG,EEG])
h = findobj([MEG,EEG],'Value',1);
if length(h)>1
set(h(2),'Value',0)
end
%----------------------------------------------------------------------------
case 'mutincomp_colormap' % Mutually icompatible checkboxes
mapping_win = findobj(0,'Tag','tesselation_select');
MEG = findobj(mapping_win ,'Tag','Normalize');
EEG = findobj(mapping_win ,'Tag','FreezeColormap');
mutincomp([MEG,EEG])
h = findobj([MEG,EEG],'Value',1);
if length(h)>1
set(h(2),'Value',0)
end
%----------------------------------------------------------------------------
case 'mutincomp_meanmax' % Mutually icompatible checkboxes
mapping_win = findobj(0,'Tag','tesselation_select');
MEG = findobj(mapping_win ,'Tag','MeanCorticalArea');
EEG = findobj(mapping_win ,'Tag','MaxCorticalArea');
OTHER = findobj(mapping_win ,'Tag','AllCorticalArea');
mutincomp([MEG,EEG,OTHER])
h = findobj([MEG,EEG,OTHER],'Value',1);
if length(h)>1
set(h(2:end),'Value',0)
end
%----------------------------------------------------------------------------
case 'mutincomp_opaque' % Mutually icompatible checkboxes
MEG = findobj(gcbf,'Tag','Opaque');
EEG = findobj(gcbf,'Tag','transparent');
mutincomp([MEG,EEG])
h = findobj([MEG,EEG],'Value',1);
if length(h)>1
set(h(2),'Value',0)
end
dataplot_cb mesh_vals
%----------------------------------------------------------------------------
case 'mapping_type' % Mutually icompatible checkboxes
mapping_win = findobj(0,'Tag','mapping');
MEG = findobj(mapping_win ,'Tag','raw');
EEG = findobj(mapping_win ,'Tag','gradient');
OTHER = findobj(mapping_win,'Tag','magnetic');
mutincomp([MEG,EEG,OTHER])
h = findobj([MEG,EEG,OTHER],'Value',1);
if length(h)>1
set(h(2),'Value',0)
end
%----------------------------------------------------------------------------
case 'mapping_head_shape' % Mutually icompatible checkboxes
mapping_win = findobj(0,'Tag','mapping');
handles = guihandles(mapping_win);
% figure(mapping_win)
mutincomp([handles.sphere,handles.fit,handles.scalp])
h = findobj([handles.sphere,handles.fit,handles.scalp],'Value',1);
if length(h)>1
set(h(2),'Value',0)
end
% ------------------------------------------------------------------
case 'GetCallback' % Pick up callback associated to items in current pulldown menu
Methods = getappdata(gcbo,'Methods'); % Callbacks were stored previously
%if isempty(Methods), return, end
iMethod = get(gcbo,'Value'); % Index of selected item in list
eval(Methods(iMethod).callback) % Launch callback
end % Switch action
% Subfunctions ------------------------------------------------------------------
% ------------------------------------------------------------------------------
function initialize_SourceTimeViewing(handle)
% when first called, build the popups from here
% Since we want to add functionality to these popups, particularly
% new viewing routines, we will explicitly build this popup and maintain it
% in the application data
Methods = struct('display',[],'localfunction',[]); % initialize
% build it here, imitating this format, rearrange as desired
% the first line
Methods(1).display = '<No Time Display>';
Methods(1).callback = ''; % comment line
% the remaining lines, use this format to allow easy rearranging.
Methods(end+1).display = 'Overlay';
Methods(end).callback = 'dataplot_cb set_SourceViewingTimeDisplay'; % local function in this m-file
Methods(end+1).display = 'Column';
Methods(end).callback = 'dataplot_cb set_SourceViewingTimeDisplay'; % local function in this m-file
Methods(end+1).display = 'Cortical Scouts';
Methods(end).callback = 'dataplot_cb CorticalScouts';
% set the popup menu
set(handle,'string',{Methods.display});
% set application data in the popup
setappdata(handle,'Methods',Methods);
% thus retrieving this application data will yield the local function to
% be used for every method
% ------------------------------------------------------------------------------
function initialize_SourceSpatialViewing(handle)
% when first called, build the popups from here
% Since we want to add functionality to these popups, particularly
% new viewing routines, we will explicitly build this popup and maintain it
% in the application data
Methods = struct('display',[],'callback',[]); % initialize
% build it here, imitating this format, rearrange as desired
% the first line
Methods(1).display = '<No Spatial Display>';
Methods(1).callback = ''; % comment line
% the remaining lines, use this format to allow easy rearranging.
Methods(end+1).display = 'Cortical Envelope';
Methods(end).callback = 'dataplot_cb SourceViewingSpatialDisplay'; % local function in this m-file
Methods(end+1).display = 'MRI';
Methods(end).callback = 'dataplot_cb SourceViewingSpatialDisplay'; % local function in this m-file
Methods(end+1).display = 'Glass Brain';
Methods(end).callback = 'dataplot_cb SourceViewingSpatialDisplay';
Methods(end+1).display = '------------';
Methods(end).callback = '';
Methods(end+1).display = 'Add Scalp Surface';
Methods(end).callback = 'dataplot_cb AddScalpSurface';
% set the popup menu
set(handle,'string',{Methods.display});
% set application data in the popup
setappdata(handle,'Methods',Methods);
% thus retrieving this application data will yield the local function to
% be used for every method
% ------------------------------------------------------------------------------
function shorterfilename = shorter_filename(longfilename);
% Shorten and edit the length of the relative filename file name LONGFILENAME
% by removing path and underscores to avoid TEX interpretation of string.
% Arguments are cell arrays of string.
fname = longfilename; clear longfilename
[PATHSTR,NAME,EXT,VERSN] = fileparts(fname{1}); % Make names shorter
fname = strrep(fname,[PATHSTR,filesep],'');
fname = strrep(fname,[EXT],'');
fname = strrep(fname,'_','-'); % Avoid TEX interpretation of fname string
shorterfilename = fname;
% ------------------------------------------------------------------------------
function slct_modal = get_selected_modalities;
% Find selected modalities from static taskbar
% Return a vector or a scalar with the following code
% 1 is MEG
% 2 is EEG
% 3 is OTHER
global data
[val,enable,h] = bst_static_taskbar('GET','MEG'); % Go and fetch this information from static taskbar
MEG = ~isempty(data.Measures.Display.SelectedChannels{1}) & val ;
[val,enable,h] = bst_static_taskbar('GET','EEG');
EEG = ~isempty(data.Measures.Display.SelectedChannels{2}) & val;
[val,enable,h] = bst_static_taskbar('GET','OTHER');
Other= ~isempty(data.Measures.Display.SelectedChannels{3}) & val;
Test = [MEG,EEG,Other];
slct_modal = find(Test); % Select modalities for display
Produced by color_mat2html, a customized BrainStorm 2.0 (Alpha) version of mat2html on Tue Oct 12 12:05:14 2004
Cross-Directory links are: ON