[Master Index] [Index for Toolbox]

# mritool_cb

## (Toolbox/mritool_cb.m in BrainStorm 2.0 (Alpha))

### Function Synopsis

    mritool_cb(action)

### Help Text

    MRITOOL_CB - OBSOLETE Switchyard corresponding to the OLDER MRITOOL GUI (mribox.fig)
     function mritool_cb(action)
     Switchyard corresponding to the MRITOOL GUI (mribox.m)

### Cross-Reference Information

This function calls

    bst_color_scheme                   C:\BrainStorm_2001\Toolbox\bst_color_scheme.m
    bst_layout                         C:\BrainStorm_2001\Toolbox\bst_layout.m
    colnorm                            C:\BrainStorm_2001\Toolbox\colnorm.m
    get_gain                           C:\BrainStorm_2001\Toolbox\get_gain.m
    get_user_directory                 C:\BrainStorm_2001\Toolbox\get_user_directory.m
    ginput2                            C:\BrainStorm_2001\Toolbox\ginput2.m
    good_channel                       C:\BrainStorm_2001\Toolbox\good_channel.m
    leaflet                            C:\BrainStorm_2001\Toolbox\leaflet.m
    norlig                             C:\BrainStorm_2001\Toolbox\norlig.m
    offset                             C:\BrainStorm_2001\Toolbox\offset.m
    tri_interp                         C:\BrainStorm_2001\Toolbox\tri_interp.m
    vec                                C:\BrainStorm_2001\Toolbox\vec.m
    vertices_connectivity              C:\BrainStorm_2001\Toolbox\vertices_connectivity.m

This function is called by

    bst_static_taskbar                 C:\BrainStorm_2001\Toolbox\bst_static_taskbar.m
    data_manager                       C:\BrainStorm_2001\Toolbox\data_manager.m

### Listing of function C:\BrainStorm_2001\Toolbox\mritool_cb.m

    function mritool_cb(action)
    %MRITOOL_CB - OBSOLETE Switchyard corresponding to the OLDER MRITOOL GUI (mribox.fig)
    % function mritool_cb(action)
    % Switchyard corresponding to the MRITOOL GUI (mribox.m)

    %<autobegin> ---------------------- 14-Jun-2004 17:10:40 -----------------------
    % --------- Automatically Generated Comments Block Using AUTO_COMMENTS ---------
    %
    % CATEGORY: Visualization
    %
    % Alphabetical list of external functions (non-Matlab):
    %   toolbox\bst_color_scheme.m
    %   toolbox\bst_layout.m
    %   toolbox\colnorm.m
    %   toolbox\get_user_directory.m
    %   toolbox\ginput2.m
    %   toolbox\good_channel.m
    %   toolbox\leaflet.m
    %   toolbox\mritool_cb.m  NOTE: Routine calls itself explicitly
    %   toolbox\norlig.m
    %   toolbox\tri_interp.m
    %   toolbox\vertices_connectivity.m
    %
    % Subfunctions in this file, in order of occurrence in file:
    %   visu_pt(pthandle)
    %   A = get_gain(fid,ndx);
    %
    % Application data and their calls in this file:
    %   'TileType'
    %
    %   setappdata(MAINWINDOW,'TileType','T');
    %
    %
    % Figure Files opened by this function:
    %   'mribox.fig'
    %
    %   Format of strings below: Type:Style:Tag, "String", CallBack Type and Call
    %   <automatic> callback is <Tag>_Callback by Matlab default
    %
    % Callbacks by figure mribox.fig
    %   text::Axes1Text1 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   text::Axes1Text1 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   text::Axes1Text2 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   text::Axes1Text2 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   text::Axes1Text3 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   text::Axes1Text3 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   text::Axes1Text4 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   text::Axes1Text4 "" uses ButtonDownFcn for ctlpanel SelectMoveResize
    %   uicontrol:checkbox:big-endian "Big-endian" uses Callback for
    %     mutincomp([findobj(gcbf,'Tag','big-endian'), findobj(gcbf,'Tag','little-endian')]);
    %   uicontrol:checkbox:flip_lr_a "" uses Callback for mritool_cb flip_lr_a
    %   uicontrol:checkbox:flip_ud_c "" uses Callback for mritool_cb flip_ud_c
    %   uicontrol:checkbox:flip_ud_s "" uses Callback for mritool_cb flip_ud_s
    %   uicontrol:checkbox:gotopoint "'Go to Point' mode" uses Callback for mritool_cb gotopoint
    %   uicontrol:checkbox:little-endian "Little-endian" uses Callback for
    %     mutincomp([findobj(gcbf,'Tag','big-endian'), findobj(gcbf,'Tag','little-endian')]);
    %   uicontrol:checkbox:mouse_slct "Select Slice with Mouse" uses Callback for mritool_cb mouse_slct
    %   uicontrol:checkbox:show_coordinates "Show Coordinates" uses Callback for
    %     mritool_cb show_coordinates
    %   uicontrol:checkbox:zoom "Activate Zoom" uses Callback for mritool_cb zoom
    %   uicontrol:listbox:listbox "" uses Callback for mritool_cb current_point
    %   uicontrol:pushbutton:BLOBS "Load SPM Clusters" uses Callback for mritool_cb addblobs
    %   uicontrol:pushbutton:deletepoint "Delete" uses Callback for mritool_cb deletepoint
    %   uicontrol:pushbutton:Hscalppoints "Load MR Volume" uses Callback for mritool_cb LoadBrainStorm
    %   uicontrol:pushbutton:LEAFLET "Leaflet" uses Callback for mritool_cb leaflet
    %   uicontrol:pushbutton:newlabel "New Label" uses Callback for mritool_cb newlabel
    %   uicontrol:pushbutton:next ">" uses Callback for mritool_cb current_point
    %   uicontrol:pushbutton:PCS "Define SCS" uses Callback for mritool_cb pcs
    %   uicontrol:pushbutton:previous "<" uses Callback for mritool_cb current_point
    %   uicontrol:pushbutton:pushbutton1 "Cortical Scout" uses Callback for mritool_cb CorticalScout
    %   uicontrol:pushbutton:Quit "Quit" uses Callback for mritool_cb quit
    %   uicontrol:pushbutton:scalppoints "Rendering" uses Callback for rendering_cb create
    %   uicontrol:pushbutton:seelabels "Show Label" uses Callback for mritool_cb seelabels
    %   uicontrol:pushbutton:seepoints "See/Hidel Points" uses Callback for mritool_cb seepoints
    %   uicontrol:pushbutton:showfiducials "Show Fiducials" uses Callback for mritool_cb showfiducials
    %   uicontrol:pushbutton:slctpoint "Brighten" uses Callback for mritool_cb brighten
    %   uicontrol:pushbutton:slctpoint2 "Darken" uses Callback for mritool_cb darken
    %   uicontrol:pushbutton:slctpoint20 "Select" uses Callback for mritool_cb slctpoint
    %   uicontrol:pushbutton:slctpoint3 "Process fMRI Files" uses Callback for mritool_cb concatenate
    %   uicontrol:pushbutton:slctpoint5 "Load Generators" uses Callback for mritool_cb readresults
    %   uicontrol:radiobutton:ZoomButton1 "" uses Callback for mritool_cb ZoomButton
    %   uicontrol:radiobutton:ZoomButton2 "" uses Callback for mritool_cb ZoomButton
    %   uicontrol:radiobutton:ZoomButton3 "" uses Callback for mritool_cb ZoomButton
    %   uicontrol:slider:1 "" uses ButtonDownFcn for mritool_cb sliders
    %   uicontrol:slider:1 "" uses Callback for mritool_cb sliders
    %   uicontrol:slider:2 "" uses ButtonDownFcn for mritool_cb sliders
    %   uicontrol:slider:2 "" uses Callback for mritool_cb sliders
    %   uicontrol:slider:3 "" uses ButtonDownFcn for mritool_cb sliders
    %   uicontrol:slider:3 "" uses Callback for mritool_cb sliders
    %   uimenu:: "" uses Callback for mritool_cb fifmri
    %   uimenu::FileImport MR Scans.mri formatuimenu1 "" uses Callback for mritool_cb mrislice
    %   uimenu::FileImport MRI Data.mri format1 "" uses Callback for mritool_cb mriformat
    %   uimenu::FileRead MR Scansuimenu1 "" uses Callback for mritool_cb saveaxial
    %   uimenu::Fileuimenu3 "" uses Callback for mritool_cb SaveAsBrainstorm
    %   uimenu::Fileuimenu4 "" uses Callback for mritool_cb LoadBrainStorm
    %   uimenu::img format "" uses Callback for mritool_cb imgformat
    %   uimenu::Import/Export Cortical Remappinguimenu1 "" uses Callback for mritool_cb saveas_points
    %   uimenu::Import/Export Import MEG Cortical Mapsuimenu1 "" uses Callback for
    %     mritool_cb cortic_remap
    %   uimenu::Import/Export Read MR ScansLoad .mri formatuimenu1 "" uses Callback for mritool_cb ctfmri
    %   uimenu::Import/Export uimenu1 "" uses Callback for mritool_cb MEGBlobs
    %   uimenu::IMPORT_mridata "" uses Callback for mritool_cb IMPORT_mridata
    %
    % At Check-in: $Author: Mosher $  $Revision: 22 $  $Date: 6/14/04 3:38p $
    %
    % This software is part of BrainStorm Toolbox Version 2.0 (Alpha) 14-Jun-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> ------------------------ 14-Jun-2004 17:10:40 -----------------------

    %-- Sylvain Baillet, Ph.D.
    %-- Signal and Image Processing Institute
    %-- University of Southern Califonia
    %-- Los Angeles - USA

    % History ----------------------------------------------------------------------
    % 10/25/00 JCM    added alphabetization to mri slice routine
    % 04/20/01 SB -   Modified routine to import CTF format
    % JCM 08-Sep-2003 Commenting
    % SB  15-Dec-2003 Updated color scheme
    % JCM 19-May-2004 Change use of variable "dir" to "rootdir" line 4053
    % ------------------------------------------------------------------------------

    frontcolor = [.8 .8 0];
    TASKBAR = findobj(0,'Tag','TASKBAR');

    DEFAULTslice_thickness = 2;
    DEFAULTsiz = 256;
    line_color = [.7 .7 .0]; % Line color for coordinates display
    FORMATtick = '%2.1f';
    NGRAY_MAX = 255; % Max gray level value for the images

    %-----------------------------------------------------------------------------------------------

    switch action

    case 'create'
        MAINWINDOW = [];%findobj(0,'Tag','mainwindow');
        if isempty(MAINWINDOW)
            MAINWINDOW = openfig('mribox.fig','reuse');
            %MAINWINDOW = findobj(0,'Tag','mainwindow');
            % bst_color_scheme(MAINWINDOW); % doesn't work well
            setappdata(MAINWINDOW,'TileType','T');
            bst_color_scheme(MAINWINDOW)
            bst_layout('align',MAINWINDOW,1,1,1);
            set(MAINWINDOW,'visible','on')
        end

        %-----------------------------------------------------------------------------------------------

    case 'read_file_scan'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        listboxx = findobj(0,'Tag','listbox');
        set(listboxx,'visible','off')
        listboxx_title = findobj(MAINWINDOW,'Tag','listboxx_title');
        set(listboxx_title,'visible','off')
        legend_sources = findobj(MAINWINDOW,'Tag','legend_sources');
        set(legend_sources,'visible','off')

        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        ax = findobj(MAINWINDOW,'Tag','colorbar');
        if ~isempty(ax)
            set(ax,'Visible','off')
        end

        set(0,'CurrentFigure',   MAINWINDOW )
        mri_scan = get(gcf,'Userdata');

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');
        mri_scan.ptname = {};
        mri_scan.otherfig = [];
        mri_scan.ptcoord = [];
        mri_scan.pthandle  = [];
        mri_scan.ptlabels  = [];
        mri_scan.gotopoint = 0;
        mri_scan.seepoints = 0;
        mri_scan.seelabels = 1;
        %  mri_scan.pcs = 0;

        axs = findobj(MAINWINDOW,'Tag','axs');
        axc = findobj(MAINWINDOW,'Tag','axc');
        axa = findobj(MAINWINDOW,'Tag','axa');
        filename = mri_scan.filemri;
        set(file_mri,'Visible','on','String',filename);

        header =  mri_scan.header ;
        set(Header,'String',int2str(header))

        siz = mri_scan.siz;

        set(image_size,'String',num2str(siz,'%1d %1d'));
        if isempty(siz)
            siz = [DEFAULTsiz,DEFAULTsiz];
            h = warndlg('Image size field is empty - default value is [256 256]');
            uiwait(h);
        end
        if length(siz)==1
            siz = [siz,siz];
        end

        scan_type = mri_scan.scantype;

        fov = mri_scan.fov ;
        set(FOV,'String',num2str([fov(1),fov(2)],'%1.1f %1.1f'));
        if isempty(fov)
            fov = siz;
        end

        slice_thickness = mri_scan.slice_thick;
        set(SLICE_thickness ,'String',num2str(slice_thickness));
        if isempty(slice_thickness)
            slice_thickness  = DEFAULTslice_thickness;
            warndlg(['Slice thickness field empty - using default',num2str(DEFAULTslice_thickeness)])
        end

        nslice = mri_scan.nslice;
        set(NSLICE,'String',int2str(nslice));

        if isempty(nslice)
            errordlg('Please enter the number of slices')
            return
        end
        set(NSLICE,'String',num2str(nslice));

        siz_tmp = siz;

        clear siz_tmp scan_type_tmp

        fov(3) = nslice*slice_thickness;

        code = mri_scan.code;

        if (~mri_scan.readslice)& ~isfield(mri_scan,'mri')

            file_mri = fopen(filename,'r',MACHINEFORMAT);
            if file_mri < 1
                disp('Invalid File Name')
                return;
            end

            fseek(file_mri,header,'bof');

            mri_scan.mri = uint8(zeros(siz(1),siz(2),nslice));

            h= waitbar(0,'Please wait...');
            for i = 1:nslice
                if feof(file_mri)
                    errordlg('Please Check Image size / Number of Slices : do not match file size')
                    return
                end
                mri_scan.mri(:,:,i) = uint8(fread(file_mri,[siz],code));
                waitbar(i/nslice)   ;

            end
            fclose(file_mri);
            delete(h);
        else
            %   mri = mri_scan.mri;
        end

        pix_siz = [fov(1)/(siz(1)-1) fov(2)/(siz(2)-1) slice_thickness];

        if strcmp(scan_type,'Coronal')
            mri_scan.mri = permute(mri_scan.mri,[1,3,2]);
        elseif strcmp(scan_type,'Sagittal')
            mri_scan.mri = permute(mri_scan.mri,[3,1,2]);
        end

        tmp = size(mri_scan.mri);
        siz = tmp(1:2);
        nslice = tmp(3);

        if strcmp(scan_type,'Coronal')
            pix_siz  = pix_siz([3,2,1]);
            fov = fov([3,2,1]);
        elseif strcmp(scan_type,'Sagittal')
            pix_siz  = pix_siz([1,3,2]);
            fov = fov([1,3,2]);
        end

        mri_scan.pix_siz = pix_siz;
        mri_scan.fov = fov;

        ic = round(siz(2)/2); % Image indices for coronal,sagittal and axial slices respectively
        is = round(siz(1)/2);
        ia = round(nslice/2);

        mri_scan.ic = ic;
        mri_scan.is = is;
        mri_scan.ia = ia;

        % Delete all previous points
        delete(findobj(get(axa,'children'),'type','patch'))
        delete(findobj(get(axc,'children'),'type','patch'))
        delete(findobj(get(axs,'children'),'type','patch'))
        delete(findobj(get(axa,'children'),'type','line'))
        delete(findobj(get(axc,'children'),'type','line'))
        delete(findobj(get(axs,'children'),'type','line'))

        ngray = 256;
        %M = (max(max(mri_scan.mri(:,:,round(size(mri_scan.mri,3)/2)))));

        M = double(max(mri_scan.mri(:))); % May be rather time consuming if limited RAM is availlable

        if M > (ngray-1)
            % Scale gray levels to 255 to save the MRI in uint8
            % Memory requirememts necessitate a slice-by-slice loop on most machines
            hw = waitbar(0,'Scaling the MRI to 256 gray levels...');
            for k = 1:size(mri_scan.mri,3)
                waitbar(k/size(mri_scan.mri,3),hw);
                tmp = double(mri_scan.mri(:,:,k)) ;
                mri_scan.mri(:,:,k) = int16(tmp * ((ngray - 1 )/M)) ;
            end

            mri_scan.mri = uint8(mri_scan.mri);
            delete(hw)
            drawnow
        end

        %% -- Axial View
        axes(axa)
        ax = imagesc([0, fov(1)],[0,fov(2)],(mri_scan.mri(:,:,ia)),'Parent',axa);
        set(axa,'Tag','axa','Units','Normal');
        set(axa,'visible','on','xcolor',line_color ,'Ycolor',line_color,'Color','k');
        mri_scan.ax = ax;
        mri_scan.axa = axa;
        set(axa,'box','on','layer','top','xgrid','on','xtick',[],'ygrid','on','ytick',[],'gridlinestyle','-')
        axis([0 fov(1), 0 fov(2)])
        set(ax,'erasemode','none');
        caxis([0 ngray-1])
        axis equal
        %% -- Axial view Done

        %% -- Sagittal view
        axes(axs)
        sag = imagesc([0 fov(1)],[0 fov(3)],((fliplr(squeeze(mri_scan.mri(is,:,:))))'),'Parent',axs);
        set(axs,'Tag','axs','Units','Normal');
        mri_scan.sag = sag;
        mri_scan.axs = axs;
        set(axs,'color',[0 0 0],'box','on','layer','top','xgrid','on','xtick',[],'ygrid','on','ytick',[],'gridlinestyle','-')
        set(axs,'visible','on','xcolor',line_color ,'Ycolor',line_color,'DataAspectRatioMode','auto' );
        axis([0 fov(1), 0 fov(3)])
        set(sag,'erasemode','none');
        set(axs,'Xlim', get(axa,'Xlim'))
        caxis([0 ngray-1])
        axis equal
        %% -- Sagittal view Done

        %% -- Coronal view
        axes(axc)
        cor = imagesc([0 fov(2)],[0 fov(3)],(fliplr(flipud(squeeze(mri_scan.mri(:,ic,:))'))),'Parent',axc);
        set(axc,'Tag','axc','Units','Normal');
        mri_scan.cor = cor;
        mri_scan.axc = axc;
        set(axc,'color',[0 0 0],'box','on','layer','top','xgrid','on','xtick',[],'ygrid','on','ytick',[],'gridlinestyle','-')
        set(axc,'visible','on','xcolor',line_color ,'Ycolor',line_color,'DataAspectRatioMode','auto');
        axis([0 fov(2), 0 fov(3)])
        set(cor,'erasemode','none');
        set(axc,'Xlim', get(axa,'Ylim'),'Ylim', get(axs,'Ylim'))
        caxis([0 ngray-1])
        axis equal

        axes(axa)
        set(axa,'Xlim', get(axs,'Xlim'),'Ylim', get(axc,'Xlim'))
        axis equal
        axes(axs)
        set(axs,'Xlim', get(axa,'Xlim'),'Ylim', get(axc,'Ylim'))
        axis equal
        axes(axc)
        set(axc,'Xlim', get(axa,'Ylim'),'Ylim', get(axs,'Ylim'))
        axis equal
        %% -- Coronal view Done

        eval(['colormap bone(',int2str(ngray),');']);

        s1 = findobj(gcbf,'Tag','1');
        s2 = findobj(gcbf,'Tag','2');
        s3 = findobj(gcbf,'Tag','3');
        set(s1,'Visible','on','Min', 0,'Max',fov(2),'Value',is*pix_siz(2))
        set(s2,'Visible','on','Min', 0,'Max',fov(3),'Value',ia*pix_siz(3))
        set(s3,'Visible','on','Min', 0,'Max',fov(1),'Value',ic*pix_siz(1))

        ind = 1;

        set(MAINWINDOW,'Userdata',mri_scan)
        set([sag,ax,cor],'ButtonDownFcn','mritool_cb gotopoint')

        %-----------------------------------------------------------------------------------------------

    case 'brighten'
        MAINWINDOW = gcbf;
        axs = findobj(MAINWINDOW,'Tag','axs');
        axc = findobj(MAINWINDOW,'Tag','axc');
        axa = findobj(MAINWINDOW,'Tag','axa');

        clim = get(axs,'CLim');
        set(axs,'CLim',.9*clim)
        set(axa,'CLim',.9*clim)
        set(axc,'CLim',.9*clim)

        %-----------------------------------------------------------------------------------------------

    case 'darken'

        MAINWINDOW = gcbf;
        axs = findobj(MAINWINDOW,'Tag','axs');
        axc = findobj(MAINWINDOW,'Tag','axc');
        axa = findobj(MAINWINDOW,'Tag','axa');

        clim = get(axs,'CLim');
        set(axs,'CLim',1.1*clim)
        set(axa,'CLim',1.1*clim)
        set(axc,'CLim',1.1*clim)

        %-----------------------------------------------------------------------------------------------

    case 'importANALYZE' % Import anatomical image in ANALYZE format  - still needs to be done (I've just cut and paste the importBlobs section below)

        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        MAINWINDOW = gcbf;
        set(0,'CurrentFigure',MAINWINDOW )
        mri_scan = get(gcbf,'Userdata');

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        axs = findobj(MAINWINDOW,'Tag','axs');
        axc = findobj(MAINWINDOW,'Tag','axc');
        axa = findobj(MAINWINDOW,'Tag','axa');

        s1 = findobj(gcbf,'Tag','1');
        s2 = findobj(gcbf,'Tag','2');
        s3 = findobj(gcbf,'Tag','3');

        % -----

        fig = MAINWINDOW;

        %set(fig,'colormap',bone(64))

        %% ---
        Current = get_user_directory;
        cd(Current.SUBJECTS)

        [anatfile, anatpath] = uigetfile('*.img','Please select the high-resolution MRI file (.img)' );
        if (anatfile == 0), return, end
        cd(anatpath);
        eval('V = spm_vol(anatfile);','ok=0;');
        Vorig = V.mat;
        clear V

        [blobfile, blobpath] = uigetfile('*.img','Please select the file containing functional blobs');
        if (blobfile == 0), return, end
        cd(blobpath);

        eval('V = spm_vol(blobfile);','ok=0;');

        %---------------------------------------
        % Read img volume

        header = 0;
        mri_scan.blob.header = header;

        siz = [V.dim(1), V.dim(2)];
        mri_scan.blob.siz = siz;

        mri_scan.blob.scantype= 'Axial';

        mri_scan.blob.nslice = V.dim(3);

        mri_scan.code = 'uint8'; % That's all folks !

        blob = zeros(siz(1),siz(2),mri_scan.blob.nslice);

        disp('Reading functional files...');
        file = fopen(V.fname,'rb',MACHINEFORMAT);
        fseek(file,header,'bof');
        for i= 1:mri_scan.blob.nslice%:-1:1 % Lower Slice first
            if feof(file)
                msgbox('Please check that data is of ''uint8'' type', 'BrainStorm Message')
                errordlg('Please Check Image size / Number of Slices : do not match file size')
                return
            end
            blob(:,:,i) = (fread(file,[siz(1),siz(2)],mri_scan.code));
            %waitbar((mri_scan.blob.nslice-i)/mri_scan.blob.nslice);
        end
        fclose(file);
        disp('Reading functional files... -> Done');

        mri_scan.blob.scan = blob;
        mri_scan.blob.V = V;

        eval('mri_scan.blob')

        %% --- reading of the functional file completed

        %% -- Interpolation to the resolution of the anatomical MR scan

        pix_siz = mri_scan.pix_siz ;  % Voxel size of the anatomical MR scan

        %% -- Reslicing
        disp('Reslicing functional scans...')
        [XI,YI] = meshgrid(linspace(1,size(blob,1),mri_scan.siz(1)),linspace(1,size(blob,2),mri_scan.siz(2)));
        iblob = zeros(mri_scan.siz(2),mri_scan.siz(1),size(blob,3));
        for i=1:size(blob,3)
            iblob(:,:,i) = interp2(blob(:,:,i),XI,YI,'*linear');
        end
        scale_func = (size(blob));
        clear blob
        % Interpolate along the z-axis

        [qo,ro] = qr(Vorig(1:3,1:3));
        [q,r] = qr(V.mat(1:3,1:3));

        scale = abs(r(9)/ro(9)); % Scaling along the z-axis
        n_slice = floor(scale * size(iblob,3));

        iiblob = zeros(size(iblob,1),size(iblob,2),n_slice);
        iiblob(:,:,1:floor(n_slice/2)) = repmat(iblob(:,:,1),[1,1,length(1:floor(n_slice/2))]);
        iiblob(:,:,floor(n_slice/2)+1:(n_slice)) = repmat(iblob(:,:,2),[1,1,length(floor(n_slice/2)+1:(n_slice))]);

        clear iblob

        % Position of the functional blobs in mm
        [iorig] = find(iiblob);
        t = iiblob(iorig); % Effects
        [i,j,k] = ind2sub(size(iiblob),iorig);
        xyz = [i';j';k'];
        clear i j k

        ROTmri2mm = (V.mat(1:3,1:3));
        TRANSmri2mm = V.mat(1:3,4);

        Vorig = inv(Vorig);
        ROTmm2mri = Vorig(1:3,1:3);
        TRANSmm2mri = Vorig(1:3,4);

        % Rescale in original voxel units
        %scale_func = (size(blob));
        scale_anat= (size(iiblob));
        scale = diag( scale_func./scale_anat);
        xyz = scale*xyz ;

        xyz =  ROTmri2mm* xyz + repmat((TRANSmri2mm),1, size(xyz,2));
        xyz = round(ROTmm2mri * xyz + repmat(TRANSmm2mri,1, size(xyz,2)));

        mri_scan.CubeOrigin = Vorig(1:3,4);%round([ORI./scale]'); % Indices of the slices containing the origin

        mri_scan.blob.Cube = xyz;

        %iiiblob = zeros(size(mri_scan.mri,1),size(mri_scan.mri,2),size(mri_scan.mri,3));
        sizz = size(mri_scan.mri);
        tt = sub2ind([sizz],mri_scan.blob.Cube(1,:),mri_scan.blob.Cube(2,:),mri_scan.blob.Cube(3,:));

        % For Kevin ----- flip U/D
        tmp = zeros(size(iiblob(:,:,1)));
        for k = 1:size(iiblob,3)
            tmp = flipud(iiblob(:,:,k));
            %  iiblob(:,:,k) = tmp;
        end
        clear tmp

        [iorig] = find(iiblob);
        t = iiblob(iorig); % Effects
        clear iiblob
        %iiiblob(tt(t>0*mean(t))) =  64+(t(t>0*mean(t))+eps)*64/max(t);
        mri_scan.mri(tt(t>0*mean(t))) =  64+(t(t>0*mean(t))+eps)*64/max(t);

        %%%----- Superimpose to regular MRI
        %  mri_scan.mri = mri_scan.mri + iiiblob;

        [Mt,ind] = max(t);
        tmp = mri_scan.blob.Cube(:,ind);

        clear blob iblob iiblob iiiblob

        ia = tmp(3);
        ic = tmp(2);
        is = tmp(1);

        ax = mri_scan.ax;
        sag = mri_scan.sag;
        cor = mri_scan.cor;

        set(sag ,'CData',(flipud(squeeze(mri_scan.mri(is,:,:))')),'erasemode','normal');
        set(get(sag,'Parent'),'CLim',[0 128])
        set(cor ,'CData',(fliplr(flipud(squeeze(mri_scan.mri(:,ic,:))'))),'erasemode','normal');
        set(get(cor,'Parent'),'CLim',[0 128])
        set(ax ,'CData',(mri_scan.mri(:,:,ia)),'erasemode','normal');
        set(get(ax,'Parent'),'CLim',[0 128])

        set(MAINWINDOW,'Userdata',mri_scan);

        split(1:64,:) = bone(64);
        split(65:128,:) = hot(64);

        ax = findobj(MAINWINDOW,'Tag','colorbar');
        axes(ax)
        colormapp = split(65:end,:);
        n = size(colormapp,1);
        image([0, 1], [0 10],(n+1:2*n)');
        set(ax,'Ydir','normal','Tag','colorbar')
        set(ax,'xtick',[],'ycolor',frontcolor,'xcolor',frontcolor)
        colormap(split)

        %-----------------------------------------------------------------------------------------------

    case 'addblobs' % Add functional blobs as written in a .img (SPM compliant) format

        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        MAINWINDOW = gcbf;
        set(0,'CurrentFigure',MAINWINDOW )
        mri_scan = get(gcbf,'Userdata');

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        axs = findobj(MAINWINDOW,'Tag','axs');
        axc = findobj(MAINWINDOW,'Tag','axc');
        axa = findobj(MAINWINDOW,'Tag','axa');

        s1 = findobj(gcbf,'Tag','1');
        s2 = findobj(gcbf,'Tag','2');
        s3 = findobj(gcbf,'Tag','3');

        % -----

        fig = MAINWINDOW;

        %set(fig,'colormap',bone(64))

        %% ---
        Current = get_user_directory;
        cd(Current.SUBJECTS)

        [anatfile, anatpath] = uigetfile('*.img','Please select the high-resolution MRI file (.img)' );
        if (anatfile == 0), return, end
        cd(anatpath);
        eval('V = spm_vol(anatfile);','ok=0;');
        Vorig = V.mat;
        clear V

        [blobfile, blobpath] = uigetfile('*.img','Please select the file containing functional blobs');
        if (blobfile == 0), return, end
        cd(blobpath);

        eval('V = spm_vol(blobfile);','ok=0;');

        %---------------------------------------
        % Read img volume

        header = 0;
        mri_scan.blob.header = header;

        siz = [V.dim(1), V.dim(2)];
        mri_scan.blob.siz = siz;

        mri_scan.blob.scantype= 'Axial';

        mri_scan.blob.nslice = V.dim(3);

        mri_scan.code = 'uint8'; % That's all folks !

        blob = zeros(siz(1),siz(2),mri_scan.blob.nslice);

        disp('Reading functional files...');
        file = fopen(V.fname,'rb',MACHINEFORMAT);
        fseek(file,header,'bof');
        for i= 1:mri_scan.blob.nslice%:-1:1 % Lower Slice first
            if feof(file)
                msgbox('Please check that data is of ''uint8'' type', 'BrainStorm Message')
                errordlg('Please Check Image size / Number of Slices : do not match file size')
                return
            end
            blob(:,:,i) = (fread(file,[siz(1),siz(2)],mri_scan.code));
            %waitbar((mri_scan.blob.nslice-i)/mri_scan.blob.nslice);
        end
        fclose(file);
        disp('Reading functional files... -> Done');

        mri_scan.blob.scan = blob;
        mri_scan.blob.V = V;

        eval('mri_scan.blob')

        %% --- reading of the functional file completed

        %% -- Interpolation to the resolution of the anatomical MR scan

        pix_siz = mri_scan.pix_siz ;  % Voxel size of the anatomical MR scan

        %% -- Reslicing
        disp('Reslicing functional scans...')
        [XI,YI] = meshgrid(linspace(1,size(blob,1),mri_scan.siz(1)),linspace(1,size(blob,2),mri_scan.siz(2)));
        iblob = zeros(mri_scan.siz(2),mri_scan.siz(1),size(blob,3));
        for i=1:size(blob,3)
            iblob(:,:,i) = interp2(blob(:,:,i),XI,YI,'*linear');
        end
        scale_func = (size(blob));
        clear blob
        % Interpolate along the z-axis

        [qo,ro] = qr(Vorig(1:3,1:3));
        [q,r] = qr(V.mat(1:3,1:3));

        scale = abs(r(9)/ro(9)); % Scaling along the z-axis
        n_slice = floor(scale * size(iblob,3));

        iiblob = zeros(size(iblob,1),size(iblob,2),n_slice);
        iiblob(:,:,1:floor(n_slice/2)) = repmat(iblob(:,:,1),[1,1,length(1:floor(n_slice/2))]);
        iiblob(:,:,floor(n_slice/2)+1:(n_slice)) = repmat(iblob(:,:,2),[1,1,length(floor(n_slice/2)+1:(n_slice))]);

        clear iblob

        % Position of the functional blobs in mm
        [iorig] = find(iiblob);
        t = iiblob(iorig); % Effects
        [i,j,k] = ind2sub(size(iiblob),iorig);
        xyz = [i';j';k'];
        clear i j k

        ROTmri2mm = (V.mat(1:3,1:3));
        TRANSmri2mm = V.mat(1:3,4);

        Vorig = inv(Vorig);
        ROTmm2mri = Vorig(1:3,1:3);
        TRANSmm2mri = Vorig(1:3,4);

        % Rescale in original voxel units
        %scale_func = (size(blob));
        scale_anat= (size(iiblob));
        scale = diag( scale_func./scale_anat);
        xyz = scale*xyz ;

        xyz =  ROTmri2mm* xyz + repmat((TRANSmri2mm),1, size(xyz,2));
        xyz = round(ROTmm2mri * xyz + repmat(TRANSmm2mri,1, size(xyz,2)));

        mri_scan.CubeOrigin = Vorig(1:3,4);%round([ORI./scale]'); % Indices of the slices containing the origin

        mri_scan.blob.Cube = xyz;

        %iiiblob = zeros(size(mri_scan.mri,1),size(mri_scan.mri,2),size(mri_scan.mri,3));
        sizz = size(mri_scan.mri);
        tt = sub2ind([sizz],mri_scan.blob.Cube(1,:),mri_scan.blob.Cube(2,:),mri_scan.blob.Cube(3,:));

        % For Kevin ----- flip U/D
        tmp = zeros(size(iiblob(:,:,1)));
        for k = 1:size(iiblob,3)
            tmp = flipud(iiblob(:,:,k));
            %  iiblob(:,:,k) = tmp;
        end
        clear tmp

        [iorig] = find(iiblob);
        t = iiblob(iorig); % Effects
        clear iiblob
        %iiiblob(tt(t>0*mean(t))) =  64+(t(t>0*mean(t))+eps)*64/max(t);
        mri_scan.mri(tt(t>0*mean(t))) =  64+(t(t>0*mean(t))+eps)*64/max(t);

        %%%----- Superimpose to regular MRI
        %  mri_scan.mri = mri_scan.mri + iiiblob;

        [Mt,ind] = max(t);
        tmp = mri_scan.blob.Cube(:,ind);

        clear blob iblob iiblob iiiblob

        ia = tmp(3);
        ic = tmp(2);
        is = tmp(1);

        ax = mri_scan.ax;
        sag = mri_scan.sag;
        cor = mri_scan.cor;

        set(sag ,'CData',(flipud(squeeze(mri_scan.mri(is,:,:))')),'erasemode','normal');
        set(get(sag,'Parent'),'CLim',[0 128])
        set(cor ,'CData',(fliplr(flipud(squeeze(mri_scan.mri(:,ic,:))'))),'erasemode','normal');
        set(get(cor,'Parent'),'CLim',[0 128])
        set(ax ,'CData',(mri_scan.mri(:,:,ia)),'erasemode','normal');
        set(get(ax,'Parent'),'CLim',[0 128])

        set(MAINWINDOW,'Userdata',mri_scan);

        split(1:64,:) = bone(64);
        split(65:128,:) = hot(64);

        ax = findobj(MAINWINDOW,'Tag','colorbar');
        axes(ax)
        colormapp = split(65:end,:);
        n = size(colormapp,1);
        image([0, 1], [0 10],(n+1:2*n)');
        set(ax,'Ydir','normal','Tag','colorbar')
        set(ax,'xtick',[],'ycolor',frontcolor,'xcolor',frontcolor)
        colormap(split)

        %-----------------------------------------------------------------------------------------------

    case 'cortic_remap'

        %%% ---- Cotical Remapping of parametric sources on the cortex

        MAINWINDOW = gcbf;
        mri_scan = get(MAINWINDOW ,'Userdata');
        if isempty(mri_scan), return, end

        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        pix_siz = mri_scan.pix_siz;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');

        User = get_user_directory;
        cd(User.STUDIES)

        % Load result file

        [result_file,result_dir] = uigetfile('*result*.mat','Load Result File...');
        if result_file == 0, return, end

        cd(result_dir)
        Results = load(result_file);

        nsource = length(Results.SourceLoc);

        % Look for synchronous sources
        isync = find(Results.SourceOrder==2 | Results.SourceOrder==3 |Results.SourceOrder==4);
        insync = setdiff(1:nsource,isync);
        SourceOrder_old = Results.SourceOrder;

        trans = zeros(size(Results.SourceOrder,2),nsource);

        i = 1;
        for src = 1:length(SourceOrder_old)
            if ~isempty(isync) & ~isempty(find(isync==src))
                Results.SourceOrder(i) = SourceOrder_old(src);
                Results.SourceOrder(i+1) = SourceOrder_old(src);
                ptname{i} = int2str(src);
                ptname{i+1} = int2str(src);
                SourceLoc(:,i:i+1) = Results.SourceLoc{src};
                COLOR(i,:) = [min(.3+abs(rand),1) min(.3+abs(rand),1) min(.3+abs(rand),1) ];
                COLOR(i+1,:) = COLOR(i,:);
                i = i+2;
            else
                Results.SourceOrder(i) = SourceOrder_old(src);
                ptname{i} = int2str(src);
                SourceLoc(:,i) = Results.SourceLoc{src};
                COLOR(i,:) = [min(.3+abs(rand),1) min(.3+abs(rand),1) min(.3+abs(rand),1) ];
                i = i+1;
            end
        end

        nsource = size(SourceLoc,2);

        j = 1;

        for i = 1:nsource
            ptcoord(i,:) = 1000*SourceLoc(:,i)';
            icoord(i,:) = [0 0 0];

            if mri_scan.pcs == 0
                orig = findstr(ptname{i},'originPCS');
                if ~isempty(orig) % This set of points can be registered owing to a MEG-EEG PCS.
                    mri_scan.pcs = 1;
                    mri_scan.pcs_type = ptname{i}(findstr(ptname{i},'_')+1:end);
                    mri_scan.center = icoord;
                    center = icoord(i,:);
                    ptcenter = ptcoord(i,:)
                else
                    mri_scan.pcs = 0;
                    mri_scan.pcs_type = 'NONE';
                    center = [0 0 0];
                end
            end

        end
        fclose all;
        disp('')

        % Load result file : END

        % Load tessellation information
        cd(User.SUBJECTS)
        load(Results.StudySubject.Subject)

        % Load Head Model: is a cortical gain matrix available ?
        cd(User.STUDIES)
        load(Results.StudySubject.HeadModel,'ImageGain')
        if isempty([ImageGain{:}]), errodlg('No cortical gain matrix was defined - remapping aborted'), return, end
        flag = zeros(1,length(ImageGain));
        for k = 1:length(ImageGain)
            flag(k) = ~isempty(ImageGain{k});
        end
        igain = find(flag);
        ImageGain = ImageGain{k};

        if isempty(Tesselation), errordlg('Subject has no cortical tessellation - remapping aborted'), return, end
        cd(User.SUBJECTS)
        load(Tesselation)

        disp(' ')
        fprintf('%s\t',Comment{igain})
        fprintf('%\n')
        disp(' ')
        %itess = input(['Which cortical tessellation would you like to use here ? (',deblank(num2str(igain)),') : ']);
        itess = 5; % CHEAT for Kevin  -for silvin : 5

        tess.vertices = Vertices{itess}'; clear Vertices
        tess.faces = Faces{itess}; clear Faces
        Comment = Comment{itess};

        % Load ImageGain matrix
        [PATH,NAME,EXT,VER] = fileparts( Results.StudySubject.Study);
        file = fopen(fullfile(User.STUDIES,PATH,ImageGain{:} ),'r',MACHINEFORMAT);
        if file <0, errordlg('Unable to open the head model file'), return, end
        G = get_gain(file, 1:size(tess.vertices,1));

        % Channels
        load(fullfile(User.STUDIES,Results.StudySubject.Channel))
        ndx = good_channel(Channel,Results.ChannelFlag,'meg'); % CHEAT meg only here

        G = G(ndx,:);
        verbose = 1;
        % Vertex Connectivity
        if isempty(VertConn)
            disp('Computing Vertex Connectivity on for this tessellation')
            drawnow
            vertconn = vertices_connectivity(tess,verbose);
            disp('Saving Connectivity Information...')
            drawnow
            [PATH,NAME,EXT,VER] = fileparts(Results.StudySubject.Subject);
            VertConn = fullfile(PATH,'VertConn.mat');
            save(fullfile(User.SUBJECTS,VertConn),'vertconn') ;
            disp('Updating Subject Information...')
            drawnow
            save(Results.StudySubject.Subject,'VertConn','-append')
            disp('Updating Subject Information...DONE')
            drawnow
        else
            load(VertConn)
        end

        % Cortical Remapping
        disp(' ')
        fprintf('Remapping Sources on Tessellation %s \n',Comment)
        nseeds = 1;
        for k = 1:size(Results.IndepTopo,2)
            [amps{k},csources{k}] = corti_remap(tess,vertconn,G,Results.IndepTopo(:,k),nseeds,verbose);
        end
        amps = [amps{:}];

        mri_scan.M = max(abs(Results.TimeSeries(:)));

        mri_scan.climm = ceil(max(get(axa,'Clim')));
        Results.TimeSeries = Results.TimeSeries*mri_scan.climm/mri_scan.M;

        for k = 1:length(csources)
            mri_scan.TimeSeries{k} = Results.TimeSeries(:,k);
        end

        icsources = [csources{:}];

        %%%% Interpolation of the Cortical Current Density Image
        if ~exist('interp_mat.mat','file')
            % Transform PCS coordinates in the MRI volume reference system
            switch mri_scan.pcs_type
            case {'NEUROMAG','CTF'}
                if ~isfield(mri_scan,'rot')
                    errordlg('Please Define a PCS First')
                    return
                end
                center = mri_scan.center;
                rot = mri_scan.rot;
                mri_scan.mript = (inv(rot)*tess.vertices')';
            end

            mri_scan.mript (:,1) = mri_scan.mript (:,1) + center(1);
            mri_scan.mript (:,2) = mri_scan.mript (:,2) + center(2);
            mri_scan.mript (:,3) = mri_scan.mript (:,3) + center(3);
            clear icoord
            icoord(:,1) = round((get(s1,'Max')-mri_scan.mript (:,2))/mri_scan.pix_siz(2)+1);
            icoord(:,2) = round(mri_scan.mript (:,1)/mri_scan.pix_siz(1)+1);
            icoord(:,3) = round((get(s2,'Max')-mri_scan.mript (:,3))/mri_scan.pix_siz(3)+1);
            [H] = tri_interp(size(mri_scan.mri),icoord, tess.faces)   ;
            disp('Saving Interpolation Matrix')
            User = get_user_directory;
            save interp_mat H
            clear tess vertconn G Results
        else
            clear tess vertconn G Results
            load interp_mat
        end

        H = H(:,icsources);

        mri_scan.GridAmp = ones(size(icsources))';%abs(amps(csources)); clear amps
        %mri_scan.GridAmp  = norlig(mri_scan.GridAmp ); % See integrated activity at each vertex along time
        mri_scan.csources = csources;

        mri_scan.M = max(mri_scan.GridAmp);

        mri_scan.mri(mri_scan.mri >= mri_scan.climm) = mri_scan.climm;
        mri_scan.GridAmp = mri_scan.GridAmp*mri_scan.climm/mri_scan.M;
        mri_scan.thres = 0*mri_scan.climm; % Threshold for visualization of current density

        %CInterp = sparse(size(H,1),1,1000*length(csources));
        CInterp = sparse(H*mri_scan.GridAmp);% OK If enough memory is available

        if 0
            tmp = sum(H,2);
            ind = find(tmp);
            blocks = unique(round(linspace(1,length(ind),100)));
            hwait = waitbar(0,'Interpolating the volumic curreny density...' );
            for k = 1:length(blocks)
                waitbar(blocks(k)/blocks(end),hwait)
                if k > 1
                    vec = ind(blocks(k-1)+1:blocks(k));
                else
                    vec = ind(1:blocks(1));
                end
                CInterp(vec) = sparse(H(vec , :)*mri_scan.GridAmp);
            end
            delete(hwait)
            ind2 =find(CInterp(ind)>=mri_scan.thres);
            mri_scan.mri(ind(ind2)) = 1.01*mri_scan.climm + nonzeros(CInterp(ind(ind2)));
        end

        ind =find(CInterp>mri_scan.thres);
        mri_scan.indmodif = ind; % indices of the voxels with modified grey levels
        mri_scan.gl_orig = mri_scan.mri(ind);

        %mri_scan.mri(ind) = round(1.01*mri_scan.climm + nonzeros(CInterp(ind)));
        mri_scan.mri(ind) = double(mri_scan.mri(ind)) + .9*nonzeros(CInterp(ind));
        minn = double(min(mri_scan.mri(ind)));
        mri_scan.mri(ind) =  double(mri_scan.mri(ind)) - minn + mri_scan.climm+1;
        maxx = double(max(mri_scan.mri(ind)));
        mri_scan.climm = round(maxx/2);
        %mri_scan.mri(ind) = log(double(mri_scan.mri(ind))+1); % Make the cortical remaps look more yellow

        % Assign time series to vertices
        mri_scan.GridAmp  = zeros(size(H,2),size(mri_scan.TimeSeries{1},1));

        for k = 1:length(mri_scan.csources)
            mri_scan.GridAmp(mri_scan.csources{k},:) = repmat(mri_scan.TimeSeries{k}',length(mri_scan.csources{k}),1);
        end
        mri_scan.GridAmp =  mri_scan.GridAmp([mri_scan.csources{:}],:);

        mags = mri_scan.GridAmp;

        save kevin_remap mags csources

        clear mags

        clear H mri_scan.GridAmp

        [M tmp] = max(mri_scan.mri(ind));
        [is ic ia] = ind2sub(size(mri_scan.mri),ind((tmp)));

        ax = mri_scan.ax;
        sag = mri_scan.sag;
        cor = mri_scan.cor;

        set(sag ,'CData',(flipud(squeeze(mri_scan.mri(is,:,:))')),'erasemode','none');
        set(get(sag,'Parent'),'CLim',[0 2*mri_scan.climm])
        set(cor ,'CData',(fliplr(flipud(squeeze(mri_scan.mri(:,ic,:))'))),'erasemode','none');
        set(get(cor,'Parent'),'CLim',[0 2*mri_scan.climm])
        set(ax ,'CData',(mri_scan.mri(:,:,ia)),'erasemode','none');
        set(get(ax,'Parent'),'CLim',[0  2*mri_scan.climm])

        split(1:mri_scan.climm,:) = bone(mri_scan.climm);
        split(mri_scan.climm+1:2*mri_scan.climm,:) = hot(mri_scan.climm);

        mri_scan.split = split;

        set(MAINWINDOW,'Userdata',mri_scan);

        split(1:mri_scan.climm,:) = bone(mri_scan.climm);
        split(mri_scan.climm+1:2*mri_scan.climm,:) = hot(mri_scan.climm);

        ax = findobj(MAINWINDOW,'Tag','colorbar');
        axes(ax)
        colormapp = split( mri_scan.climm+1:end,:);
        n = size(colormapp,1);
        image([0, 1], [0 10],(n+1:2*n)');
        set(ax,'Ydir','normal','Tag','colorbar')
        set(ax,'xtick',[],'ycolor',frontcolor,'xcolor',frontcolor)
        colormap(split)

        %-----------------------------------------------------------------------------------------------

    case 'cortic_remap_update'

        %%% ---- Update of the Cortical Remapping of parametric sources on the cortex

        MAINWINDOW = gcf;
        mri_scan = get(MAINWINDOW ,'Userdata');
        if isempty(mri_scan), return, end

        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        pix_siz = mri_scan.pix_siz;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');
        mri_scan.is = round((get(s1,'Max')-get(s1,'Value'))/pix_siz(2));
        mri_scan.ia= round(get(s2,'Value')/pix_siz(3));
        mri_scan.ic = round(get(s3,'Value')/pix_siz(1));

        % Load interpolation matrix
        User = get_user_directory;
        cd(User.SUBJECTS)
        load interp_mat
        H = H(:,[mri_scan.csources{:}]);

        mri_scan.thres = 0*mri_scan.climm; % Threshold for visualization of current density

        %CInterp = sparse(size(H,1),size(mri_scan.GridAmp,2));
        % clear H

        ax = mri_scan.ax;
        sag = mri_scan.sag;
        cor = mri_scan.cor;

        %figure
        %plot([mri_scan.TimeSeries{:}])
        M = norlig(mri_scan.GridAmp)';
        CInterp = sparse(H*M);
        indd = find(CInterp>.2*max(M));
        CInterp = sparse(H(indd,:)*abs(mri_scan.GridAmp));

        fig = figure;
        set(gcf,'Color','k','Units','normal','position',[.05 .5 .80 .3])

        axa2 = subplot(133);
        axc2 = subplot(132);
        axs2 = subplot(131);

        pax = 1*get(axa,'position');
        pax2 = get(axa2,'position');
        paxc = 1*get(axc,'position');
        paxc2 = get(axc2,'position');
        paxs = 1*get(axs,'position');
        paxs2 = get(axs2,'position');

        cop = copyobj([axs axc axa],gcf);
        set(cop,'units','normal')
        set(cop(3),'position',[pax2(1) pax2(2) pax(3) pax(4)])
        set(cop(2),'position',[paxc2(1) paxc2(2) paxc(3) paxc(4)])
        set(cop(1),'position',[paxs2(1) paxs2(2) paxs(3) paxs(4)])

        delete([axa2 axc2 axs2])

        colormap(mri_scan.split)

        pause

        for time = 1:1:size(mri_scan.GridAmp,2)
            time
            %CInterp = sparse(H*abs(mri_scan.GridAmp(:,time)));
            % Reset MRI to original
            mri_scan.mri( mri_scan.indmodif) =  mri_scan.gl_orig;
            ind = find(CInterp(:,time)>mri_scan.thres);
            mri_scan.indmodif= ind; % indices of the voxels with modified grey levels
            mri_scan.gl_orig = mri_scan.mri(ind);
            mri_scan.mri(indd(ind)) = round(1.01*mri_scan.climm + nonzeros(CInterp(ind,time)));
            set(findobj(cop(1),'Type','image') ,'CData',(flipud(squeeze(mri_scan.mri(mri_scan.is,:,:))')),'erasemode','none');
            set(findobj(cop(2),'Type','image') ,'CData',(fliplr(flipud(squeeze(mri_scan.mri(:,mri_scan.ic,:))'))),'erasemode','none');
            set(findobj(cop(3),'Type','image') ,'CData',(mri_scan.mri(:,:,mri_scan.ia)),'erasemode','none');
            drawnow
            pause(.1)
        end

        set(MAINWINDOW,'Userdata',mri_scan)

        %-----------------------------------------------------------------------------------------------

    case 'CorticalScout'

        %%% ---- Initialize visulization
        MAINWINDOW = gcbf;
        mri_scan = get(MAINWINDOW ,'Userdata');

        if isempty(mri_scan) %~exist('mri_scan','var')
            errordlg('Please load an MR file first')
            return
        end

        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        pix_siz = mri_scan.pix_siz;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');

        % Delete all previous points
        delete(findobj(get(axa,'children'),'type','patch'))
        delete(findobj(get(axc,'children'),'type','patch'))
        delete(findobj(get(axs,'children'),'type','patch'))

        %%% ---- END: Initialize visulization

    %     TASKBAR = findobj(0,'Tag','TASKBAR');
    %     if isempty(TASKBAR), return, end
        Current = get_user_directory;

        cd(Current.STUDIES)

        [result_file,result_dir] = uigetfile('CorticalScout.mat','File containing the Cortical Scouts...');
        if result_file == 0, return, end
        cd(result_dir)
        Results = load(result_file);
        Results.SourceLoc = Results.CorticalScouts.CorticalMarkers';

        nsource = size(Results.SourceLoc,2);

        for src = 1:nsource
            Results.SourceOrder(src) = -1;
            ptname{src} = Results.CorticalScouts.CorticalMarkersLabels{src};
            SourceLoc(:,src) = Results.CorticalScouts.CorticalMarkers(src,:)';
            COLOR(src,:) = [min(.3+abs(rand),1) min(.3+abs(rand),1) min(.3+abs(rand),1) ];
        end

        % Is it EEG or MEG
        if ~isfield(Results,'DataFlag')
            Results.DataFlag = 'MEG'; %Assume older data types are MEG
        end

        global EEG MEG
        if isempty(strmatch('EEG', Results.DataFlag));
            MEG = 1;
            EEG = 0;
        else
            MEG = 0;
            EEG = 1;
        end

        nsource = size(SourceLoc,2);

        j = 1;

        for i = 1:nsource

            ptcoord(i,:) = 1000*SourceLoc(:,i)';
            icoord(i,:) = [0 0 0];

            if mri_scan.pcs == 0
                orig = findstr(ptname{i},'originPCS');
                if ~isempty(orig) % This set of points can be registered owing to a MEG-EEG PCS.
                    mri_scan.pcs = 1;
                    mri_scan.pcs_type = ptname{i}(findstr(ptname{i},'_')+1:end);
                    mri_scan.center = icoord;
                    center = icoord(i,:);
                    ptcenter = ptcoord(i,:)
                else
                    mri_scan.pcs = 0;
                    mri_scan.pcs_type = 'NONE';
                    center = [0 0 0];
                end
            end

        end
        fclose all;

        % Transform PCS coordinates in the MRI volume reference system
        switch mri_scan.pcs_type
        case {'NEUROMAG','CTF'}
            if ~isfield(mri_scan,'rot')
                errordlg('Please Define a PCS First')
                return
            end
            center = mri_scan.center;
            rot = mri_scan.rot;
            ptcoord = (inv(rot)*ptcoord')';
        end

        ptcoord(:,1) = ptcoord(:,1) + center(1);
        ptcoord(:,2) = ptcoord(:,2) + center(2);
        ptcoord(:,3) = ptcoord(:,3) + center(3);

        icoord(:,1) = round(ptcoord(:,1)/pix_siz(2));
        icoord(:,2) = round(ptcoord(:,2)/pix_siz(1));
        icoord(:,3) = round(ptcoord(:,3)/pix_siz(3));
        mri_scan.pthandle = [];

        for i = 1:size(ptcoord,1)
            x = ptcoord(i,1);
            y = ptcoord(i,2);
            z = ptcoord(i,3);

            axes(axs)
            hold on
            switch Results.SourceOrder(i)
            case -1 % Current Dipole
                marker = 'o';
            case 0 % Magnetic Dipole
                marker = 's';
            case 1 % Multipole
                marker = 'd';
            case 2 % Synchronous Current Dipoles
                marker = 'v';
            case 3 % Synchronous Current Dipoles
                marker = '^';
            case 4 % Synchronous Multipoles
                marker = '*';
            end

            pt_s = scatter(x,z,marker,'filled');
            set(pt_s,'Parent',axs,'userdata',y)
            pt_slabel = text(x,z,num2str(size(mri_scan.pthandle,1)));
            set(pt_slabel,'Parent',axs,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',y)

            axes(axa)
            hold on
            pt_a = scatter(x,get(s1,'Max')-y,marker,'filled');
            set(pt_a,'Parent',axa,'userdata',z)
            pt_alabel = text(x,get(s1,'Max')-y,num2str(size(mri_scan.pthandle,1)));
            set(pt_alabel,'Parent',axa,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',z)

            axes(axc)
            hold on
            pt_c = scatter(y,z,marker,'filled');
            set(pt_c,'Parent',axc,'userdata',x)
            pt_clabel = text(y,z,num2str(size(mri_scan.pthandle,1)));
            set(pt_clabel,'Parent',axc,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',x)

            set([pt_s,pt_a,pt_c],'markerfacecolor','b')
            mri_scan.pthandle = [mri_scan.pthandle;[pt_s,pt_a,pt_c]];
            mri_scan.ptlabels= [mri_scan.ptlabels;[pt_slabel,pt_alabel,pt_clabel]];

            set([pt_s,pt_a,pt_c],'markerfacecolor',COLOR(i,:),'MarkerEDGEColor',COLOR(i,:))
        end

        seepoints = findobj(MAINWINDOW,'Tag','seepoints');
        seelabels = findobj(MAINWINDOW,'Tag','seelabels');
        LEAFLET = findobj(MAINWINDOW,'Tag','LEAFLET');
        set(seelabels,'enable','on')
        set(seepoints,'enable','on')
        set(LEAFLET,'enable','on')

        set(findobj(MAINWINDOW,'Tag','deletepoint'),'enable','on')

        listboxx = findobj(0,'Tag','listbox');
        set(listboxx,'visible','on')
        set(listboxx,'Value',1,'String',ptname(:))
        listboxx_title = findobj(MAINWINDOW,'Tag','listboxx_title');
        set(listboxx_title,'visible','on')
        legend_sources = findobj(MAINWINDOW,'Tag','legend_sources');
        set(legend_sources,'visible','on')

        RENDERING = findobj(0,'Tag','rendering');
        if ~isempty(RENDERING)
            listboxx_rend = findobj(RENDERING,'Tag','listobx_rend');
            set(listboxx_rend,'Value',1,'String',ptname)
        end

        mri_scan.ptcurrent = size( mri_scan.ptcoord,1);
        mri_scan.ptname = ptname ;
        mri_scan.ptcoord = ptcoord ;

        visu_pt(mri_scan.pthandle)

        set(MAINWINDOW,'Userdata',mri_scan)

        %-----------------------------------------------------------------------------------------------------------

    case 'MEGBlobs' % Visualize local cortical current density estimates within the MR volume
        % As those obtained from MNE or non-linear imaging methods
        MAINWINDOW = gcbf;
        set(0,'CurrentFigure',MAINWINDOW )
        mri_scan = get(gcbf,'Userdata');

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        axs = findobj(MAINWINDOW,'Tag','axs');
        axc = findobj(MAINWINDOW,'Tag','axc');
        axa = findobj(MAINWINDOW,'Tag','axa');
        gca = axs;
        s1 = findobj(gcbf,'Tag','1');
        s2 = findobj(gcbf,'Tag','2');
        s3 = findobj(gcbf,'Tag','3');

        %Get Results file
        Current = get_user_directory;
        cd(Current.STUDIES)
        [resfile, path] = uigetfile('*.mat','Pick-up a Result file');
        cd(path)
        load(resfile)

        if isempty(ImageGridAmp)
            errordlg('No Cortical Current Density Images Available for this Study')
            return
        end

        % Regular way
        % Tessellation file
        cd(Current.SUBJECTS)
        load(StudySubject.Subject)
        if ~exist(Tesselation,'file')
            errordlg('No Cortical Tessellation is Available for that Subject ')
            return
        end
        load(Tesselation,'Vertices','Faces');

        % CHEAT
        %load('g:\brainstorm\subjects\huangmx\SUBJECTESS_SMOOTH_SCS_red.MAT','Vertices')
        %load g:\brainstorm\subjects\subjects_old\whitekevin\subjectess_smooth_scs_rap.mat
        %load G:\Brainstorm\subjects\BailletS\SUBJECtTESS_SMOOTH_SCS_red_CTF.MAT.old -mat

        mri_scan.mript = Vertices{GUI.iGrid}';
        clear Vertices;
        Faces = Faces{GUI.iGrid};

        % See the whole tessellation
        %GridAmp = 10*ones(size(mri_scan.mript));
        %ImageGridAmp = GridAmp ;
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        mri_scan.GridAmp = norlig(ImageGridAmp)'; % See integrated activity at each vertex along time
        tmax = 1;% See integrated activity at each vertex along time
        mri_scan.M = max(mri_scan.GridAmp );

        %mri_scan.GridAmp = abs(ImageGridAmp); % see regular mapping
        %[mri_scan.M , tmax] = max(max(abs(ImageGridAmp)));% see regular mapping

        mri_scan.climm = ceil(max(get(gca,'Clim')));

        mri_scan.mri(mri_scan.mri >= mri_scan.climm) = mri_scan.climm;
        mri_scan.GridAmp = mri_scan.GridAmp*mri_scan.climm/mri_scan.M;

        mri_scan.thres = .2*mri_scan.climm; % Threshold for visualization of current density

        %mri_scan.ivisu = find(mri_scan.GridAmp >= mri_scan.thres); % Regular
        %mri_scan.ivisu = 1:size(mri_scan.mript,1); % CHEAT - see all points

        rooot = findstr(StudySubject.Study,'brainstormstudy.mat');

        if isempty(rooot)
            errodlg('Study file name should be of the form ''*brainstormstudy.mat''')
            return
        end

        rooot = StudySubject.Study(1:rooot-2);
        BrainStorm.rooot = rooot;

        mri_scan.mript = 1000*mri_scan.mript; % CHEAT
        %length(mri_scan.ivisu)

        %--------

        % Transform PCS coordinates in the MRI volume reference system
        switch mri_scan.pcs_type
        case {'NEUROMAG','CTF'}
            if ~isfield(mri_scan,'rot')
                errordlg('Please Define a PCS First')
                return
            end
            center = mri_scan.center;
            rot = mri_scan.rot;
            mri_scan.mript = (inv(rot)*mri_scan.mript')';
        end

        mri_scan.mript (:,1) = mri_scan.mript (:,1) + center(1);
        mri_scan.mript (:,2) = mri_scan.mript (:,2) + center(2);
        mri_scan.mript (:,3) = mri_scan.mript (:,3) + center(3);

        icoord(:,1) = round((get(s1,'Max')-mri_scan.mript (:,2))/mri_scan.pix_siz(2)+1);
        icoord(:,2) = round(mri_scan.mript (:,1)/mri_scan.pix_siz(1)+1);
        icoord(:,3) = round((get(s2,'Max')-mri_scan.mript (:,3))/mri_scan.pix_siz(3)+1);

        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        %ind = sub2ind(size(mri_scan.mri),icoord(:,1),icoord(:,2),icoord(:,3));
        %[uind,ii] = unique(ind);

        %%%% Interpolation of the Cortical Current Density Image
        if ~exist('interp_mat.mat','file')
            [H] = tri_interp(size(mri_scan.mri),icoord, Faces)   ;
            disp('Saving Interpolation Matrix')
            User = get_user_directory;
            save interp_mat H
        else
            load interp_mat
        end

        CInterp = sparse(H*mri_scan.GridAmp(:,tmax));
        mri_scan.csources = {[1:size(H,2)]};
        clear H mri_scan.GridAmp

        ind =find(CInterp>=mri_scan.thres);

        mri_scan.indmodif= ind; % indices of the voxels with modified grey levels
        mri_scan.gl_orig = mri_scan.mri(ind);

        %  mri_scan.mri(ind) = 1.01*mri_scan.climm + nonzeros(CInterp(ind));
        mri_scan.mri(ind) = double(mri_scan.mri(ind)) + nonzeros(CInterp(ind));
        minn = double(min(mri_scan.mri(ind)));
        mri_scan.mri(ind) =  double(mri_scan.mri(ind)) - minn + mri_scan.climm;

        %%%----- Superimpose to regular MRI
        %  mri_scan.mri = mri_scan.mri + iiiblob;

        [M tmp] = max(mri_scan.mri(ind));
        [is ic ia] = ind2sub(size(mri_scan.mri),ind(tmp));

        ax = mri_scan.ax;
        sag = mri_scan.sag;
        cor = mri_scan.cor;

        set(sag ,'CData',(flipud(squeeze(mri_scan.mri(is,:,:))')),'erasemode','none');
        set(get(sag,'Parent'),'CLim',[0 2*mri_scan.climm])
        set(cor ,'CData',(fliplr(flipud(squeeze(mri_scan.mri(:,ic,:))'))),'erasemode','none');
        set(get(cor,'Parent'),'CLim',[0 2*mri_scan.climm])
        set(ax ,'CData',(mri_scan.mri(:,:,ia)),'erasemode','none');
        set(get(ax,'Parent'),'CLim',[0  2*mri_scan.climm])

        split(1:mri_scan.climm,:) = bone(mri_scan.climm);
        split(mri_scan.climm+1:2*mri_scan.climm,:) = hot(mri_scan.climm);
        mri_scan.split = split;

        set(MAINWINDOW,'Userdata',mri_scan);

        ax = findobj(MAINWINDOW,'Tag','colorbar');
        axes(ax)
        colormapp = split( mri_scan.climm+1:end,:);
        n = size(colormapp,1);
        image([0, 1], [0 10],(n+1:2*n)');
        set(ax,'Ydir','normal','Tag','colorbar')
        set(ax,'xtick',[],'ycolor',frontcolor,'xcolor',frontcolor)
        colormap(split)

        %-----------------------------------------------------------------------------------------------------------

    case 'MEGBlob_update' % Update the display of the cortical current density

        disp('   ')

    case 'SaveAsBrainstorm' % Saves the Image cube according to the Brainstorm data structure
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(gcf,'Userdata');
        if isempty(mri_scan)
            errordlg('Please Load a Scan First','The BrainStorm Toolbox')
            return
        end

        Cube = uint8(mri_scan.mri); % Convert to int8 data type

        Voxsize = mri_scan.fov./(size(Cube));
        Voxsize = mri_scan.fov([2 1 3])./(size(Cube)); % To be compliant with the reference system of the MRI volume here.
        %Voxsize(3) = mri_scan.fov([3])./size(Cube,3); % Different for slic thickness

        if isfield(mri_scan,'Segment')
            Segment = mri_scan.Segment;
        else
            Segment = [];
        end

        if isfield(mri_scan,'pcs') % A PCS has been defined
            PCS.R = inv(mri_scan.rot); % According to BrainStorm convention
            PCS.t = mri_scan.center; % According to BrainStorm convention
            PCS.Comment = mri_scan.pcs_type;
            PCS.PCSFiducial = mri_scan.PCSFiducial;
            PCS.CubeFiducial = mri_scan.CubeFiducial;
            PCS.FiducialName = mri_scan.FiducialName;
            Comment = mri_scan.pcs_type;
        else
            PCS = [];
            Comment = '';
        end

        % Current = get_user_directory;
        Current = get_user_directory;
        cd(Current.SUBJECTS)

        [file,path] = uiputfile('subjectimage.mat','Save Anatomical Scans in...');
        if file == 0
            return
        end
        cd(path)
        eval(['save ',file,' Cube Voxsize Comment Segment PCS -mat'])
        mri_scan.filename = file;
        set(MAINWINDOW,'Userdata',mri_scan)

        %-----------------------------------------------------------------------------------------------------------

    case 'LoadBrainStorm'
        % Pretty much the same as 'READ_HEADER', even more simple though.
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        set(0,'CurrentFigure',MAINWINDOW )
        set(MAINWINDOW,'Userdata',[]);
        set(findobj(MAINWINDOW,'Type','image'),'erasemode','normal')
        axes(findobj(MAINWINDOW,'Tag','axs'));
        cla
        axes(findobj(MAINWINDOW,'Tag','axc'));
        cla
        axes(findobj(MAINWINDOW,'Tag','axa'));
        cla

        clear mri_scan

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        Current = get_user_directory;
        cd(Current.SUBJECTS)

        [filebs, pathbs] = uigetfile('*subjectimage.mat','Select a .mat file containing the subject image');
        if filebs==0
            return
        end
        cd(pathbs);
        eval(['load ',filebs,' -mat'])

        mri_scan.filename = fullfile(pathbs,filebs);
        mri_scan.mri = Cube;
        clear Cube
        mri_scan.pix_size = Voxsize([2 1 3]);
        siz = size(mri_scan.mri);
        siz = siz([2 1 3]);

        %mri_scan.pix_size = mri_scan.pix_size./(1-1./siz);

        mri_scan.fov = Voxsize([2 1 3]).*(siz);
        mri_scan.scantype = 'Axial';
        mri_scan.filemri = Comment;
        mri_scan.header = 0;
        mri_scan.siz = siz(1:2);
        mri_scan.nslice= siz(3);
        mri_scan.slice_thick = Voxsize(3);
        mri_scan.code= 'char';
        mri_scan.readslice = 0;

        if isfield(PCS,'R')% A PCS has been defined
            mri_scan.pcs = 1;
            mri_scan.rot = inv(PCS.R);
            mri_scan.center = PCS.t ;
            mri_scan.pcs_type = PCS.Comment ;
            mri_scan.PCSFiducial = PCS.PCSFiducial ;
            mri_scan.CubeFiducial = PCS.CubeFiducial ;
            mri_scan.FiducialName = PCS.FiducialName;
            set(findobj(MAINWINDOW,'Tag','showfiducials'),'Enable','on')

            if exist('scale_fiducials','var') % User uses the dummy head
                mri_scan.scale_fiducials = scale_fiducials;
                mri_scan.rot = mri_scan.scale_fiducials*mri_scan.rot ;
            end

        else
            mri_scan.pcs = 0;
            set(findobj(MAINWINDOW,'Tag','showfiducials'),'Enable','off')
        end

        set(MAINWINDOW,'Userdata',mri_scan)
        mritool_cb read_file_scan

    case 'mrislice'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        set(0,'CurrentFigure',MAINWINDOW )
        set(MAINWINDOW,'Userdata',[]);
        set(findobj(MAINWINDOW,'Type','image'),'erasemode','normal')
        delete(findobj(MAINWINDOW,'Type','image'))
        clear mri_scan
        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');
        C = get(findobj(MAINWINDOW,'Tag','CurrentDrive'),'String');
        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        switch lower(computer)
        case 'pcswin'
            mri_scan.cdrive = C;
            cd(C);
        end

        d = dir;
        [ignore,sorti] = sort(lower({d.name})); % sort
        str = {d.name}; % unsorted list
        str = str(sorti); % sorted without respect to capitalization
        [s,v] = listdlg('PromptString','Select a file:',...
            'SelectionMode','multiple',...
            'ListString',str);

        if v == 0
            return
        end

        while length(s)==1
            cd(str{s});
            d = dir;
            [ignore,sorti] = sort(lower({d.name})); % sort
            str = {d.name}; % unsorted list
            str = str(sorti); % sorted without respect to capitalization
            [s,v] = listdlg('PromptString','Select a file:',...
                'SelectionMode','multiple',...
                'ListString',str);
            if v==0
                return
            end

        end

        mri_scan.s = s;
        mri_scan.str = str;
        nslice = length(s);

        header = str2num(get(Header,'String'));
        mri_scan.header = header;

        siz = str2num(get(image_size,'String'));
        if length(siz)==1
            siz = [siz,siz];
        end
        mri_scan.siz = siz;

        scan_type_tmp = get(scan_type,'String');
        tmp = get(scan_type,'Value');
        scan_type = strtok(char(scan_type_tmp(tmp)));
        mri_scan.scantype= scan_type;

        fov = str2num(get(FOV,'String'));
        if isempty(fov)
            fov = siz;
        end
        mri_scan.fov = fov;

        slice_thickness = str2num(get(SLICE_thickness ,'String'));
        if isempty(slice_thickness)
            slice_thickness  = DEFAULTslice_thickness;
            warndlg(['Slice thickness field empty - using default',num2str(DEFAULTslice_thickeness)])
        end
        mri_scan.slice_thick = slice_thickness;

        set(NSLICE,'String',nslice);
        if isempty(nslice)
            errordlg('Please enter the number of slices')
            return
        end

        siz_tmp = siz;

        clear siz_tmp scan_type_tmp

        mri_scan.nslice = nslice;

        pix_siz = [fov(1)/(siz(1)-1) fov(2)/(siz(2)-1) slice_thickness];
        mri_scan.pix_siz = pix_siz;

        code = (get(data_format,'String'));
        tmp = get(data_format,'Value');
        code = strtok(char(code(tmp)));
        mri_scan.code = code;

        mri = zeros(siz(1),siz(2),nslice);
        hh = waitbar(0,'Reading files...');
        %   str = str(3:end);
        str = str(s);
        for i=1:nslice
            file = fopen(str{i},'rb',MACHINEFORMAT);
            fseek(file,header,'bof');
            if feof(file)
                errordlg('Please Check Image size / Number of Slices : do not match file size')
                return
            end
            mri(:,:,i) = fread(file,[siz(1),siz(2)],code);
            fclose(file);
            waitbar(i/nslice);
        end
        close(hh);

        mri_scan.mri = mri;
        clear mri

        ngray = 256;
        M = max(mri_scan.mri(:)); % May be rather time consuming if limited RAM is available

        if M > (ngray-1)
            mri_scan.mri = double(mri_scan.mri) ;
            M = double(M);
            mri_scan.mri = (mri_scan.mri) * ((ngray - 1 )/M) ;
            mri_scan.mri = uint8(mri_scan.mri);
        end

        mri_scan.readslice = 1;
        mri_scan.filemri = str{i};

        set(gcf,'Userdata',mri_scan)

        mritool_cb read_file_scan

        %-----------------------------------------------------------------------------------------------------------
    case 'ctfmri' % Test for the proper reading of CTF .mri file formats

        % CTF MRI File Version 2.1
        % Pretty much the same as 'READ_HEADER', even simpler though.
        MAINWINDOW = findobj(0,'Tag','mainwindow');

        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        set(0,'CurrentFigure',MAINWINDOW )
        set(MAINWINDOW,'Userdata',[]);
        set(findobj(MAINWINDOW,'Type','image'),'erasemode','normal')
        axes(findobj(MAINWINDOW,'Tag','axs'));
        cla
        axes(findobj(MAINWINDOW,'Tag','axc'));
        cla
        axes(findobj(MAINWINDOW,'Tag','axa'));
        cla

        clear mri_scan

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        Current = get_user_directory;
        cd(Current.SUBJECTS)

        [filebs, pathbs] = uigetfile('*.mri','Please select a CTF .mri file');
        if filebs==0
            return
        end
        cd(pathbs);

        file = fopen(filebs,'rb',MACHINEFORMAT);
        if file < 1
            errordlg(['Error when opening : ',fullfile(pathbs, filebs)]);
            return
        end

        Header.identifierString = char(fread(file,32,'char')');
        Header.imageSize = fread(file,1,'short');
        Header.dataSize = fread(file,1,'short');
        Header.clippingRange = fread(file,1,'short');
        Header.imageOrientation= fread(file,1,'short');
        Header.mmPerPixel_sagittal = fread(file,1,'float32');
        Header.mmPerPixel_coronal = fread(file,1,'float32');
        Header.mmPerPixel_axial = fread(file,1,'float32');

        % Head Model Info
        Header.HeadModel_Info.Nasion_Sag = fread(file,1,'short');
        Header.HeadModel_Info.Nasion_Cor = fread(file,1,'short');
        Header.HeadModel_Info.Nasion_Axi = fread(file,1,'short');
        Header.HeadModel_Info.LeftEar_Sag = fread(file,1,'short');
        Header.HeadModel_Info.LeftEar_Cor = fread(file,1,'short');
        Header.HeadModel_Info.LeftEar_Axi = fread(file,1,'short');
        Header.HeadModel_Info.RightEar_Sag = fread(file,1,'short');
        Header.HeadModel_Info.RightEar_Cor = fread(file,1,'short');
        Header.HeadModel_Info.RightEar_Axi = fread(file,1,'short');
        Header.HeadModel_Info.defaultSphereX= fread(file,1,'float32');
        Header.HeadModel_Info.defaultSphereY= fread(file,1,'float32');
        Header.HeadModel_Info.defaultSphereZ= fread(file,1,'float32');
        Header.HeadModel_Info.defaultSphereRadius= fread(file,1,'float32');
        % Head Model Info ********************************************

        % Image Info
        Header.Image_Info.modality = fread(file,1,'short');
        Header.Image_Info.manufacturerName = fread(file,64,'char');
        Header.Image_Info.instituteName = fread(file,64,'char');
        Header.Image_Info.patientID = fread(file,32,'char');
        Header.Image_Info.dateAndTime = fread(file,32,'char');
        Header.Image_Info.scanType = fread(file,32,'char');
        Header.Image_Info.contrastAgent = fread(file,32,'char');
        Header.Image_Info.imagedNucleus = fread(file,32,'char');
        Header.Image_Info.Frequency = fread(file,1,'float32');
        Header.Image_Info.FieldStrengh = fread(file,1,'float32');
        Header.Image_Info.EchoTime = fread(file,1,'float32');
        Header.Image_Info.RepetitionTime = fread(file,1,'float32');
        Header.Image_Info.InversionTime = fread(file,1,'float32');
        Header.Image_Info.FlipAngle = fread(file,1,'float32');
        Header.Image_Info.NoExcitations = fread(file,1,'short');
        Header.Image_Info.NoAcquisitions = fread(file,1,'short');
        Header.Image_Info.commentString = fread(file,256,'char');
        Header.Image_Info.forFutureUse = fread(file,64,'char');
        % Image Info ********************************************

        Header.headOrigin_sagittal = fread(file,1,'float32');
        Header.headOrigin_coronal = fread(file,1,'float32');
        Header.headOrigin_axial  = fread(file,1,'float32');

        Header.rotate_coronal = fread(file,1,'float32');
        Header.headOrigin_sagittal = fread(file,1,'float32');
        Header.headOrigin_axial  = fread(file,1,'float32');
        Header.orthogonalFlag = fread(file,1,'short');
        Header.unused = fread(file,272,'uchar');

        fseek(file,1028,-1); % Skip the whole header by padding to 1028

        % Header Info  ********************************************

        %Read Image
        mri_scan.nslice = Header.imageSize;
        mri_scan.siz =  [256 256 mri_scan.nslice];

        %mri_scan.mri = zeros(mri_scan.siz(1),mri_scan.siz(2),mri_scan.nslice);

        switch(Header.dataSize)
        case 1
            mri_scan.code = 'uchar';
        case 2
            mri_scan.code = 'ushort';
        otherwise
            errordlg('Unrecognized data format - Please check the file format');
            return
        end

        %    hh = waitbar(0,['Reading ', char(Header.identifierString),' ...']);
        %    for i=1:mri_scan.nslice
        %       mri_scan.mri(:,:,i) = uint8(fread(file,[mri_scan.siz(1),mri_scan.siz(2)],mri_scan.code));
        %       waitbar(i/mri_scan.nslice);
        %    end

        hmsg = msgbox('Reading file...');
        set(MAINWINDOW,'Pointer','watch')
        drawnow

        mri_scan.mri = int16(fread(file, prod(mri_scan.siz),mri_scan.code)); % Read the whole volume / store in a huge vector
        fclose(file);
        mri_scan.mri = reshape(mri_scan.mri,mri_scan.siz(1),mri_scan.siz(2),mri_scan.siz(3)); % reshape it into a 3-D array.
        mri_scan.clippingRange = Header.clippingRange ;

        delete(hmsg)
        set(MAINWINDOW,'Pointer','arrow')
        drawnow

        %    ngray = 256;
        %    M = max(mri_scan.mri(:)); % May be rather time consuming if limited RAM is available
        %
        %    if M > (ngray-1)
        %       mri_scan.mri = double(mri_scan.mri) ;
        %       M = double(M);
        %       mri_scan.mri = (mri_scan.mri) * ((ngray - 1 )/M) ;
        %        mri_scan.mri = uint8(mri_scan.mri);
        %    end
        %
        mri_scan.scantype = 'Sagittal';
        mri_scan.fov = [mri_scan.siz].*[Header.mmPerPixel_sagittal Header.mmPerPixel_coronal Header.mmPerPixel_axial];
        mri_scan.slice_thick = Header.mmPerPixel_sagittal;

        mri_scan.readslice = 1;
        mri_scan.filemri = fullfile(pathbs, filebs);
        mri_scan.header = 0;

        set(MAINWINDOW,'Userdata',mri_scan)

        mritool_cb read_file_scan
        mritool_cb flip_ud_s
        mritool_cb flip_lr_a

        %-----------------------------------------------------------------------------------------------------------
    case 'fifmri' % Load FIF MRI format (4D NeuroImaging)

        MAINWINDOW = findobj(0,'Tag','mainwindow');

        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        set(0,'CurrentFigure',MAINWINDOW )
        set(MAINWINDOW,'Userdata',[]);
        set(findobj(MAINWINDOW,'Type','image'),'erasemode','normal')
        axes(findobj(MAINWINDOW,'Tag','axs'));
        cla
        axes(findobj(MAINWINDOW,'Tag','axc'));
        cla
        axes(findobj(MAINWINDOW,'Tag','axa'));
        cla

        clear mri_scan

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        Current = get_user_directory;
        cd(Current.SUBJECTS)

        if ~exist('loadmri.m','file') % meg_1.2 routine not available on this machine
            errordlg('meg_1.2 routines not available on this machine. Please check the following link: http://boojum.hut.fi/~kuutela/meg-pd/');
            return
        end
        [filebs, pathbs] = uigetfile('*.fif','Please select a FIF MRI file');
        if filebs==0
            return
        end
        cd(pathbs);
        disp('Loading MRI volume...' )
        drawnow
        [M,coords]=loadmri(filebs);
        disp('Loading MRI volume...-> DONE' )
        drawnow

        %Check if fiducials are defined
        try
            T = loadtrans(filebs,'HEAD','MRI');
        catch
            msgdlg('Fiducials were note defined for this MRI - Please proceed manually within BrainStorm');
        end

        mri_scan.PCS.T = T;

        if isempty(M)
            errordlg(['Error when opening : ',fullfile(pathbs, filebs)]);
            return
        end

        % Header Info  ********************************************

        %Read Image
        mri_scan.nslice = size(M,3);
        mri_scan.siz =  [size(M,1) size(M,2) mri_scan.nslice];

        kk = whos('M');
        mri_scan.code = kk.class;

        %mri_scan.mri = reshape(mri_scan.mri,mri_scan.siz(1),mri_scan.siz(2),mri_scan.siz(3)); % reshape it into a 3-D array.
        mri_scan.mri = M; clear M

        %mri_scan.clippingRange = Header.clippingRange ;

        mri_scan.scantype = 'Sagittal';
        mri_scan.fov = 1000*abs([mri_scan.siz].*[coords(find(coords(:,1)),1), coords(find(coords(:,2)),2),...
                coords(find(coords(:,3)),3)]);

        mri_scan.slice_thick = 1000*abs(coords(find(coords(:,3)),3));

        mri_scan.readslice = 1;
        mri_scan.filemri = fullfile(pathbs, filebs);
        mri_scan.header = 0;
        mri_scan.PCS.t = [];;

        set(MAINWINDOW,'Userdata',mri_scan)

        mritool_cb read_file_scan
        %-----------------------------------------------------------------------------------------------------------
    case 'imgformat' % Test for the proper reading of CTF (?) .img file formats - headers of these files seem to be of variable size from on file to the other

        MAINWINDOW = findobj(0,'Tag','mainwindow');

        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        set(0,'CurrentFigure',MAINWINDOW )
        set(MAINWINDOW,'Userdata',[]);
        set(findobj(MAINWINDOW,'Type','image'),'erasemode','normal')
        delete(findobj(MAINWINDOW,'Type','image'))
        clear mri_scan
        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');
        C = get(findobj(MAINWINDOW,'Tag','CurrentDrive'),'String');

        mri_scan.cdrive = C;
        cd(C);

        d = dir;
        str = {d.name};
        [s,v] = listdlg('PromptString','Select a file:',...
            'SelectionMode','multiple',...
            'ListString',str);

        if v == 0
            return
        end

        while length(s)==1
            cd(str{s});
            d = dir;
            str = {d.name};
            [s,v] = listdlg('PromptString','Select a file:',...
                'SelectionMode','multiple',...
                'ListString',str);
            if v==0
                return
            end

        end

        mri_scan.s = s;
        mri_scan.str = str;
        nslice = length(s);

        header = str2num(get(Header,'String'));
        mri_scan.header = header;

        siz = str2num(get(image_size,'String'));
        if length(siz)==1
            siz = [siz,siz];
        end
        mri_scan.siz = siz;

        scan_type_tmp = get(scan_type,'String');
        tmp = get(scan_type,'Value');
        scan_type = strtok(char(scan_type_tmp(tmp)));
        mri_scan.scantype= scan_type;

        fov = str2num(get(FOV,'String'));
        if isempty(fov)
            fov = siz;
        end
        mri_scan.fov = fov;

        slice_thickness = str2num(get(SLICE_thickness ,'String'));
        if isempty(slice_thickness)
            slice_thickness  = DEFAULTslice_thickness;
            warndlg(['Slice thickness field empty - using default',num2str(DEFAULTslice_thickeness)])
        end
        mri_scan.slice_thick = slice_thickness;

        set(NSLICE,'String',nslice);
        if isempty(nslice)
            errordlg('Please enter the number of slices')
            return
        end

        siz_tmp = siz;

        clear siz_tmp scan_type_tmp

        mri_scan.nslice = nslice;

        pix_siz = [fov(1)/(siz(1)-1) fov(2)/(siz(2)-1) slice_thickness];
        mri_scan.pix_siz = pix_siz;

        code = (get(data_format,'String'));
        tmp = get(data_format,'Value');
        code = strtok(char(code(tmp)));
        mri_scan.code = code;

        mri = zeros(siz(1),siz(2),nslice);
        hh = waitbar(0,'Reading files...');
        %   str = str(3:end);
        str = str(s);

        for i=1:nslice
            file = fopen(str{i},'rb',MACHINEFORMAT);
            % Assume here that code is 'int16'
            status = fseek(file,-siz(1)*siz(2)*2,'eof');
            if status == -1
                errordlg('Please Check Image size / Number of Slices : do not match file size')
                return
            end
            mri(:,:,i) = fread(file,[siz(1),siz(2)],code);
            fclose(file);
            waitbar(i/nslice);
        end

        close(hh);

        mri_scan.mri = mri;
        clear mri

        ngray = 256;
        M = max(mri_scan.mri(:)); % May be rather time consuming if limited RAM is available

        if M > (ngray-1)
            mri_scan.mri = double(mri_scan.mri) ;
            M = double(M);
            mri_scan.mri = (mri_scan.mri) * ((ngray - 1 )/M) ;
            mri_scan.mri = uint8(mri_scan.mri);
        end

        mri_scan.readslice = 1;
        mri_scan.filemri = str{i};

        set(gcf,'Userdata',mri_scan)

        mritool_cb read_file_scan

    case 'IMPORT_mridata'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        set(0,'CurrentFigure',   MAINWINDOW )
        set(MAINWINDOW,'Userdata',[]);
        set(findobj(MAINWINDOW,'Type','image'),'erasemode','normal')
        delete(findobj(MAINWINDOW,'Type','image'))
        clear mri_scan

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        Current = get_user_directory;
        cd(Current.SUBJECTS)

        [filemri, pathmri] = uigetfile('*.*','Select a MRI image file for visualization');
        if filemri==0
            return
        end

        filename = findobj(gcbf,'Tag','mr_filename');

        set(filename,'String',filemri)

        filemri = [pathmri,filemri];
        cd(pathmri);

        mri_scan.filemri = filemri;
        mri_scan.pathmri = pathmri;

        header = str2num(get(Header,'String'));
        mri_scan.header = header;

        siz = str2num(get(image_size,'String'));
        if length(siz)==1
            siz = [siz,siz];
        end
        mri_scan.siz = siz;

        scan_type_tmp = get(scan_type,'String');
        tmp = get(scan_type,'Value');
        scan_type = strtok(char(scan_type_tmp(tmp)));
        mri_scan.scantype= scan_type;

        fov = str2num(get(FOV,'String'));
        if isempty(fov)
            fov = siz;
        end
        mri_scan.fov = fov;

        slice_thickness = str2num(get(SLICE_thickness ,'String'));
        if isempty(slice_thickness)
            slice_thickness  = DEFAULTslice_thickness;
            warndlg(['Slice thickness field empty - using default',num2str(DEFAULTslice_thickeness)])
        end
        mri_scan.slice_thick = slice_thickness;

        nslice = str2num(get(NSLICE,'String'));
        if isempty(nslice)
            errordlg('Please enter the numer of slices')
            return
        end

        siz_tmp = siz;

        mri_scan.nslice = nslice;
        code = (get(data_format,'String'));
        tmp = get(data_format,'Value');
        code = strtok(char(code(tmp)));
        mri_scan.code = code;

        mri_scan.readslice = 0;
        set(gcf,'Userdata',mri_scan)

        mritool_cb read_file_scan

    case 'mriformat'
        MAINWINDOW = findobj(0,'Tag','mainwindow');

        set(0,'CurrentFigure',   MAINWINDOW )
        set(MAINWINDOW,'Userdata',[]);
        set(findobj(MAINWINDOW,'Type','image'),'erasemode','normal')
        delete(findobj(MAINWINDOW,'Type','image'))
        clear mri_scan

        Header = findobj(gcbf,'Tag','header');
        image_size = findobj(gcbf,'Tag','image_size');
        SLICE_thickness = findobj(gcbf,'Tag','slice_thickness');
        FOV = findobj(gcbf,'Tag','fov');
        NSLICE = findobj(gcbf,'Tag','nslice');
        data_format = findobj(gcbf,'Tag','data_format');
        file_mri= findobj(gcbf,'Tag','file_mri');
        scan_type= findobj(gcbf,'Tag','scan_type');

        be = findobj(MAINWINDOW,'Tag','big-endian');
        le = findobj(MAINWINDOW,'Tag','little-endian');

        if get(le,'value');
            MACHINEFORMAT = 'l';
        else
            MACHINEFORMAT = 'b';
        end

        Current = get_user_directory;
        cd(Current.SUBJECTS)

        [filemri, pathmri] = uigetfile('*.mri','Select a .mri image file for visualization');
        if filemri==0
            return
        end

        filemri = [pathmri,filemri];
        cd(pathmri);

        mri_scan.filemri = filemri;
        mri_scan.pathmri = pathmri;

        file_mri = fopen(filemri,'r',MACHINEFORMAT);
        if file_mri < 1
            disp('Invalid File Name')
            return;
        end

        mri_scan.header = 512;

        for i=1:22
            fgetl(file_mri);
        end

        siz = fgetl(file_mri);
        [tmp,siz] = strtok(siz,'=');
        siz = str2num(siz(2:end));

        nslice = siz(3);
        siz = siz(1:2);
        if length(siz)==1
            siz = [siz,siz];
        end

        scan_type_tmp = get(scan_type,'String');
        tmp = get(scan_type,'Value');
        scan_type = strtok(char(scan_type_tmp(tmp)));
        mri_scan.scantype= scan_type;

        cmpix = fgetl(file_mri);
        [tmp,cmpix] = strtok(cmpix,'=');
        cmpix = str2num(cmpix(2:end));

        fov = siz.*cmpix(1:2);
        if isempty(fov)
            fov = siz;
        end
        mri_scan.fov = fov;

        slice_thickness = cmpix(3);
        if isempty(slice_thickness)
            slice_thickness  = DEFAULTslice_thickness;
            warndlg(['Slice thickness field empty - using default',num2str(DEFAULTslice_thickeness)])
        end
        mri_scan.slice_thick = slice_thickness;

        if isempty(nslice)
            errordlg('Please enter the number of slices')
            return
        end

        siz_tmp = siz;
        if strcmp(scan_type,'Coronal')
            siz(2) = nslice;
            nslice = siz_tmp(2);

        elseif strcmp(scan_type,'Sagittal')
            siz(1) = nslice;
            siz(2) = siz_tmp(1);
            nslice = siz_tmp(2);
        elseif strcmp(scan_type,'Axial')

        end

        clear siz_tmp scan_type_tmp

        mri_scan.nslice = nslice;
        mri_scan.siz = siz;

        pix_siz = [fov(1)/(siz(1)-1) fov(2)/(siz(2)-1) slice_thickness];
        mri_scan.pix_siz = pix_siz;

        code = 'uint8';
        set(data_format,'value',8)

        mri_scan.code = code;

        mri_scan.readslice = 0;

        set(gcf,'Userdata',mri_scan)

        mritool_cb read_file_scan

    case 'mouse_slct'

        mri_scan = get(gcf,'Userdata');

        s1 = findobj(gcbf,'Tag','1');
        s2 = findobj(gcbf,'Tag','2');
        s3 = findobj(gcbf,'Tag','3');

        MOUSE_SLCT = findobj(gco,'tag','mouse_slct');
        val_MOUSE_SLCT = get(MOUSE_SLCT,'value');

        ZOOM = findobj(gcbf,'Tag','zoom');
        set(ZOOM,'Value',0);
        set(gcbf,'Pointer','Arrow')
        zoom off

        gotopoint = findobj(gcbf,'Tag','gotopoint');
        set(gotopoint,'Value',0)

        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        nslice = mri_scan.nslice;
        siz = mri_scan.siz;
        slice_thick = mri_scan.slice_thick ;
        fov = mri_scan.fov;

        pix_siz = mri_scan.pix_siz ;

        while val_MOUSE_SLCT
            [x,y,button] = ginput2(1);
            clear x y;
            current_ax = gco;
            switch current_ax
            case sag
                imax = size(mri_scan.mri,1);
                ii = round((get(s1,'Max')-get(s1,'Value'))/pix_siz(2));
                is = ii;
                axi = sag;
                str = 'ii,:,:';
                sldr = s1;
            case ax
                imax = size(mri_scan.mri,3);
                ii = round(get(s2,'Value')/pix_siz(3));
                ia = ii;
                axi = ax;
                str = ':,:,ii';
                sldr = s2;
            case cor
                imax = size(mri_scan.mri,2);
                ii = round(get(s3,'Value')/pix_siz(1));
                ic = ii;
                axi = cor;
                str = ':,ii,:';
                sldr = s3;

            case MOUSE_SLCT
                set(MOUSE_SLCT,'value',0)
                return

            otherwise
                set(MOUSE_SLCT,'value',0)
                val_MOUSE_SLCT = get(MOUSE_SLCT,'value');
            end

            if button== 1
                ii =ii+1;
            else
                ii = ii-1;
            end

            show_coordinates = findobj(gcbf,'Tag','show_coordinates');
            if get(show_coordinates,'Value')
                SHOW_COORDINATES = 1;
            else
                SHOW_COORDINATES = 0;
            end

            switch current_ax
            case {sag,cor}
                if current_ax == sag
                    imax = size(mri_scan.mri,1);
                    is = ii;
                    set(s1,'Value',get(s1,'Max')-is*pix_siz(2))
                    eval(['mri_tmp = (flipud(squeeze(mri_scan.mri(',str,'))''));']);
                elseif current_ax == cor
                    imax = size(mri_scan.mri,2);
                    eval(['mri_tmp = (fliplr(flipud(squeeze(mri_scan.mri(',str,'))'')));']);
                    ic = ii;
                    set(s3,'Value',ic*pix_siz(1))

                end

            case ax
                %         eval(['mri_tmp = flipud(squeeze(mri(',str,')));']);
                eval(['mri_tmp = (squeeze(mri_scan.mri(',str,')));']);
                imax = size(mri_scan.mri,3);
                ia = ii;
                set(s2,'Value',ia*pix_siz(3))

            end

            if (ii>0)&(ii<=imax)
                set(axi,'Cdata',mri_tmp);
                drawnow
                %  set(sldr,'Value',ii)
                switch current_ax
                case sag
                    if SHOW_COORDINATES
                        set(axc,'Xtick',get(s1,'Value'),'Xticklabel',num2str(get(s1,'Value'),FORMATtick))
                        set(axa,'Ytick',get(s1,'Max')-get(s1,'Value'));%,'Yticklabel',num2str(get(s1,'Value'),FORMATtick))
                        %set(axs,'Visible','on','Xtick',ic,'Ytick',ia)

                    end
                case cor
                    if SHOW_COORDINATES
                        set(axs,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
                        set(axa,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
                        %set(axa,'Visible','on','Xtick',is,'Ytick',ia)
                    end

                case ax
                    if SHOW_COORDINATES
                        set(axc,'Ytick',get(s2,'Max')-get(s2,'Value'),'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
                        set(axs,'Ytick',get(s2,'Max')-get(s2,'Value'));%'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
                        % set(ax,'Visible','on','Xtick',ic,'Ytick',is)
                    end
                end
            elseif is == 0
                is = 1;

            end

            val_MOUSE_SLCT = get(MOUSE_SLCT,'value');

        end

        %-----------------------------------------------------------------------------------------------
    case 'sliders'

        MAINWINDOW = findobj(0,'Tag','mainwindow');

        set(0,'CurrentFigure',   MAINWINDOW )
        mri_scan = get(gcf,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        nslice = mri_scan.nslice;
        siz = mri_scan.siz;
        ic = mri_scan.ic ;
        is = mri_scan.is ;
        ia = mri_scan.ia ;
        pix_siz = mri_scan.pix_siz ;

        gtpt = mri_scan.gotopoint;

        if gtpt
            current_sldr = 'all';
        else
            current_sldr = gco;
        end

        s1 = findobj(   MAINWINDOW ,'Tag','1');
        s2 = findobj(   MAINWINDOW ,'Tag','2');
        s3 = findobj(   MAINWINDOW ,'Tag','3');

        visu_pt(mri_scan.pthandle)

        show_coordinates = findobj(   MAINWINDOW ,'Tag','show_coordinates');
        if get(show_coordinates,'Value')
            SHOW_COORDINATES = 1;
        else
            SHOW_COORDINATES = 0;
        end

        fov = mri_scan.fov;

        switch current_sldr

        case s1
            imax = size(mri_scan.mri,1);
            ii = round((get(s1,'Max')-get(s1,'Value'))/pix_siz(2)+1);
            is = ii;
            is = max([1,min([size(mri_scan.mri,1),is])]);
            axi = sag;

            str = 'is,:,:';
            gca = axs;
            if SHOW_COORDINATES
                set(axc,'Xtick',get(s1,'Value'),'Xticklabel',num2str(get(s1,'Value'),FORMATtick))
                set(axa,'Ytick',get(s1,'Max')-get(s1,'Value'));%,'Yticklabel',num2str(get(s1,'Value'),FORMATtick))
            end

        case s2
            imax = size(mri_scan.mri,3);
            ii = round(get(s2,'Value')/pix_siz(3)+1);
            ia = ii;
            ia = max([1,min([size(mri_scan.mri,3),ia])]);
            axi = ax;
            imax = size(mri_scan.mri,3);
            str = ':,:,ia';
            gca = axa;
            if SHOW_COORDINATES
                set(axc,'Ytick',get(s2,'Max')-get(s2,'Value'),'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
                set(axs,'Ytick',get(s2,'Max')-get(s2,'Value'));%'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
            end

        case s3
            imax = size(mri_scan.mri,2);
            ii = round(get(s3,'Value')/pix_siz(1)+1);
            ic = ii;
            ic = max([1,min([size(mri_scan.mri,2),ic])]);
            axi = cor;
            imax = size(mri_scan.mri,2);
            str = ':,ic,:';
            gca = axc;
            if SHOW_COORDINATES
                set(axs,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
                set(axa,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
            end

        case 'all'
            is = round((get(s1,'Max')-get(s1,'Value'))/pix_siz(2)+1);
            if SHOW_COORDINATES
                set(axc,'Xtick',get(s1,'Value'),'Xticklabel',num2str(get(s1,'Value'),FORMATtick))
                set(axa,'Ytick',get(s1,'Max')-get(s1,'Value'));%,'Yticklabel',num2str(get(s1,'Value'),FORMATtick))
            end

            ia = round(get(s2,'Value')/pix_siz(3)+1);
            ia = max([1,min([size(mri_scan.mri,3),ia])]);
            if SHOW_COORDINATES
                set(axc,'Ytick',get(s2,'Max')-get(s2,'Value'),'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
                set(axs,'Ytick',get(s2,'Max')-get(s2,'Value'));%'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
            end

            ic = round(get(s3,'Value')/pix_siz(1)+1);
            ic = max([1,min([size(mri_scan.mri,2),ic])]);
            if SHOW_COORDINATES
                set(axs,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
                set(axa,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
            end
            ii = 1;
            imax = 2;
        end

        mri_scan.ic = ic;
        mri_scan.is = is;
        mri_scan.ia = ia;

        switch current_sldr
        case s1
            eval(['mri_tmp = (flipud(squeeze(mri_scan.mri(',str,'))''));']);
        case s3
            eval(['mri_tmp = (fliplr(flipud(squeeze(mri_scan.mri(',str,'))'')));']);

        case s2
            eval(['mri_tmp = (squeeze(mri_scan.mri(',str,')));']);
            %     eval(['mri_tmp = flipud(squeeze(mri(',str,')));']);

        end

        if (ii>0)&(ii<=imax)
            switch current_sldr

            case 'all'
                strs = 'is,:,:';
                stra = ':,:,ia';
                strc = ':,ic,:';
                eval(['mri_tmp = (flipud(squeeze(mri_scan.mri(',strs,'))''));']);
                set(sag,'Cdata',(mri_tmp));
                eval(['mri_tmp = fliplr(flipud(squeeze(mri_scan.mri(',strc,'))''));']);
                set(cor,'Cdata',(mri_tmp));
                eval(['mri_tmp = squeeze(mri_scan.mri(',stra,'));']);
                %    eval(['mri_tmp = flipud(squeeze(mri(',str,')));']);
                set(ax,'Cdata',(mri_tmp));

                RENDERING = findobj(0,'Tag','rendering');
                if ~isempty(RENDERING)
                    listboxx_rend = findobj(RENDERING,'Tag','listobx_rend');
                    set(listboxx_rend,'Userdata',[is,ia,ic])

                end

            otherwise

                set(axi,'Cdata',(mri_tmp));
                drawnow
                gca = get(axi,'Parent');

            end

        elseif is == 0
            is = 1;

        end

        %-----------------------------------------------------------------------------------------------

    case 'show_coordinates'
        show_coordinates = findobj(gcbf,'Tag','show_coordinates');
        mri_scan = get(gcf,'Userdata');
        axa = mri_scan.axa;
        axs = mri_scan.axs;
        axc = mri_scan.axc;
        s1 = findobj(gcbf,'Tag','1');
        s2 = findobj(gcbf,'Tag','2');
        s3 = findobj(gcbf,'Tag','3');
        ic = (get(s3,'Value'));
        is = (get(s1,'Value'));
        ia = (get(s2,'Value'));
        pix_siz = mri_scan.pix_siz ;

        if get(show_coordinates,'Value')
            set(axa,'Visible','on','Layer','Top','Xtick',ic,'Xticklabel',num2str(ic,FORMATtick),'Ytick',get(s1,'Max')-get(s1,'Value'),'Yticklabel','')
            set(axc,'Visible','on','Layer','Top','Xtick',is,'Xticklabel',num2str(is,FORMATtick),'Ytick',get(s2,'Max')-ia,'Yticklabel',num2str(ia,FORMATtick))
            set(axs,'Visible','on','Layer','Top','Xtick',ic,'Ytick',get(s2,'Max')-ia,'Xticklabel',num2str(ic,FORMATtick),'Yticklabel','')
        else
            set(axa,'Visible','on','Xtick',[],'Ytick',[])
            set(axc,'Visible','on','Xtick',[],'Ytick',[])
            set(axs,'Visible','on','Xtick',[],'Ytick',[])
        end

    case 'zoom'
        mri_scan = get(gcf,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        ZOOM = findobj(gcbf,'Tag','zoom');
        valZOOM = get(ZOOM,'Value');
        MOUSE_SLCT = findobj(gcbf,'tag','mouse_slct');
        gotopoint = findobj(gcbf,'tag','gotopoint');

        val_MOUSE_SLCT = get(MOUSE_SLCT,'Value');
        val_gotopoint = get(gotopoint,'Value');

        %mutincomp([ZOOM MOUSE_SLCT])

        if valZOOM
            set(MOUSE_SLCT,'Value',0)
            set(gotopoint ,'Value',0)
            zoom on
            set(gcbf,'Pointer','Circle')
        else
            zoom off
            set(gcbf,'Pointer','arrow')
        end

        %-----------------------------------------------------------------------------------------------
    case 'slctpoint'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        show_coordinates = findobj(MAINWINDOW ,'Tag','show_coordinates');
        set(show_coordinates ,'Value',1)
        mritool_cb show_coordinates
        drawnow

        listboxx = findobj(0,'Tag','listbox');
        set(listboxx,'visible','on')
        listboxx_title = findobj(0,'Tag','listboxx_title');
        set(listboxx_title,'visible','on')

        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        nslice = mri_scan.nslice;
        siz = mri_scan.siz;
        ic = mri_scan.ic ;
        is = mri_scan.is ;
        ia = mri_scan.ia ;
        pix_siz = mri_scan.pix_siz ;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');

        x = get(s3,'Value');
        y = get(s1,'Value');
        z = get(s2,'Max')-get(s2,'Value');

        set(axs,'Selected','on')
        hold on
        pt_s = scatter(x,z,'o','filled');
        set(pt_s,'Parent',axs,'Userdata',y)
        pt_slabel = text(x,z,num2str(size(mri_scan.pthandle,1)));
        set(pt_slabel,'Parent',axs,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
            'Userdata',y)

        pt_a = scatter(x,get(s1,'Max')-y,'o','filled');
        set(pt_a,'Parent',axa,'Userdata',z)
        pt_alabel = text(x,get(s1,'Max')-y,num2str(size(mri_scan.pthandle,1)));
        set(pt_alabel,'Parent',axa,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
            'Userdata',z)

        pt_c = scatter(y,z,'o','filled');
        set(pt_c,'Parent',axc,'Userdata',x)
        pt_clabel = text(y,z,num2str(size(mri_scan.pthandle,1)));
        set(pt_clabel,'Parent',axc,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
            'Userdata',x)

        set([pt_s,pt_a,pt_c],'markerfacecolor','c')

        prompt  = {'Enter point name:'};
        title   = 'Please assign a label to the selected point';
        lines= 1;
        def     = {'LeftEar'};
        answer  = inputdlg(prompt,title,lines,def);

        if isempty(answer)
            delete([pt_s pt_c pt_a pt_slabel pt_clabel pt_alabel   ])
            clear pt_s pt_c pt_a pt_slabel pt_clabel pt_alabel
            return
        end
        hold on

        if ~isempty(mri_scan.ptname)
            mri_scan.ptname(end+1) = answer;
        else
            mri_scan.ptname(1) = answer;
        end

        set(pt_s,'tag',char(answer));   set(pt_a,'tag',char(answer));
        set(pt_c,'tag',char(answer));

        mri_scan.seepoints = 0;
        seepoints = findobj(gcbf,'Tag','seepoints');
        set(seepoints,'String', 'Hide Points');

        mri_scan.ptcoord = [mri_scan.ptcoord;[x,y,z]];
        mri_scan.pthandle = [mri_scan.pthandle;[pt_s,pt_a,pt_c]];
        mri_scan.ptcurrent = size( mri_scan.ptcoord,1);
        mri_scan.ptlabels = [mri_scan.ptlabels;[pt_slabel,pt_alabel,pt_clabel]];

        set(gcbf,'Userdata',mri_scan)

        listboxx = findobj(listboxx,'Tag','listbox');
        set(listboxx,'Value',1,'String',mri_scan.ptname)

        seepoints = findobj(MAINWINDOW ,'Tag','seepoints');
        seelabels = findobj(MAINWINDOW ,'Tag','seelabels');
        newlabel = findobj(gcbf,'Tag','newlabel');
        LEAFLET = findobj(MAINWINDOW ,'Tag','LEAFLET');
        set(seelabels,'enable','on')
        set(newlabel,'enable','on')
        set(seepoints,'enable','on')
        set(LEAFLET,'enable','on')

        set(findobj(MAINWINDOW ,'Tag','deletepoint'),'enable','on')

        if size(mri_scan.ptlabels,1) > 2
            set(findobj(MAINWINDOW,'Tag','PCS'),'enable','on')
        else
            set(findobj(MAINWINDOW,'Tag','PCS'),'enable','off')
        end

        %-----------------------------------------------------------------------------------------------

    case 'seepoints'
        mri_scan = get(gcbf,'Userdata');
        pthandle = mri_scan.pthandle ;
        seepoints = findobj(gcbf,'Tag','seepoints');

        if mri_scan.seepoints == 1
            set(seepoints,'String', 'Hide Points');
            set(pthandle,'Visible','on');
            mri_scan.seepoints = 0;
        else
            set(seepoints,'String', 'See All Points');
            set(pthandle,'Visible','off');
            mri_scan.seepoints = 1;
        end

        set(gcf,'Userdata',mri_scan);

        %-----------------------------------------------------------------------------------------------

    case 'seelabels'
        mri_scan = get(gcbf,'Userdata');
        ptlabels = mri_scan.ptlabels;
        seelabels = findobj(gcbf,'Tag','seelabels');

        if mri_scan.seelabels == 1
            set(seelabels,'String', 'Hide Labels');
            set(ptlabels,'Visible','on');
            mri_scan.seelabels = 0;
        else
            set(seelabels,'String','Show Labels');
            set(ptlabels,'Visible','off');
            mri_scan.seelabels = 1;
        end

        set(gcf,'Userdata',mri_scan);

        %-----------------------------------------------------------------------------------------------

    case 'newlabel' % Assign a new label to the current point in the listbox
        MAINWINDOW = findobj(0,'Tag','mainwindow');

        mri_scan = get(gcbf,'Userdata');
        ptlabels = mri_scan.ptlabels;
        ptname = mri_scan.ptname;
        seelabels = findobj(gcbf,'Tag','seelabels');

        prompt  = {'Enter a new label for the current point:'};
        title   = 'Please assign a label to the selected point';
        lines = 1;
        def     = {'I''d rather go to the beach'};
        answer  = inputdlg(prompt,title,lines,def);

        if isempty(answer)
            return
        else
            listboxx = findobj(MAINWINDOW,'Tag','listbox');
            current_pt = get(listboxx,'Value');
            ptname(current_pt) = answer;
            set(listboxx,'String',ptname)
            mri_scan.ptname = ptname;
            set(gcf,'Userdata',mri_scan);
        end

        %-----------------------------------------------------------------------------------------------
    case 'current_point'
        MAINWINDOW = findobj(0,'Tag','mainwindow');

        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        mri = mri_scan.mri;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');
        x = get(s3,'Value');
        y = get(s1,'Value');
        z = get(s2,'Max')-get(s2,'Value');
        ptname =  mri_scan.ptname ;
        ptcoord =  mri_scan.ptcoord;
        pthandle =  mri_scan.pthandle ;
        ptcurrent = mri_scan.ptcurrent;

        switch get(gcbo,'Tag')

        case 'previous'
            if ptcurrent > 1
                ptcurrent = ptcurrent - 1;
            end
        case 'next'
            if ptcurrent < size(ptcoord,1)
                ptcurrent = ptcurrent+1;
            end
        case 'listbox'
            ptcurrent = get(gcbo,'Value');
        end

        listboxx = findobj(MAINWINDOW,'Tag','listbox');
        set(listboxx,'Value',ptcurrent)

        mri_scan.ptcurrent = ptcurrent;
        x = ptcoord(ptcurrent,1);
        y = ptcoord(ptcurrent,2);
        z = ptcoord(ptcurrent,3);

        set(s1,'Value',y);
        set(s2,'Value',get(s2,'Max') - z);
        set(s3,'Value',x);

        mri_scan.gotopoint = 1;
        set(MAINWINDOW ,'Userdata',mri_scan);

        mritool_cb sliders

        mri_scan.gotopoint = 0;
        set(MAINWINDOW ,'Userdata',mri_scan);
        %-----------------------------------------------------------------------------------------------
    case 'deletepoint'
        MAINWINDOW = findobj(0,'Tag','mainwindow');

        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        mri = mri_scan.mri;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');
        x = get(s3,'Value');
        y = get(s1,'Value');
        z = get(s2,'Max')-get(s2,'Value');
        ptname =  mri_scan.ptname ;
        ptcoord =  mri_scan.ptcoord;
        pthandle =  mri_scan.pthandle ;
        ptcurrent = mri_scan.ptcurrent;

        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');
        x = get(s3,'Value');
        y = get(s1,'Value');
        z = get(s2,'Max')-get(s2,'Value');
        ptname =  mri_scan.ptname ;
        ptcoord =  mri_scan.ptcoord;
        pthandle =  mri_scan.pthandle ;
        ptcurrent = mri_scan.ptcurrent;
        ptlabels = mri_scan.ptlabels;

        delete(ptlabels(ptcurrent,:))
        delete(pthandle(ptcurrent,:))

        ptname(ptcurrent) = [];
        ptcoord(ptcurrent,:) = [];
        pthandle(ptcurrent,:) = [];
        ptlabels(ptcurrent,:)= [];

        ptcurrent = 1;

        if isempty(ptlabels)
            set(findobj(MAINWINDOW,'Tag','deletepoint'),'enable','off')
        end

        listboxx = findobj(MAINWINDOW,'Tag','listbox');
        set(listboxx,'Value',1,'String',ptname)
        set(listboxx,'Value',ptcurrent)

        mri_scan.ptname = ptname ;
        mri_scan.ptcoord   = ptcoord;
        mri_scan.pthandle = pthandle ;
        mri_scan.ptcurrent = ptcurrent;
        mri_scan.ptlabels = ptlabels;

        set(MAINWINDOW ,'Userdata',mri_scan);

        if size(mri_scan.ptlabels,1) > 2
            set(findobj(MAINWINDOW,'Tag','PCS'),'enable','on')
        else
            set(findobj(MAINWINDOW,'Tag','PCS'),'enable','off')
        end

        %-----------------------------------------------------------------------------------------------
    case 'flip_lr_a'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        cor = mri_scan.cor;
        flip = get(findobj(gcbf,'Tag','flip_lr_a'),'Value');

        axa  = mri_scan.axa;

        mri_scan.mri = mri_scan.mri([size(mri_scan.mri,1):-1:1],:,:);

        s2 = findobj(   MAINWINDOW ,'Tag','2');
        s3 = findobj(   MAINWINDOW ,'Tag','3');
        pix_siz = mri_scan.pix_siz;
        ii = round(get(s2,'Value')/pix_siz(3)+1);
        str = ':,:,ii';
        eval(['mri_tmp = squeeze(mri_scan.mri(',str,'));']);
        set(ax,'Cdata',(mri_tmp));

        ic = round(get(s3,'Value')/pix_siz(1)+1);
        strc = ':,ic,:';
        eval(['mri_tmp = fliplr(flipud(squeeze(mri_scan.mri(',strc,'))''));']);
        set(cor,'Cdata',(mri_tmp));

        set(MAINWINDOW,'Userdata',mri_scan);

        %-----------------------------------------------------------------------------------------------

    case 'flip_ud_s'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        axs = mri_scan.axs;
        pix_siz = mri_scan.pix_siz;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s3 = findobj(MAINWINDOW ,'Tag','3');
        sag = mri_scan.sag;
        cor = mri_scan.cor;

        %flip = get(findobj(gcbf,'Tag','flip_ud_s'),'Value');
        mri_scan.mri = mri_scan.mri(:,:,[size(mri_scan.mri,3):-1:1]);

        set(MAINWINDOW ,'Userdata',mri_scan);

        ii = round((get(s1,'Max')-get(s1,'Value'))/pix_siz(2)+1);
        str = 'ii,:,:';
        eval(['mri_tmp = flipud(squeeze(mri_scan.mri(',str,'))'');']);
        set(sag,'Cdata',(mri_tmp));

        ic = round(get(s3,'Value')/pix_siz(1)+1);

        strc = ':,ic,:';
        eval(['mri_tmp = fliplr(flipud(squeeze(mri_scan.mri(',strc,'))''));']);
        set(cor,'Cdata',(mri_tmp));

        %-----------------------------------------------------------------------------------------------

    case 'flip_ud_c'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        axc = mri_scan.axc;
        flip = get(findobj(gcbf,'Tag','flip_ud_c'),'Value');
        if flip
            set(axc,'Ydir','normal')
        else
            set(axc,'Ydir','reverse')
        end

        %-----------------------------------------------------------------------------------------------

    case 'saveas_points'

        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        if isempty(mri_scan)
            return
        end

        ptname =  mri_scan.ptname ;
        ptcoord =  mri_scan.ptcoord;

        if isempty(ptcoord)
            return
        end

        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');
        x = ptcoord(:,1);
        y = ptcoord(:,2);
        z = ptcoord(:,3);

        pix_size = mri_scan.pix_size;
        CubeSize = size(mri_scan.mri);

        %VoxSize = mri_scan.pix_siz([2 1 3]);

        VoxSize = mri_scan.fov./CubeSize([2 1 3]);

        pix = VoxSize([2 1 3]);
        fov  = pix.* CubeSize;

        ix = ((fov(2)-y)/pix_size(2)+1);
        iy = (x/pix_size(1)+1);
        iz = ((fov(3)-z)/pix_size(3)+1);

        if mri_scan.pcs == 1    % If a PCS exists - get its paramters
            center = mri_scan.center;
            pcs = mri_scan.pcs_type;

            switch pcs
            case {'NEUROMAG','CTF'}
                if 0
                    rot = mri_scan.rot;
                    tmp = rot*[x';y';z'];
                    x = tmp(1,:);
                    y = tmp(2,:);
                    z = tmp(3,:);
                end
                PCS.R = inv(mri_scan.rot);
                PCS.t = mri_scan.center;

                [XYZpcs] = mri2pcs([ix,iy,iz], PCS, VoxSize([2 1 3]),CubeSize);

                if 0
                    x = x - PCS.t(1);
                    y = y - PCS.t(2);
                    z = z - PCS.t(3);
                    XYZpcs = PCS.R*([x,y,z]');
                    XYZpcs = XYZpcs';
                end
            end
        end

        [fpt_file,fpt_dir] = uiputfile('*.fpt','Save point locations in...');

        file = fopen([fpt_dir,fpt_file],'w+');
        if ~file
            errordlg('I/O Error',['Error trying to create ',fpt_file])
            return
        end

        for i=1:size(ptcoord,1)
            tmp = char(ptname{i});
            fprintf(file,'%d\t%s\t\t\t%6.2f\t%6.2f\t%6.2f\t%d\t%d\t%d\n',i,tmp,[XYZpcs(i,1),XYZpcs(i,2),XYZpcs(i,3)],round([ix(i),iy(i),iz(i)]));
        end
        fclose(file);

        mri_scan.fpt_file = [fpt_dir,fpt_file];

        %-----------------------------------------------------------------------------------------------

    case 'leaflet' % display every fiducial or focus in a window with corresponding MR slices and coordinates
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        color = get(MAINWINDOW,'colormap');
        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');
        ptname =  mri_scan.ptname ;
        ptcoord =  mri_scan.ptcoord;
        pthandle =  mri_scan.pthandle ;
        ptcurrent = mri_scan.ptcurrent;
        mri_scan.ptcurrent = ptcurrent;

        mri_scan.leaflet = 1;
        toto = 0;

        % Determine the color of the source time series according to the MRI markers' colors
        h = findobj(flipud(get(axa,'Children')),'Type','patch');
        colors = get(h,'MarkerfaceColor');
        if ~iscell(colors) % Basically when there's just one source
            colors = {colors};
        end
        colors =  reshape([colors{:}],3,length([colors{:}])/3)';

        for ptcurrent = 1:size(pthandle,1)
            x = ptcoord(ptcurrent,1);
            y = ptcoord(ptcurrent,2);
            z = ptcoord(ptcurrent,3);
            set(s1,'Value',y);
            set(s2,'Value',get(s2,'Max') - z);
            set(s3,'Value',x);
            mri_scan.gotopoint = 1;
            set(MAINWINDOW ,'Userdata',mri_scan);
            mritool_cb sliders

            leaflet
            leaflets = findobj(0,'Tag','FIG_LEAFLET');
            set(0,'CurrentFigure',leaflets(1));
            set(gcf,'Name',['Leaflet - ',upper(char(ptname{ptcurrent}))],'colormap',color)
            l_axs = findobj(gcf,'Tag','leaf_axs');
            pos = get(l_axs,'Position');
            delete(l_axs)
            l_axs = copyobj(axs,gcf);
            set(l_axs,'Position',pos)

            l_axc = findobj(gcf,'Tag','leaf_axc');
            pos = get(l_axc,'Position');
            delete(l_axc)
            l_axc = copyobj(axc,gcf);
            set(l_axc,'Position',pos)

            l_axa = findobj(gcf,'Tag','leaf_axa');
            pos = get(l_axa,'Position');
            delete(l_axa)
            l_axa = copyobj(axa,gcf);
            set(l_axa,'Position',pos)

            h = copyobj(flipud(get(axs,'Children')),l_axs);
            % flipud to plot the MRI scan first then the points above
            % otherwise points are not visible (sent to the back of the picture)
            h = findobj(h,'Type','patch');
            if isempty(h), return, end
            set(gcf,'CurrentAxes',l_axs)
            %axis equal
            a = get(h,'tag');
            i_hh = strmatch(char(ptname{ptcurrent}),[a(:)],'exact');
            set(h(i_hh),'visible','off')
            set(h(i_hh),'visible','on')
            set(h(i_hh),'Markersize',2)

            h = copyobj(flipud(get(axa,'Children')),l_axa);
            h = findobj(h,'Type','patch');
            if isempty(h), return, end
            set(gcf,'CurrentAxes',l_axa)
            %axis equal
            axis ij
            a = get(h,'tag');
            i_hh = strmatch(char(ptname{ptcurrent}),[a(:)],'exact');
            set(h(i_hh),'visible','off')
            set(h(i_hh),'visible','on')
            set(h(i_hh),'Markersize',2)

            h = copyobj(flipud(get(axc,'Children')),l_axc);
            h = findobj(h,'Type','patch');
            if isempty(h), return, end
            set(gcf,'CurrentAxes',l_axc)
            %axis equal
            a = get(h,'tag');
            i_hh = strmatch(char(ptname{ptcurrent}),[a(:)],'exact');
            set(h(i_hh),'visible','off')
            set(h(i_hh),'visible','on')

            ax_time = findobj(gcf,'Tag','timeseries');
            if isempty(findobj(0,'Tag','mri_src_mapping'))
                set(ax_time,'Visible','off')
                couleur{ptcurrent} = 'c';
            else
                Results  = get(findobj(0,'Tag','mri_src_mapping'),'Userdata');
                S = Results.TimeSeries;

                % Get the Time Values
                User = get_user_directory;
                cd(User.STUDIES)
                load(Results.StudySubject.Data{1},'Time'); % in msec
                Time = 1000*Time(Results.Time);% in msec

                t = Time;

                Sn = colnorm(S);
                Sn = S./Sn(ones(1,size(S,1)),:);
                % each waveform is now unity in norm. Weight
                %  by its total contribution to the field
                axes(ax_time)
                %tmp = set(ax_time,'colororder');
                set(ax_time,'colororder',colors,'color',get(gcf,'color'))
                grid on
                hold on
                hh = plot(t,S);
                if ptcurrent > 1
                    if strcmp(ptname{ptcurrent},ptname{ptcurrent-1}) % 2 synchronous sources
                        toto = toto - 1;
                    else
                        toto = toto + 1;
                    end
                else
                    toto = 1;
                end

                set(hh(toto),'linewidth',3)
                set(ax_time,'xcolor',frontcolor,'ycolor',frontcolor)
                grid on
                %col = get(hh,'color');
                %col = col{toto};
                %set(findobj(gcf,'Type','patch'),'MarkerFaceColor',col,'MarkerEdgeColor',col)
                %         couleur{ptcurrent} = col;
                tmp =  get(findobj(gcf,'Type','patch'),'MarkerFaceColor');
                couleur{ptcurrent}  = tmp{1};
            end

        end

        if size(pthandle,1) > 1
            seepoints = findobj(gcbf,'Tag','seepoints');
            set(seepoints,'String', 'Hide Points');
            set(pthandle,'Visible','on');

            if 0
                for i = 1:size(pthandle,1)
                    col = couleur{i};
                    %set(pthandle(i,:),'MarkerFaceColor',col,'MarkerEdgeColor',col)
                end
            end

            mri_scan.seepoints = 0;

            leaflet
            leaflets = findobj(0,'Tag','FIG_LEAFLET');
            set(0,'CurrentFigure',leaflets(1));
            set(gcf,'Name','Leaflet - All Sources','colormap',color)
            l_axs = findobj(gcf,'Tag','leaf_axs');
            pos = get(l_axs,'Position');
            delete(l_axs)
            l_axs = copyobj(axs,gcf);
            set(l_axs,'Position',pos)

            l_axc = findobj(gcf,'Tag','leaf_axc');
            pos = get(l_axc,'Position');
            delete(l_axc)
            l_axc = copyobj(axc,gcf);
            set(l_axc,'Position',pos)

            l_axa = findobj(gcf,'Tag','leaf_axa');
            pos = get(l_axa,'Position');
            delete(l_axa)
            l_axa = copyobj(axa,gcf);
            set(l_axa,'Position',pos)

            h = copyobj(flipud(get(axs,'Children')),l_axs);
            % flipud to plot the MRI scan first then the points above
            % otherwise points are not visible (sent to the back of the picture)
            h = findobj(h,'Type','patch');
            if isempty(h), return, end
            set(gcf,'CurrentAxes',l_axs)
            %axis equal
            a = get(h,'tag');
            i_hh = strmatch(char(ptname{ptcurrent}),[a(:)],'exact');
            set(h(i_hh),'visible','off')
            set(h(i_hh),'visible','on')
            set(h(i_hh),'Markersize',2)

            h = copyobj(flipud(get(axa,'Children')),l_axa);
            h = findobj(h,'Type','patch');
            if isempty(h), return, end
            set(gcf,'CurrentAxes',l_axa)
            %axis equal
            axis ij
            a = get(h,'tag');
            i_hh = strmatch(char(ptname{ptcurrent}),[a(:)],'exact');
            set(h(i_hh),'visible','off')
            set(h(i_hh),'visible','on')
            set(h(i_hh),'Markersize',2)

            h = copyobj(flipud(get(axc,'Children')),l_axc);
            h = findobj(h,'Type','patch');
            if isempty(h), return, end
            set(gcf,'CurrentAxes',l_axc)
            %axis equal
            a = get(h,'tag');
            i_hh = strmatch(char(ptname{ptcurrent}),[a(:)],'exact');
            set(h(i_hh),'visible','off')
            set(h(i_hh),'visible','on')
            set(h(i_hh),'Markersize',2)

            ax_time = findobj(gcf,'Tag','timeseries');
            if isempty(findobj(0,'Tag','mri_src_mapping'))
                set(ax_time,'Visible','off')
            else
                Results  = get(findobj(0,'Tag','mri_src_mapping'),'Userdata');
                S = Results.TimeSeries;

                t = Time;

                Sn = colnorm(S);
                Sn = S./Sn(ones(1,size(S,1)),:);
                % each waveform is now unity in norm. Weight
                %  by its total contribution to the field
                axes(ax_time)
                grid on
                set(ax_time,'colororder',colors,'color',get(gcf,'color'))
                hold on
                hh = plot(t,S);
                set(hh,'linewidth',2)
                set(ax_time,'xcolor',frontcolor,'ycolor',frontcolor)
                grid on

            end

        end

        mri_scan.leaflet = 0;
        mri_scan.gotopoint = 0;
        set(MAINWINDOW ,'Userdata',mri_scan);

        %-----------------------------------------------------------------------------------------------

    case 'showfiducials'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        pix_siz = mri_scan.pix_siz;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');

        ptname = mri_scan.FiducialName;
        ptcoord = [mri_scan.ptcoord;mri_scan.PCSFiducial'];

        % Transform PCS coordinates in the MRI volume reference system
        switch mri_scan.pcs_type
        case {'NEUROMAG','CTF'}
            if ~isfield(mri_scan,'rot')
                errordlg('Please Define a PCS First')
                return
            end
            center = mri_scan.center;
            rot = mri_scan.rot;
            ptcoord = (inv(rot)*ptcoord')';
        end

        ptcoord(:,1) = ptcoord(:,1) + center(1);
        ptcoord(:,2) = ptcoord(:,2) + center(2);
        ptcoord(:,3) = ptcoord(:,3) + center(3);

        switch mri_scan.pcs_type
        case {'NEUROMAG','CTF'}
            icoord(:,1) = round(ptcoord(:,1)/pix_siz(3)+1);
            icoord(:,2) = round(ptcoord(:,2)/pix_siz(1)+1);
            icoord(:,3) = round(ptcoord(:,3)/pix_siz(2)+1);
        end

        for i = 1:size(ptcoord,1)
            x = ptcoord(i,1);
            y = ptcoord(i,2);
            z = ptcoord(i,3);

            axes(axs)
            hold on
            pt_s = scatter(x,z,'o','filled');
            set(pt_s,'Parent',axs,'userdata',y)
            pt_slabel = text(x,z,num2str(size(mri_scan.pthandle,1)));
            set(pt_slabel,'Parent',axs,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',y)

            axes(axa)
            hold on
            pt_a = scatter(x,get(s1,'Max')-y,'o','filled');
            set(pt_a,'Parent',axa,'userdata',z)
            pt_alabel = text(x,get(s1,'Max')-y,num2str(size(mri_scan.pthandle,1)));
            set(pt_alabel,'Parent',axa,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',z)

            axes(axc)
            hold on
            pt_c = scatter(y,z,'o','filled');
            set(pt_c,'Parent',axc,'userdata',x)
            pt_clabel = text(y,z,num2str(size(mri_scan.pthandle,1)));
            set(pt_clabel,'Parent',axc,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',x)

            set([pt_s,pt_a,pt_c],'markerfacecolor','c')
            mri_scan.pthandle = [mri_scan.pthandle;[pt_s,pt_a,pt_c]];
            mri_scan.ptlabels= [mri_scan.ptlabels;[pt_slabel,pt_alabel,pt_clabel]];

        end

        seepoints = findobj(gcbf,'Tag','seepoints');
        seelabels = findobj(gcbf,'Tag','seelabels');
        newlabel = findobj(gcbf,'Tag','newlabel');

        LEAFLET = findobj(gcbf,'Tag','LEAFLET');
        set(seelabels,'enable','on')
        set(newlabel,'enable','on')

        set(seepoints,'enable','on')
        set(LEAFLET,'enable','on')

        set(findobj(gcbf,'Tag','deletepoint'),'enable','on')

        listboxx = findobj(MAINWINDOW,'Tag','listbox');
        set(listboxx,'Visible','on')
        listboxx_title = findobj(MAINWINDOW,'Tag','listboxx_title');
        set(listboxx_title,'visible','on')
        listboxx = findobj(listboxx,'Tag','listbox');
        set(listboxx,'Value',1,'String',ptname)

        mri_scan.ptcurrent = size( mri_scan.ptcoord,1);

        mri_scan.ptname = ptname ;
        mri_scan.ptcoord = ptcoord ;

        visu_pt(mri_scan.pthandle)

        set(MAINWINDOW,'Userdata',mri_scan)

        points'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        pix_siz = mri_scan.pix_siz;
        s1 = findobj(MAINWINDOW ,'Tag','1');
        s2 = findobj(MAINWINDOW ,'Tag','2');
        s3 = findobj(MAINWINDOW ,'Tag','3');

        % Delete all previous points
        delete(findobj(get(axa,'children'),'type','patch'))
        delete(findobj(get(axc,'children'),'type','patch'))
        delete(findobj(get(axs,'children'),'type','patch'))

        [fpt_file,fpt_dir] = uigetfile('*.fpt','Load fiducial coordinates from...');
        if isempty(fpt_file), return, end

        file = fopen([fpt_dir,fpt_file],'r');
        if ~file
            errordlg('I/O Error',['Error while loading from ',fpt_file])
            return
        end
        i = 0;
        mri_scan.pthandle = [];
        mri_scan.ptlabels = [];
        %mri_scan.pcs = 0;

        while ~isempty(i)
            i = fscanf(file,'%d',1);
            if isempty(i), break, end
            ptname{i} = fscanf(file,'%s',1);
            ptcoord(i,:) = fscanf(file,'%f',3)';
            icoord(i,:) = fscanf(file,'%d',3)';

            if mri_scan.pcs == 0
                orig = findstr(ptname{i},'originPCS');
                if ~isempty(orig) % This set of points can be registered owing to a MEG-EEG PCS.
                    mri_scan.pcs = 1;
                    mri_scan.pcs_type = ptname{i}(findstr(ptname{i},'_')+1:end);
                    mri_scan.center = icoord;
                    center = icoord(i,:);
                    ptcenter = ptcoord(i,:)
                else
                    mri_scan.pcs = 0;
                    mri_scan.pcs_type = 'NONE';
                    center = [0 0 0];
                end
            end

        end
        fclose all;

        % Transform PCS coordinates in the MRI volume reference system
        switch mri_scan.pcs_type
        case 'NEUROMAG'
            %xtemp = ptcoord(:,1);
            %%%%%%ptcoord(:,1) = -ptcoord(:,2);
            %ptcoord(:,1) = ptcoord(:,2);
            %ptcoord(:,2) = xtemp;
            if ~isfield(mri_scan,'rot')
                errordlg('Please Define a PCS First')
                return
            end
            center = mri_scan.center;
            rot = mri_scan.rot;
            ptcoord = (inv(rot)*ptcoord')';
        end

        ptcoord(:,1) = ptcoord(:,1) + center(1);
        ptcoord(:,2) = ptcoord(:,2) + center(2);
        ptcoord(:,3) = ptcoord(:,3) + center(3);

        switch mri_scan.pcs_type
        case 'NEUROMAG'
            %      ptcoord(end,:) = ptcenter;
        end

        icoord(:,1) = round(ptcoord(:,1)/pix_siz(3)+1);
        icoord(:,2) = round(ptcoord(:,2)/pix_siz(1)+1);
        icoord(:,3) = round(ptcoord(:,3)/pix_siz(2)+1);

        for i = 1:size(ptcoord,1)
            x = ptcoord(i,1);
            y = ptcoord(i,2);
            z = ptcoord(i,3);

            %    set(axs,'Selected','on')

            axes(axs)
            hold on
            pt_s = scatter(x,z,'o','filled');
            set(pt_s,'Parent',axs,'userdata',y)
            pt_slabel = text(x,z,num2str(size(mri_scan.pthandle,1)));
            set(pt_slabel,'Parent',axs,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',y)

            axes(axa)
            hold on
            pt_a = scatter(x,get(s1,'Max')-y,'o','filled');
            set(pt_a,'Parent',axa,'userdata',z)
            pt_alabel = text(x,get(s1,'Max')-y,num2str(size(mri_scan.pthandle,1)));
            set(pt_alabel,'Parent',axa,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',z)

            axes(axc)
            hold on
            pt_c = scatter(y,z,'o','filled');
            set(pt_c,'Parent',axc,'userdata',x)
            pt_clabel = text(y,z,num2str(size(mri_scan.pthandle,1)));
            set(pt_clabel,'Parent',axc,'VerticalAlignment','top','Visible','off','Color','y','FontW','Bold',...
                'Userdata',x)

            set([pt_s,pt_a,pt_c],'markerfacecolor','c')
            mri_scan.pthandle = [mri_scan.pthandle;[pt_s,pt_a,pt_c]];
            mri_scan.ptlabels= [mri_scan.ptlabels;[pt_slabel,pt_alabel,pt_clabel]];

        end

        seepoints = findobj(gcbf,'Tag','seepoints');
        seelabels = findobj(gcbf,'Tag','seelabels');
        newlabel = findobj(gcbf,'Tag','newlabel');

        LEAFLET = findobj(gcbf,'Tag','LEAFLET');
        set(seelabels,'enable','on')
        set(newlabel,'enable','on')
        set(seepoints,'enable','on')
        set(LEAFLET,'enable','on')

        set(findobj(gcbf,'Tag','deletepoint'),'enable','on')

        listboxx = findobj(MAINWINDOW,'Tag','listbox');
        set(listboxx,'Visible','on')
        listboxx_title = findobj(MAINWINDOW,'Tag','listboxx_title');
        set(listboxx_title,'visible','on')
        legend_sources = findobj(MAINWINDOW,'Tag','legend_sources');
        set(legend_sources,'visible','on')
        listboxx = findobj(listboxx,'Tag','listbox');
        set(listboxx,'Value',1,'String',ptname)

        mri_scan.ptcurrent = size( mri_scan.ptcoord,1);

        mri_scan.ptname = ptname ;
        mri_scan.ptcoord = ptcoord ;

        visu_pt(mri_scan.pthandle)

        set(MAINWINDOW,'Userdata',mri_scan)

        %-----------------------------------------------------------------------------------------------

    case 'readresults'

        mri_src_mapping

        %-----------------------------------------------------------------------------------------------

    case 'concatenate'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        Header = findobj(gcbf,'Tag','header');
        header = str2num(get(Header,'String'));

        C = get(findobj(MAINWINDOW,'Tag','CurrentDrive'),'String');
        cd(C);

        d = dir;
        str1 = {d.name};
        [s1,v] = listdlg('PromptString','First Set of Files :',...
            'SelectionMode','multiple',...
            'ListString',str1);

        if v == 0
            return
        end

        while length(s1)==1
            cd(str1{s1});
            d = dir;
            str1 = {d.name};

            [s1,v] = listdlg('ListString',str1);

            if v==0
                return
            end

        end

        dir1 = pwd;
        nfile1 = length(s1);

        %-------------------------

        d = dir;
        str2 = {d.name};
        [s2,v] = listdlg('PromptString','Second Set of Files :',...
            'SelectionMode','multiple',...
            'ListString',str2);

        if v == 0
            return
        end

        while length(s2)==1
            cd(str2{s2});
            d = dir;
            str2 = {d.name};
            [s2,v] = listdlg('PromptString','Select a file :',...
                'SelectionMode','multiple',...
                'ListString',str2);
            if v==0
                return
            end

        end
        dir2 = pwd;
        nfile2 = length(s2);

        if nfile1~=nfile2
            errodlg('Please Select the Same Number of Files for Both Sets')
            return
        end

        data_format = findobj(gcbf,'Tag','data_format');
        code = (get(data_format,'String'));
        tmp = get(data_format,'Value');
        code = strtok(char(code(tmp)));

        [rootfile,dirroot] = uiputfile('toto.img','Enter a Root File Name...');
        hh = waitbar(0,'Concatenating files...');
        for i=1:nfile1
            root = strtok(rootfile,'.');
            if isempty(root)
                root= rootfile;
            end

            if i<10
                str = '00';
            elseif i<100
                str = '0';
            else
                str = '';
            end

            f1 = fopen([dir1,'\',str1{s1(i)}],'r');
            fseek(f1,header,'bof');
            f2 = fopen([dir2,'\',str2{s2(i)}],'r');
            fseek(f2,header,'bof');
            file = fopen([dirroot,root,str,num2str(i),'.img'],'w+');

            if ~file
                errordlg('I/O Error',['Error trying to create ',root])
                delete(hh)
                return
            end

            mri1 = fliplr(fread(f1,[128,128],code)); % Convention spm
            mri2 = fliplr(fread(f2,[128 128],code));

            fwrite(file,[mri1,mri2],code);

            fclose all;
            waitbar(i/nfile1);

        end
        delete(hh)

        %-----------------------------------------------------------------------------------------------

    case 'saveaxial'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        nslice = mri_scan.nslice;

        data_format = findobj(gcbf,'Tag','data_format');
        code = (get(data_format,'String'));
        tmp = get(data_format,'Value');
        code = strtok(char(code(tmp)));

        [rootfile,rootdir] = uiputfile('*.img','Enter a Root File Name...');

        hh = waitbar(0,'Writing files...');
        for i=1:size(mri_scan.mri,3)
            root = strtok(rootfile,'.');
            if isempty(root)
                root= rootfile;
            end

            if i<10
                str = '00';
            elseif i<100
                str = '0';
            else
                str = '';
            end

            file = fopen([rootdir,root,str,num2str(i),'.img'],'w+');
            if ~file
                errordlg('I/O Error',['Error trying to create ',root])
                delete(hh)
                return
            end

            fwrite(file,(mri_scan.mri(:,:,i)),code);

            fclose(file);
            waitbar(i/nslice);

        end
        delete(hh)

        %-----------------------------------------------------------------------------------------------

    case 'gotopoint'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        nslice = mri_scan.nslice;
        fov = mri_scan.fov;
        siz = mri_scan.siz;
        ic = mri_scan.ic ;
        is = mri_scan.is ;
        ia = mri_scan.ia ;
        pix_siz = mri_scan.pix_siz ;
        s1 = findobj(gcbf,'Tag','1');
        s2 = findobj(gcbf,'Tag','2');
        s3 = findobj(gcbf,'Tag','3');
        show_coordinates = findobj(   MAINWINDOW ,'Tag','show_coordinates');
        if get(show_coordinates,'Value')
            SHOW_COORDINATES = 1;
        else
            SHOW_COORDINATES = 0;
        end
        pix_siz = mri_scan.pix_siz ;

        MOUSE_SLCT = findobj(MAINWINDOW ,'tag','mouse_slct');
        set(MOUSE_SLCT,'value',0);
        gotopoint = findobj(MAINWINDOW,'Tag','gotopoint');

        if ~get(gotopoint,'Value')
            return
        end

        switch get(MAINWINDOW,'CurrentObject')
        case ax
            tmp = get(axa,'Currentpoint');
            pt = tmp(1,1:2);
            x = pt(1);
            y = pt(2);
            set(s1,'Value',get(s1,'Max')-y);
            set(s3,'Value',x);
            ic = round(get(s3,'Value')/pix_siz(1)+1);

            if SHOW_COORDINATES
                set(axs,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
                set(axa,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
            end

            is = round((get(s1,'Max')-get(s1,'Value'))/pix_siz(2)+1);
            if SHOW_COORDINATES
                set(axc,'Xtick',get(s1,'Value'),'Xticklabel',num2str(get(s1,'Value'),FORMATtick))
                set(axa,'Ytick',get(s1,'Max')-get(s1,'Value'));
            end

            strs = 'is,:,:';
            strc = ':,ic,:';
            eval(['mri_tmp = flipud(squeeze(mri_scan.mri(',strs,'))'');']);
            set(sag,'Cdata',(mri_tmp));
            eval(['mri_tmp = fliplr(flipud(squeeze(mri_scan.mri(',strc,'))''));']);
            set(cor,'Cdata',(mri_tmp));

        case cor
            tmp = get(axc,'Currentpoint');
            pt = tmp(1,1:2);
            y = pt(1);
            z = pt(2);
            set(s1,'Value',y);
            set(s2,'Value',get(s2,'Max')-z);
            is = round((get(s1,'Max')-get(s1,'Value'))/pix_siz(2)+1);
            if SHOW_COORDINATES
                set(axc,'Xtick',get(s1,'Value'),'Xticklabel',num2str(get(s1,'Value'),FORMATtick))
                set(axa,'Ytick',get(s1,'Max')-get(s1,'Value'));
            end

            ia = round(get(s2,'Value')/pix_siz(3)+1);
            if SHOW_COORDINATES
                set(axc,'Ytick',get(s2,'Max') - get(s2,'Value'),'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
                set(axs,'Ytick',get(s2,'Max') - get(s2,'Value'));
            end

            strs = 'is,:,:';
            stra = ':,:,ia';
            eval(['mri_tmp = flipud(squeeze(mri_scan.mri(',strs,'))'');']);
            set(sag,'Cdata',(mri_tmp));
            eval(['mri_tmp = squeeze(mri_scan.mri(',stra,'));']);
            set(ax,'Cdata',(mri_tmp));

        case sag
            tmp = get(axs,'Currentpoint');
            pt = tmp(1,1:2);
            x = pt(1);
            z = pt(2);
            set(s3,'Value',x);
            set(s2,'Value',get(s2,'Max')-z);
            ic = round(get(s3,'Value')/pix_siz(1)+1);
            if SHOW_COORDINATES
                set(axs,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
                set(axa,'Xtick',get(s3,'Value'),'Xticklabel',num2str(get(s3,'Value'),FORMATtick))
            end

            ia = round(get(s2,'Value')/pix_siz(3)+1);
            if SHOW_COORDINATES
                set(axc,'Ytick',get(s2,'Max') - get(s2,'Value'),'Yticklabel',num2str(get(s2,'Value'),FORMATtick ))
                set(axs,'Ytick',get(s2,'Max') - get(s2,'Value'));
            end

            stra = ':,:,ia';
            strc = ':,ic,:';
            eval(['mri_tmp = fliplr(flipud(squeeze(mri_scan.mri(',strc,'))''));']);
            set(cor,'Cdata',(mri_tmp));
            eval(['mri_tmp = squeeze(mri_scan.mri(',stra,'));']);
            set(ax,'Cdata',(mri_tmp));

        end

        %-----------------------------------------------------------------------------------------------

    case 'ZoomButton'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;

        fig = figure;
        if isempty(mri_scan.otherfig )
            mri_scan.otherfig = fig;
        else
            mri_scan.otherfig = [  mri_scan.otherfig,fig];
        end

        gcob = get(MAINWINDOW,'CurrentObject');
        switch get(gcob,'Tag')
        case 'ZoomButton1'
            handle = axs;
        case 'ZoomButton2'
            handle = axa;
        case 'ZoomButton3'
            handle = axc;
        end

        color = get(MAINWINDOW,'colormap');
        handle = copyobj([handle],fig);

        set(handle,'Units','Normal','Position',[.01 .01 .98 .98])
        set(MAINWINDOW ,'Userdata' , mri_scan );
        set(0,'CurrentFigure',fig)
        set(fig,'colormap',color,'color',color(1,:),'Numbertitle','off','Name',['Zooooooom ',int2str(length( mri_scan.otherfig))]);
        set(fig,'Deletefcn','mritool_cb DeleteOtherFig')
        colormenu
        set(gcob,'Value',0)
        axes(handle)
        set(handle,'color',color(1,:));

        axis equal
        %-----------------------------------------------------------------------------------------------

    case 'quit'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        if ~isempty(mri_scan)
            if ~isempty(mri_scan.otherfig)
                delete(mri_scan.otherfig)
            end
        end

        close(MAINWINDOW)
        close(findobj(0,'Tag','fig_listofpoints'))

        %-----------------------------------------------------------------------------------------------

    case 'DeleteOtherFig'
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        fig = (gcbf);
        mri_scan.otherfig = mri_scan.otherfig(mri_scan.otherfig ~= fig);
        set(MAINWINDOW,'Userdata',mri_scan);
        %-----------------------------------------------------------------------------------------------

    case 'pcs'
        % Change of coordinate system -  to Neuromag, BTi, Ctf  -
        MAINWINDOW = findobj(0,'Tag','mainwindow');
        mri_scan = get(MAINWINDOW ,'Userdata');
        ax = mri_scan.ax;
        axa = mri_scan.axa;
        sag = mri_scan.sag;
        axs = mri_scan.axs;
        cor = mri_scan.cor;
        axc = mri_scan.axc;
        nslice = mri_scan.nslice;
        fov = mri_scan.fov;
        siz = mri_scan.siz;
        ic = mri_scan.ic ;
        is = mri_scan.is ;
        ia = mri_scan.ia ;
        pix_siz = mri_scan.pix_siz ;
        s1 = findobj(gcf,'Tag','1');
        s2 = findobj(gcf,'Tag','2');
        s3 = findobj(gcf,'Tag','3');
        pthandle = mri_scan.pthandle;
        ptlabels = mri_scan.ptlabels;
        ptcoord =  mri_scan.ptcoord;
        ptname = mri_scan.ptname;
        pcs_choice
        PCSWin = gcf;
        quit = findobj(PCSWin,'Tag','QUIT');
        set(gcf,'CurrentObject',findobj(gcf,'Tag','NEUROMAG'))
        while get(gcf,'CurrentObject') ~= quit
            waitforbuttonpress
            set(quit,'String',get(gco,'String'))
            if get(gcf,'CurrentObject') ~= quit
                pcs = get(get(gcf,'CurrentObject'),'Tag');
            else
                delete(gcf)
                break
            end
        end

        listboxx = findobj(0,'Tag','listbox');

        dummy = axes;
        set(dummy,'Visible','off')
        set(MAINWINDOW,'CurrentObject',dummy)

        h = msgbox('Please Select the Nasion Point in the List');
        waitfor(h)
        waitfor(MAINWINDOW,'CurrentObject',listboxx)
        NAS = get(listboxx,'Value');

        h = msgbox('Please Select the RIGHT Preauricular Point in the List');
        waitfor(h)
        waitfor(listboxx,'Value')
        RPA = get(listboxx,'Value');

        h = msgbox('Please Select the LEFT Preauricular Point in the List');
        waitfor(h)
        waitfor(listboxx,'Value')
        LPA = get(listboxx,'Value');
        delete(dummy)

        for i=1:3
            set(pthandle(NAS,i),'Markerfacecolor','y')
            set(pthandle(LPA,i),'Markerfacecolor','y')
            set(pthandle(RPA,i),'Markerfacecolor','y')
        end

        % Get the coordinates of the fiducials

        str_listboxx = get(listboxx,'String');
        mri_scan.FiducialName = {str_listboxx{NAS},str_listboxx{LPA},str_listboxx{RPA},'Origin'};

        NAS = ptcoord(NAS,:);
        LPA = ptcoord(LPA,:);
        RPA = ptcoord(RPA,:);

        scale = [pix_siz(2),pix_siz(1),pix_siz(3)];

        mri_scan.CubeFiducial = round([NAS./scale;LPA./scale;RPA./scale]'); % Indices of the slices containing the fiducials

        % New Coordinate System - PCS
        switch pcs
        case 'NEUROMAG'
            LR = LPA - RPA; % Left\Right Vector
            LR = LR/norm(LR);
            LRp = [0 -1 0;1 0 0;0 0 0]* LR'; % A vector orthogonal to LR that will define a plane perpendicular to the NLR plane
            LRp = LRp'/norm(LRp);
            % note: The LR line is defined according to the intersection between 2 orthogonal planes.

            nLR= cross(NAS-RPA,LPA-RPA);  % Vector normal to the NLR plane
            nLR = nLR/norm(nLR);

            A = [nLR;LRp;LR];
            B = sum(A.*[LPA;LPA;NAS],2);

            center = A\B;

            % Rotation associee
            vy = (RPA-center')'/norm((RPA-center'));
            vx = (NAS-center')'/norm((NAS-center'));
            rot = [0 1 0;1 0 0;0 0 1]*inv([vx,vy,cross(vx,vy)]);
            mri_scan.pcs_type = 'NEUROMAG';

        case 'CTF'
            old = 0;

            if old
                LR = LPA - RPA; % Left\Right Vector
                LR = LR/norm(LR);
                LRp = [0 -1 0;1 0 0;0 0 0]* LR'; % A vector orthogonal to LR that will define a plane perpendicular to the NLR plane
                LRp = LRp'/norm(LRp);
                % note: The LR line is defined according to the intersection between 2 orthogonal planes.

                nLR= cross(NAS-RPA,LPA-RPA);  % Vector normal to the NLR plane
                nLR = nLR/norm(nLR);

                A = [nLR;LRp;LR];
                B = sum(A.*[LPA;LPA;NAS],2);

                center = A\B;

                % Rotation associee
                vy = (RPA-center')'/norm((RPA-center'));
                vx = (NAS-center')'/norm((NAS-center'));
            else
                center = .5*(LPA+RPA)';
                nLR= cross(NAS-RPA,LPA-RPA);  % Vector normal to the NLR plane
                nLR = nLR/norm(nLR);

                vx = (NAS-center')'/norm((NAS-center'));
                vy = inv([vx';nLR;cross(vx',nLR)])*[0 0 1]'; % y direction
                vy = vy/norm(vy);

            end

            rot = [0 1 0;1 0 0;0 0 1]*inv([vx,vy,cross(vx,vy)]);
            rot = [0 1 0;-1 0 0;0 0 1]* rot;
            mri_scan.pcs_type = 'CTF';

        end

        mri_scan.CubeFiducial = [mri_scan.CubeFiducial,round(center./scale')];

        x = center(1);
        y = center(2);
        z = center(3);

        center_s = scatter(x,z,'o','filled');
        set(center_s,'Parent',axs,'Userdata',y,'Visible','on','MarkerfaceColor','r')

        center_a = scatter(x,get(s1,'Max')-y,'o','filled');
        set(center_a,'Parent',axa,'Userdata',z,'Visible','on','MarkerfaceColor','r')

        center_c = scatter(y,z,'o','filled');
        set(center_c,'Parent',axc,'Userdata',x,'Visible','on','MarkerfaceColor','r')

        mri_scan.pcs = 1;
        mri_scan.center = center;
        mri_scan.RPA = RPA;
        mri_scan.LPA = LPA;
        mri_scan.NAS = NAS;
        mri_scan.rot = rot;

        % Coordinates of the fiducials in the PCS
        fiduc(:,1) = rot*(NAS'-center);
        fiduc(:,2) = rot*(LPA'-center);
        fiduc(:,3) = rot*(RPA'-center);
        mri_scan.PCSFiducial = [fiduc,[0 0 0]'];

        set(MAINWINDOW,'Userdata',mri_scan)

        mritool_cb SaveAsBrainstorm

    end

    %%----------------------------------------------------------------------------------%%
    %%----------------------------------------------------------------------------------%%
    %%----------------------------------------------------------------------------------%%
    %%                                Subroutines
    %%----------------------------------------------------------------------------------%%
    %%----------------------------------------------------------------------------------%%
    %%------------------------------------------------------------------------------

    function visu_pt(pthandle)
    % Check whether there is any selected point in the current slices
    % If no : set them visible | off
    % If yes : set them visible | on
    % Author : Sylvain Baillet, Ph.D.
    % Signal and Image Processing Institute - University of Southern California
    % Los Angeles - USA
    % The BrainStorm Toolbox
    % October 7, 1998.

    if isempty(pthandle)
        return
    end
    MAINWINDOW = findobj(0,'Tag','mainwindow');
    mri_scan = get(MAINWINDOW ,'Userdata');
    s1 = findobj(MAINWINDOW ,'Tag','1');
    s2 = findobj(MAINWINDOW ,'Tag','2');
    s3 = findobj(MAINWINDOW ,'Tag','3');

    axa = mri_scan.axa;
    axs = mri_scan.axs;
    axc = mri_scan.axc;

    x = get(s3,'Value');
    y = get(s1,'Value');
    z = get(s2,'Max')-get(s2,'Value');

    obj_c = findobj(MAINWINDOW ,'Parent',axc,'Userdata',x);
    if ~isempty(obj_c)
        if mri_scan.seelabels == 0
            set(findobj(obj_c,'type','text'),'Visible','on');
        end
        set(findobj(MAINWINDOW ,'Parent',axc,'type','patch'),'visible','off');
        set(findobj(obj_c,'type','patch'),'Visible','on');

    else
        set(findobj(MAINWINDOW ,'Parent',axc,'Type','patch'),'Visible','off');
        set(findobj(MAINWINDOW ,'Parent',axc,'Type','text'),'Visible','off');
    end

    obj_s = findobj(MAINWINDOW ,'Parent',axs,'Userdata',y);
    if ~isempty(obj_s)
        if mri_scan.seelabels == 0
            set(findobj(obj_s,'type','text'),'Visible','on');
        end
        set(findobj(MAINWINDOW ,'Parent',axs,'type','patch'),'visible','off');
        set(findobj(obj_s,'type','patch'),'Visible','on');

    else
        tmp = findobj(MAINWINDOW ,'Parent',axs,'Type','patch');
        set(tmp,'Visible','off');
        set(findobj(MAINWINDOW ,'Parent',axs,'Type','text'),'Visible','off');

    end

    obj_a = findobj(MAINWINDOW ,'Parent',axa);
    val = get(obj_a,'Userdata');
    val = [val{:}];

    i = find(abs(val-z)/z < 1e-10);
    obj_a = obj_a(i);

    if ~isempty(obj_a)

        if mri_scan.seelabels == 0

            set(findobj(obj_a,'type','text'),'Visible','on');

        end

        set(findobj(MAINWINDOW ,'Parent',axa,'type','patch'),'visible','off');

        set(findobj(obj_a,'type','patch'),'Visible','on');

    else

        set(findobj(MAINWINDOW ,'Parent',axa,'Type','patch'),'Visible','off');

        set(findobj(MAINWINDOW ,'Parent',axa,'Type','text'),'Visible','off');

    end

    % --------------------- SUBFUNCTION TO READ BINARY DATA ------------------------
    function A = get_gain(fid,ndx);

    %GET_GAIN - Get a set of source foward fields from a .bin gain matrix file
    % function A = get_gain(fid,ndx);
    % Get a set of source foward fields A from a .bin gain matrix file
    % INPUTS
    %       fid : a file identifier following a fopen call on a valid binary gain matrix file
    %       ndx : vector array of source indices for which the forward fields are requested
    % OUTPUTS
    %       A   : array of requested forward fields
    % See also READ_GAIN

    % \------------------------------------------------------/
    % | *** 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: October 2002
    % Script History -----------------------------------------------------------------------------------
    %---------------------------------------------------------------------------------------------------

    frewind(fid);

    rows = fread(fid,1,'uint32');

    if nargin == 2
       cols = length(ndx);

       A = zeros(rows,cols);

       for i = 1:cols,
          % 4 bytes per element, find starting point
          offset = 4 + (ndx(i)-1)*rows*4;
          status = fseek(fid,offset,'bof');
          if(status == -1),
             error(sprintf('Error reading file at column %.0f',i));
          end

          A(:,i) = fread(fid,[rows,1],'float32');

       end

       return

    else % ndx is not specified: read the whole matrix

       offset = 4;
       status = fseek(fid,offset,'bof');
       fbegin = ftell(fid);
       status = fseek(fid,0,'eof');
       fend = ftell(fid);

       frewind(fid);
       offset = 4;
       status = fseek(fid,offset,'bof');

       cols = (fend - fbegin + 1) / (4* rows); % Number of sources / columns

       A = fread(fid,[rows, cols],'float32');

    end

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