nvisBase.m

classdef (Abstract) nvisBase < handle
    %nvisBase Baseclass for nvis GUIs
    %   This class serves as a base class for the 'nvis...' classes,
    % 	which are optimized for visualizing multidimensional (complex)
    % 	matrices. nvisBase.m provides the building block for the GUI which are
    % 	placed in the figure by the inheriting classes.
    %
    %   Many of the UI features (windowing, colormap overlay,...) are
    %   handled by nvis member functions.
    
    %______________________________________________________________________
    % Authors:  Johannes Fischer
    %           Yanis Taege
   
    properties (Access = public)
        f
        Type
        
    end
		
    properties (Access = private)
        % DISPLAY PROPERTIES
        
        fftStatus       % keeps track of fft-button status
        
        
        % WINDOWING PROPERTIES
        Max             % maximum value in both images
        Min             % minimum value in both images
        Std             % standard deviation in both images
        center          % current value mapped to the center of the colormap
        width           % width of values mapped to the colormap, around center
        widthMin        % minimalWidth of the colormap, prevents division by 0
        centerStep      % how much 'center' changes when windowing
        widthStep       % how much 'width' changes when windowing
        nanColor        % color that used for data values 'NaN'
        
        
    end
    
    properties (Access = protected)
        %% INPUT PROPERTIES
        
        nImages         % number of images (1 or 2)
        nAxes           % number of displayed image Axes (nvis: 1, nvis3: 3)
        img             % cell array in which the input matrices are stored
        nDims           % number of image dimensions
        ston            % cell array for dimensions where a matrix is the only singleton
        isComplex       % is one of the inputs complex
        isFloat         % are the inputs float or integer
        hasNan          % a currently shown slice contains NaN values
        S               % size of the image(s)
        p               % input parser
        standardTitle   % name of the figure, default depends on inputnames
        varargin        % member variable varargin
                
        %% DISPLAYING
        
        % link sliders to image dimensions
        % mapSliderToDim(2) = 4 means, that slider 2 controls the slice along the
        % 4th dimension.
        mapSliderToDim
        
        % link sliders to images
        % mapSliderToImage{2} = 1   means, that slider 2 changes values in
        % obj.sel{1, :}.
        % mapSliderToImage{2} = ':' means, that slider 2 changes the
        % selector for all shown images
        mapSliderToImage
        
        % showDims(1, :) = [3 4] means, that in axis 1, the first
        % dimensions shows the input data along its third dimension, the
        % second axis shows the input data along its fourth dimension.
        showDims

        % if fixedDim ~= 0, this dimension remains the dimension looped by
        % the timer, and will never be one of the selected dimensions
        fixedDim
                
        % cell array that stores the location information in the input data
        % of each currently shown slice.
        % obj.sel{2, :} contains the subscripts to obtain the image shown
        % in axis 2
        sel
        
        % cell array containing the current slice image information
        slice
                
        % index of the currently active dimension for slider scrolling
        % etc...
        activeDim
        
        % index of the currently active ax element
        activeAx

        % which of the images is currently shown?
        layerShown      
        
        % timer
        t
        % index of the slider that is inc- or decremented by the timer
        % interrupt
        interruptedSlider
        % framerate of timer
        fps
        
        % stores the current complex representation mode
        complexMode
        
        % resize factor for the displayed data
        resize
        
        % used to rotate the view on the axes when necessary
        azimuthAng
        % stores the angular information in a rotation matrix
        rotMat
        
        % coordinates of the current point under the cursor (third element
        % is the axis, pt is empty when curser not over any axis)
        pt
        
        % contains the information, which contrast is currently chosen
        contrast
        
        % Foregroud color for text, similar in hue to the colormap of the
        % associated image
        COLOR_m
        
        % colormap for all images as a cell array, containing Nx3 colormaps
        cmap
        
        % overlay mode (1: add, 2: multiply, 3: overlay)
        overlay
        
        % label for each dimension
        dimLabel
        
        % values for each dimension
        dimVal

        % mask of nan values in currently displayed image
        nanLocs
        
        %% GUI ELEMENTS
        
        % array of images displayed in 'ax', the handle to the respective axis can always be obtained via
		% get(obj.hImage(...), 'Parent')
        hImage
               
        % array of slider handles to navigate through the slices
        hSlider
        hTextSlider
        hEditSlider
        
        % cw-windowing element arrays
        hTextC
        hTextW
        hEditC
        hEditW        
        hBtnHide
        hBtnToggle
        hBtnCwCopy
        hBtnCwHome
        hBtnCwSlice
        hBtnCwLink

        hBtnRotL
        hBtnRotR
        
        % select the colormap for each input image
        hPopCm
        
        % select the overlay mode
        hPopOverlay
        
        % buttons array for complex data display
        hBtnCmplx
        
        % FFT button
        hBtnFFT
        
        % Roi
        hBtnRoi
        hTextRoi
        hTextSNR
        hTextSNRvals
        hTextRoiType
        hPopRoiType
        hBtnDelRois
        hBtnSaveRois
        hLocAndVals
        
        % colorbars
        hAxCb        
        
        % animation elements
        hBtnRun
        hEditF
        hTextFPS
        
        % saving images and videos
        hBtnSaveImg
        hBtnSaveVid
        % minimize/maximize control panel
        hBtnMinimMaxim
        
        %% GUI ELEMENT PROPERTIES
        
        % number of sliders in the UI
        nSlider
        inputNames
        valNames
        
        % units of the input data
        unit
        
        % array with ROIs
        rois
        
        % mean in the signal rois
        signal
        
        % std-deviation in the noie rois
        noise
        
        % do we see the colorbars?
        cbShown
        
        % how are the colorbars oriented ('horizontal' or 'vertical')
        cbDirection
        
        % max number of letters for variable names in the locVal section
        maxLetters
        
        % colormaps available
        availableCmaps
        cmapStrings
        
        % are both images windowed simultaneously?
        linkedWindowing

        % keeps the state of the control panel (bool)
        maximized

        % figure title
        figureTitle
        
        %% other
        
        % path to this file
        resPath
        
    end
    
    
    properties (Constant = true, Hidden = true)
        % color scheme of the GUI
        COLOR_BG  = [0.2 0.2 0.2];
        COLOR_B   = [0.1 0.1 0.1];
        COLOR_F   = [0.9 0.9 0.9];
        COLOR_roi = [1.0 0.0 0.0;
                     0.0 0.0 1.0];
        contrastList = {'green-magenta', 'PET', 'heat'};
        zoomInFac  = 1.1;
        zoomOutFac = 0.9;
        
        BtnHideKey = {'w' 'e'};
        BtnTgglKey = 'q';
        
        overlayStrings = {'add', 'multiply', 'overlay'}
    end    
    
    
    %% abstract methods    
    methods (Abstract, Access = protected)
        locVal(obj, axNo)
        refreshUI(obj)
        incDecActiveDim(obj, incDec)
        mouseBtnNormal(obj, pt)
        mouseBtnAlt(src, evtData)
        recolor(obj)
        saveImgBtn(obj)
        minimMaximBtn(obj)
        mouseBtnDouble(obj)
    end
        
    
    methods (Access = protected)
        function obj = nvisBase(in, varargin)
            % CONSTRUCTOR
            obj.varargin = varargin;
            
            % check varargin for a sencond input matrix
            obj.inputCheck(in)
            
            % The slider for which dimension is initially active?
            obj.activeDim   = 1;
            
            % necessary for view orientation, already needed when saving image or video
            obj.azimuthAng  = 0;
            
            % set the default value for max Number of letters is locVal
            % section
            obj.maxLetters = 6;

            % start control panel in maximized state
            obj.maximized = true;
            
            % prepare roi parameters
            obj.rois         = {[], []};
            obj.signal       = NaN(1, obj.nImages);
            obj.noise        = NaN(1, obj.nImages);
            
            % initialize UI colors
            obj.COLOR_m = [obj.COLOR_F; obj.COLOR_F];
            
            % set the correct default value for complexMode
            if any(obj.isComplex)
                obj.complexMode = 1;
            else
                % if neither input is complex, display the real part of the
                % data
                obj.complexMode = 3;
            end
            
            % find min and max values in the input data
            obj.findMinMax()
            
            % prepare the input parser
            obj.prepareParser()
            
            % prepare the colormaps
            obj.prepareColormaps()
            
            [obj.resPath, ~, ~] = fileparts(mfilename('fullpath'));
            obj.resPath = [obj.resPath filesep() 'res' filesep()];
        end
        
        
        function delete(obj)            
            if ~isempty(obj.f) && isvalid(obj.f)
                close(obj.f)
                % close also calls the destructor on obj (again)
            else
                delete(obj)
            end
        end
        
        
        function findMinMax(obj)
            % Calculates the minimal and maximal value in the upto two
            % input matrices. If there are +-Inf values in the data, a
            % slower, less memory efficient calculation is performed.
            
            % min and max values are cast as doubles, to have their
            % datatype be independet of the input datatype
            if verLessThan('matlab', '9.5')
                % version is older than 2018b, use slower, but not very
                % slow max/min calculation implementation.
                obj.Max = [double(obj.cleverMax(obj.img{1})), double(obj.cleverMax(obj.img{2}))];
                obj.Min = [double(obj.cleverMin(obj.img{1})), double(obj.cleverMin(obj.img{2}))];
            else
                obj.Max = [double(max(obj.img{1}, [], 'all', 'omitnan')), double(max(obj.img{2}, [], 'all', 'omitnan'))];
                obj.Min = [double(min(obj.img{1}, [], 'all', 'omitnan')), double(min(obj.img{2}, [], 'all', 'omitnan'))];                
            end

            hasInf = obj.Max == Inf;
            for ii = find(hasInf)
                warning('Inf values present in input %d. For large input matrices this can cause memory overflow and long startup time.', ii)
                obj.Max(ii)           = double(max(obj.img{ii}(~isinf(obj.img{ii})), [], 'omitnan'));
            end
            
            hasInf = obj.Min == -Inf;
            for ii = find(hasInf)
                warning('Inf values present in input %d. For large input matrices this can cause memory overflow and long startup time.', ii)
                obj.Min(ii)           = min(obj.img{ii}(~isinf(obj.img{ii})), [], 'omitnan');
            end
            
            if obj.nImages == 1
                obj.Min(2) = 0;
                obj.Max(2) = 1;
            end
            
            obj.Max(obj.isComplex)  = abs(obj.Max(obj.isComplex));
            obj.Min(obj.isComplex)  = abs(obj.Min(obj.isComplex));
        end
        
        
        function inputCheck(obj, in)
            
            if ~isempty(obj.varargin) && ( isnumeric(obj.varargin{1}) || islogical(obj.varargin{1}) )
                % two input matrices
                obj.img{1}      = in;
                % get second matrix from varargin
                obj.img{2}      = obj.varargin{1};
                % remove second matrix from varargin, should only contain
                % NVPs now
                obj.varargin(1) = [];
                isEmpt          = cellfun(@isempty, obj.img);
                if ~sum( isEmpt )
                    % neither is empty
                    obj.nImages     = 2;
                    obj.isComplex   = ~cellfun(@isreal, obj.img);
                    obj.isFloat     = cellfun(@isfloat, obj.img);
                    obj.layerShown  = [1, 1];
                    obj.checkSize()
                elseif sum(isEmpt) == 1
                    % one input matrix is empty
                    warning('Input %d is empty! Only non-empty iputs are shown', find(isEmpt))
                    obj.nImages     = 1;
                    obj.isComplex   = ~cellfun(@isreal, obj.img);
                    obj.isFloat     = cellfun(@isfloat, obj.img);
                    obj.img(isEmpt) = [];
                    % for nImages=1, the second cell must be explicitly
                    % empty
                    obj.img{2} = [];
                    obj.S = size(obj.img{1});
                    obj.ston{1} = [];
                else
                    error('Both input matrices are empty')                    
                end
            else
                % one input matrix
                obj.img{1}       = in;
                obj.img{2}       = [];
                obj.nImages      = 1;                
                obj.isComplex    = ~isreal(obj.img{1});
                obj.isFloat      = isfloat(obj.img{1});
                obj.layerShown   = [1, 0];
                obj.S = size(obj.img{1});
                obj.ston{1} = [];
            end            
            obj.nDims = numel(obj.S);

            if any(obj.isComplex .* ~obj.isFloat)
                error('Complex integer types are currently not supported!')
            end
        end
        
        
        function checkSize(obj)
            
            % get the image sizes
            s1 = size(obj.img{1});
            s2 = size(obj.img{2});
            if numel(s1) ~= numel(s2)
                % and image dimensions (trailing singleton dimensions are not
                % considered by size)
                d1 = ndims(obj.img{1});
                d2 = ndims(obj.img{2});
                if d1 > d2
                    s2 = [s2 ones(1, d1-d2)];
                else
                    s1 = [s1 ones(1, d2-d1)];
                end
            end
            
            if any(s1 ~= s2)
                % there are dimensions, in wich both matrices have different
                % sizes
                
                % combine the sizes into one array
                s = [s1; s2];
                
                % check that for those dimensions, where the size differs,
                % one is equal to 1
                if any(min(s(:, s1~=s2),[], 1) ~= 1)
                    % there are dimensions where the size differs and
                    % neither of the matrices has a size of one along that
                    % dimension
                    error('Matrix dimensions must agree.')
                else
                    % find unique singleton dimensions in matrices
                    obj.ston{1} = find((s1 ~= s2) & s1 == 1);
                    obj.ston{2} = find((s1 ~= s2) & s2 == 1);
                end
                
                obj.S = max(s, [], 1);
            else
                % both input matrices have exactly the same size
                obj.ston{1} = [];
                obj.ston{2} = [];
                obj.S = size(obj.img{1});
            end
        end
        
        
        function prepareParser(obj)
            
            % default figure position and size. is adapted to actual screensize
            % and is separated from top/bottom by 10% of up/down screensize
            screenS = get(0, 'ScreenSize');
            defaultPosition = [ 300, round(0.1*screenS(4)), 800, round(0.8*screenS(4))];

            obj.p = inputParser;
            % add parameters to the input parser
            addParameter(obj.p, 'Position',     defaultPosition,                @(x) isnumeric(x) && numel(x) == 4);
            addParameter(obj.p, 'Overlay',      1,                              @(x) floor(x)==x && x >= 1); %is integer greater 1
            addParameter(obj.p, 'Colormap',     gray(256),                      @(x) iscell(x) | isnumeric(x) | ischar(x));
            addParameter(obj.p, 'Contrast',     'green-magenta',                @(x) obj.isContrast(x));
            addParameter(obj.p, 'ComplexMode',  obj.complexMode,                @(x) isnumeric(x) && x <= 4);
            addParameter(obj.p, 'AspectRatio',  'square',                       @(x) any(strcmp({'image', 'square'}, x)));
            addParameter(obj.p, 'Resize',       1,                              @isnumeric);
            addParameter(obj.p, 'Title',        obj.standardTitle,              @ischar);
            addParameter(obj.p, 'CW',           [(obj.Max(1) - obj.Min(1))/2+obj.Min(1), ...
                                                obj.Max(1)-obj.Min(1); ...
                                                (obj.Max(2) - obj.Min(2))/2+obj.Min(2), ...
                                                obj.Max(2)-obj.Min(2)],         @isnumeric);            
            addParameter(obj.p, 'widthMin',     0,                              @isnumeric);
            addParameter(obj.p, 'ImgLabel',     repmat({''}, 1, obj.nImages),   @(x) (iscell(x) && numel(x) <= 2) | ischar(x));
            addParameter(obj.p, 'Unit',         repmat({''}, 1, obj.nImages),   @(x) (iscell(x) && numel(x) <= 2) | ischar(x));
            addParameter(obj.p, 'DimLabel',     strcat(repmat({}, 1, numel(obj.S))), @(x) iscell(x) && numel(x) >= obj.nDims);
            addParameter(obj.p, 'DimVal',       cellfun(@(x) 1:x, num2cell(obj.S), 'UniformOutput', false), @iscell);            
            addParameter(obj.p, 'SaveImage',    '',                             @ischar);
            addParameter(obj.p, 'SaveVideo',    '',                             @ischar);
            addParameter(obj.p, 'fps',          0,                              @isnumeric);
            addParameter(obj.p, 'LoopDimension',3,                              @(x) isnumeric(x) && x <= obj.nDims && obj.nDims >= 3);
            addParameter(obj.p, 'LoopCount',    Inf,                            @isnumeric);
            addParameter(obj.p, 'fixedDim',     0,                              @isnumeric);
            addParameter(obj.p, 'InitRot',      zeros(1, obj.nAxes),            @isnumeric);
            addParameter(obj.p, 'NaNColor',     [1 0 0],                        @isnumeric);

        end
        
        
        function prepareColors(obj)            
            % Depending on the amount of input matrices and the provided
            % colormaps or contrast information, the colorscheme for the UI
            % is set and 'center', 'width', and 'widthMin' are given proper
            % initial values.
            %
            % Called by constructor of inheriting class
            %
            
            % set the string values for the colormaps in the popdown menus.
            
            
            % from the inputParser, get the initial colormaps
            if ~contains('Colormap', obj.p.UsingDefaults)
                % Colormap was used as NVP, this overrules any input from
                % the 'Contrast' NVP     
                obj.setInitialColormap(obj.p.Results.Colormap)
            elseif obj.nImages == 2
                % get initial Contrast for the display from InputParser values
                obj.setInitialContrast()
            end
            
            set(obj.hPopCm(1), 'String', obj.cmapStrings)
            if obj.nImages == 2
                set(obj.hPopCm(2), 'String', obj.cmapStrings)
            end
        
            obj.widthMin = [0 0];
            obj.center = zeros(4, 2);
            obj.width = zeros(4, 2);
            for idh = 1:obj.nImages
                obj.center([1 3 4], idh) = double(obj.p.Results.CW(idh, 1));
                obj.width([1 3 4], idh)  = double(obj.p.Results.CW(idh, 2));
                % set phase to range 0 2*pi
                obj.center(2, idh) = 0;
                obj.width(2, idh)  = 2*pi;
                set(obj.hEditC(idh), 'String', num2sci(obj.center(1, idh), 'padding', 'right'));
                set(obj.hEditW(idh), 'String', num2sci(obj.width(1, idh),  'padding', 'right'));
                % apply the initial colormaps to the popdown menus
                obj.setCmap(obj.hPopCm(idh))
            end
            obj.centerStep  = double(obj.center);
            obj.widthStep   = double(obj.width);

            % if any of the center/width values is zero, set the step to
            % that of the other value
            obj.centerStep(obj.centerStep == 0) = obj.widthStep(obj.centerStep == 0);
            obj.widthStep(obj.centerStep == 0) = obj.centerStep(obj.centerStep == 0);

            color = obj.p.Results.NaNColor(:);

             for iImage = 1:obj.nImages
                if any(sqrt(sum((obj.cmap{iImage} - color').^2, 2)) < 0.01)
                    warning('NaNColor is part of, or very close to one colormap. Change either to avoid ambiguity!')
                end
            end

            % prepare the NaN-Color
            obj.nanColor = reshape(color, [1, 1, 3]);

        end
        
        
        function prepareGUIElements(obj)
            
            % create figure handle, but hide figure
            obj.f = figure('Color', obj.COLOR_BG, ...
                'Visible',              'off',...
                'AutoResizeChildren',   'off');            
            
            % create UI elements for center and width
            obj.hTextC = uicontrol( ...
                'Style',                'text', ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hTextW = uicontrol( ...
                'Style',                'text', ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            for idh = 1:obj.nImages
                obj.hEditC(idh) = uicontrol( ...
                    'Style',                'edit', ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'Enable',               'on', ...
                    'Callback',             @obj.setCW, ...
                    'Tooltip',              'center value for applied colormap');
                
                obj.hEditW(idh) = uicontrol( ...
                    'Style',                'edit', ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'Enable',               'on', ...
                    'Callback',             @obj.setCW, ...
                    'Tooltip',              'width value for applied colormap');
                
                obj.hBtnCwHome(idh) = uicontrol( ...
                    'Style',                'pushbutton', ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F, ...
                    'Callback',             {@obj.BtnCwHomeCallback}, ...
                    'String',               char(8962), ...
                    'Tooltip',              'use initial windowing');
                
                obj.hBtnCwSlice(idh) = uicontrol( ...
                    'Style',                'pushbutton', ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F, ...
                    'Callback',             {@obj.BtnCwSliceCallback}, ...
                    'String',               char(9633), ...
                    'Tooltip',              'window current slice');

                if obj.nImages == 2
                    obj.hBtnHide(idh) = uicontrol( ...
                        'Style',                'togglebutton', ...
                        'BackgroundColor',      obj.COLOR_BG, ...
                        'Callback',             {@obj.BtnHideCallback});
                    
                    num = {'second', 'first'};
                    arrows = [8592, 8594];
                    obj.hBtnCwCopy(idh) = uicontrol( ...
                        'Style',                'pushbutton', ...
                        'BackgroundColor',      obj.COLOR_BG, ...
                        'ForegroundColor',      obj.COLOR_F, ...
                        'String',               char(arrows(idh)), ...
                        'Tooltip',              ['copy CW values form ' num{idh} ' image'], ...
                        'Callback',             {@obj.BtnCwCopyCallback});
                    
                    set(obj.hBtnCwHome(idh),  'Tooltip', ['use initial windowing on ' num{idh} ' image']);
                    set(obj.hBtnCwSlice(idh), 'Tooltip', ['window current slice of ' num{idh} ' image']);
                end
            end
            
            if obj.nImages == 2
                obj.hBtnCwLink = uicontrol( ...
                    'Style',                'pushbutton', ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F, ...
                    'Tooltip',              'link windowing in both images', ...
                    'String',               sprintf('<html><img src="file:/%sunlinked.png" height="15" width="15"/></html>', obj.resPath), ...
                    'Callback',             {@obj.BtnCwLinkCallback});                
                
                obj.hBtnToggle = uicontrol( ...
                    'Style',                'pushbutton', ...
                    'String',               ['Toggle (' obj.BtnTgglKey ')'], ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F, ...
                    'Callback',             {@obj.BtnToggleCallback});                
            end
            obj.linkedWindowing = false;
                        
            obj.hPopCm(1) = uicontrol( ...
                'Style',                'popup', ...
                'String',               {''}, ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F, ...
                'Callback',             {@obj.changeCmap});
            
            if obj.nImages == 2
                obj.hPopOverlay = uicontrol( ...
                    'Style',                'popup', ...
                    'String',               obj.overlayStrings, ...
                    'Value',                obj.overlay, ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F, ...
                    'Callback',             {@obj.changeOverlay});
                
                obj.hPopCm(2) = uicontrol( ...
                    'Style',                'popup', ...
                    'String',               {''}, ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F, ...
                    'Callback',             {@obj.changeCmap});
            end
            
            %--
            % regions of interest
            %--
            
            % uicontrols must be initialized alone, cannot be done without
            % loop (i guess...)
            for iHdl = 1:2
                obj.hBtnRoi(iHdl) = uicontrol( ...
                    'Style',                'pushbutton', ...
                    'Callback',             {@obj.drawRoi}, ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F);
                for jHdl = 1:obj.nImages
                    obj.hTextRoi(iHdl, jHdl) = uicontrol( ...
                        'Style',                'text', ...
                        'BackgroundColor',      obj.COLOR_BG, ...
                        'ForegroundColor',      obj.COLOR_F);
                end
            end
            
            for iHdl = 1:obj.nImages
                obj.hTextSNRvals(iHdl) = uicontrol( ...
                    'Style',                'text', ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F);
            end
            
            obj.hTextSNR = uicontrol( ...
                'Style',                'text', ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hTextRoiType = uicontrol( ...
                'Style',                'text', ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hPopRoiType = uicontrol( ...
                'Style',                'popup', ...
                'String',               {'Polygon', 'Ellipse', 'Freehand'}, ...
                'Value',                1, ...
                'Tooltip',              'Select the ROI type', ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hBtnDelRois = uicontrol( ...
                'Style',                'pushbutton', ...
                'Callback',             {@obj.delRois}, ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hBtnSaveRois = uicontrol( ...
                'Style',                'pushbutton', ...
                'Callback',             {@obj.saveRois}, ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);            
            
            %--
            % FFT and complex mode display
            %--
            obj.hBtnFFT = uicontrol( ...
                'Style',                'pushbutton', ...
                'String',               'FFT', ...
                'Tooltip',              'Show the 2D FFT of the currently displayed data', ...
                'Callback',             {@obj.setFFTStatus}, ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hBtnCmplx(1) = uicontrol( ...
                'Style',                'togglebutton', ...
                'String',               'abs', ...
                'Tooltip',              'Show absolute value of data', ...
                'Callback',             {@obj.BtnCmplxCallback},...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hBtnCmplx(2) = uicontrol( ...
                'Style',                'togglebutton', ...
                'String',               'phase', ...
                'Tooltip',              'Show phase value of data', ...
                'Callback',             {@obj.BtnCmplxCallback},...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hBtnCmplx(3) = uicontrol( ...
                'Style',                'togglebutton', ...
                'String',               'real', ...
                'Tooltip',              'Show real part of data', ...
                'Callback',             {@obj.BtnCmplxCallback},...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hBtnCmplx(4) = uicontrol( ...
                'Style',                'togglebutton', ...
                'String',               'imag', ...
                'Tooltip',              'Show imaginary part of data', ...
                'Callback',             {@obj.BtnCmplxCallback},...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            %--
            % animation
            %--
            if obj.nDims > 2
                obj.hBtnRun = uicontrol( ...
                    'Style',                'pushbutton', ...
                    'Units',                'pixel', ...
                    'String',               'Run', ...
                    'Callback',             { @obj.toggleTimer}, ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F);
                
                obj.hEditF = uicontrol( ...
                    'Style',                'edit', ...
                    'Units',                'pixel', ...
                    'String',               sprintf('%.2f', obj.fps), ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F, ...
                    'Enable',               'on', ...
                    'Tooltip',              'timer precision is 1 ms', ...
                    'Callback',             @obj.setFPS);
                
                obj.hTextFPS = uicontrol( ...
                    'Style',                'text', ...
                    'Units',                'pixel', ...
                    'String',               sprintf('fps'), ...
                    'BackgroundColor',      obj.COLOR_BG, ...
                    'ForegroundColor',      obj.COLOR_F);
            end
            %--
            % saving
            %--
            obj.hBtnSaveImg = uicontrol( ...
                'Style',                'pushbutton', ...
                'String',               'Save Image', ...
                'Callback',             {@obj.saveImgBtn}, ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.hBtnSaveVid = uicontrol( ...
                'Style',                'pushbutton', ...
                'String',               'Save Video', ...
                'Callback',             {@obj.saveVidBtn}, ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);

            obj.hBtnMinimMaxim = uicontrol( ...
                'Style',                'pushbutton', ...
                'String',               '<', ...
                'Callback',             {@obj.minimMaximBtn}, ...
                'BackgroundColor',      obj.COLOR_BG, ...
                'ForegroundColor',      obj.COLOR_F);
            
            obj.t = timer(...
                'BusyMode',         'queue', ...
                'ExecutionMode',    'fixedRate', ...
                'Period',           1, ...
                'StartDelay',       0, ...
                'TimerFcn',         @(t, event) obj.interrupt, ...
                'TasksToExecute',   Inf);
            
        end

        
        function parseDimLabelsVals(obj)
            % dimension labels
            
            if ~contains('DimLabel', obj.p.UsingDefaults)
                % check number of input labels equals dimensions of image
                if numel(obj.p.Results.DimLabel) ~= obj.nDims
                    warning('Number of DimLabel is not equal to the number of image dimensions.')
                end
               % if cell entry is empty, use default value
               emptyCell = cellfun(@isempty, obj.p.Results.DimLabel);
               obj.dimLabel(~emptyCell) = obj.p.Results.DimLabel(~emptyCell);
            end
            
            % dimension values
            
            % set default values via size of each dimension
            obj.dimVal = cellfun(@(x) 1:x, num2cell(obj.S), 'UniformOutput', false);
            
            if ~contains('DimVal', obj.p.UsingDefaults)
                % check number of value arrays equals dimensions of image
                if numel(obj.p.Results.DimVal) ~= obj.nDims
                    % allow for trailing singleton dimensions
                    % check for all surplus dimensions in DimVal, that
                    % their size is one.
                    if numel(obj.p.Results.DimVal) > obj.nDims && ~all(cellfun(@numel, obj.p.Results.DimVal(obj.nDims+1:end)))
                        error('Number of elements in DimVal must equal the number of image dimensions.')
                    end
                end
                % if cell entry is empty, use default value
                emptyCell = cellfun(@isempty, obj.p.Results.DimVal);
                obj.dimVal(~emptyCell) = obj.p.Results.DimVal(~emptyCell);
                
                % value array for each dimension must have obj.S entries
                if ~isequal(obj.S, cellfun(@numel, obj.dimVal))
                    error('Number of elements in DimVal for dimension(s) %s do not match image size', mat2str(find(obj.S ~= cellfun(@numel, obj.dimVal))))
                end
            end
            
            obj.dimVal = valsToString(obj.dimVal);
        end
        
        
        function prepareSliceData(obj)
            % obtain image information form
            for iImg = 1:obj.nImages
                for iax = 1:obj.nAxes
                    % get the image information of the current slice(s)
                    % from the input matrices
                    
                    % for dimensions where one matrix is singleton, the
                    % selector-value must be adjusted to 1
                    select = obj.sel(iax, :);
                    select(obj.ston{iImg}) = {1};
                    
                    if ~isempty(obj.ston{iImg})
                        % this matrix has singleton dimensions where the
                        % other does not
                        
                        % is the matrix singleton along a shown dimension?
                        isect = intersect(obj.showDims(iax, :), obj.ston{iImg});
                        % if the matrix is singleton along one of the shown
                        % image dimensions, use repmat
                        repDims = ones(1, obj.nDims);
                        repDims(isect) = obj.S(isect);
                    else
                        % no unique singleton dimensions, no repetition
                        % necessary
                        repDims = ones(1, obj.nDims);
                    end
                    
                    % use permute instead of squeeze, because squeeze
                    % reduces a matrix of  size 1, 1, 100 to 100, 1
                    % instead of 1, 100
                    permDims = 1:obj.nDims;
                    permDims(obj.showDims(iax, :)) = [];
                    permDims = [obj.showDims(iax, :) permDims];
                    
                    % repeat along singleton if necessary, then permute to
                    % get orientation right
                    obj.slice{iax, iImg} = permute(repmat(obj.img{iImg}(select{:}), repDims), permDims);
                    
                    if obj.fftStatus == 1
                        % if chosen by the user, perform a 2D fft on the
                        % Data
                        obj.slice{iax, iImg} = fftshift(fftn(fftshift(obj.slice{iax, iImg})));
                    end

                    % check if any slice contains nan values and where
                    if any(isnan(obj.slice{iax, iImg}(:)))
                        obj.hasNan(iImg) = 1;
                        obj.nanLocs{iImg} = find(isnan(obj.slice{iax, iImg}));
                    else
                        obj.hasNan(iImg) = 0;
                        obj.nanLocs{iImg} = [];
                    end
                end
            end

            if any(obj.isComplex)
                % convert the displayed data to the complex mode chosen by
                % the user and then to datatype single
                obj.slice = cellfun(@single, ...
                    cellfun(@obj.complexPart, obj.slice, 'UniformOutput', false), ...
                    'UniformOutput', false);
            else
                % convert the displayed data to datatype single
                obj.slice = cellfun(@single, obj.slice, 'UniformOutput', false);
            end

            % Since the content in the axes changes, also recalculate the
            % values inside the ROIs.
            obj.calcROI
        end
        
        
        function cImage = sliceMixer(obj, axNo)
            % calculates an RGB image depending on the windowing values,
            % the used colormaps and the current slice position. when the
            % slice position was changed, obj.prepareSliceData should be
            % run before calling the slice mixer.
            % axNo defines the axis for which the image is prepared.
            if nargin == 1
                axNo = 1;
            end
            
            imgSize = [obj.resize * size(obj.slice{axNo, 1}), 3];
            switch (obj.overlay)
                % for assignment of overlay modes, see
                % obj.overlayStrings                
                case 1 % add
                    cImage  = zeros(imgSize);
                case 2 % multiply
                    cImage  = ones(imgSize);
                case 3 % overlay
                    cImage  = zeros(imgSize);
            end
            for idd = 1:obj.nImages
                % map images to range [0, cmapResolution]
                cLimLow  = single(obj.center(obj.complexMode, idd) - obj.width(obj.complexMode, idd)/2);
                imgMapped = (obj.slice{axNo, idd} - cLimLow)/single(obj.width(obj.complexMode, idd)) * size(obj.cmap{idd}, 1);

                if obj.resize ~= 1
                    imgMapped = imresize(imgMapped, obj.resize);
                end

                % create RGB image data using selected colormap
                imgRGB  = ind2rgb(round(imgMapped+0.5), obj.cmap{idd}) * obj.layerShown(idd);

                if obj.hasNan(idd)

                    % Expand indices to cover all 3 channels at once
                    idx3D = repmat(obj.nanLocs{idd}, 1, 3) + numel(obj.slice{axNo, idd}) * (0:2);

                    stru = struct('type', '()', 'subs', {{idx3D}});
                    imgRGB = subsasgn(imgRGB, stru, repmat(obj.nanColor, numel(obj.nanLocs{idd}), 1));
                end

                switch (obj.overlay)
                    % for assignment of overlay modes, see
                    % obj.overlayStrings
                    case 1 % add
                        cImage  = cImage  + imgRGB;
                    case 2 % multiply
                        cImage  = cImage .* imgRGB;
                    case 3 % overlay
                        if obj.layerShown(idd)
                            mask = repmat(~isnan(obj.slice{axNo, idd}), 1, 1, 3);
                            cImage(mask) = imgRGB(mask);
                        end
                end
            end
            
            if obj.nImages ~= 1
                cImage(isnan(obj.slice{axNo, 1}) & isnan(obj.slice{axNo, 2})) = NaN;
            end
            
            % make sure no channel has values above 1
            cImage(cImage > 1) = 1;

            % if at least one of the inputs is a gpuArray, gather it in
            % order to be able to show it
            cImage = gather(cImage);
        end


        function startDragFcn(obj, src, evtData)
             % when middle mouse button is pressed, save current point and start
            % tracking of mouse movements

            callingAx = src.Parent;
            Pt = callingAx.CurrentPoint;
            axNo = callingAx.UserData.axNo;

            if obj.nAxes > 1
                obj.activateAx(axNo);
            end

            if strcmp(obj.f.SelectionType, 'open')
                obj.mouseBtnDouble(src, evtData);
            end

            % Store start values
            sCenter = obj.center(obj.complexMode, :);
            sWidth  = obj.width(obj.complexMode, :);
            cStep   = obj.centerStep(obj.complexMode, :);
            wStep   = obj.widthStep(obj.complexMode, :);

            % Normalization factor
            dims = find(obj.showDims(axNo, :));
            nrmFac = 1 ./ ([obj.S(dims(1)) obj.S(dims(end))] * obj.resize);

            switch obj.f.SelectionType

                case 'alt'
                    if ~isempty(obj.img{2}) && obj.layerShown(2)
                        cStep = cStep .* [obj.linkedWindowing, 1];
                        wStep = wStep .* [obj.linkedWindowing, 1];

                        obj.f.WindowButtonMotionFcn = ...
                            {@obj.draggingFcn, callingAx, Pt, sCenter, sWidth, cStep, wStep, nrmFac};
                    end

                case 'extend'
                    if isempty(obj.img{2}) || obj.layerShown(1)
                        cStep = cStep .* [1, obj.linkedWindowing];
                        wStep = wStep .* [1, obj.linkedWindowing];

                        obj.f.WindowButtonMotionFcn = ...
                            {@obj.draggingFcn, callingAx, Pt, sCenter, sWidth, cStep, wStep, nrmFac};
                    end

                case 'normal'
                    obj.mouseBtnNormal(Pt);
            end
        end


        function draggingFcn(obj, ~, ~, callingAx, StartPt, sCenter, sWidth, cStep, wStep, nrmFac)

            cPoint = callingAx.CurrentPoint;
            axNo   = callingAx.UserData.axNo;

            % Vectorized + normalized motion
            dxy = (cPoint(1,1:2) - StartPt(1,1:2)) .* nrmFac([2 1]);
            dx = dxy(1);
            dy = dxy(2);

            % Rotate back using PRECOMPUTED matrix
            dVecRot = obj.rotMat{axNo} * [dx; dy];

            obj.width(obj.complexMode, :)  = sWidth  + wStep .* dVecRot(1);
            obj.center(obj.complexMode, :) = sCenter - cStep .* dVecRot(2);

            obj.cw();
        end

        
        function cw(obj)
            % adjust windowing values depending on values for center and width
            obj.width = max(obj.width, eps);%obj.widthMin(obj.width <= obj.widthMin);
            
            for ida = 1:numel(obj.hImage)
                set(obj.hImage(ida), 'CData', obj.sliceMixer(ida));
            end
            
            for idi = 1:obj.nImages
                set(obj.hEditC(idi), 'String', num2sci(obj.center(obj.complexMode, idi), 'padding', 'right'));
                set(obj.hEditW(idi), 'String', num2sci(obj.width(obj.complexMode, idi) , 'padding', 'right'));
            end
            
            if obj.cbShown
                % only recalculate the tickvalues when colorbars are
                % acutally visible
                
                % depending on the direction of the colorbar, elementy of
                % the x or y axis must be changed
                if strcmp(obj.cbDirection, 'horizontal')
                    Data = 'XData';
                    Lim = 'XLim';
                    Tick = 'XTick';
                    TickLabel = 'XTickLabel';
                else
                    Data = 'YData';
                    Lim = 'YLim';
                    Tick = 'YTick';
                    TickLabel = 'YTickLabel';
                end
                
                for idi = 1:obj.nImages

                    if obj.width(obj.complexMode, idi) == 0
                        % only two colors are present in the image: max and
                        % min color of the colormap. Show only those in
                        % colorbar, and only the tick at the threshold value
                        % in the middle
                        set(allchild(obj.hAxCb(idi)), 'CData', [0; 1])

                        set(allchild(obj.hAxCb(idi)), ...
                            Data,    [0 1])
                        set(obj.hAxCb(idi), ...
                            Lim,     [0 1])

                        ticks = 0.5;
                        set(obj.hAxCb(idi), Tick, ticks);
                        ticks_new = {};
                        ticks_new{1} = [sprintf('\\color[rgb]{%.3f,%.3f,%.3f} ', obj.COLOR_m(idi,  :)) num2str(obj.center(obj.complexMode, idi))];
                    else
                        range = [ obj.center(obj.complexMode, idi) - obj.width(obj.complexMode, idi)/2 ...
                                  obj.center(obj.complexMode, idi) + obj.width(obj.complexMode, idi)/2];
                        % x/ydata for the image must be smaller by half the
                        % width of a colorbar 'pixel at both ends
                        delta = diff(range) / size(obj.cmap{idi}, 1)/2;
                        data = linspace(range(1)+delta, range(2)-delta, size(obj.cmap{idi}, 1));

                        set(allchild(obj.hAxCb(idi)), 'CData', linspace(0, 1, size(obj.cmap{idi}, 1))')

                        set(obj.hAxCb(idi), [Tick 'Mode'], 'auto')
                        set(allchild(obj.hAxCb(idi)), Data, data)
                        set(obj.hAxCb(idi),           Lim, range)

                        % get tick positions
                        ticks = get(obj.hAxCb(idi), Tick);
                        % prepend a color for each tick label
                        ticks_new = cell(size(ticks));
                        for ii = 1:length(ticks)
                            ticks_new{ii} = [sprintf('\\color[rgb]{%.3f,%.3f,%.3f} ', obj.COLOR_m(idi,  :)) num2str(ticks(ii))];
                        end
                    end
                    set(obj.hAxCb(idi), TickLabel, ticks_new);
                end
            end
        end
        
        
        function minmax = getMinMax(obj)
            
            minmax = [obj.Min(1) obj.Max(1)];
            
        end
        
        
        function BtnCwHomeCallback(obj, src, ~)
            % set center and width to the initial values
            iImg = (obj.hBtnCwHome == src);
            obj.center(:, iImg) = obj.p.Results.CW(iImg, 1);
            obj.width(:, iImg)  = obj.p.Results.CW(iImg, 2);
            
            % apply changes to center and width
            obj.cw();
        end
        
        
        function BtnCwSliceCallback(obj, src, ~)
            % set center and width to optimize display of the current slice
            iImg = (obj.hBtnCwSlice == src);
            
            % calculate cw values for the slice
            obj.center(obj.complexMode, iImg) = (obj.cleverMax(obj.slice{iImg})+obj.cleverMin(obj.slice{iImg})) / 2;
            obj.width(obj.complexMode, iImg)  = obj.cleverMax(obj.slice{iImg})-obj.cleverMin(obj.slice{iImg});
            
            % apply changes to center and width
            obj.cw();
        end
        
        
        function BtnHideCallback(obj, src, ~)
            % call the toggle layer fucntion
            obj.toggleLayer( find(obj.hBtnHide == src) );
        end
        
        
        function BtnCwCopyCallback(obj, src, ~)
            % copy the CW-values from one image to another
            obj.center(obj.complexMode, obj.hBtnCwCopy == src) = obj.center(obj.complexMode, obj.hBtnCwCopy ~= src);
            obj.width(obj.complexMode, obj.hBtnCwCopy == src)  = obj.width(obj.complexMode, obj.hBtnCwCopy ~= src);
            obj.cw();
        end
        
        
        function BtnCwLinkCallback(obj, ~, ~)
            % apply windowing to both images at once
            if obj.linkedWindowing == true
                % change state
                obj.linkedWindowing = false;
                % change button icon
                set(obj.hBtnCwLink, 'String', sprintf('<html><img src="file:/%sunlinked.png" height="15" width="15"/></html>', obj.resPath));                
                set(obj.hBtnCwLink, 'Tooltip', 'link windowing in both images');
            else
                % change state
                obj.linkedWindowing = true;
                % change button icon
                set(obj.hBtnCwLink, 'String', sprintf('<html><img src="file:/%slinked.png" height="15" width="15"/></html>', obj.resPath));
                set(obj.hBtnCwLink, 'Tooltip', 'unlink windowing in both images');
            end
        end


        function keyPressedFcn(obj, src, ~)
            % listen to keypress and toggle between or hide/show the images
            key = get(src, 'CurrentCharacter');

            switch (key)
                case obj.BtnHideKey
                    obj.toggleLayer(find(ismember(obj.BtnHideKey, lower(key))))
                case obj.BtnTgglKey
                    obj.BtnToggleCallback()
            end
        end
        
        
        function BtnToggleCallback(obj, ~, ~)
            if sum(obj.layerShown) == 1
                % if only one of the layers is shown, toggle both
                obj.toggleLayer(1);
                obj.toggleLayer(2);
            else
                % if both are hidden or shown, only show the first or the
                % last layer
                obj.toggleLayer(1);
            end

            % if opened, apply visibility to external plot

        end
        
        
        function toggleLayer(obj, layer)
            % toggles the display of obj.img{layer}
            % toggle the state
            %obj.hBtnHide(layer)
            obj.layerShown(layer) = ~obj.layerShown(layer);
            
            if obj.layerShown(layer)
                string = ['Hide (' obj.BtnHideKey{layer} ')'];
                set(obj.hBtnHide(layer), 'String', string)
            else
                string = ['Show (' obj.BtnHideKey{layer} ')'];
                set(obj.hBtnHide(layer), 'String', string)
            end
            set(obj.hBtnHide(layer), 'Value', obj.layerShown(layer))
            obj.refreshUI()
        end
        
        
        function BtnCmplxCallback(obj, source, ~)
            % toggleComplex(source, ~)
            % source:       handle to uicontrol button
            %
            % called by:    uicontrol togglebutton: Callback
            %
            % Is called when one of the 4 complex data buttons is pressed.
            % These buttons are only visible when at least one matrix has
            % complex data.
            % Depending on which button was pressed last, the magnitude, phase,
            % real part or imaginary part of complex data is shown.
            %
            % complexMode:
            % 1:    magnitude
            % 2:    phase
            % 3:    real
            % 4:    imag
            
            % set all buttons unpressed
            set(obj.hBtnCmplx, 'Value', 0)
            btnIdx = find(source == obj.hBtnCmplx);
                        
            obj.complexMode = btnIdx;
            set(obj.hBtnCmplx(btnIdx), 'Value', 1)
            
            obj.cw()
            obj.refreshUI()
        end


        function out = complexPart(obj, in)
            % complexPart(obj, in)
            % in:           array with (potentially) complex data
            % complexMode:  int defining the complex part of out
            %               1: Magnitude
            %               2: Phase
            %               3: real part
            %               4: imaginary part
            %
            % out:    magnitude, phase, real or imaginary part of in
            %
            % depending on the value in 'complexMode' either the magnitude,
            % phase, real part or imaginary part is returned
            
            switch(obj.complexMode)
                case 1
                    out = abs(in);
                case 2
                    out = angle(in);
                case 3
                    out = real(in);
                case 4
                    out = imag(in);
            end
        end

        
        function setFFTStatus(obj, ~, ~)
            %called by the 'Run'/'Stop' button and controls the state of the
            %timer
            if obj.fftStatus == 1
                obj.fftStatus = 0;
                set(obj.hBtnFFT, 'String', 'FFT')
                % when leaving fft mode, also reset CW values to initial
                % values
                obj.prepareColors
                obj.cw                
                
                % reset the tooltip
                set(obj.hBtnFFT, 'Tooltip', 'Show the 2D FFT of the currently displayed data')
            else
                obj.fftStatus = 1;
                set(obj.hBtnFFT, 'String', '<HTML>FFT<SUP>-1</SUP>')
                set(obj.hBtnFFT, 'Tooltip', 'Remove 2D FFT and show original data')
            end
            obj.refreshUI;
        end
        
        
        function setSlider(obj, src, ~)
            % function is called when an index next to a slider is changed
            % and sets the selector and the image to the new coordinate.
            dim = obj.mapSliderToDim(obj.hEditSlider == src);            
            inSlice = round(str2double(get(src, 'String')));
            % make sure the new value is within reasonable bounds
            inSlice = max([1 inSlice]);
            inSlice = min([inSlice obj.S(dim)]);
                        
            obj.sel{obj.mapSliderToImage{obj.hEditSlider == src}, dim} = inSlice;
            obj.activateSlider(dim)
            
            obj.refreshUI();
        end
        
        
        function newSlice(obj, src, ~)
            % called when slider is moved, get current slice
            dim = obj.mapSliderToDim(obj.hSlider == src);
            im  = obj.mapSliderToImage{obj.hSlider == src};

            if strcmp(im, ':')
                for ii = 1:size(obj.sel, 1)
                    obj.sel{ii, dim} = round(src.Value);
                end
            else
                obj.sel{im, dim} = round(src.Value);
            end
            
            obj.activateSlider(dim);
            obj.refreshUI();
        end
        
        % Think about combining setSlider, newSlice and scrollSlider
        
        function scrollSlider(obj, ~, evtData)
            % scroll slider is a callback of the mouse wheel and handles
            % zooming within a slice and scrolling through the slices by
            % incrementing or decrementing the index along the
            % activeSlider.
            if strcmp(get(gcf, 'CurrentModifier'), 'control') & ~isempty(obj.pt)
                % zoom-mode
                % ctrl-key is pressed and obj.pt is not empty
                ax = get(obj.hImage(obj.pt(3)), 'Parent');
                if evtData.VerticalScrollCount < 0
                    % zoom in
                    % keep the point below the cursor at its position so
                    % users can zoom exactly to the point they want to
                    ax.XLim(1) = ax.XLim(1)/obj.zoomInFac + obj.resize*obj.pt(2)*(1-1/obj.zoomInFac);
                    ax.XLim(2) = ax.XLim(2)/obj.zoomInFac + obj.resize*obj.pt(2)*(1-1/obj.zoomInFac);
                    
                    ax.YLim(1) = ax.YLim(1)/obj.zoomInFac + obj.resize*obj.pt(1)*(1-1/obj.zoomInFac);
                    ax.YLim(2) = ax.YLim(2)/obj.zoomInFac + obj.resize*obj.pt(1)*(1-1/obj.zoomInFac);                    
                elseif evtData.VerticalScrollCount > 0
                    % zoom out
                    % zoom out such, that limits increase independent of
                    % cursor position
                    dX = 0.5*(ax.XLim(2)-ax.XLim(1))*(1/obj.zoomOutFac-1);
                    XLim(1) = ax.XLim(1) - dX;
                    XLim(2) = ax.XLim(2) + dX;
                    
                    dY = 0.5*(ax.YLim(2)-ax.YLim(1))*(1/obj.zoomOutFac-1);
                    YLim(1) = ax.YLim(1) - dY;
                    YLim(2) = ax.YLim(2) + dY;
                    
                    % make sure not to scroll beyond the limits
                    XLim(1) = max([XLim(1) 0.5]);
                    YLim(1) = max([YLim(1) 0.5]);
                    XLim(2) = min([XLim(2) obj.resize*size(obj.slice{obj.pt(3)}, 2)+0.5]);
                    YLim(2) = min([YLim(2) obj.resize*size(obj.slice{obj.pt(3)}, 1)+0.5]);
                    
                    ax.XLim = XLim;
                    ax.YLim = YLim;
                end
            else
                % scroll mode
                if evtData.VerticalScrollCount < 0 && obj.nSlider > 0
                    obj.incDecActiveDim(-1);
                elseif evtData.VerticalScrollCount > 0 && obj.nSlider > 0
                    obj.incDecActiveDim(+1);
                end
            end
        end
        
        
        function activateSlider(obj, dim)
            % change current axes and indicate to user by drawing coloured line
            % around current axes, but only if dim wasnt the active axis before
            if obj.activeDim ~= dim
                obj.activeDim = dim;
            end
        end
        
        
        function setCW(obj, src, ~)
            % called by the center and width edit fields
            s = get(src, 'String');
            %turn "," into "."
            s(s == ',') = '.';
            
            for idi = 1:obj.nImages
                if src == obj.hEditC(idi)
                    obj.center(obj.complexMode, idi) = str2double(s);
                    set(src, 'String', num2sci(obj.center(obj.complexMode, idi), 'padding', 'right'));
                elseif src == obj.hEditW(idi)
                    obj.width(obj.complexMode, idi) = str2double(s);
                    set(src, 'String', num2sci(obj.width(obj.complexMode, idi), 'padding', 'right'));
                end
            end
            
            % cw is called in order to update the colobar ticks
            obj.cw();
            obj.refreshUI();
        end


        function [c, w] = getCW(obj)
            c = obj.center;
            w = obj.width;
        end
        
        
        function stopDragFcn(obj, ~, ~)
            % on realease of middle mouse button, stop tracking mouse movement
            set(obj.f, 'WindowButtonMotionFcn', { @obj.mouseMovement});  %reattach mouse movement function
        end
        
        
        function mouseMovement(obj, ~, ~)        % display location and value
            for ida = 1:numel(obj.hImage)
				iteratingAx = get(obj.hImage(ida), 'Parent');
                pAx = round(get(iteratingAx, 'CurrentPoint')/obj.resize);
                if obj.inAxis(iteratingAx, pAx(1, 1), pAx(1, 2))
                    pAx = round(pAx);
                    obj.locVal({pAx(1, 2), pAx(1, 1)}, ida);
                    obj.pt = [pAx(1, 2) pAx(1, 1) ida];
                    return
                end
            end
            % if the cursor is not on top of any axis, set it empty
            obj.locVal([]);
            obj.pt = [];
        end
        
        
        function b = inAxis(obj, ax, x, y)
            % inAxis checks, whether the point with coordinates (x, y) lies
            % within the limits of 'ax' and returns a bool
            if x >= ax.XLim(1)/obj.resize && x <= ax.XLim(2)/obj.resize && ...
                    y >= ax.YLim(1)/obj.resize && y <= ax.YLim(2)/obj.resize
                b = true;
            else
                b = false;
            end
        end
        
         
        function createROI(obj, roiNo, polygon)
            % when the user provides coordinates for a ROI polygon, create
            % the UI object
            
            obj.rois{roiNo} = images.roi.Polygon(...
                'Parent',   gca, ...
                'Color',    obj.COLOR_roi(roiNo, :), ...
                'Position', polygon);
            
            obj.calcROI()
            addlistener(obj.rois{roiNo}, 'MovingROI', @obj.calcROI);
            
        end
        
        
        function drawRoi(obj, src, ~)
            % check for signal or noise ROI
            roiNo = find(obj.hBtnRoi == src);
            % if there is currently a roi connected to the handle, delete
            % graphics element
            if ~isempty(obj.rois{roiNo})
                obj.deleteRoi(roiNo)
            end
            
            % instantiate new roi depending on choice
            switch(get(obj.hPopRoiType, 'Value'))
                case 1
                    obj.rois{roiNo} = images.roi.Polygon('Parent', gca, 'Color', obj.COLOR_roi(roiNo, :));
                case 2
                    obj.rois{roiNo} = images.roi.Ellipse('Parent', gca, 'Color', obj.COLOR_roi(roiNo, :));
                case 3
                    obj.rois{roiNo} = images.roi.Freehand('Parent', gca, 'Color', obj.COLOR_roi(roiNo, :));
            end

            axNo = obj.getAxNo(gca);
            obj.rois{roiNo}.Tag = num2str(axNo);

            addlistener(obj.rois{roiNo}, 'MovingROI', @obj.calcROI);
            draw(obj.rois{roiNo})
            
            obj.calcROI();
        end
        
        
        function calcROI(obj, ~, ~)
            % calculate masks, mean/std and display values and SNR
                        
            % get current image
            for ii = 1:obj.nImages
                if ~isempty(obj.rois{1})
                    % get axis
                    axNo = str2double(obj.rois{1}.Tag);
                    % This use does not work with resize ~= 1 !
                    Mask = obj.slice{axNo, ii}(obj.rois{1}.createMask);
                    obj.signal(ii) = mean(Mask(:));
                    set(obj.hTextRoi(1, ii), 'String', num2sci(obj.signal(ii), 'padding', 'right'));
                end
                if ~isempty(obj.rois{2})
                    % get axis
                    axNo = str2double(obj.rois{2}.Tag);
                    % This use does not work with resize ~= 1 !
                    Mask = obj.slice{axNo, ii}(obj.rois{2}.createMask);
                    % input to std must be floating point
                    obj.noise(ii) = std2(Mask);
                    set(obj.hTextRoi(2, ii), 'String', num2sci(obj.noise(ii), 'padding', 'right'));
                end
                set(obj.hTextSNRvals(ii), 'String', num2sci(obj.signal(ii)./obj.noise(ii), 'padding', 'right'));
            end
        end


        function axNo = getAxNo(obj, ax)

            % get hImage from parent axis
            children = ax.Children;
            for iCh = 1:numel(children)
                if isa(children(iCh), 'matlab.graphics.primitive.Image')
                    axNo = find(obj.hImage == children(iCh));
                end
            end

        end
        
        
        function deleteRoi(obj, roiNo)
            % remove roi shape from axes
            delete(obj.rois{roiNo})
            % make roi handle empty
            obj.rois{roiNo} = [];
            set(obj.hTextRoi(roiNo, :), 'String', '');           
            set(obj.hTextSNRvals(:),    'String', '');
            if roiNo == 1
                obj.signal = [NaN NaN];
            else
                obj.noise = [NaN NaN];
            end
        end
        
        
        function delRois(obj, ~, ~)
            obj.deleteRoi(1)
            obj.deleteRoi(2)
        end
        
        
        function saveRois(obj, ~, ~)
            % function is called by the 'Save ROIs' button and saves the
            % vertices of the current ROIs to the base workspace.
            if ~isempty(obj.rois{1})
                assignin('base', 'ROI_Signal', obj.rois{1}.Position);
                fprintf('ROI_Signal saved to workspace\n');
            else
                fprintf('ROI_Signal not found\n');
            end
            if ~isempty(obj.rois{2})
                assignin('base', 'ROI_Noise', obj.rois{2}.Position);
                fprintf('ROI_Noise saved to workspace\n');
            else
                fprintf('ROI_Noise not found\n');
            end
        end


        function rotateView(obj, src, ~, angle)
            % function is called by the BtnRotL or BtnRotR
            
            if angle > 0
                %rotate right
                axNo = find(obj.hBtnRotR == src);
            else
                % rotate left
                axNo = find(obj.hBtnRotL == src);
            end
            obj.azimuthAng(axNo) = mod(obj.azimuthAng(axNo) + angle, 360);
            obj.rotMat{axNo} = [cosd(obj.azimuthAng(axNo)), - sind(obj.azimuthAng(axNo)); ...
                                sind(obj.azimuthAng(axNo)), + cosd(obj.azimuthAng(axNo))];
            set(obj.hImage(axNo).Parent, 'View', [obj.azimuthAng(axNo) 90])
        end
                
        
        function setFPS(obj, src, ~)
            % called by the center and width edit fields
            s = get(src, 'String');
            %turn "," into "."
            s(s == ',') = '.';
            
            obj.fps = str2double(s);
            % set(src, 'String', num2str(obj.fps));
            stop(obj.t)
            set(obj.hBtnRun, 'String', 'Run');
            if obj.fps ~= 0
                obj.setAndStartTimer;
                set(obj.hBtnRun, 'String', 'Stop');
            end
        end
        
        
        function setAndStartTimer(obj)
            % make sure fps is not higher 100
            period  = 1/abs(obj.fps) + (abs(obj.fps) > 100)*(1/100-1/abs(obj.fps));
            % provide 1 ms precision to avoid warning
            period = round(period*1000)/1000;
            
            obj.t.Period    = period;
            obj.t.TimerFcn  = @(t, event) obj.interrupt(obj.fps);
            set(obj.hEditF, 'String', num2str(sign(obj.fps)/obj.t.Period));
            start(obj.t)
        end
        
        
        function toggleTimer(obj, ~, ~)
            %called by the 'Run'/'Stop' button and controls the state of the
            %timer
            if strcmp(get(obj.t, 'Running'), 'off') && obj.fps ~= 0
                obj.setAndStartTimer;
                set(obj.hBtnRun, 'String',  'Stop');
%                 set(obj.hBtnG,   'Visible', 'on');
            else
                stop(obj.t)
                set(obj.hBtnRun, 'String',  'Run');
%                 set(obj.hBtnG,   'Visible', 'off');
            end
        end
        
        
        function interrupt(obj, ~, ~)
            % this function is called for every interrupt of the timer and
            % increments/decrements the slider value.
            
            % what dimension to adjust
            interDim = obj.mapSliderToDim(obj.interruptedSlider);
            if obj.fps > 0
                obj.sel{1, interDim} = obj.sel{1, interDim} + 1;
            elseif obj.fps < 0
                obj.sel{1, interDim} = obj.sel{1, interDim} - 1;
            end
                obj.sel{1, interDim} = mod(obj.sel{1, interDim}-1, obj.S(interDim))+1;
            obj.refreshUI();
        end
        
        
        function saveVidBtn(obj, ~, ~)
            % get the filepath from a UI and call saveVideo function to save
            % the video or gif
            [filename, filepath] = uiputfile({'*.avi', 'AVI-file (*.avi)'; ...
                '*.gif', 'gif-Animation (*.gif)'}, ...
                'Save video', '.avi');
            
            if filepath == 0
                return
            else
                if strcmp(filename(end-2:end), 'avi') || strcmp(filename(end-2:end), 'gif')
                obj.saveVideo([filepath, filename])
                else
                    warning('Invalid filename! Data was not saved. Choose ''.gif'' or ''.avi'' as filetype.');
                end
            end
        end
        
        
        function saveVideo(obj, path)
            % save video of matrix with current windowing and each frame being
            % one slice along the dimension connected to the interrupted slider.
            
            if ~isempty(obj.t)
                % get the state of the timer
                bRunning = strcmp(obj.t.Running, 'on');
                % stop the interrupt, to get control over the data shown.
                if bRunning
                    stop(obj.t)
                end
            end
            
            
            if  strcmp(path(end-2:end), 'gif')
                gif = 1;
            else
                gif = 0;
                % start the video writer
                v           = VideoWriter(path);
                v.FrameRate = obj.fps;
                v.Quality   = 100;
                open(v);
            end
            % select the looping slices that are currently shown, resize
            % image, apply the colormap and rotate according to the
            % azimuthal angle of the view.
            for ii = 1:obj.S(obj.mapSliderToDim(obj.interruptedSlider))
                obj.sel{obj.mapSliderToDim(obj.interruptedSlider)} = ii;
                obj.prepareSliceData
                
                %rotate images to have same orientation as in GUI
                imgOut = rot90(obj.sliceMixer(), -round(obj.azimuthAng/90));
                
                if gif
                    [gifImg, cm] = rgb2ind(imgOut, 256);
                    if ii == 1
                        imwrite(gifImg, cm, path, 'gif', ...
                            'WriteMode',    'overwrite', ...
                            'DelayTime',    1/obj.fps, ...
                            'LoopCount',    obj.p.Results.LoopCount);
                    else
                        imwrite(gifImg, cm, path, 'gif', ...
                            'WriteMode',    'append',...
                            'DelayTime',    1/obj.fps);
                    end
                else
                    imgOut(imgOut > 1) = 1;
                    imgOut(imgOut < 0) = 0;
                    writeVideo(v, imgOut);
                end
            end
            
            if ~gif
                close(v)
            end
            
            if ~isempty(obj.t)
                % restart the timer if it was running before
                if bRunning
                    start(obj.t)
                end
            end
        end
        
        
        function setValNames(obj)
            
            for ii = 1:obj.nImages
                % create empty val names
                obj.valNames{ii} = {};
                
                % if available, take the name of the input variable
                if ~isempty(obj.inputNames{ii})
                    if numel(obj.inputNames{ii}) > obj.maxLetters
                        obj.valNames{ii} = obj.inputNames{ii}(1:obj.maxLetters);
                    else
                        obj.valNames{ii} = obj.inputNames{ii};
                    end                    
                end

                % if explicit names were provided, overwrite val names
                if ~contains('ImgLabel', obj.p.UsingDefaults)
                    if ischar(obj.p.Results.ImgLabel)                     
                        obj.valNames{1} = obj.p.Results.ImgLabel;
                    elseif ii <= numel(obj.p.Results.ImgLabel{ii})
                        obj.valNames{ii} = obj.p.Results.ImgLabel{ii};
                    else
                        obj.valNames{ii} = '';
                    end
                end

                % text is shown using the LaTeX interpreter. We need to
                % escape underscores
                obj.valNames{ii} = strrep(obj.valNames{ii}, '_', '\_');

                % if the val name is still empty, overwrite with default
                % name
                if isempty(obj.valNames{ii})
                    obj.valNames{ii} = ['input ' num2str(ii)];
                end
            end
            
            % to get the number of the displayed characters correct, we
            % need to know howm many '_' are in each name to compensate the
            % result from numel
            usNo = cellfun(@(x) sum(x == '_'), obj.valNames);
            
            % find number of trailing whitespace
            wsToAdd = max(cellfun(@numel, obj.valNames) - usNo) - (cellfun(@numel, obj.valNames) - usNo);
            ws = cell(1, obj.nImages);
            for ii = 1:obj.nImages
                ws{ii} = repmat(' ', [1, wsToAdd(ii)]);
            end
            obj.valNames = strcat(obj.valNames, ws);
        end


        function setTitle(obj)

            obj.figureTitle = obj.p.Results.Title;

            % overwrite the default title if a title was provided
            if ismember('Title', obj.p.UsingDefaults)
                obj.figureTitle = strrep(strjoin(obj.valNames, ', '), '\', '');
            end

        end
        
              
        function changeOverlay(obj, src, ~)
            % get the index of the new overlay value in obj.overlayStrings
            obj.overlay = find(cellfun( @(x) strcmp(x, obj.overlayStrings{get(src, 'Value')}), obj.overlayStrings));
            obj.refreshUI()
        end
        
        
        function setCmap(obj, src, ~)
            % which colormap is selected
            idx = find(src == obj.hPopCm);
            cm = obj.cmapStrings{get(src, 'Value')};
            obj.cmap{idx} = obj.availableCmaps.(cm);

            % set UI text colors
            cid = obj.cmap{idx}(round(size(obj.availableCmaps.(cm), 1) * 0.9), :);
            % set the value ('brightness') of the color to match the value
            % of the gray colormap
            cid_hsv = rgb2hsv(cid);
            cid_hsv(3) = 0.9;            
            obj.COLOR_m(idx, :) = hsv2rgb(cid_hsv);

            % change color of c/w edit fields
            set(obj.hEditC(idx), 'ForegroundColor', obj.COLOR_m(idx, :))
            set(obj.hEditW(idx), 'ForegroundColor', obj.COLOR_m(idx, :))
            if obj.nImages == 2
                set(obj.hBtnHide(idx), 'ForegroundColor', obj.COLOR_m(idx, :))
            end

            % change colorbar axes
            if ~isempty(obj.hAxCb)
                % many UI elements dont exist when prepare colors is called
                % the first time
                colormap(obj.hAxCb(idx), obj.cmap{idx})
                % recolor the ticks on the colorbars
                obj.cw()
            end

            if obj.nImages == 2 && strcmp(get(obj.f, 'Visible'), 'on')
                % the first time setCmap is called, not all UI Elements are
                % created yet, so we wait until obj.f is actually shown to
                % the user

                obj.recolor()
            end
        end
        
        
        function changeCmap(obj, src, ~)
            
            obj.setCmap(src)
            
            % reclaculate the shown image with the new colormap
            obj.refreshUI()
        end
        
        
        function isContrast = isContrast(obj, inputContrast)
            contrasts = {'green-magenta', 'PET', 'heat'};
            if obj.nImages == 1
                isContrast = true;
                warning('Only one image available - contrast value ignored');
            else
                switch class(inputContrast)
                    case 'char'
                        if sum(strcmp(contrasts, inputContrast))
                            isContrast = true;
                        else
                            fprintf('Contrast must be any of the following or cell:\n');
                            for con = contrasts
                                fprintf('%s\n', con{1});
                            end
                            error('Choose a valid contrast!');
                        end
                    case 'cell'
                        isContrast = obj.isColormap(inputContrast{1}) && obj.isColormap(inputContrast{2});
                    otherwise
                        error('Contrast must be an identifier string or colormap-cell!');
                end
            end
        end
        
        
        function prepareColormaps(obj)
            cmapResolution = 256;
            obj.availableCmaps.gray    = gray(cmapResolution);
            obj.availableCmaps.green   = [zeros(cmapResolution,1) linspace(0,1,cmapResolution)' zeros(cmapResolution,1)];
            obj.availableCmaps.magenta = [linspace(0,1,cmapResolution)' zeros(cmapResolution,1) linspace(0,1,cmapResolution)'];
            obj.availableCmaps.hot     = hot(cmapResolution);
            obj.availableCmaps.parula  = parula(cmapResolution);
            if ~verLessThan('matlab', '9.9')
                % this colormap was only introduced in 2020b
                obj.availableCmaps.turbo   = turbo(cmapResolution);
            end
            
            % check whether colorcet (https://colorcet.com/) is available
            if exist('colorcet.m',  'file') == 2
                % replace hot with fire
                obj.availableCmaps.fire = colorcet('fire', 'N', cmapResolution);
                obj.availableCmaps = rmfield(obj.availableCmaps, 'hot');                
                % add some more cmaps
                obj.availableCmaps.redblue      = colorcet('D4', 'N', cmapResolution);
                obj.availableCmaps.cyclic       = colorcet('C2', 'N', cmapResolution);
                obj.availableCmaps.isolum       = colorcet('I1', 'N', cmapResolution);
                obj.availableCmaps.protanopic   = colorcet('CBL2', 'N', cmapResolution);
                obj.availableCmaps.tritanopic   = colorcet('CBTL1', 'N', cmapResolution);
                obj.availableCmaps.rainbow      = colorcet('R2', 'N', cmapResolution);
                obj.availableCmaps.coolwarm     = colorcet('D1', 'N', cmapResolution);
            end
            % check whether certain colormaps are available
            if exist('viridis.m', 'file') == 2
                obj.availableCmaps.viridis = viridis;
            end
            if exist('inferno.m', 'file') == 2
                obj.availableCmaps.inferno = inferno;
            end

            % check 'colormaps' folder for additional colormaps
            [currentPath, ~, ~] = fileparts(mfilename('fullpath'));
            files = dir([currentPath filesep 'colormaps']);
            for iFile = 3:numel(files)
                % skip '.' and '..'
                [~, mapName, ext] = fileparts(files(iFile).name);
                if strcmp(ext, '.m')
                    obj.availableCmaps.(mapName) = feval(mapName, cmapResolution);
                elseif strcmp(ext, '.mat')
                    mapData = load([files(iFile).folder filesep files(iFile).name]);                    
                    fNames = fieldnames(mapData);
                    % loop over colormaps in file
                    for iMap = 1:numel(fNames)
                        % only allow 2dimensional matrices with 3 columns
                        if ismatrix(mapData.(fNames{iMap})) && size(mapData.(fNames{iMap}), 2) == 3
                            obj.availableCmaps.(fNames{iMap}) = mapData.(fNames{iMap});
                        end
                    end
                else
                    warning('Colormap %s is not supported!', [mapName '.' ext])
                end
            end
            obj.cmapStrings = fieldnames(obj.availableCmaps);
        end
        
        
        function setInitialColormap(obj, inputMap)

            if iscell(inputMap) & numel(inputMap)==1 & obj.nImages==2
                % if only one map is provided for two input matrices, use
                % it for both matrices
                inputMap{2} = inputMap{1};
            end
            
            % make non-cell input easier to work with
            if ~iscell(inputMap)
                inputMap = {inputMap, inputMap};
            end
            
                        
            % counter for custom colormaps
            customCtr = 1;
            for idx = 1:obj.nImages
                % set both popdown menus to the default 'gray(256)' and overwrite when
                % suitable maps are provided
                obj.setPopCm(idx, 'gray')
                if ischar(inputMap{idx})
                    % find index in colormap List
                    if ismember(inputMap{idx}, obj.cmapStrings)
                        obj.setPopCm(idx, inputMap{idx})
                        continue
                    end
                elseif isnumeric(inputMap{idx})
                    if size(inputMap{idx}, 2) == 3
                        obj.availableCmaps.(['custom' num2str(customCtr)]) = inputMap{idx};
                        obj.cmapStrings = fieldnames(obj.availableCmaps);
                        obj.setPopCm(idx, ['custom' num2str(customCtr)])
                        customCtr = customCtr+1;
                        continue
                    end
                end
                
                % input not supported
                warning('Could not parse input for colormap %d, using gray(256) instead', idx)
            end
        end
        
        
        function setInitialContrast(obj)
            % depending on the selected contrast, both colormaps are generated
            % and stored in cm, as well as the colors for the text in the control
            % panel (c1, c2)
            switch obj.contrast
                case 'green-magenta'
                    obj.setPopCm(1, 'magenta')
                    obj.setPopCm(2, 'green')
                case 'PET'
                    obj.setPopCm(1, 'gray')
                    if isfield(obj.availableCmaps, 'fire')
                        obj.setPopCm(2, 'fire')
                    else
                        obj.setPopCm(2, 'hot')
                    end
                case 'heat'
                    obj.setPopCm(1, 'gray')
                    obj.setPopCm(2, 'redblue')
                otherwise
                    error(['Contrast not available. Choose', ...
                        "\t'green-magenta'", ...
                        "\t'PET'", ...
                        "or \t''"]);
            end
        end
        
        
        function setPopCm(obj, idx, cName)
           % sets the value of hPopCm(idx) to the string specified by cName
           
           idxValue = find(cellfun( @(x) strcmp(x, cName), obj.cmapStrings));
           
           set(obj.hPopCm(idx), 'Value', idxValue);            
        end
        
        
        function tmp = cleverMax(~, in)
            % this function is called by MATLAB versions older than R2018a
            % in which 'max(A, [], 'all')' syntax was implemented. It
            % iteratively calculates the max value along the remaining
            % largest dimension. Calculating max like this proves less
            % memory intensive than max(in(:)), which gets slow for large
            % arrays.
            
            sz = size(in);
            
            for i = 1:numel(sz)
                % find the index for the largest dimenison
                [~, idx] = max(sz);
                if i==1
                    tmp = max(in,[], idx(1), 'omitnan');
                else
                    tmp = max(tmp,[], idx(1), 'omitnan');
                end
                sz = size(tmp);
            end
        end
        
        
        function tmp = cleverMin(~, in)
            % this function is called by MATLAB versions older than R2018a
            % in which 'min(A, [], 'all')' syntax was implemented. It
            % iteratively calculates the min value along the remaining
            % largest dimension. Calculating min like this proves less
            % memory intensive than min(in(:)), which gets slow for large
            % arrays.
            
            sz = size(in);
            
            for i = 1:numel(sz)
                % find the index for the largest dimenison
                [~, idx] = max(sz);
                if i==1
                    tmp = min(in,[], idx(1), 'omitnan');
                else
                    tmp = min(tmp,[], idx(1), 'omitnan');
                end
                sz = size(tmp);
            end
        end
    end
end


function str = valsToString(valCell)
	% makes sure all entries in dimVals are strings
    
    % initialize output
    str = valCell;
    
    % find numeric arrays
    numArray = cellfun(@isnumeric, valCell);
    if any(numArray)
        % convert matrix to cell
        str(numArray) = cellfun(@num2cell, valCell(numArray), 'UniformOutput', 0);
        % convert numbers to strings
        for ii = find(numArray)
            str{ii} = cellfun(@num2str, str{ii}, 'UniformOutput', 0);
        end
    end
    
    % find char arrays
    charArray = cellfun(@ischar, valCell);
    if any(charArray)
        % convert char to cell
        str(charArray) = cellfun(@(x) {x}, valCell(charArray), 'UniformOutput', 0);
    end
end