# VMT_GraphicsControl

## PURPOSE

--- THE VELOCITY MAPPING TOOLBOX ---

## SYNOPSIS

function varargout = VMT_GraphicsControl(varargin)

## DESCRIPTION

     --- THE VELOCITY MAPPING TOOLBOX ---
     VMT_GRAPHICSCONTROL is a sub-GUI of VMT which allows the user to
     dynamically adjust the figures.
    __________________________________________________________________________
     Frank L. Engel, U.S. Geological Survey, Illinois Water Science Center
     (fengel@usgs.gov)

     Code contributed by P.R. Jackson, D. Parsons, D. Mueller, and J. Czuba.
    __________________________________________________________________________

## CROSS-REFERENCE INFORMATION

This function calls:

- cptcmap CPTCMAP Apply a .cpt file as colormap to an axis

This function is called by:

## SUBFUNCTIONS

- function VMT_GraphicsControl_OpeningFcn(hObject, eventdata, handles, varargin)
- function varargout = VMT_GraphicsControl_OutputFcn(hObject, eventdata, handles)
- function UseDataLimitsPlanview_Callback(hObject, eventdata, handles)
- function MinVelocityPlanview_Callback(hObject, eventdata, handles)
- function MaxVelocityPlanview_Callback(hObject, eventdata, handles)
- function ColormapPlanview_Callback(hObject, eventdata, handles)
- function UseDataLimitsMCS_Callback(hObject, eventdata, handles)
- function MinVelocityMCS_Callback(hObject, eventdata, handles)
- function MaxVelocityMCS_Callback(hObject, eventdata, handles)
- function ColormapMCS_Callback(hObject, eventdata, handles)
- function ReferenceVelocity_Callback(hObject, eventdata, handles)
- function UseDefaults_Callback(hObject, eventdata, handles)
- function Distance_Callback(hObject, eventdata, handles)
- function Depth_Callback(hObject, eventdata, handles)
- function ApplyChanges_Callback(hObject, eventdata, handles)
- function Close_Callback(hObject, eventdata, handles)
- function initGUI(handles)
- function [guiparams] = createGUIparams
- function set_enable(handles,enable_state)
- function UpdatePlotStyle(hObject, eventdata, handles)
- function load_prefs(hfigure)
- function store_prefs(hfigure,pref)

## SOURCE CODE

    0001 function varargout = VMT_GraphicsControl(varargin)
    0002 % --- THE VELOCITY MAPPING TOOLBOX ---
    0003 % VMT_GRAPHICSCONTROL is a sub-GUI of VMT which allows the user to
    0004 % dynamically adjust the figures.
    0005 %__________________________________________________________________________
    0006 % Frank L. Engel, U.S. Geological Survey, Illinois Water Science Center
    0007 % (fengel@usgs.gov)
    0008 %
    0009 % Code contributed by P.R. Jackson, D. Parsons, D. Mueller, and J. Czuba.
    0010 %__________________________________________________________________________
    0011
    0012 % Last Modified by GUIDE v2.5 24-Jul-2013 14:55:36
    0013
    0014 % Begin initialization code - DO NOT EDIT
    0015 gui_Singleton = 1;
    0016 gui_State = struct('gui_Name',       mfilename, ...
    0017     'gui_Singleton',  gui_Singleton, ...
    0018     'gui_OpeningFcn', @VMT_GraphicsControl_OpeningFcn, ...
    0019     'gui_OutputFcn',  @VMT_GraphicsControl_OutputFcn, ...
    0020     'gui_LayoutFcn',  [] , ...
    0021     'gui_Callback',   []);
    0022 if nargin && ischar(varargin{1})
    0023     gui_State.gui_Callback = str2func(varargin{1});
    0024 end
    0025
    0026 if nargout
    0027     [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
    0028 else
    0029     gui_mainfcn(gui_State, varargin{:});
    0030 end
    0031 % End initialization code - DO NOT EDIT
    0032
    0033
    0034 % --- Executes just before VMT_GraphicsControl is made visible.
    0035 function VMT_GraphicsControl_OpeningFcn(hObject, eventdata, handles, varargin)
    0036 % This function has no output args, see OutputFcn.
    0037 % hObject    handle to figure
    0038 % eventdata  reserved - to be defined in a future version of MATLAB
    0039 % handles    structure with handles and user data (see GUIDATA)
    0040 % varargin   command line arguments to VMT_GraphicsControl (see VARARGIN)
    0041
    0042 % Choose default command line output for VMT_GraphicsControl
    0043 handles.output = hObject;
    0044
    0045 % Update handles structure
    0046 guidata(hObject, handles);
    0047
    0048 % Initialize the GUI parameters:
    0049 % ------------------------------
    0050 guiparams = createGUIparams;
    0051
    0052 % Store the application data
    0053 % --------------------------
    0054 setappdata(handles.figure1,'guiparams',guiparams)
    0055
    0056 % Load the GUI preferences:
    0057 % -------------------------
    0058 load_prefs(handles.figure1)
    0059
    0060 % Initialize the GUI:
    0061 % -------------------
    0062 initGUI(handles)
    0063 % set_enable(handles,'init')
    0064
    0065 % UIWAIT makes VMT_GraphicsControl wait for user response (see UIRESUME)
    0066 % uiwait(handles.figure1);
    0067
    0068 % [EOF] VMT_GraphicsControl_OpeningFcn
    0069
    0070
    0071 % --- Outputs from this function are returned to the command line.
    0072 function varargout = VMT_GraphicsControl_OutputFcn(hObject, eventdata, handles)
    0073 % varargout  cell array for returning output args (see VARARGOUT);
    0074 % hObject    handle to figure
    0075 % eventdata  reserved - to be defined in a future version of MATLAB
    0076 % handles    structure with handles and user data (see GUIDATA)
    0077
    0078 % Get default command line output from handles structure
    0079 varargout{1} = handles.output;
    0080
    0081
    0082 % --- Executes on button press in UseDataLimitsPlanview.
    0083 function UseDataLimitsPlanview_Callback(hObject, eventdata, handles)
    0084
    0085 % Get the Application Data
    0086 % ------------------------
    0087 guiparams = getappdata(handles.figure1,'guiparams');
    0088
    0089 % Modify the Application data:
    0090 % ----------------------------
    0091 guiparams.use_data_limits_planview = logical(get(hObject,'Value')); % boolean
    0092
    0093 if ~guiparams.use_data_limits_planview % User wants to set limits
    0094     % Update the GUI:
    0095     % ---------------
    0096     set_enable(handles,'setplanviewon')
    0097 else
    0098     % Re-populate edit boxes with the data limits
    0099     % -------------------------------------------
    0100     % Compute the data limits to populate edit boxes
    0101     PVdata = guiparams.gp_vmt.iric_anv_planview_data.outmat';
    0102     PVdata(:,4:5) = PVdata(:,4:5).*100; % in cm/s
    0103     vr = sqrt(PVdata(:,4).^2+PVdata(:,5).^2);
    0104     guiparams.min_velocity_planview  = nanmin(vr);
    0105     guiparams.max_velocity_planview  = nanmax(vr);
    0106
    0107     % Ensure correct units
    0108     if ~guiparams.gp_vmt.english_units
    0109         % No further action
    0110     else
    0111         guiparams.min_velocity_planview = guiparams.min_velocity_planview*0.03281;
    0112         guiparams.max_velocity_planview = guiparams.max_velocity_planview*0.03281;
    0113         %guiparams.min_velocity_mcs      = guiparams.min_velocity_mcs*0.03281;
    0114         %guiparams.max_velocity_mcs      = guiparams.max_velocity_mcs*0.03281;
    0115     end
    0116     set(handles.MinVelocityPlanview, 'String', guiparams.min_velocity_planview);
    0117     set(handles.MaxVelocityPlanview, 'String', guiparams.max_velocity_planview);
    0118
    0119     % Update the GUI:
    0120     % ---------------
    0121     set_enable(handles,'setplanviewoff')
    0122 end
    0123
    0124 % Re-store the Application data:
    0125 % ------------------------------
    0126 setappdata(handles.figure1,'guiparams',guiparams)
    0127
    0128 % [EOF] VMT_GraphicsControl_OutputFcn
    0129
    0130
    0131
    0132
    0133
    0134 function MinVelocityPlanview_Callback(hObject, eventdata, handles)
    0135 % Get the Application data:
    0136 % -------------------------
    0137 guiparams = getappdata(handles.figure1,'guiparams');
    0138
    0139 % Get the new entry and make sure it is valid (numeric, positive):
    0140 % ----------------------------------------------------------------
    0141 new_value = str2double(get(hObject,'String'));
    0142 is_a_number = ~isnan(new_value);
    0143
    0144 % Modify the Application data:
    0145 % ----------------------------
    0146 if is_a_number
    0147     guiparams.min_velocity_planview = new_value;
    0148
    0149     % Re-store the Application data:
    0150     % ------------------------------
    0151     setappdata(handles.figure1,'guiparams',guiparams)
    0152
    0153 else % Reject the (incorrect) input
    0154     set(hObject,'String',guiparams.min_velocity_planview)
    0155 end
    0156 % [EOF] MinVelocityPlanview_Callback
    0157
    0158
    0159
    0160
    0161
    0162 function MaxVelocityPlanview_Callback(hObject, eventdata, handles)
    0163 % Get the Application data:
    0164 % -------------------------
    0165 guiparams = getappdata(handles.figure1,'guiparams');
    0166
    0167 % Get the new entry and make sure it is valid (numeric, positive):
    0168 % ----------------------------------------------------------------
    0169 new_value = str2double(get(hObject,'String'));
    0170 is_a_number = ~isnan(new_value);
    0171
    0172 % Modify the Application data:
    0173 % ----------------------------
    0174 if is_a_number
    0175     guiparams.max_velocity_planview = new_value;
    0176
    0177     % Re-store the Application data:
    0178     % ------------------------------
    0179     setappdata(handles.figure1,'guiparams',guiparams)
    0180
    0181 else % Reject the (incorrect) input
    0182     set(hObject,'String',guiparams.max_velocity_planview)
    0183 end
    0184 % [EOF] MaxVelocityPlanview_Callback
    0185
    0186
    0187
    0188 % --- Executes on selection change in ColormapPlanview.
    0189 function ColormapPlanview_Callback(hObject, eventdata, handles)
    0190 % Get the Application data:
    0191 % -------------------------
    0192 guiparams = getappdata(handles.figure1,'guiparams');
    0193 guiprefs  = getappdata(handles.figure1,'guiprefs');
    0194
    0195 % Modify the Application data:
    0196 % ----------------------------
    0197 idx_variable = get(hObject,'Value');
    0198 guiparams.idx_colormap_planview = idx_variable;
    0199 guiparams.colormap_planview = guiparams.colormaps_planview(idx_variable).string;
    0200
    0201 if strcmpi('Browse for more (cpt)...',guiparams.colormap_planview)
    0202     [FileName,PathName] = uigetfile('*.cpt','Select the cpt colormap file',...
    0203         fullfile(guiprefs.cpt_path,guiprefs.cpt_file));
    0204     guiparams.cpt_planview = fullfile(PathName,FileName);
    0205
    0206     % Update the preferences:
    0207     % -----------------------
    0208     guiprefs.cpt_path = PathName;
    0209     guiprefs.cpt_file = FileName;
    0210     setappdata(handles.figure1,'guiprefs',guiprefs)
    0211     store_prefs(handles.figure1,'cptplanview')
    0212 end
    0213
    0214 % Re-store the Application data:
    0215 % ------------------------------
    0216 setappdata(handles.figure1,'guiparams',guiparams)
    0217
    0218 % [EOF] ColormapPlanview_Callback
    0219
    0220
    0221
    0222 % --- Executes on button press in UseDataLimitsMCS.
    0223 function UseDataLimitsMCS_Callback(hObject, eventdata, handles)
    0224 % Get the Application Data
    0225 % ------------------------
    0226 guiparams = getappdata(handles.figure1,'guiparams');
    0227
    0228 % Modify the Application data:
    0229 % ----------------------------
    0230 guiparams.use_data_limits_mcs = logical(get(hObject,'Value')); % boolean
    0231
    0232 if ~guiparams.use_data_limits_mcs % User wants to set limits
    0233     % Update the GUI:
    0234     % ---------------
    0235     set_enable(handles,'setmcson')
    0236 else
    0237     % Re-populate edit boxes with the data limits
    0238     % -------------------------------------------
    0239     % Compute the data limits to populate edit boxes
    0240     switch guiparams.gp_vmt.contour
    0241         case 'streamwise'
    0242             vmin = nanmin(guiparams.gp_vmt.V.uSmooth(:));
    0243             vmax = nanmax(guiparams.gp_vmt.V.uSmooth(:));
    0244         case 'transverse'
    0245             vmin = nanmin(guiparams.gp_vmt.V.vSmooth(:));
    0246             vmax = nanmax(guiparams.gp_vmt.V.vSmooth(:));
    0247         case 'vertical'
    0248             vmin = nanmin(guiparams.gp_vmt.V.wSmooth(:));
    0249             vmax = nanmax(guiparams.gp_vmt.V.wSmooth(:));
    0250         case 'mag'
    0251             vmin = nanmin(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0252             vmax = nanmax(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0253         case 'east'
    0254             vmin = nanmin(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0255             vmax = nanmax(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0256         case 'north'
    0257             vmin = nanmin(guiparams.gp_vmt.V.mcsEastSmooth(:));
    0258             vmax = nanmax(guiparams.gp_vmt.V.mcsNorthSmooth(:));
    0259         case 'primary_zsd'
    0260             vmin = nanmin(guiparams.gp_vmt.V.vpSmooth(:));
    0261             vmax = nanmax(guiparams.gp_vmt.V.vpSmooth(:));
    0262         case 'secondary_zsd'
    0263             vmin = nanmin(guiparams.gp_vmt.V.vsSmooth(:));
    0264             vmax = nanmax(guiparams.gp_vmt.V.vsSmooth(:));
    0265         case 'primary_roz'
    0266             vmin = nanmin(guiparams.gp_vmt.V.Roz.upSmooth(:));
    0267             vmax = nanmax(guiparams.gp_vmt.V.Roz.upSmooth(:));
    0268         case 'secondary_roz'
    0269             vmin = nanmin(guiparams.gp_vmt.V.Roz.usSmooth(:));
    0270             vmax = nanmax(guiparams.gp_vmt.V.Roz.usSmooth(:));
    0271         case 'primary_roz_x'
    0272             vmin = nanmin(guiparams.gp_vmt.V.Roz.upxSmooth(:));
    0273             vmax = nanmax(guiparams.gp_vmt.V.Roz.upxSmooth(:));
    0274         case 'primary_roz_y'
    0275             vmin = nanmin(guiparams.gp_vmt.V.Roz.upySmooth(:));
    0276             vmax = nanmax(guiparams.gp_vmt.V.Roz.upySmooth(:));
    0277         case 'secondary_roz_x'
    0278             vmin = nanmin(guiparams.gp_vmt.V.Roz.usxSmooth(:));
    0279             vmax = nanmax(guiparams.gp_vmt.V.Roz.usxSmooth(:));
    0280         case 'secondary_roz_y'
    0281             vmin = nanmin(guiparams.gp_vmt.V.Roz.usySmooth(:));
    0282             vmax = nanmax(guiparams.gp_vmt.V.Roz.usySmooth(:));
    0283         case 'backscatter'
    0284             vmin = nanmin(guiparams.gp_vmt.V.mcsBackSmooth(:));
    0285             vmax = nanmax(guiparams.gp_vmt.V.mcsBackSmooth(:));
    0286         case 'flowangle'
    0287             vmin = nanmin(guiparams.gp_vmt.V.mcsDirSmooth(:));
    0288             vmax = nanmax(guiparams.gp_vmt.V.mcsDirSmooth(:));
    0289     end
    0290     guiparams.min_velocity_mcs              = vmin;
    0291     guiparams.max_velocity_mcs              = vmax;
    0292
    0293     % Ensure correct units
    0294     if ~guiparams.gp_vmt.english_units
    0295         % No further action
    0296     else
    0297         %guiparams.min_velocity_planview = guiparams.min_velocity_planview*0.03281;
    0298         %guiparams.max_velocity_planview = guiparams.max_velocity_planview*0.03281;
    0299         guiparams.min_velocity_mcs      = guiparams.min_velocity_mcs*0.03281;
    0300         guiparams.max_velocity_mcs      = guiparams.max_velocity_mcs*0.03281;
    0301     end
    0302     set(handles.MinVelocityMCS, 'String', guiparams.min_velocity_mcs);
    0303     set(handles.MaxVelocityMCS, 'String', guiparams.max_velocity_mcs);
    0304
    0305     % Update the GUI:
    0306     % ---------------
    0307     set_enable(handles,'setmcsoff')
    0308 end
    0309
    0310 % Re-store the Application data:
    0311 % ------------------------------
    0312 setappdata(handles.figure1,'guiparams',guiparams)
    0313
    0314 % [EOF] UseDataLimitsMCS_Callback
    0315
    0316
    0317 function MinVelocityMCS_Callback(hObject, eventdata, handles)
    0318 % Get the Application data:
    0319 % -------------------------
    0320 guiparams = getappdata(handles.figure1,'guiparams');
    0321
    0322 % Get the new entry and make sure it is valid (numeric):
    0323 % ----------------------------------------------------------------
    0324 new_value = str2double(get(hObject,'String'));
    0325 is_a_number = ~isnan(new_value);
    0326
    0327 % Modify the Application data:
    0328 % ----------------------------
    0329 if is_a_number
    0330     guiparams.min_velocity_mcs = new_value;
    0331
    0332     % Re-store the Application data:
    0333     % ------------------------------
    0334     setappdata(handles.figure1,'guiparams',guiparams)
    0335
    0336 else % Reject the (incorrect) input
    0337     set(hObject,'String',guiparams.min_velocity_mcs)
    0338 end
    0339 % [EOF] MinVelocityMCS_Callback
    0340
    0341
    0342
    0343
    0344 function MaxVelocityMCS_Callback(hObject, eventdata, handles)
    0345 % Get the Application data:
    0346 % -------------------------
    0347 guiparams = getappdata(handles.figure1,'guiparams');
    0348
    0349 % Get the new entry and make sure it is valid (numeric):
    0350 % ----------------------------------------------------------------
    0351 new_value = str2double(get(hObject,'String'));
    0352 is_a_number = ~isnan(new_value);
    0353
    0354 % Modify the Application data:
    0355 % ----------------------------
    0356 if is_a_number
    0357     guiparams.max_velocity_mcs = new_value;
    0358
    0359     % Re-store the Application data:
    0360     % ------------------------------
    0361     setappdata(handles.figure1,'guiparams',guiparams)
    0362
    0363 else % Reject the (incorrect) input
    0364     set(hObject,'String',guiparams.max_velocity_mcs)
    0365 end
    0366 % [EOF] MaxVelocityMCS_Callback
    0367
    0368
    0369
    0370 % --- Executes on selection change in ColormapMCS.
    0371 function ColormapMCS_Callback(hObject, eventdata, handles)
    0372 % Get the Application data:
    0373 % -------------------------
    0374 guiparams = getappdata(handles.figure1,'guiparams');
    0375 guiprefs  = getappdata(handles.figure1,'guiprefs');
    0376
    0377 % Modify the Application data:
    0378 % ----------------------------
    0379 idx_variable = get(hObject,'Value');
    0380 guiparams.idx_colormap_mcs = idx_variable;
    0381 guiparams.colormap_mcs = guiparams.colormaps_mcs(idx_variable).string;
    0382
    0383 if strcmpi('Browse for more (cpt)...',guiparams.colormap_mcs)
    0384     [FileName,PathName] = uigetfile('*.cpt','Select the cpt colormap file',...
    0385         fullfile(guiprefs.cpt_path,guiprefs.cpt_file));
    0386     guiparams.cpt_mcs = fullfile(PathName,FileName);
    0387
    0388     % Update the preferences:
    0389     % -----------------------
    0390     guiprefs.cpt_path = PathName;
    0391     guiprefs.cpt_file = FileName;
    0392     setappdata(handles.figure1,'guiprefs',guiprefs)
    0393     store_prefs(handles.figure1,'cptmcs')
    0394 end
    0395
    0396 % Re-store the Application data:
    0397 % ------------------------------
    0398 setappdata(handles.figure1,'guiparams',guiparams)
    0399
    0400 % [EOF] ColormapMCS_Callback
    0401
    0402
    0403
    0404 function ReferenceVelocity_Callback(hObject, eventdata, handles)
    0405 % Get the Application data:
    0406 % -------------------------
    0407 guiparams = getappdata(handles.figure1,'guiparams');
    0408
    0409 % Get the new entry and make sure it is valid (numeric, positive):
    0410 % ----------------------------------------------------------------
    0411 new_value = str2double(get(hObject,'String'));
    0412 is_a_number = ~isnan(new_value);
    0413 is_positive = new_value>=0;
    0414
    0415 % Modify the Application data:
    0416 % ----------------------------
    0417 if is_a_number && is_positive
    0418     guiparams.reference_velocity = new_value;
    0419
    0420     % Re-store the Application data:
    0421     % ------------------------------
    0422     setappdata(handles.figure1,'guiparams',guiparams)
    0423
    0424 else % Reject the (incorrect) input
    0425     set(hObject,'String',guiparams.reference_velocity)
    0426 end
    0427 % [EOF] ReferenceVelocity_Callback
    0428
    0429
    0430
    0431
    0432 % --- Executes on button press in UseDefaults.
    0433 function UseDefaults_Callback(hObject, eventdata, handles)
    0434 % Get the Application Data
    0435 % ------------------------
    0436 guiparams = getappdata(handles.figure1,'guiparams');
    0437
    0438 % Modify the Application data:
    0439 % ----------------------------
    0440 guiparams.use_defaults = logical(get(hObject,'Value')); % boolean
    0441
    0442 if ~guiparams.use_defaults % User wants to set limits
    0443     % Update the GUI:
    0444     % ---------------
    0445     set_enable(handles,'setrefon')
    0446 else
    0447     [~,J] = ind2sub(size(guiparams.gp_vmt.V.vp(1,:)),find(~isnan(guiparams.gp_vmt.V.vp(1,:))==1));
    0448     et = J(1):guiparams.gp_vmt.horizontal_vector_spacing:J(end);
    0449     [r, ~]=size(guiparams.gp_vmt.V.vp);
    0450     bi = 1:guiparams.gp_vmt.vertical_vector_spacing:r;
    0451     switch guiparams.gp_vmt.secondary_flow_vector_variable
    0452         case 'transverse'
    0453             reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.vSmooth(bi,et)))));
    0454         case 'secondary_zsd'
    0455             reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.vsSmooth(bi,et)))));
    0456         case 'secondary_roz'
    0457             reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.Roz.usSmooth(bi,et)))));
    0458         case 'secondary_roz_y'
    0459             reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.Roz.usySmooth(bi,et)))));
    0460         case 'primary_roz_y'
    0461             reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.Roz.upySmooth(bi,et)))));
    0462     end
    0463
    0464     distance = 0.06*max(guiparams.gp_vmt.V.mcsDist(:));
    0465     depth    = 0.95*max(guiparams.gp_vmt.V.mcsBed(:));
    0466     if guiparams.gp_vmt.english_units
    0467         reference_velocity = reference_velocity*0.03281; % cm/s to ft/s
    0468         distance = distance*3.281;
    0469         depth    = depth*3.281;
    0470     end
    0471
    0472
    0473     set(handles.ReferenceVelocity, 'String', num2str(reference_velocity))
    0474     set(handles.Distance,          'String', num2str(distance))
    0475     set(handles.Depth,             'String', num2str(depth))
    0476
    0477     % Re-store the Application data:
    0478     % ------------------------------
    0479     guiparams.reference_velocity = reference_velocity;
    0480     guiparams.distance           = distance;
    0481     guiparams.depth              = depth;
    0482     setappdata(handles.figure1,'guiparams',guiparams)
    0483
    0484     % Update the GUI:
    0485     % ---------------
    0486     set_enable(handles,'setrefoff')
    0487 end
    0488
    0489
    0490 % [EOF] UseDefaults_Callback
    0491
    0492
    0493 function Distance_Callback(hObject, eventdata, handles)
    0494 % Get the Application data:
    0495 % -------------------------
    0496 guiparams = getappdata(handles.figure1,'guiparams');
    0497
    0498 % Get the new entry and make sure it is valid (numeric, positive):
    0499 % ----------------------------------------------------------------
    0500 new_value = str2double(get(hObject,'String'));
    0501 is_a_number = ~isnan(new_value);
    0502 is_positive = new_value>=0;
    0503
    0504 % Modify the Application data:
    0505 % ----------------------------
    0506 if is_a_number && is_positive
    0507     guiparams.distance = new_value;
    0508
    0509     % Re-store the Application data:
    0510     % ------------------------------
    0511     setappdata(handles.figure1,'guiparams',guiparams)
    0512
    0513 else % Reject the (incorrect) input
    0514     set(hObject,'String',guiparams.distance)
    0515 end
    0516 % [EOF] Distance_Callback
    0517
    0518
    0519
    0520
    0521
    0522 function Depth_Callback(hObject, eventdata, handles)
    0523 % Get the Application data:
    0524 % -------------------------
    0525 guiparams = getappdata(handles.figure1,'guiparams');
    0526
    0527 % Get the new entry and make sure it is valid (numeric, positive):
    0528 % ----------------------------------------------------------------
    0529 new_value = str2double(get(hObject,'String'));
    0530 is_a_number = ~isnan(new_value);
    0531 is_positive = new_value>=0;
    0532
    0533 % Modify the Application data:
    0534 % ----------------------------
    0535 if is_a_number && is_positive
    0536     guiparams.depth = new_value;
    0537
    0538     % Re-store the Application data:
    0539     % ------------------------------
    0540     setappdata(handles.figure1,'guiparams',guiparams)
    0541
    0542 else % Reject the (incorrect) input
    0543     set(hObject,'String',guiparams.depth)
    0544 end
    0545 % [EOF] Depth_Callback
    0546
    0547
    0548
    0549
    0550 % --- Executes on button press in ApplyChanges.
    0551 function ApplyChanges_Callback(hObject, eventdata, handles)
    0552 % Get the Application data:
    0553 % -------------------------
    0554 guiparams = getappdata(handles.figure1,'guiparams');
    0555 guiprefs  = getappdata(handles.figure1,'guiprefs');
    0556 z   = guiparams.gp_vmt.z;
    0557 A   = guiparams.gp_vmt.A;
    0558 V   = guiparams.gp_vmt.V;
    0559 Map = guiparams.gp_vmt.Map;
    0560
    0561 % See if PLOT 1 exists already, if so grab the handle.
    0562 fig_planview_handle = findobj(0,'name','Plan View Map');
    0563
    0564 % If PLOT 1 exists, go ahead and apply any changes
    0565 if ~isempty(fig_planview_handle) &&  ishandle(fig_planview_handle)
    0566     figure(fig_planview_handle);
    0567     % Plot the data:
    0568     % --------------
    0569     %msgbox('Plotting Plan View','VMT Status','help','replace');
    0570     depth_range = [guiparams.gp_vmt.depth_range_min guiparams.gp_vmt.depth_range_max];
    0571
    0572     minrng = guiparams.min_velocity_planview;
    0573     maxrng = guiparams.max_velocity_planview;
    0574     usecolormap = guiparams.colormap_planview;
    0575     cptfullfile = guiparams.cpt_planview;
    0576     [~,~,~] = VMT_PlotPlanViewQuivers(z,A,V,Map, ...
    0577         depth_range, ...
    0578         guiparams.gp_vmt.vector_scale_plan_view, ...
    0579         guiparams.gp_vmt.vector_spacing_plan_view, ...
    0580         guiparams.gp_vmt.smoothing_window_size, ...
    0581         guiparams.gp_vmt.display_shoreline, ...
    0582         guiparams.gp_vmt.english_units,...
    0583         guiparams.gp_vmt.mat_file, ...
    0584         guiparams.gp_vmt.mat_path,...
    0585         minrng,...
    0586         maxrng,...
    0587         usecolormap,...
    0588         cptfullfile); % PLOT2
    0589
    0590     % Plot Shoreline
    0591     if guiparams.gp_vmt.display_shoreline
    0592
    0593         if ischar(guiprefs.shoreline_file) % User did not hit cancel
    0594             mapdata = dlmread(fullfile(guiprefs.shoreline_path,guiprefs.shoreline_file));
    0595             Map.UTMe   = mapdata(:,1);
    0596             Map.UTMn   = mapdata(:,2);
    0597             Map.infile = fullfile(guiprefs.shoreline_path,guiprefs.shoreline_file);
    0598             %Map.UTMzone = zone;
    0599         else
    0600             Map = [];
    0601         end
    0602         VMT_PlotShoreline(Map)
    0603     end
    0604
    0605     % Overlay DOQQ
    0606     if guiparams.gp_vmt.add_background
    0607         [~,~] = VMT_OverlayDOQQ(guiprefs,true);
    0608     end
    0609 end
    0610
    0611 % See if PLOT 3 exists already, if so clear the figure
    0612 fig_contour_handle = findobj(0,'name','Mean Cross Section Contour');
    0613
    0614 % If PLOT 3 exists, go ahead and apply any changes
    0615 if ~isempty(fig_contour_handle) &&  ishandle(fig_contour_handle)
    0616     figure(fig_contour_handle);
    0617
    0618     % Modify reference vector, only if it's already being plotted
    0619     if guiparams.gp_vmt.plot_secondary_flow_vectors
    0620         if ~guiparams.gp_vmt.english_units
    0621             [~,A,V,plot_cont_log_text] = VMT_PlotXSContQuiver(z,A,V, ...
    0622                 guiparams.gp_vmt.contour, ...
    0623                 guiparams.gp_vmt.vector_scale_cross_section, ...
    0624                 guiparams.gp_vmt.vertical_exaggeration, ...
    0625                 guiparams.gp_vmt.horizontal_vector_spacing, ...
    0626                 guiparams.gp_vmt.vertical_vector_spacing, ...
    0627                 guiparams.gp_vmt.secondary_flow_vector_variable, ...
    0628                 guiparams.gp_vmt.include_vertical_velocity, ...
    0629                 guiparams.gp_vmt.english_units,...
    0630                 guiparams.reference_velocity,...
    0631                 guiparams.distance,...
    0632                 guiparams.depth); %#ok<ASGLU> % PLOT3
    0633         else
    0634             [~,A,V,plot_cont_log_text] = VMT_PlotXSContQuiver(z,A,V, ...
    0635                 guiparams.gp_vmt.contour, ...
    0636                 guiparams.gp_vmt.vector_scale_cross_section, ...
    0637                 guiparams.gp_vmt.vertical_exaggeration, ...
    0638                 guiparams.gp_vmt.horizontal_vector_spacing, ...
    0639                 guiparams.gp_vmt.vertical_vector_spacing, ...
    0640                 guiparams.gp_vmt.secondary_flow_vector_variable, ...
    0641                 guiparams.gp_vmt.include_vertical_velocity, ...
    0642                 guiparams.gp_vmt.english_units,...
    0643                 guiparams.reference_velocity.*30.48,... %cm/s
    0644                 guiparams.distance.*0.3048,...          %m
    0645                 guiparams.depth.*0.3048); %#ok<ASGLU> % PLOT3
    0646         end
    0647     end
    0648
    0649     % Set data limits
    0650     caxis([
    0651         guiparams.min_velocity_mcs
    0652         guiparams.max_velocity_mcs])
    0653
    0654     % Apply the color map
    0655     if ~strcmpi('Browse for more (cpt)...',guiparams.colormap_mcs)
    0656         colormap(guiparams.colormap_mcs)
    0657     else
    0658         cptcmap(guiparams.cpt_mcs)
    0659     end
    0660 end
    0661
    0662 % Force plots to be formated properly
    0663 % -----------------------------------
    0664 if guiparams.gp_vmt.presentation
    0665     UpdatePlotStyle(hObject, eventdata, handles)
    0666 else
    0667     UpdatePlotStyle(hObject, eventdata, handles)
    0668 end
    0669 % [EOF] ApplyChanges_Callback
    0670
    0671
    0672 % --- Executes on button press in Close.
    0673 function Close_Callback(hObject, eventdata, handles)
    0674
    0675 close(handles.figure1)
    0676
    0677 % [EOF] Close_Callback
    0678
    0679 % --------------------------------------------------------------------
    0680 function initGUI(handles)
    0681 % Initialize the UI controls in the GUI.
    0682
    0683 guiparams = getappdata(handles.figure1,'guiparams');
    0684
    0685 % Plan View Map Panel
    0686 set(handles.UseDataLimitsPlanview,    'Value',  guiparams.use_data_limits_planview);
    0687 set(handles.MinVelocityPlanview,      'String', guiparams.min_velocity_planview);
    0688 set(handles.MinVelocityPlanviewUnits, 'String', guiparams.min_velocity_planview_units);
    0689 set(handles.MaxVelocityPlanview,      'String', guiparams.max_velocity_planview);
    0690 set(handles.MaxVelocityPlanviewUnits, 'String', guiparams.max_velocity_planview_units);
    0691 set(handles.ColormapPlanview,         'String',{guiparams.colormaps_planview.string}, ...
    0692     'Value', guiparams.idx_colormap_planview)
    0693
    0694 % Mean Cross Section Contours
    0695 set(handles.UseDataLimitsMCS,           'Value',  guiparams.use_data_limits_mcs);
    0696 set(handles.MinVelocityMCS,             'String', guiparams.min_velocity_mcs);
    0697 set(handles.MinVelocityMCSUnits,        'String', guiparams.min_velocity_mcs_units);
    0698 set(handles.MaxVelocityMCS,             'String', guiparams.max_velocity_mcs);
    0699 set(handles.MaxVelocityMCSUnits,        'String', guiparams.max_velocity_mcs_units);
    0700 set(handles.UseDefaults,                'Value',  guiparams.use_defaults);
    0701 set(handles.ReferenceVelocity,          'String', guiparams.reference_velocity);
    0702 set(handles.ReferenceVelocityUnits,     'String', guiparams.reference_velocity_units);
    0703 set(handles.Distance,                   'String', guiparams.distance);
    0704 set(handles.DistanceUnits,              'String', guiparams.distance_units);
    0705 set(handles.Depth,                      'String', guiparams.depth);
    0706 set(handles.DepthUnits,                 'String', guiparams.depth_units);
    0707 set(handles.ColormapMCS,                'String',{guiparams.colormaps_mcs.string}, ...
    0708     'Value', guiparams.idx_colormap_mcs);
    0709
    0710 % Update the GUI:
    0711 % ---------------
    0712 if iscell(guiparams.gp_vmt.mat_file) % Multiple mat files loaded
    0713     set_enable(handles,'initmultiple')
    0714 else
    0715     set_enable(handles,'init')
    0716 end
    0717 % [EOF] initGUI
    0718
    0719 function [guiparams] = createGUIparams
    0720
    0721 % Get the VMT current state for use by the sub-GUI
    0722 % ------------------------------------------------
    0723 hVMTgui                 = getappdata(0,'hVMTgui');
    0724 guiparams_vmt           = getappdata(hVMTgui,'guiparams');
    0725 guiparams.gp_vmt        = guiparams_vmt;
    0726
    0727 % Check to see what plots already exist
    0728 % -------------------------------------
    0729 fig_planview_handle = findobj(0,'name','Plan View Map');
    0730 fig_mcs_handle = findobj(0,'name','Mean Cross Section Contour');
    0731 % if ~isempty(fig_planview_handle) &&  ishandle(fig_planview_handle)
    0732 %     figure(fig_planview_handle); clf
    0733 % else
    0734 %     fig_planview_handle = figure('name','Plan View Map'); clf
    0735 %     %set(gca,'DataAspectRatio',[1 1 1],'PlotBoxAspectRatio',[1 1 1])
    0736 % end
    0737
    0738 %%%%%%%%%%%%%%%%%
    0739 % Plan View Map %
    0740 %%%%%%%%%%%%%%%%%
    0741 guiparams.use_data_limits_planview      = 1;
    0742
    0743 if ~isempty(fig_planview_handle) && ishandle(fig_planview_handle)
    0744     % Compute the data limits to populate edit boxes
    0745     PVdata = guiparams.gp_vmt.iric_anv_planview_data.outmat';
    0746     PVdata(:,4:5) = PVdata(:,4:5).*100; % in cm/s
    0747     vr = sqrt(PVdata(:,4).^2+PVdata(:,5).^2);
    0748     guiparams.min_velocity_planview  = nanmin(vr);
    0749     guiparams.max_velocity_planview  = nanmax(vr);
    0750 else
    0751     guiparams.min_velocity_planview  = 0;
    0752     guiparams.max_velocity_planview  = 0;
    0753 end
    0754
    0755 % Colormap choices
    0756 guiparams.idx_colormap_planview  = 1;
    0757 idx = 1;
    0758 guiparams.colormaps_planview(idx).string   = 'Jet';
    0759 idx = idx + 1;
    0760 guiparams.colormaps_planview(idx).string   = 'HSV';
    0761 idx = idx + 1;
    0762 guiparams.colormaps_planview(idx).string   = 'Hot';
    0763 idx = idx + 1;
    0764 guiparams.colormaps_planview(idx).string   = 'Cool';
    0765 idx = idx + 1;
    0766 guiparams.colormaps_planview(idx).string   = 'Spring';
    0767 idx = idx + 1;
    0768 guiparams.colormaps_planview(idx).string   = 'Summer';
    0769 idx = idx + 1;
    0770 guiparams.colormaps_planview(idx).string   = 'Autumn';
    0771 idx = idx + 1;
    0772 guiparams.colormaps_planview(idx).string   = 'Winter';
    0773 idx = idx + 1;
    0774 guiparams.colormaps_planview(idx).string   = 'Gray';
    0775 idx = idx + 1;
    0776 guiparams.colormaps_planview(idx).string   = 'Bone';
    0777 idx = idx + 1;
    0778 guiparams.colormaps_planview(idx).string   = 'Copper';
    0779 idx = idx + 1;
    0780 guiparams.colormaps_planview(idx).string   = 'Pink';
    0781 idx = idx + 1;
    0782 guiparams.colormaps_planview(idx).string   = 'Browse for more (cpt)...';
    0783 guiparams.colormap_planview = ...
    0784     guiparams.colormaps_planview(guiparams.idx_colormap_planview).string;
    0785 guiparams.cpt_planview                     = [];
    0786
    0787 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    0788 % Mean Cross Section Contours %
    0789 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    0790 guiparams.use_data_limits_mcs           = 1;
    0791 guiparams.use_defaults                  = 1;
    0792
    0793 if ~isempty(fig_mcs_handle) && ishandle(fig_mcs_handle)
    0794 if iscell(guiparams.gp_vmt.mat_file) % Multiple mat files loaded
    0795     guiparams.min_velocity_mcs   = 0;
    0796     guiparams.max_velocity_mcs   = 0;
    0797     guiparams.distance           = 0;
    0798     guiparams.depth              = 0;
    0799     guiparams.reference_velocity = 0; % cm/s to ft/s
    0800 else
    0801     % Compute the data limits for the edit box, based on the currently selected
    0802     % contour plot variable
    0803     switch guiparams.gp_vmt.contour
    0804         case 'streamwise'
    0805             vmin = nanmin(guiparams.gp_vmt.V.uSmooth(:));
    0806             vmax = nanmax(guiparams.gp_vmt.V.uSmooth(:));
    0807         case 'transverse'
    0808             vmin = nanmin(guiparams.gp_vmt.V.vSmooth(:));
    0809             vmax = nanmax(guiparams.gp_vmt.V.vSmooth(:));
    0810         case 'vertical'
    0811             vmin = nanmin(guiparams.gp_vmt.V.wSmooth(:));
    0812             vmax = nanmax(guiparams.gp_vmt.V.wSmooth(:));
    0813         case 'mag'
    0814             vmin = nanmin(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0815             vmax = nanmax(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0816         case 'east'
    0817             vmin = nanmin(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0818             vmax = nanmax(guiparams.gp_vmt.V.mcsMagSmooth(:));
    0819         case 'north'
    0820             vmin = nanmin(guiparams.gp_vmt.V.mcsEastSmooth(:));
    0821             vmax = nanmax(guiparams.gp_vmt.V.mcsNorthSmooth(:));
    0822         case 'primary_zsd'
    0823             vmin = nanmin(guiparams.gp_vmt.V.vpSmooth(:));
    0824             vmax = nanmax(guiparams.gp_vmt.V.vpSmooth(:));
    0825         case 'secondary_zsd'
    0826             vmin = nanmin(guiparams.gp_vmt.V.vsSmooth(:));
    0827             vmax = nanmax(guiparams.gp_vmt.V.vsSmooth(:));
    0828         case 'primary_roz'
    0829             vmin = nanmin(guiparams.gp_vmt.V.Roz.upSmooth(:));
    0830             vmax = nanmax(guiparams.gp_vmt.V.Roz.upSmooth(:));
    0831         case 'secondary_roz'
    0832             vmin = nanmin(guiparams.gp_vmt.V.Roz.usSmooth(:));
    0833             vmax = nanmax(guiparams.gp_vmt.V.Roz.usSmooth(:));
    0834         case 'primary_roz_x'
    0835             vmin = nanmin(guiparams.gp_vmt.V.Roz.upxSmooth(:));
    0836             vmax = nanmax(guiparams.gp_vmt.V.Roz.upxSmooth(:));
    0837         case 'primary_roz_y'
    0838             vmin = nanmin(guiparams.gp_vmt.V.Roz.upySmooth(:));
    0839             vmax = nanmax(guiparams.gp_vmt.V.Roz.upySmooth(:));
    0840         case 'secondary_roz_x'
    0841             vmin = nanmin(guiparams.gp_vmt.V.Roz.usxSmooth(:));
    0842             vmax = nanmax(guiparams.gp_vmt.V.Roz.usxSmooth(:));
    0843         case 'secondary_roz_y'
    0844             vmin = nanmin(guiparams.gp_vmt.V.Roz.usySmooth(:));
    0845             vmax = nanmax(guiparams.gp_vmt.V.Roz.usySmooth(:));
    0846         case 'backscatter'
    0847             vmin = nanmin(guiparams.gp_vmt.V.mcsBackSmooth(:));
    0848             vmax = nanmax(guiparams.gp_vmt.V.mcsBackSmooth(:));
    0849         case 'flowangle'
    0850             vmin = nanmin(guiparams.gp_vmt.V.mcsDirSmooth(:));
    0851             vmax = nanmax(guiparams.gp_vmt.V.mcsDirSmooth(:));
    0852     end
    0853     guiparams.min_velocity_mcs              = vmin;
    0854     guiparams.max_velocity_mcs              = vmax;
    0855
    0856     % Reference arrow
    0857     [~,J] = ind2sub(size(guiparams.gp_vmt.V.vp(1,:)),find(~isnan(guiparams.gp_vmt.V.vp(1,:))==1));
    0858     et = J(1):guiparams.gp_vmt.horizontal_vector_spacing:J(end);
    0859     [r, ~]=size(guiparams.gp_vmt.V.vp);
    0860     bi = 1:guiparams.gp_vmt.vertical_vector_spacing:r;
    0861     switch guiparams.gp_vmt.secondary_flow_vector_variable
    0862         case 'transverse'
    0863             guiparams.reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.vSmooth(bi,et)))));
    0864         case 'secondary_zsd'
    0865             guiparams.reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.vsSmooth(bi,et)))));
    0866         case 'secondary_roz'
    0867             guiparams.reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.Roz.usSmooth(bi,et)))));
    0868         case 'secondary_roz_y'
    0869             guiparams.reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.Roz.usySmooth(bi,et)))));
    0870         case 'primary_roz_y'
    0871             guiparams.reference_velocity = ceil(max(max(abs(guiparams.gp_vmt.V.Roz.upySmooth(bi,et)))));
    0872     end
    0873
    0874     guiparams.distance = 0.06*max(guiparams.gp_vmt.V.mcsDist(:));
    0875     guiparams.depth    = 0.95*max(guiparams.gp_vmt.V.mcsBed(:));
    0876     if guiparams.gp_vmt.english_units
    0877         guiparams.reference_velocity = guiparams.reference_velocity*0.03281; % cm/s to ft/s
    0878         guiparams.distance           = guiparams.distance*3.281;
    0879         guiparams.depth              = guiparams.depth*3.281;
    0880     end
    0881 end
    0882 else
    0883     guiparams.min_velocity_mcs   = 0;
    0884     guiparams.max_velocity_mcs   = 0;
    0885     guiparams.distance           = 0;
    0886     guiparams.depth              = 0;
    0887     guiparams.reference_velocity = 0; % cm/s to ft/s
    0888 end
    0889
    0890 guiparams.idx_colormap_mcs              = 1;
    0891
    0892 % Colormap choices
    0893 idx = 1;
    0894 guiparams.colormaps_mcs(idx).string   = 'Jet';
    0895 idx = idx + 1;
    0896 guiparams.colormaps_mcs(idx).string   = 'HSV';
    0897 idx = idx + 1;
    0898 guiparams.colormaps_mcs(idx).string   = 'Hot';
    0899 idx = idx + 1;
    0900 guiparams.colormaps_mcs(idx).string   = 'Cool';
    0901 idx = idx + 1;
    0902 guiparams.colormaps_mcs(idx).string   = 'Spring';
    0903 idx = idx + 1;
    0904 guiparams.colormaps_mcs(idx).string   = 'Summer';
    0905 idx = idx + 1;
    0906 guiparams.colormaps_mcs(idx).string   = 'Autumn';
    0907 idx = idx + 1;
    0908 guiparams.colormaps_mcs(idx).string   = 'Winter';
    0909 idx = idx + 1;
    0910 guiparams.colormaps_mcs(idx).string   = 'Gray';
    0911 idx = idx + 1;
    0912 guiparams.colormaps_mcs(idx).string   = 'Bone';
    0913 idx = idx + 1;
    0914 guiparams.colormaps_mcs(idx).string   = 'Copper';
    0915 idx = idx + 1;
    0916 guiparams.colormaps_mcs(idx).string   = 'Pink';
    0917 idx = idx + 1;
    0918 guiparams.colormaps_mcs(idx).string   = 'Browse for more (cpt)...';
    0919 guiparams.colormap_mcs = ...
    0920     guiparams.colormaps_mcs(guiparams.idx_colormap_mcs).string;
    0921 guiparams.cpt_mcs                      = [];
    0922
    0923 % Set the units
    0924 switch guiparams.gp_vmt.contour
    0925     case 'backscatter'
    0926         guiparams.min_velocity_mcs_units   = 'dB';
    0927         guiparams.max_velocity_mcs_units   = 'dB';
    0928         if ~guiparams.gp_vmt.english_units
    0929             guiparams.min_velocity_planview_units   = 'cm/s';
    0930             guiparams.max_velocity_planview_units   = 'cm/s';
    0931             %guiparams.min_velocity_mcs_units        = 'cm/s';
    0932             %guiparams.max_velocity_mcs_units        = 'cm/s';
    0933             guiparams.reference_velocity_units      = 'cm/s';
    0934             guiparams.distance_units                = 'm';
    0935             guiparams.depth_units                   = 'm';
    0936         else
    0937             guiparams.min_velocity_planview_units   = 'ft/s';
    0938             guiparams.max_velocity_planview_units   = 'ft/s';
    0939             %guiparams.min_velocity_mcs_units        = 'ft/s';
    0940             %guiparams.max_velocity_mcs_units        = 'ft/s';
    0941             guiparams.reference_velocity_units      = 'ft/s';
    0942             guiparams.distance_units                = 'ft';
    0943             guiparams.depth_units                   = 'ft';
    0944         end
    0945     case 'flowangle'
    0946         guiparams.min_velocity_mcs_units   = 'deg';
    0947         guiparams.max_velocity_mcs_units   = 'deg';
    0948         if ~guiparams.gp_vmt.english_units
    0949             guiparams.min_velocity_planview_units   = 'cm/s';
    0950             guiparams.max_velocity_planview_units   = 'cm/s';
    0951             %guiparams.min_velocity_mcs_units        = 'cm/s';
    0952             %guiparams.max_velocity_mcs_units        = 'cm/s';
    0953             guiparams.reference_velocity_units      = 'cm/s';
    0954             guiparams.distance_units                = 'm';
    0955             guiparams.depth_units                   = 'm';
    0956         else
    0957             guiparams.min_velocity_planview_units   = 'ft/s';
    0958             guiparams.max_velocity_planview_units   = 'ft/s';
    0959             %guiparams.min_velocity_mcs_units        = 'ft/s';
    0960             %guiparams.max_velocity_mcs_units        = 'ft/s';
    0961             guiparams.reference_velocity_units      = 'ft/s';
    0962             guiparams.distance_units                = 'ft';
    0963             guiparams.depth_units                   = 'ft';
    0964         end
    0965     otherwise
    0966         if ~guiparams.gp_vmt.english_units
    0967             guiparams.min_velocity_planview_units   = 'cm/s';
    0968             guiparams.max_velocity_planview_units   = 'cm/s';
    0969
    0970             guiparams.min_velocity_mcs_units        = 'cm/s';
    0971             guiparams.max_velocity_mcs_units        = 'cm/s';
    0972             guiparams.reference_velocity_units      = 'cm/s';
    0973             guiparams.distance_units                = 'm';
    0974             guiparams.depth_units                   = 'm';
    0975         else
    0976             guiparams.min_velocity_planview_units   = 'ft/s';
    0977             guiparams.max_velocity_planview_units   = 'ft/s';
    0978
    0979             guiparams.min_velocity_mcs_units        = 'ft/s';
    0980             guiparams.max_velocity_mcs_units        = 'ft/s';
    0981             guiparams.reference_velocity_units      = 'ft/s';
    0982             guiparams.distance_units                = 'ft';
    0983             guiparams.depth_units                   = 'ft';
    0984
    0985             guiparams.min_velocity_planview = guiparams.min_velocity_planview*0.03281;
    0986             guiparams.max_velocity_planview = guiparams.max_velocity_planview*0.03281;
    0987             guiparams.min_velocity_mcs      = guiparams.min_velocity_mcs*0.03281;
    0988             guiparams.max_velocity_mcs      = guiparams.max_velocity_mcs*0.03281;
    0989         end
    0990 end
    0991 % [EOF] createGUIparams
    0992
    0993 % --------------------------------------------------------------------
    0994 function set_enable(handles,enable_state)
    0995
    0996 guiparams = getappdata(handles.figure1,'guiparams');
    0997
    0998 switch enable_state
    0999     case 'init'
    1000         % Plan View Map Panel
    1001         set([handles.UseDataLimitsPlanview
    1002             handles.ColormapPlanview],'Enable', 'on');
    1003         set([handles.MinVelocityPlanview
    1004             handles.MinVelocityPlanviewUnits
    1005             handles.MaxVelocityPlanview
    1006             handles.MaxVelocityPlanviewUnits], 'Enable', 'off');
    1007
    1008         % Mean Cross Section Contours
    1009         set([handles.UseDataLimitsMCS
    1010             handles.UseDefaults
    1011             handles.ColormapMCS],'Enable', 'on');
    1012         set([handles.MinVelocityMCS
    1013             handles.MinVelocityMCSUnits
    1014             handles.MaxVelocityMCS
    1015             handles.MaxVelocityMCSUnits
    1016             handles.ReferenceVelocity
    1017             handles.ReferenceVelocityUnits
    1018             handles.Distance
    1019             handles.DistanceUnits
    1020             handles.Depth
    1021             handles.DepthUnits], 'Enable', 'off');
    1022     case 'initmultiple'
    1023         % Plan View Map Panel
    1024         set([handles.UseDataLimitsPlanview
    1025             handles.ColormapPlanview],'Enable', 'on');
    1026         set([handles.MinVelocityPlanview
    1027             handles.MinVelocityPlanviewUnits
    1028             handles.MaxVelocityPlanview
    1029             handles.MaxVelocityPlanviewUnits], 'Enable', 'off');
    1030
    1031         % Mean Cross Section Contours
    1032         set([handles.UseDataLimitsMCS
    1033             handles.UseDefaults
    1034             handles.ColormapMCS],'Enable', 'off');
    1035         set([handles.MinVelocityMCS
    1036             handles.MinVelocityMCSUnits
    1037             handles.MaxVelocityMCS
    1038             handles.MaxVelocityMCSUnits
    1039             handles.ReferenceVelocity
    1040             handles.ReferenceVelocityUnits
    1041             handles.Distance
    1042             handles.DistanceUnits
    1043             handles.Depth
    1044             handles.DepthUnits], 'Enable', 'off');
    1045     case 'setplanviewon'
    1046         % Plan View Map Panel
    1047         set([handles.UseDataLimitsPlanview
    1048             handles.ColormapPlanview],'Enable', 'on');
    1049         set([handles.MinVelocityPlanview
    1050             handles.MinVelocityPlanviewUnits
    1051             handles.MaxVelocityPlanview
    1052             handles.MaxVelocityPlanviewUnits], 'Enable', 'on');
    1053     case 'setplanviewoff'
    1054         % Plan View Map Panel
    1055         set([handles.UseDataLimitsPlanview
    1056             handles.ColormapPlanview],'Enable', 'on');
    1057         set([handles.MinVelocityPlanview
    1058             handles.MinVelocityPlanviewUnits
    1059             handles.MaxVelocityPlanview
    1060             handles.MaxVelocityPlanviewUnits], 'Enable', 'off');
    1061     case 'setmcson'
    1062         % Mean Cross Section Contours
    1063         set([handles.UseDataLimitsMCS
    1064             handles.ColormapMCS],'Enable', 'on');
    1065         set([handles.MinVelocityMCS
    1066             handles.MinVelocityMCSUnits
    1067             handles.MaxVelocityMCS
    1068             handles.MaxVelocityMCSUnits
    1069             ], 'Enable', 'on');
    1070     case 'setmcsoff'
    1071         % Mean Cross Section Contours
    1072         set([handles.UseDataLimitsMCS
    1073             handles.ColormapMCS],'Enable', 'on');
    1074         set([handles.MinVelocityMCS
    1075             handles.MinVelocityMCSUnits
    1076             handles.MaxVelocityMCS
    1077             handles.MaxVelocityMCSUnits
    1078             ], 'Enable', 'off');
    1079     case 'setrefon'
    1080         set([handles.ReferenceVelocity
    1081             handles.ReferenceVelocityUnits
    1082             handles.Distance
    1083             handles.DistanceUnits
    1084             handles.Depth
    1085             handles.DepthUnits], 'Enable', 'on');
    1086     case 'setrefoff'
    1087         set([handles.ReferenceVelocity
    1088             handles.ReferenceVelocityUnits
    1089             handles.Distance
    1090             handles.DistanceUnits
    1091             handles.Depth
    1092             handles.DepthUnits], 'Enable', 'off');
    1093     otherwise
    1094 end
    1095 % [EOF] set_enable
    1096
    1097 % --------------------------------------------------------------------
    1098 function UpdatePlotStyle(hObject, eventdata, handles)
    1099 % Get the Application Data:
    1100 % -------------------------
    1101 guiparams = getappdata(handles.figure1,'guiparams');
    1102
    1103 % Modify the existing figures
    1104 % ---------------------------
    1105 % Find what plots exist already
    1106 hf = findobj('type','figure');
    1107 valid_names = {'Plan View Map'; 'Mean Cross Section Contour'};
    1108
    1109 if guiparams.gp_vmt.presentation
    1110     % Defaults for Presentation Stlye Figure
    1111     BkgdColor   = 'black';
    1112     AxColor     = 'white';
    1113     FigColor    = 'black'; % [0.3 0.3 0.3]
    1114     FntSize     = 14;
    1115 else
    1116     % Defaults for Print Stlye Figure
    1117     BkgdColor   = 'white';
    1118     AxColor     = 'black';
    1119     FigColor    = 'white'; % [0.3 0.3 0.3]
    1120     FntSize     = 14;
    1121 end
    1122 % Loop through valid figures and adjust
    1123 % -------------------------------------
    1124 if ~isempty(hf) &&  any(ishandle(hf))
    1125
    1126     for i = 1:length(valid_names)
    1127         switch valid_names{i}
    1128             case 'Plan View Map'
    1129                 % Focus the figure
    1130                 hff = findobj('name','Plan View Map');
    1131                 if ~isempty(hff) &&  ishandle(hff)
    1132                     figure(hff)
    1133
    1134                     % Make the changes to figure
    1135                     set(gcf,'Color',BkgdColor);
    1136                     set(gca,'FontSize',FntSize)
    1137                     set(get(gca,'Title'),'FontSize',FntSize)
    1138                     set(gca,'Color',FigColor)
    1139                     set(gca,'XColor',AxColor)
    1140                     set(gca,'YColor',AxColor)
    1141                     set(gca,'ZColor',AxColor)
    1142                     set(findobj(gcf,'tag','Colorbar'),'FontSize',FntSize,'XColor',AxColor,'YColor',AxColor);
    1143                     set(get(gca,'Title'),'FontSize',FntSize,'Color',AxColor)
    1144                     set(get(gca,'xLabel'),'FontSize',FntSize,'Color',AxColor)
    1145                     set(get(gca,'yLabel'),'FontSize',FntSize,'Color',AxColor)
    1146                 end
    1147             case 'Mean Cross Section Contour'
    1148                 % Focus the figure
    1149                 hff = findobj('name','Mean Cross Section Contour');
    1150                 if ~isempty(hff) &&  ishandle(hff)
    1151                     figure(hff)
    1152
    1153                     % Make the changes to figure
    1154                     set(gcf,'Color',BkgdColor);
    1155                     set(gca,'FontSize',FntSize)
    1156                     set(get(gca,'Title'),'FontSize',FntSize)
    1157                     set(gca,'Color',[0.3 0.3 0.3]) %FigColor)
    1158                     set(gca,'XColor',AxColor)
    1159                     set(gca,'YColor',AxColor)
    1160                     set(gca,'ZColor',AxColor)
    1161                     set(findobj(gcf,'tag','Colorbar'),'FontSize',FntSize,'XColor',AxColor,'YColor',AxColor);
    1162                     set(get(gca,'Title'),'FontSize',FntSize,'Color',AxColor)
    1163                     set(get(gca,'xLabel'),'FontSize',FntSize,'Color',AxColor)
    1164                     set(get(gca,'yLabel'),'FontSize',FntSize,'Color',AxColor)
    1165                     set(findobj(gca,'tag','PlotBedElevation')   ,'color'    ,AxColor)
    1166                     set(findobj(gca,'tag','ReferenceVectorText'),'color'    ,AxColor)
    1167                 end
    1168             otherwise
    1169         end
    1170     end
    1171
    1172
    1173 end
    1174
    1175 % [EOF] UpdatePlotStyle
    1176 % --------------------------------------------------------------------
    1177
    1178 % --------------------------------------------------------------------
    1179 function load_prefs(hfigure)
    1180 % Load the GUI preferences.  Also, initialize preferences if they don't
    1181 % already exist.
    1182
    1183 % Preferences:
    1184 % 'cptplanview'     Path and filenames of current graphic (cpt) files for planview
    1185 % 'cptmcs'          Path and filenames of current graphic (cpt) files for MCS
    1186 % 'shoreline;
    1187 % 'aerial'
    1188
    1189 if ispref('VMT','cptplanview')
    1190     cptplanview = getpref('VMT','cptplanview');
    1191     if exist(cptplanview.path,'dir')
    1192         guiprefs.cpt_path = cptplanview.path;
    1193     else
    1194         guiprefs.cpt_path = pwd;
    1195     end
    1196
    1197     if exist(fullfile(cptplanview.path,cptplanview.file),'file')
    1198         guiprefs.cpt_file = cptplanview.file;
    1199     else
    1200         guiprefs.cpt_file = [];
    1201     end
    1202
    1203 else % Initialize graphics
    1204     guiprefs.cpt_path = pwd;
    1205     guiprefs.cpt_file = [];
    1206
    1207     cptplanview.path = pwd;
    1208     cptplanview.file = [];
    1209     setpref('VMT','cptplanview',cptplanview)
    1210 end
    1211
    1212 if ispref('VMT','cptmcs')
    1213     cptmcs = getpref('VMT','cptmcs');
    1214     if exist(cptmcs.path,'dir')
    1215         guiprefs.cpt_path = cptmcs.path;
    1216     else
    1217         guiprefs.cpt_path = pwd;
    1218     end
    1219
    1220     if exist(fullfile(cptmcs.path,cptmcs.file),'file')
    1221         guiprefs.cpt_file = cptmcs.file;
    1222     else
    1223         guiprefs.cpt_file = [];
    1224     end
    1225
    1226 else % Initialize graphics
    1227     guiprefs.cpt_path = pwd;
    1228     guiprefs.cpt_file = [];
    1229
    1230     cptmcs.path = pwd;
    1231     cptmcs.file = [];
    1232     setpref('VMT','cptplanview',cptplanview)
    1233 end
    1234 if ispref('VMT','shoreline')
    1235     shoreline = getpref('VMT','shoreline');
    1236     if exist(shoreline.path,'dir')
    1237         guiprefs.shoreline_path = shoreline.path;
    1238     else
    1239         guiprefs.shoreline_path = pwd;
    1240     end
    1241
    1242     if exist(fullfile(shoreline.path,shoreline.file),'file')
    1243         guiprefs.shoreline_file = shoreline.file;
    1244     else
    1245         guiprefs.shoreline_file = [];
    1246     end
    1247 end
    1248 if ispref('VMT','aerial')
    1249     aerial = getpref('VMT','aerial');
    1250     if exist(aerial.path,'dir')
    1251         guiprefs.aerial_path = aerial.path;
    1252     else
    1253         guiprefs.aerial_path = pwd;
    1254     end
    1255     if iscell(aerial.file)
    1256         if exist(fullfile(aerial.path,aerial.file{1}),'file')
    1257             guiprefs.aerial_file = aerial.file;
    1258         else
    1259             guiprefs.aerial_file = [];
    1260         end
    1261     else
    1262         if exist(fullfile(aerial.path,aerial.file),'file')
    1263             guiprefs.aerial_file = aerial.file;
    1264         else
    1265             guiprefs.aerial_file = [];
    1266         end
    1267     end
    1268 end
    1269
    1270 % Store the prefs
    1271 % ---------------
    1272 setappdata(hfigure,'guiprefs',guiprefs)
    1273
    1274 function store_prefs(hfigure,pref)
    1275 % Store preferences in the Application data and in the persistent
    1276 % preferences data.
    1277
    1278 % Preferences:
    1279 % 'cptplanview'     Path and filenames of current graphic (cpt) files for planview
    1280 % 'cptmcs'          Path and filenames of current graphic (cpt) files for MCS
    1281
    1282 guiprefs = getappdata(hfigure,'guiprefs');
    1283
    1284 switch pref
    1285     case 'cptplanview'
    1286         cptplanview.path = guiprefs.cpt_path;
    1287         cptplanview.file = guiprefs.cpt_file;
    1288         setpref('VMT','cptplanview',cptplanview)
    1289     case 'cptmcs'
    1290         cptmcs.path = guiprefs.cpt_path;
    1291         cptmcs.file = guiprefs.cpt_file;
    1292         setpref('VMT','cptmcs',cptmcs)
    1293     otherwise
    1294 end
    1295
    1296 % [EOF] store_prefs