function varargout = stereoTestBed(varargin)
% STEREOTESTBED M-file for stereoTestBed.fig
% STEREOTESTBED, by itself, creates a new STEREOTESTBED or raises the existing
% singleton*.
%
% H = STEREOTESTBED returns the handle to a new STEREOTESTBED or the handle to
% the existing singleton*.
%
% STEREOTESTBED('CALLBACK',hObject,eventData,handles,...) calls the local
% function named CALLBACK in STEREOTESTBED.M with the given input arguments.
%
% STEREOTESTBED('Property','Value',...) creates a new STEREOTESTBED or raises the
% existing singleton*. Starting from the left, property value pairs are
% applied to the GUI before stereoTestBed_OpeningFcn gets called. An
% unrecognized property name or invalid value makes property application
% stop. All inputs are passed to stereoTestBed_OpeningFcn via varargin.
%
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
% instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES
% Edit the above text to modify the response to help stereoTestBed
% Last Modified by GUIDE v2.5 18-Apr-2012 16:30:57
addpath ../ALGORITHMS/homomorphicFiltering-1
addpath ../ALGORITHMS/homomorphicFiltering-2
addpath ../ALGORITHMS/histogramMatching
addpath ../ALGORITHMS/OpenCV2.3
addpath ../ALGORITHMS/clusteringFilter
addpath ../ALGORITHMS/stereoMatching
addpath ../ALGORITHMS/3DStereoDisp
addpath ../ALGORITHMS/3DStereoDisp/msseg
addpath ../ALGORITHMS/StereoRegion
addpath ../ALGORITHMS/stereoFlow
addpath ../ALGORITHMS/denseMatch
addpath ../ALGORITHMS/ENCC
addpath ../ALGORITHMS/GCS
addpath ../UTIL
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @stereoTestBed_OpeningFcn, ...
'gui_OutputFcn', @stereoTestBed_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before stereoTestBed is made visible.
function stereoTestBed_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to stereoTestBed (see VARARGIN)
% Choose default command line output for stereoTestBed
handles.output = hObject;
% Update handles structure
guidata(hObject, handles);
% UIWAIT makes stereoTestBed wait for user response (see UIRESUME)
% uiwait(handles.window);
set(handles.leftImage, 'Visible', 'off');
set(handles.rightImage, 'Visible', 'off');
set(handles.loadLeftImageButton, 'UserData', '*');
clear global variable PROCESSES
clear global PROCESSES;
clear global LEFT_IMAGE;
clear global RIGHT_IMAGE;
clear global DISPARITY;
clear global GROUND_TRUTH;
% --- Outputs from this function are returned to the command line.
function varargout = stereoTestBed_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Get default command line output from handles structure
varargout{1} = handles.output;
% --- Executes on selection change in processesList.
function processesList_Callback(hObject, eventdata, handles)
% hObject handle to processesList (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hints: contents = get(hObject,'String') returns processesList contents as cell array
% contents{get(hObject,'Value')} returns selected item from processesList
global PROCESSES;
global SELECTED_PROCESS;
if isempty(get(handles.processesList, 'String'))
return;
end
index = get(handles.processesList, 'Value');
parameters = PROCESSES(index).parameters;
SELECTED_PROCESS = PROCESSES(index).id;
%parameters
hidePanels(handles);
if PROCESSES(index).id == Processes.HF1
% Homomorfic Filtering (Gaussian)
set(handles.HFPanel, 'Visible', 'on');
set(handles.HFParamOrder, 'Enable', 'off');
% Parameters: RGB/HSV, d, L, H
[param, remain] = strtok(parameters);
if (str2num(param) == 1)
set(handles.HFParamRGB, 'Value', 1);
elseif (str2num(param) == 2)
set(handles.HFParamHSV, 'Value', 1);
end
[param, remain] = strtok(remain);
set(handles.HFParamd, 'String', param);
[param, remain] = strtok(remain);
set(handles.HFParamL, 'String', param);
[param, remain] = strtok(remain);
set(handles.HFParamH, 'String', param);
elseif PROCESSES(index).id == Processes.HF2
% Homomorfic Filtering (Butterworth)
set(handles.HFPanel, 'Visible', 'on');
set(handles.HFParamOrder, 'Enable', 'on');
% Parameters: RGB/HSV, d, order, L, H
[param, remain] = strtok(parameters);
if (str2num(param) == 1)
set(handles.HFParamRGB, 'Value', 1);
elseif (str2num(param) == 2)
set(handles.HFParamHSV, 'Value', 1);
end
[param, remain] = strtok(remain);
set(handles.HFParamd, 'String', param);
[param, remain] = strtok(remain);
set(handles.HFParamOrder, 'String', param);
[param, remain] = strtok(remain);
set(handles.HFParamL, 'String', param);
[param, remain] = strtok(remain);
set(handles.HFParamH, 'String', param);
elseif PROCESSES(index).id == Processes.HM
% Histogram Matching
set(handles.HMPanel, 'Visible', 'on');
% Parameters: Gray/RGB/HSV
[param, remain] = strtok(parameters);
if (str2num(param) == 1)
set(handles.HMParamGray, 'Value', 1);
elseif (str2num(param) == 2)
set(handles.HMParamRGB, 'Value', 1);
elseif (str2num(param) == 3)
set(handles.HMParamHSV, 'Value', 1);
end
elseif PROCESSES(index).id == Processes.AI
% Adjust Image Intensisy
set(handles.emptyPanel, 'Visible', 'on');
elseif PROCESSES(index).id == Processes.SAD || PROCESSES(index).id == Processes.SSD || PROCESSES(index).id == Processes.NCC
% Sum of Absolute Differences (SAD)
if PROCESSES(index).id == Processes.SAD
set(handles.SAD_SSD_NCCAlg1, 'String', ' SAD Algorithm');
set(handles.SAD_SSD_NCCAlg2, 'String', ' Zero-mean sum of SAD (ZSAD)');
set(handles.SAD_SSD_NCCAlg3, 'String', ' Locally scaled sum of SAD (LSAD)');
set(handles.SAD_SSD_NCCAlg3, 'Visible', 'on');
elseif PROCESSES(index).id == Processes.SSD
set(handles.SAD_SSD_NCCAlg1, 'String', ' SSD Algorithm');
set(handles.SAD_SSD_NCCAlg2, 'String', ' Zero-mean sum of SSD (ZSSD)');
set(handles.SAD_SSD_NCCAlg3, 'String', ' Locally scaled sum of SSD (LSSD)');
set(handles.SAD_SSD_NCCAlg3, 'Visible', 'on');
elseif PROCESSES(index).id == Processes.NCC
set(handles.SAD_SSD_NCCAlg1, 'String', ' NCC Algorithm');
set(handles.SAD_SSD_NCCAlg2, 'String', ' Zero-mean NCC (ZNCC)');
set(handles.SAD_SSD_NCCAlg3, 'String', '');
set(handles.SAD_SSD_NCCAlg3, 'Visible', 'off');
end
set(handles.SAD_SSD_NCCPanel, 'Visible', 'on');
% Parameters: algorithm, dmin, dmax, windowSize
[param, remain] = strtok(parameters);
if (str2num(param) == 1)
set(handles.SAD_SSD_NCCAlg1, 'Value', 1);
elseif (str2num(param) == 2)
set(handles.SAD_SSD_NCCAlg2, 'Value', 1);
elseif (str2num(param) == 3)
set(handles.SAD_SSD_NCCAlg3, 'Value', 1);
end
[param, remain] = strtok(remain);
set(handles.SAD_SSD_NCCdMin, 'String', param);
[param, remain] = strtok(remain);
set(handles.SAD_SSD_NCCdMax, 'String', param);
[param, remain] = strtok(remain);
set(handles.SAD_SSD_NCCWS, 'String', param);
elseif PROCESSES(index).id == Processes.StereoDisp
% 3D Stereo Disparity algorithm
set(handles.lanktonPanel, 'Visible', 'on');
% Parameters: dmin, dmax, hs, hr, M
[param, remain] = strtok(parameters);
set(handles.LanktonMinDisp, 'String', param);
[param, remain] = strtok(remain);
set(handles.LanktonMaxDisp, 'String', param);
[param, remain] = strtok(remain);
set(handles.LanktonSB, 'String', param);
[param, remain] = strtok(remain);
set(handles.LanktonRB, 'String', param);
[param, remain] = strtok(remain);
set(handles.LanktonMSS, 'String', param);
elseif PROCESSES(index).id == Processes.RegionBased
% Region-Based Stereo Matching
set(handles.RBSMPanel, 'Visible', 'on');
% Parameters: method, dmax, matching, threshold, alpha
[param, remain] = strtok(parameters);
if (str2num(param) == 1)
set(handles.RBSMMethod1, 'Value', 1);
elseif (str2num(param) == 2)
set(handles.RBSMMethod2, 'Value', 1);
end
[param, remain] = strtok(remain);
set(handles.RBSMMaxDisp, 'String', param);
[param, remain] = strtok(remain);
set(handles.RBSMMatching, 'String', param);
[param, remain] = strtok(remain);
set(handles.RBSMThreshold, 'String', param);
[param, remain] = strtok(remain);
set(handles.RBSMAlpha, 'String', param);
elseif PROCESSES(index).id == Processes.SMOgale
% Stereo Matching (Abhijit Ogale)
set(handles.SMOgalePanel, 'Visible', 'on');
% Parameters: dmax, dmin, alpha
[param, remain] = strtok(parameters);
set(handles.SMOgaleMaxd, 'String', param);
[param, remain] = strtok(remain);
set(handles.SMOgaleMind, 'String', param);
[param, remain] = strtok(remain);
set(handles.SMOgaleAlpha, 'String', param);
elseif PROCESSES(index).id == Processes.OFOgale
% Optical Flow (Abhijit Ogale)
set(handles.OFPanel, 'Visible', 'on')
% Parameters: dmaxX, dminX, dmaxY dminY, alpha
[param, remain] = strtok(parameters);
set(handles.OFMaxdX, 'String', param);
[param, remain] = strtok(remain);
set(handles.OFMindX, 'String', param);
[param, remain] = strtok(remain);
set(handles.OFMaxdY, 'String', param);
[param, remain] = strtok(remain);
set(handles.OFMindY, 'String', param);
[param, remain] = strtok(remain);
set(handles.OFAlpha, 'String', param);
elseif PROCESSES(index).id == Processes.SMAbbeloos
% Stereo Matching (Wim Abbeloos)
set(handles.SMAbbeloosPanel, 'Visible', 'on')
% Parameters: dmax, windowSize, spacc
[param, remain] = strtok(parameters);
set(handles.SMAbbeloosMaxd, 'String', param);
[param, remain] = strtok(remain);
set(handles.SMAbbeloosWS, 'String', param);
[param, remain] = strtok(remain);
set(handles.SMAbbeloosSPA, 'Value', str2num(param));
elseif PROCESSES(index).id == Processes.ENCC
% Stereo Matching (Wim Abbeloos)
set(handles.ENCCPanel, 'Visible', 'on')
% Parameters: version, dmax, windowX, windowY, ZMFlag, SWMFlag
[param, remain] = strtok(parameters);
if str2num(param) == 1
set(handles.ENCCMatlab, 'Value', 1);
else
set(handles.ENCCCpp, 'Value', 1);
end
[param, remain] = strtok(remain);
set(handles.ENCCDMax, 'String', param);
[param, remain] = strtok(remain);
set(handles.ENCCWx, 'String', param);
[param, remain] = strtok(remain);
set(handles.ENCCWy, 'String', param);
[param, remain] = strtok(remain);
set(handles.ENCCZMF, 'Value', str2num(param));
[param, remain] = strtok(remain);
set(handles.ENCCSWMF, 'Value', str2num(param));
elseif PROCESSES(index).id == Processes.OpenCV_BM
% OpenCV BM algorithm
set(handles.OpenCVBMPanel, 'Visible', 'on');
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% numberOfDisparities, SADWindowSize, minDisparity,
% preFilterCap, uniquenessRatio, textureThreshold,
% speckleWindowSize, speckleRange, disp12MaxDiff
[alg, remain] = strtok(parameters);
[param, remain] = strtok(remain);
set(handles.BMParamNumberOfDisparities, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamSADWindowSize, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamMinDisparity, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamPreFilterCap, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamUniquenessRatio, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamTextureThreshold, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamSpeckleWindowSize, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamSpeckleRange, 'String', param);
[param, remain] = strtok(remain);
set(handles.BMParamDisp12MaxDiff, 'String', param);
elseif PROCESSES(index).id == Processes.OpenCV_SGBM
% OpenCV SGBM algorithm
set(handles.OpenCVSGBMPanel, 'Visible', 'on');
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% numberOfDisparities, SADWindowSize, minDisparity,
% preFilterCap, uniquenessRatio, P1, P2, speckleWindowSize,
% speckleRange, disp12MaxDiff, fullDP
[alg, remain] = strtok(parameters);
[param, remain] = strtok(remain);
set(handles.SGBMParamNumberOfDisparities, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamSADWindowSize, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamMinDisparity, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamPreFilterCap, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamUniquenessRatio, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamP1, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamP2, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamSpeckleWindowSize, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamSpeckleRange, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamDisp12MaxDiff, 'String', param);
[param, remain] = strtok(remain);
set(handles.SGBMParamFullDP, 'Value', str2num(param));
elseif PROCESSES(index).id == Processes.OpenCV_VAR
% OpenCV VAR algorithm
set(handles.OpenCVVARPanel, 'Visible', 'on');
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% minDisparity, maxDisparity, levels, pyrScale, nIt,
% poly_n, poly_sigma, fi, lambda, penalization,
% cycle, flags
[alg, remain] = strtok(parameters);
[param, remain] = strtok(remain);
set(handles.VARParamMinDisparity, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamNumberOfDisparities, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamLevels, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamPyrScale, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamNIt, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamPoly_n, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamPoly_sigma, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamFi, 'String', param);
[param, remain] = strtok(remain);
set(handles.VARParamLambda, 'String', param);
elseif PROCESSES(index).id == Processes.GCS
% Growing Correspondence Seeds
set(handles.emptyPanel, 'Visible', 'on');
elseif PROCESSES(index).id == Processes.Clustering
% Clustering filter
set(handles.clusteringPanel, 'Visible', 'on');
% Parameters: filter(0: filter out all but the largets cluster,
% 1: filter out the largets cluster
% 2: filter out clusters with less than "num" pixels
% 3: filter out the "num" smallest clusters), "num"
% for filters 2 and 3.
[param, remain] = strtok(parameters);
switch str2num(param)
case 0
set(handles.clusteringOption1, 'Value', 1);
case 1
set(handles.clusteringOption2, 'Value', 1);
case 2
set(handles.clusteringOption3, 'Value', 1);
case 3
set(handles.clusteringOption4, 'Value', 1);
end
[param, remain] = strtok(remain);
set(handles.ClusteringParamX, 'String', param);
[param, remain] = strtok(remain);
switch str2num(param)
case 4
set(handles.connectivityOption1, 'Value', 1);
case 8
set(handles.connectivityOption2, 'Value', 1);
end
end
set(handles.addProcessButton, 'String', 'Update');
% --- Executes on selection change in prefiltersList.
function prefiltersList_Callback(hObject, eventdata, handles)
% hObject handle to prefiltersList (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hints: contents = get(hObject,'String') returns prefiltersList contents as cell array
% contents{get(hObject,'Value')} returns selected item from prefiltersList
%sprintf(contents{get(hObject,'Value')})
global SELECTED_PROCESS;
hidePanels(handles);
set(handles.addProcessButton, 'String', 'Add process');
switch get(hObject,'Value')
case 1
SELECTED_PROCESS = Processes.HF1;
set(handles.HFPanel, 'Visible', 'on');
set(handles.HFParamOrder, 'Enable', 'off');
case 2
SELECTED_PROCESS = Processes.HF2;
set(handles.HFPanel, 'Visible', 'on');
set(handles.HFParamOrder, 'Enable', 'on');
case 3
SELECTED_PROCESS = Processes.HM;
set(handles.HMPanel, 'Visible', 'on');
case 4
SELECTED_PROCESS = Processes.AI;
set(handles.emptyPanel, 'Visible', 'on');
end
% --- Executes on selection change in algorithmsList.
function algorithmsList_Callback(hObject, eventdata, handles)
% hObject handle to algorithmsList (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hints: contents = get(hObject,'String') returns algorithmsList contents as cell array
% contents{get(hObject,'Value')} returns selected item from algorithmsList
%get(hObject,'Value')
global SELECTED_PROCESS;
hidePanels(handles);
set(handles.addProcessButton, 'String', 'Add process');
switch get(hObject,'Value')
case 1
SELECTED_PROCESS = Processes.SAD;
set(handles.SAD_SSD_NCCAlg1, 'String', ' SAD Algorithm');
set(handles.SAD_SSD_NCCAlg2, 'String', ' Zero-mean sum of SAD (ZSAD)');
set(handles.SAD_SSD_NCCAlg3, 'String', ' Locally scaled sum of SAD (LSAD)');
set(handles.SAD_SSD_NCCAlg1, 'Value', 1);
set(handles.SAD_SSD_NCCAlg3, 'Visible', 'on');
set(handles.SAD_SSD_NCCPanel, 'Visible', 'on');
case 2
SELECTED_PROCESS = Processes.SSD;
set(handles.SAD_SSD_NCCAlg1, 'String', ' SSD Algorithm');
set(handles.SAD_SSD_NCCAlg2, 'String', ' Zero-mean sum of SSD (ZSSD)');
set(handles.SAD_SSD_NCCAlg3, 'String', ' Locally scaled sum of SSD (LSSD)');
set(handles.SAD_SSD_NCCAlg1, 'Value', 1);
set(handles.SAD_SSD_NCCAlg3, 'Visible', 'on');
set(handles.SAD_SSD_NCCPanel, 'Visible', 'on');
case 3
SELECTED_PROCESS = Processes.NCC;
set(handles.SAD_SSD_NCCAlg1, 'String', ' NCC Algorithm');
set(handles.SAD_SSD_NCCAlg2, 'String', ' Zero-mean NCC (ZNCC)');
set(handles.SAD_SSD_NCCAlg3, 'String', '');
set(handles.SAD_SSD_NCCAlg1, 'Value', 1);
set(handles.SAD_SSD_NCCAlg3, 'Visible', 'off');
set(handles.SAD_SSD_NCCPanel, 'Visible', 'on');
case 4
SELECTED_PROCESS = Processes.StereoDisp;
set(handles.lanktonPanel, 'Visible', 'on');
case 5
SELECTED_PROCESS = Processes.RegionBased;
set(handles.RBSMPanel, 'Visible', 'on');
case 6
SELECTED_PROCESS = Processes.SMOgale;
set(handles.SMOgalePanel, 'Visible', 'on');
case 7
SELECTED_PROCESS = Processes.OFOgale;
set(handles.OFPanel, 'Visible', 'on');
case 8
SELECTED_PROCESS = Processes.SMAbbeloos;
set(handles.SMAbbeloosPanel, 'Visible', 'on');
case 9
SELECTED_PROCESS = Processes.ENCC;
set(handles.ENCCPanel, 'Visible', 'on');
case 10
SELECTED_PROCESS = Processes.OpenCV_BM;
set(handles.OpenCVBMPanel, 'Visible', 'on');
case 11
SELECTED_PROCESS = Processes.OpenCV_SGBM;
set(handles.OpenCVSGBMPanel, 'Visible', 'on');
case 12
SELECTED_PROCESS = Processes.OpenCV_VAR;
set(handles.OpenCVVARPanel, 'Visible', 'on');
case 13
SELECTED_PROCESS = Processes.GCS;
set(handles.emptyPanel, 'Visible', 'on');
end
% --- Executes on selection change in postfiltersList.
function postfiltersList_Callback(hObject, eventdata, handles)
% hObject handle to postfiltersList (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hints: contents = get(hObject,'String') returns postfiltersList contents as cell array
% contents{get(hObject,'Value')} returns selected item from postfiltersList
%get(hObject,'Value')
global SELECTED_PROCESS;
hidePanels(handles);
set(handles.addProcessButton, 'String', 'Add process');
switch get(hObject,'Value')
case 1
SELECTED_PROCESS = Processes.Clustering;
set(handles.clusteringPanel, 'Visible', 'on');
end
% --- Executes during object creation, after setting all properties.
function postfiltersList_CreateFcn(hObject, eventdata, handles)
% hObject handle to postfiltersList (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: listbox controls usually have a white background on Windows.
% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
% --- Executes on button press in addProcessButton.
function addProcessButton_Callback(hObject, eventdata, handles)
% hObject handle to addProcessButton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global SELECTED_PROCESS;
global PROCESSES;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Process process parameters
%%%%%%%%%%%%%%%%%%%%%%%%%%%%
parameters = '';
if SELECTED_PROCESS == Processes.HF1
% Homomorfic Filtering (Gaussian)
% Parameters: RGB/HSV, d, L, H
param1 = 0;
if (get(handles.HFParamRGB, 'Value') == 1)
param1 = 1;
elseif (get(handles.HFParamHSV, 'Value') == 1)
param1 = 2;
end
param2 = get(handles.HFParamd, 'String');
param3 = get(handles.HFParamL, 'String');
param4 = get(handles.HFParamH, 'String');
parameters = sprintf('%d %s %s %s', param1, param2, param3, param4);
elseif SELECTED_PROCESS == Processes.HF2
% Homomorfic Filtering (Butterworth)
% Parameters: RGB/HSV, d, order, L, H
param1 = 0;
if (get(handles.HFParamRGB, 'Value') == 1)
param1 = 1;
elseif (get(handles.HFParamHSV, 'Value') == 1)
param1 = 2;
end
param2 = get(handles.HFParamd, 'String');
param3 = get(handles.HFParamOrder, 'String');
param4 = get(handles.HFParamL, 'String');
param5 = get(handles.HFParamH, 'String');
parameters = sprintf('%d %s %s %s %s', param1, param2, param3, param4, param5);
elseif SELECTED_PROCESS == Processes.HM
% Histogram Matching
% Parameters: Gray/RGB/HSV
param1 = 0;
if (get(handles.HMParamGray, 'Value') == 1)
param1 = 1;
elseif (get(handles.HMParamRGB, 'Value') == 1)
param1 = 2;
elseif (get(handles.HMParamHSV, 'Value') == 1)
param1 = 3;
end
parameters = sprintf('%d', param1);
elseif SELECTED_PROCESS == Processes.AI
% Adjust Image Intensity
% Parameters: N/A
elseif SELECTED_PROCESS == Processes.SAD || SELECTED_PROCESS == Processes.SSD || SELECTED_PROCESS == Processes.NCC
% Sum of Absolute Differences (SAD)
% Sum of Squared Differences (SSD)
% Normalized Cross-Correlation (NCC)
% Parameters: algorithm, dmin, dmax, windowSize
param1 = 0;
if (get(handles.SAD_SSD_NCCAlg1, 'Value') == 1)
param1 = 1;
elseif (get(handles.SAD_SSD_NCCAlg2, 'Value') == 1)
param1 = 2;
elseif (get(handles.SAD_SSD_NCCAlg3, 'Value') == 1)
param1 = 3;
end
param2 = get(handles.SAD_SSD_NCCdMin, 'String');
param3 = get(handles.SAD_SSD_NCCdMax, 'String');
param4 = get(handles.SAD_SSD_NCCWS, 'String');
parameters = sprintf('%d %s %s %s', param1, param2, param3, param4);
elseif SELECTED_PROCESS == Processes.StereoDisp
% 3D Stereo Disparity algorithm
% Parameters: dmin, dmax, hs, hr, M
param1 = get(handles.LanktonMinDisp, 'String');
param2 = get(handles.LanktonMaxDisp, 'String');
param3 = get(handles.LanktonSB, 'String');
param4 = get(handles.LanktonRB, 'String');
param5 = get(handles.LanktonMSS, 'String');
parameters = sprintf('%s %s %s %s %s', param1, param2, param3, param4, param5);
elseif SELECTED_PROCESS == Processes.RegionBased
% Region-Based Stereo Matching
% Parameters: method, dmax, matching, threshold, alpha
param1 = 0;
if (get(handles.RBSMMethod1, 'Value') == 1)
param1 = 1;
elseif (get(handles.RBSMMethod2, 'Value') == 1)
param1 = 2;
end
param2 = get(handles.RBSMMaxDisp, 'String');
param3 = get(handles.RBSMMatching, 'String');
param4 = get(handles.RBSMThreshold, 'String');
param5 = get(handles.RBSMAlpha, 'String');
parameters = sprintf('%d %s %s %s %s', param1, param2, param3, param4, param5);
elseif SELECTED_PROCESS == Processes.SMOgale
% Stereo Matching (Abhijit Ogale)
% Parameters: dmax, dmin, alpha
param1 = get(handles.SMOgaleMaxd, 'String');
param2 = get(handles.SMOgaleMind, 'String');
param3 = get(handles.SMOgaleAlpha, 'String');
parameters = sprintf('%s %s %s', param1, param2, param3);
elseif SELECTED_PROCESS == Processes.OFOgale
% Optical Flow (Abhijit Ogale)
% Parameters: dmaxX, dminX, dmaxY dminY, alpha
param1 = get(handles.OFMaxdX, 'String');
param2 = get(handles.OFMindX, 'String');
param3 = get(handles.OFMaxdY, 'String');
param4 = get(handles.OFMindY, 'String');
param5 = get(handles.OFAlpha, 'String');
parameters = sprintf('%s %s %s %s %s', param1, param2, param3, param4, param5);
elseif SELECTED_PROCESS == Processes.SMAbbeloos
% Stereo Matching (Wim Abbeloos)
% Parameters: dmax, windowSize, spacc
param1 = get(handles.SMAbbeloosMaxd, 'String');
param2 = get(handles.SMAbbeloosWS, 'String');
param3 = get(handles.SMAbbeloosSPA, 'Value');
parameters = sprintf('%s %s %d', param1, param2, param3);
elseif SELECTED_PROCESS == Processes.ENCC
% Stereo Matching (Wim Abbeloos)
% Parameters: version,dmax, windowX, windowY, ZMFlag, SWMFlag
param1 = 0;
if get(handles.ENCCMatlab, 'Value') == 1
param1 = 1;
else
param1 = 2;
end
param2 = get(handles.ENCCDMax, 'String');
param3 = get(handles.ENCCWx, 'String');
param4 = get(handles.ENCCWy, 'String');
param5 = get(handles.ENCCZMF, 'Value');
param6 = get(handles.ENCCSWMF, 'Value');
parameters = sprintf('%d %s %s %s %d %d', param1, param2, param3, param4, param5, param6);
elseif SELECTED_PROCESS == Processes.OpenCV_BM
% OpenCV BM algorithm
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% numberOfDisparities, SADWindowSize, minDisparity,
% preFilterCap, uniquenessRatio, textureThreshold,
% speckleWindowSize, speckleRange, disp12MaxDiff
param1 = 0;
param2 = get(handles.BMParamNumberOfDisparities, 'String');
param3 = get(handles.BMParamSADWindowSize, 'String');
param4 = get(handles.BMParamMinDisparity, 'String');
param5 = get(handles.BMParamPreFilterCap, 'String');
param6 = get(handles.BMParamUniquenessRatio, 'String');
param7 = get(handles.BMParamTextureThreshold, 'String');
param8 = get(handles.BMParamSpeckleWindowSize, 'String');
param9 = get(handles.BMParamSpeckleRange, 'String');
param10 = get(handles.BMParamDisp12MaxDiff, 'String');
parameters = sprintf('%d %s %s %s %s %s %s %s %s %s', param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
elseif SELECTED_PROCESS == Processes.OpenCV_SGBM
% OpenCV SGBM algorithm
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% numberOfDisparities, SADWindowSize, minDisparity,
% preFilterCap, uniquenessRatio, P1, P2, speckleWindowSize,
% speckleRange, disp12MaxDiff, fullDP
param1 = 1;
param2 = get(handles.SGBMParamNumberOfDisparities, 'String');
param3 = get(handles.SGBMParamSADWindowSize, 'String');
param4 = get(handles.SGBMParamMinDisparity, 'String');
param5 = get(handles.SGBMParamPreFilterCap, 'String');
param6 = get(handles.SGBMParamUniquenessRatio, 'String');
param7 = get(handles.SGBMParamP1, 'String');
param8 = get(handles.SGBMParamP2, 'String');
param9 = get(handles.SGBMParamSpeckleWindowSize, 'String');
param10 = get(handles.SGBMParamSpeckleRange, 'String');
param11 = get(handles.SGBMParamDisp12MaxDiff, 'String');
param12 = get(handles.SGBMParamFullDP, 'Value');
parameters = sprintf('%d %s %s %s %s %s %s %s %s %s %s %d', param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12);
elseif SELECTED_PROCESS == Processes.OpenCV_VAR
% OpenCV VAR algorithm
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% minDisparity, maxDisparity, levels, pyrScale, nIt,
% poly_n, poly_sigma, fi, lambda, penalization,
% cycle, flags
param1 = 2;
param2 = get(handles.VARParamMinDisparity, 'String');
param3 = get(handles.VARParamNumberOfDisparities, 'String');
param4 = get(handles.VARParamLevels, 'String');
param5 = get(handles.VARParamPyrScale, 'String');
param6 = get(handles.VARParamNIt, 'String');
param7 = get(handles.VARParamPoly_n, 'String');
param8 = get(handles.VARParamPoly_sigma, 'String');
param9 = get(handles.VARParamFi, 'String');
param10 = get(handles.VARParamLambda, 'String');
parameters = sprintf('%d %s %s %s %s %s %s %s %s %s', param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
elseif SELECTED_PROCESS == Processes.GCS
% Growing Correspondence Seeds
% Parameters: N/A
elseif SELECTED_PROCESS == Processes.Clustering
% Clustering filter
% Parameters: filter(0: filter out all but the largets cluster,
% 1: filter out the largets cluster
% 2: filter out clusters with less than "num" pixels
% 3: filter out the "num" smallest clusters), "num"
% for filters 2 and 3.
if get(handles.clusteringOption1, 'Value')
param1 = 0;
elseif get(handles.clusteringOption2, 'Value')
param1 = 1;
elseif get(handles.clusteringOption3, 'Value')
param1 = 2;
elseif get(handles.clusteringOption4, 'Value')
param1 = 3;
end
param2 = get(handles.ClusteringParamX, 'String');
if get(handles.connectivityOption1, 'Value')
param3 = 4;
elseif get(handles.connectivityOption2, 'Value')
param3 = 8;
end
parameters = sprintf('%d %s %d', param1, param2, param3);
end
if strcmp(get(handles.addProcessButton, 'String'), 'Update')
% update process parameters
PROCESSES(get(handles.processesList, 'Value')).parameters = parameters;
set(handles.addProcessButton, 'String', 'Add process');
else
% add process id and parameters to the structure
index = length(PROCESSES)+1;
PROCESSES(index).id = SELECTED_PROCESS;
PROCESSES(index).parameters = parameters;
end
% update processes list
updateProcessesList(handles);
% Warn a method may take a long time
% returns 1 if ok, 0 in any other case
function response = warning()
% Warn this method may take a long time
choice = questdlg('This method may take a long time. Continue?', ...
'Warning', ...
'Proceed','Cancel','Proceed');
% Handle response
response = strcmp(choice, 'Proceed');
% --- Executes on button press in proceedButton.
function proceedButton_Callback(hObject, eventdata, handles)
% hObject handle to proceedButton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global PROCESSES;
global LEFT_IMAGE;
global RIGHT_IMAGE;
global DISPARITY;
global GROUND_TRUTH;
if (isempty(LEFT_IMAGE) || isempty(RIGHT_IMAGE))
return;
end
fprintf('Processing...\n');
set(handles.addProcessButton, 'String', 'Add process');
set(handles.Pixels, 'String', '0');
set(handles.Time, 'String', '0 secs.');
imageLeftTemp = LEFT_IMAGE;
imageRightTemp = RIGHT_IMAGE;
%change cursor
%set(0,'DefaultFigurePointer','watch');
%set(handles.window, 'Pointer', 'watch');
%set(gcf, 'Pointer', 'watch');
%setptr(handles.window, 'hand');
tic
for i = 1:length(PROCESSES)
id = PROCESSES(i).id;
parameters = PROCESSES(i).parameters;
if id == Processes.HF1
% Parameters: RGB/HSV, d, L, H
[param, remain] = strtok(parameters);
RGBHSV = str2num(param);
[param, remain] = strtok(remain);
d = str2num(param);
[param, remain] = strtok(remain);
L = str2num(param);
[param, remain] = strtok(remain);
H = str2num(param);
% Call function
imageLeftTemp = homofil1Wrapper(imageLeftTemp, RGBHSV, d, L, H);
imageRightTemp = homofil1Wrapper(imageRightTemp, RGBHSV, d, L, H);
% Show results
figure('name', 'HF1 - Left Image');imshow(imageLeftTemp);
figure('name', 'HF1 - Right Image');imshow(imageRightTemp);
elseif id == Processes.HF2
% Parameters: RGB/HSV, d, order, alphaL, alphaH
[param, remain] = strtok(parameters);
RGBHSV = str2num(param);
[param, remain] = strtok(remain);
d = str2num(param);
[param, remain] = strtok(remain);
order = str2num(param);
[param, remain] = strtok(remain);
L = str2num(param);
[param, remain] = strtok(remain);
H = str2num(param);
% Call function
imageLeftTemp = homofil2Wrapper(imageLeftTemp, RGBHSV, d, order, L, H);
imageRightTemp = homofil2Wrapper(imageRightTemp, RGBHSV, d, order, L, H);
% Show results
figure('name', 'HF2 - Left Image');imshow(imageLeftTemp);
figure('name', 'HF2 - Right Image');imshow(imageRightTemp);
elseif id == Processes.HM
% Parameters: Gray/RGB/HSV
[param, remain] = strtok(parameters);
type = str2num(param);
imageRightTemp = histogramMatching(imageLeftTemp, imageRightTemp, type);
if (type == 1 && ndims(imageLeftTemp) > 2)
imageLeftTemp = rgb2gray(imageLeftTemp);
end
% Show results
figure('name', 'HM - Left Image');imshow(imageLeftTemp);
figure('name', 'HM - Right Image');imshow(imageRightTemp);
elseif id == Processes.AI
% Parameters: N/A
%convert RGB to Gray
if (ndims(imageLeftTemp) > 2)
imageLeftTemp = rgb2gray(imageLeftTemp);
imageRightTemp = rgb2gray(imageRightTemp);
end
imageLeftTemp = imadjust(imageLeftTemp);
imageRightTemp = imadjust(imageRightTemp);
% Show results
figure('name', 'Adjust Image Intensity - Left Image');imshow(imageLeftTemp);
figure('name', 'Adjust Image Intensity - Right Image');imshow(imageRightTemp);
elseif id == Processes.SAD || id == Processes.SSD || id == Processes.NCC
% Parameters: algorithm, dmin, dmax, windowSize
[param, remain] = strtok(parameters);
alg = str2num(param);
[param, remain] = strtok(remain);
dmin = str2num(param);
[param, remain] = strtok(remain);
dmax = str2num(param);
[param, remain] = strtok(remain);
windowSize = str2num(param);
% Call function
if (warning() == 1)
if id == Processes.SAD
if alg==1
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'SAD');
elseif alg==2
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'ZSAD');
elseif alg==3
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'LSAD');
end
%show disparities
figure('name', 'Sum of Absolute Differences (SAD) - Disparity');imagesc(DISPARITY);impixelinfo;colorbar;
elseif id == Processes.SSD
if alg==1
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'SSD');
elseif alg==2
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'ZSSD');
elseif alg==3
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'LSSD');
end
%show disparities
figure('name', 'Sum of Squared Differences (SSD) - Disparity');imagesc(DISPARITY);impixelinfo;colorbar;
elseif id == Processes.NCC
if alg==1
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'NNC');
elseif alg==2
DISPARITY = denseMatch(imageLeftTemp, imageRightTemp, windowSize, dmin, dmax, 'ZNNC');
end
%show disparities
figure('name', 'Normalized Cross-Correlation (NCC) - Disparity');imagesc(DISPARITY);impixelinfo;colorbar;
end
end
elseif id == Processes.StereoDisp
% Parameters: dmin, dmax, hs, hr, M
[param, remain] = strtok(parameters);
dmin = str2num(param);
[param, remain] = strtok(remain);
dmax = str2num(param);
[param, remain] = strtok(remain);
hs = str2num(param);
[param, remain] = strtok(remain);
hr = str2num(param);
[param, remain] = strtok(remain);
M = str2num(param);
% Call function
[DISPARITY pixel_dsp segs labels] = total_stereo(imageRightTemp, imageLeftTemp, hs, hr, M, dmin, dmax);
%show disparities
figure('name', '3D Stereo Disparity - Disparity');imagesc(DISPARITY);impixelinfo;colorbar;
%show other figures
figure('name', '3D Stereo Disparity - Disparity before final filtering');imagesc(pixel_dsp);impixelinfo;colorbar;
figure('name', '3D Stereo Disparity - Segmented Image');imshow(segs);impixelinfo;
figure('name', '3D Stereo Disparity - Labels Map');imagesc(labels);impixelinfo;colorbar;
elseif id == Processes.RegionBased
% Parameters: method, dmax, matching, threshold, alpha
[param, remain] = strtok(parameters);
method = str2num(param);
[param, remain] = strtok(remain);
dmax = str2num(param);
[param, remain] = strtok(remain);
matching = str2num(param);
[param, remain] = strtok(remain);
threshold = str2num(param);
[param, remain] = strtok(remain);
alpha = str2num(param);
dispx = [];
dispR = [];
if (method == 1)
if (warning() == 1)
%Global Error Energy Minimization
[dispx dispR DISPARITY] = stereoGlobalEnergyMin(imageLeftTemp, imageRightTemp, dmax, matching, alpha);
%show disparities and other figures
figure('name', 'Region-Based Stereo Matching - Disparity Map');imagesc(dispx);impixelinfo;colorbar;
figure('name', 'Region-Based Stereo Matching - Disparity Map with Reliable Disparities');imagesc(dispR);impixelinfo;colorbar;
figure('name', 'Region-Based Stereo Matching - Median Filtered Disparity Map with Reliable Disparities');imagesc(DISPARITY);impixelinfo;colorbar;
end
elseif (method == 2)
%Line Growing
[dispx dispR DISPARITY] = stereoRegionGrowingLine(imageLeftTemp, imageRightTemp, dmax, threshold, alpha);
%show disparities and other figures
figure('name', 'Region-Based Stereo Matching - Disparity Map');imagesc(dispx);impixelinfo;colorbar;
figure('name', 'Region-Based Stereo Matching - Disparity Map with Reliable Disparities');imagesc(dispR);impixelinfo;colorbar;
figure('name', 'Region-Based Stereo Matching - Median Filtered Disparity Map with Reliable Disparities');imagesc(DISPARITY);impixelinfo;colorbar;
end
elseif id == Processes.SMOgale
% Parameters: dmax, dmin, alpha
[param, remain] = strtok(parameters);
dmax = str2num(param);
[param, remain] = strtok(remain);
dmin = str2num(param);
[param, remain] = strtok(remain);
alpha = str2num(param);
[bestshiftsL, occlL, bestshiftsR, occlR] = stereoCorrespond(imageLeftTemp, imageRightTemp, [dmin:dmax], alpha);
figure('name', 'Stereo Matching - Left Disparity Map');imagesc(bestshiftsL);impixelinfo;colorbar;
figure('name', 'Stereo Matching - Left Occlusions');imagesc(occlL);impixelinfo;colorbar;
figure('name', 'Stereo Matching - Right Disparity Map');imagesc(bestshiftsR);impixelinfo;colorbar;
figure('name', 'Stereo Matching - Right Occlusions');imagesc(occlR);impixelinfo;colorbar;
DISPARITY = bestshiftsL;
elseif id == Processes.OFOgale
% Parameters: dmaxX, dminX, dmaxY dminY, alpha
[param, remain] = strtok(parameters);
dmaxX = str2num(param);
[param, remain] = strtok(remain);
dminX = str2num(param);
[param, remain] = strtok(remain);
dmaxY = str2num(param);
[param, remain] = strtok(remain);
dminY = str2num(param);
[param, remain] = strtok(remain);
alpha = str2num(param);
[bestshiftsLX, bestshiftsLY, occlL, bestshiftsRX, bestshiftsRY, occlR] = flow(imageLeftTemp, imageRightTemp, [dminX:dmaxX], [dminY:dmaxY], alpha);
figure('name', 'Optical Flow - X-component of flow of left image');imagesc(bestshiftsLX);impixelinfo;colorbar;
figure('name', 'Optical Flow - Y-component of flow of left image');imagesc(bestshiftsLY);impixelinfo;colorbar;
figure('name', 'Optical Flow - Occlusions in left image');imagesc(occlL);impixelinfo;colorbar;
figure('name', 'Optical Flow - X-component of flow of right image');imagesc(bestshiftsRX);impixelinfo;colorbar;
figure('name', 'Optical Flow - Y-component of flow of right image');imagesc(bestshiftsRY);impixelinfo;colorbar;
figure('name', 'Optical Flow - Occlusions in right image');imagesc(occlR);impixelinfo;colorbar;
DISPARITY = bestshiftsLX;
elseif id == Processes.SMAbbeloos
% Parameters: dmax, windowSize, spacc
[param, remain] = strtok(parameters);
dmax = str2num(param);
[param, remain] = strtok(remain);
windowSize = str2num(param);
[param, remain] = strtok(remain);
spacc = str2num(param);
[DISPARITY costmap, pcost, wcost] = stereomatch(imageLeftTemp, imageRightTemp, windowSize, dmax, spacc);
figure('name', 'Stereo Matching - Disparity Map');imagesc(DISPARITY);impixelinfo;colorbar;
figure('name', 'Stereo Matching - Cost Map');imshow(costmap, [min(min(costmap)) max(max(costmap))]); colorbar; impixelinfo;
figure('name', 'Stereo Matching - Single pixel match cost'); bar(0:dmax, shiftdim(pcost(100, 100,:))); xlim([-1 dmax+1]); xlabel('Disparity [pixels]'); ylabel('Absolute intensity differences');
figure('name', 'Stereo Matching - Window match cost'); bar(0:dmax, shiftdim(wcost(100, 100,:))); xlim([-1 dmax+1]); xlabel('Disparity [pixels]'); ylabel('Sum of absolute differences');
elseif id == Processes.ENCC
if (warning() == 1)
% Parameters: version, dmax, windowX, windowY, ZMFlag, SWMFlag
[param, remain] = strtok(parameters);
version = str2num(param);
[param, remain] = strtok(remain);
dmax = str2num(param);
[param, remain] = strtok(remain);
windowX = str2num(param);
[param, remain] = strtok(remain);
windowY = str2num(param);
[param, remain] = strtok(remain);
ZMFlag = str2num(param);
[param, remain] = strtok(remain);
SWMFlag = str2num(param);
if (version == 1)
[DISPARITY, tau, enccArray] = encc(imageLeftTemp, imageRightTemp, [windowX windowY], dmax, ZMFlag, SWMFlag);
else
%convert RGB to Gray
if (ndims(imageLeftTemp) > 2)
imageLeftTemp = rgb2gray(imageLeftTemp);
imageRightTemp = rgb2gray(imageRightTemp);
end
[DISPARITY, tau, enccArray] = enccMEX(double(imageLeftTemp), double(imageRightTemp), [windowX windowY], dmax, ZMFlag, SWMFlag);
end
figure('name', 'Enhanced Normalized Cross Correlation - Disparity Map');imagesc(DISPARITY);impixelinfo;colorbar;
figure('name', 'Enhanced Normalized Cross Correlation - Subpixel correction at each position');imagesc(tau); colorbar; impixelinfo;
figure('name', 'Enhanced Normalized Cross Correlation - Optimum ENCC value'); imagesc(enccArray); colorbar; impixelinfo;
end
elseif id == Processes.OpenCV_BM
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% numberOfDisparities, SADWindowSize, minDisparity,
% preFilterCap, uniquenessRatio, textureThreshold,
% speckleWindowSize, speckleRange, disp12MaxDiff
[param, remain] = strtok(parameters);
algorithm = str2num(param);
[param, remain] = strtok(remain);
NumberOfDisparities = str2num(param);
[param, remain] = strtok(remain);
SADWindowSize = str2num(param);
[param, remain] = strtok(remain);
MinDisparity = str2num(param);
[param, remain] = strtok(remain);
PreFilterCap = str2num(param);
[param, remain] = strtok(remain);
UniquenessRatio = str2num(param);
[param, remain] = strtok(remain);
textureThreshold = str2num(param);
[param, remain] = strtok(remain);
SpeckleWindowSize = str2num(param);
[param, remain] = strtok(remain);
SpeckleRange = str2num(param);
[param, remain] = strtok(remain);
Disp12MaxDiff = str2num(param);
DISPARITY = matlab_stereo_match(imageLeftTemp, imageRightTemp, algorithm, NumberOfDisparities, SADWindowSize, MinDisparity, PreFilterCap, UniquenessRatio, textureThreshold, SpeckleWindowSize, SpeckleRange, Disp12MaxDiff);
figure('name', 'OpenCV BM - Disparity');imagesc(DISPARITY);colorbar;impixelinfo;
elseif id == Processes.OpenCV_SGBM
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% numberOfDisparities, SADWindowSize, minDisparity,
% preFilterCap, uniquenessRatio, P1, P2, speckleWindowSize,
% speckleRange, disp12MaxDiff, fullDP
[param, remain] = strtok(parameters);
algorithm = str2num(param);
[param, remain] = strtok(remain);
NumberOfDisparities = str2num(param);
[param, remain] = strtok(remain);
SADWindowSize = str2num(param);
[param, remain] = strtok(remain);
MinDisparity = str2num(param);
[param, remain] = strtok(remain);
PreFilterCap = str2num(param);
[param, remain] = strtok(remain);
UniquenessRatio = str2num(param);
[param, remain] = strtok(remain);
P1 = str2num(param);
[param, remain] = strtok(remain);
P2 = str2num(param);
[param, remain] = strtok(remain);
SpeckleWindowSize = str2num(param);
[param, remain] = strtok(remain);
SpeckleRange = str2num(param);
[param, remain] = strtok(remain);
Disp12MaxDiff = str2num(param);
[param, remain] = strtok(remain);
FullDP = str2num(param);
DISPARITY = matlab_stereo_match(imageLeftTemp, imageRightTemp, algorithm, NumberOfDisparities, SADWindowSize, MinDisparity, PreFilterCap, UniquenessRatio, P1, P2, SpeckleWindowSize, SpeckleRange, Disp12MaxDiff, FullDP);
figure('name', 'OpenCV SGBM - Disparity');imagesc(DISPARITY);colorbar;impixelinfo;
elseif id == Processes.OpenCV_VAR
% Parameters: algorithm(0 = BM, 1 = SGBM, 2 = VAR)
% minDisparity, maxDisparity, levels, pyrScale, nIt,
% poly_n, poly_sigma, fi, lambda, penalization,
% cycle, flags
[param, remain] = strtok(parameters);
algorithm = str2num(param);
[param, remain] = strtok(remain);
minDisparity = str2num(param);
[param, remain] = strtok(remain);
maxDisparity = str2num(param);
[param, remain] = strtok(remain);
levels = str2num(param);
[param, remain] = strtok(remain);
pyrScale = str2num(param);
[param, remain] = strtok(remain);
nIt = str2num(param);
[param, remain] = strtok(remain);
poly_n = str2num(param);
[param, remain] = strtok(remain);
poly_sigma = str2num(param);
[param, remain] = strtok(remain);
fi = str2num(param);
[param, remain] = strtok(remain);
lambda = str2num(param);
DISPARITY = matlab_stereo_match(imageLeftTemp, imageRightTemp, algorithm, minDisparity, maxDisparity, levels, pyrScale, nIt, poly_n, poly_sigma, fi, lambda, 0, 0, 0);
figure('name', 'OpenCV VAR - Disparity');imagesc(DISPARITY);colorbar;impixelinfo;
elseif id == Processes.GCS
% Parameters: N/A
[DISPARITY,W,x,w,K,SEEDs] = gcs(imageLeftTemp, imageRightTemp, []);
figure('name', 'Growing Correspondence Seeds - Left image');
imagesc(imageLeftTemp); axis image; colormap gray(256); hold on;
plot(SEEDs(:,1),SEEDs(:,3),'b+');
figure('name', 'Growing Correspondence Seeds - Disparity map');
imagesc(DISPARITY); axis image; colorbar; %set(gca,'clim',[-100,100]);
impixelinfo;
figure('name', 'Growing Correspondence Seeds - Correlation map');
imagesc(W); axis image; colorbar; impixelinfo;
elseif id == Processes.Clustering
% Parameters: filter(0: filter out all but the largets cluster,
% 1: filter out the largets cluster
% 2: filter out clusters with less than "num" pixels
% 3: filter out the "num" smallest clusters), "num"
% for filters 2 and 3.
[param, remain] = strtok(parameters);
filter = str2num(param);
[param, remain] = strtok(remain);
num = str2num(param);
[param, remain] = strtok(remain);
connectivity = str2num(param);
[clusters DISPARITY] = clusteringFilter(DISPARITY, filter, num, connectivity);
figure('name', 'Clustering filter - Clusters');imagesc(clusters);colorbar;impixelinfo;
figure('name', 'Clustering filter - Disparity');imagesc(DISPARITY);colorbar;impixelinfo;
end
% Display results
pixels = nnz(DISPARITY);
totalPixels = numel(DISPARITY);
set(handles.Pixels, 'String', strcat(int2str(pixels), ' of ', int2str(totalPixels), ' -> ', num2str((pixels/totalPixels)*100.0,'%10.2f'), '%'));
set(handles.Time, 'String', strcat(num2str(toc),' secs.'));
end
%check ground truth if any
if (~isempty(GROUND_TRUTH))
groundTruthCheck(DISPARITY, GROUND_TRUTH);
end
fprintf('Done!\n');
% --- Executes on button press in loadLeftImageButton.
function loadLeftImageButton_Callback(hObject, eventdata, handles)
% hObject handle to loadLeftImageButton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
path = get(handles.loadLeftImageButton, 'UserData');
[FileName,PathName,FilterIndex] = uigetfile(strcat(path, '*.*'));
if FileName == 0
return;
end
global LEFT_IMAGE;
LEFT_IMAGE = imread(strcat(PathName, FileName));
A = uint8(LEFT_IMAGE);
imshow(A, 'Parent', handles.leftImage);
set(handles.leftImage, 'Visible', 'off');
%images properties
[pathstr, name, ext] = fileparts(FileName);
set(handles.leftImageName, 'String', name);
set(handles.leftSize, 'String', strcat(int2str(size(A,2)),'x', int2str(size(A,1))));
if ndims(LEFT_IMAGE) == 3
set(handles.leftRGB, 'String', 'Yes');
else
set(handles.leftRGB, 'String', 'No');
end
set(handles.leftFormat, 'String', ext);
set(handles.loadLeftImageButton, 'UserData', PathName);
% --- Executes on button press in loadRightImageButton.
function loadRightImageButton_Callback(hObject, eventdata, handles)
% hObject handle to loadRightImageButton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
path = get(handles.loadLeftImageButton, 'UserData');
[FileName,PathName,FilterIndex] = uigetfile(strcat(path, '*.*'));
if FileName == 0
return;
end
global RIGHT_IMAGE;
RIGHT_IMAGE = imread(strcat(PathName, FileName));
A = uint8(RIGHT_IMAGE);
imshow(A, 'Parent', handles.rightImage);
set(handles.rightImage, 'Visible', 'off');
%images properties
[pathstr, name, ext] = fileparts(FileName);
set(handles.rightImageName, 'String', name);
set(handles.rightSize, 'String', strcat(int2str(size(A,2)),'x', int2str(size(A,1))));
if ndims(RIGHT_IMAGE) == 3
set(handles.rightRGB, 'String', 'Yes');
else
set(handles.rightRGB, 'String', 'No');
end
set(handles.rightFormat, 'String', ext);
set(handles.loadLeftImageButton, 'UserData', PathName);
% Hide panels
function hidePanels(handles)
set(handles.HFPanel, 'Visible', 'off');
set(handles.HMPanel, 'Visible', 'off');
set(handles.emptyPanel, 'Visible', 'off');
set(handles.OpenCVBMPanel, 'Visible', 'off');
set(handles.OpenCVSGBMPanel, 'Visible', 'off');
set(handles.OpenCVVARPanel, 'Visible', 'off');
set(handles.clusteringPanel, 'Visible', 'off');
set(handles.lanktonPanel, 'Visible', 'off');
set(handles.RBSMPanel, 'Visible', 'off');
set(handles.SMOgalePanel, 'Visible', 'off');
set(handles.OFPanel, 'Visible', 'off');
set(handles.SMAbbeloosPanel, 'Visible', 'off');
set(handles.ENCCPanel, 'Visible', 'off');
set(handles.SAD_SSD_NCCPanel, 'Visible', 'off');
function updateProcessesList(handles)
global PROCESSES;
set(handles.processesList, 'String', '');
for i = 1:length(PROCESSES)
if PROCESSES(i).id == Processes.HF1
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Homomorfic Filtering (Gaussian)'}))
elseif PROCESSES(i).id == Processes.HF2
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Homomorfic Filtering (Butterworth)'}))
elseif PROCESSES(i).id == Processes.HM
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Histogram Matching'}))
elseif PROCESSES(i).id == Processes.AI
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Adjust Image Intensity'}))
elseif PROCESSES(i).id == Processes.SAD
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Sum of Absolute Differences (SAD)'}))
elseif PROCESSES(i).id == Processes.SSD
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Sum of Squared Differences (SSD)'}))
elseif PROCESSES(i).id == Processes.NCC
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Normalized Cross-Correlation (NCC)'}))
elseif PROCESSES(i).id == Processes.StereoDisp
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'3D Stereo Disparity (Shawn Lankton)'}))
elseif PROCESSES(i).id == Processes.RegionBased
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Region-Based Stereo Matching (Baykant Alagoz)'}))
elseif PROCESSES(i).id == Processes.SMOgale
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Stereo Matching (Abhijit S. Ogale)'}))
elseif PROCESSES(i).id == Processes.OFOgale
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Optical Flow (Abhijit S. Ogale)'}))
elseif PROCESSES(i).id == Processes.SMAbbeloos
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Stereo Matching (Wim Abbeloos)'}))
elseif PROCESSES(i).id == Processes.ENCC
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Enhanced Normalized Cross Correlation (E.Z. Psarakis)'}))
elseif PROCESSES(i).id == Processes.OpenCV_BM
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Block Matching (OpenCV)'}))
elseif PROCESSES(i).id == Processes.OpenCV_SGBM
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Semi-Global Block Matching (OpenCV)'}))
elseif PROCESSES(i).id == Processes.OpenCV_VAR
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Variational Stereo Correspondence (OpenCV)'}))
elseif PROCESSES(i).id == Processes.GCS
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Growing Correspondence Seeds (Jan Cech)'}))
elseif PROCESSES(i).id == Processes.Clustering
set( handles.processesList, 'string', cat( 1, get( handles.processesList, 'String' ), {'Clustering'}))
end
end
% --- Executes on button press in upButton.
function upButton_Callback(hObject, eventdata, handles)
% hObject handle to upButton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global PROCESSES;
index = get(handles.processesList, 'Value');
if index > 1
aux = PROCESSES(index-1);
PROCESSES(index-1) = PROCESSES(index);
PROCESSES(index) = aux;
updateProcessesList(handles);
set(handles.processesList, 'Value', index-1);
end
set(handles.addProcessButton, 'String', 'Add process');
% --- Executes on button press in downButton.
function downButton_Callback(hObject, eventdata, handles)
% hObject handle to downButton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global PROCESSES;
index = get(handles.processesList, 'Value');
if index < length(PROCESSES)
aux = PROCESSES(index+1);
PROCESSES(index+1) = PROCESSES(index);
PROCESSES(index) = aux;
updateProcessesList(handles);
set(handles.processesList, 'Value', index+1);
end
set(handles.addProcessButton, 'String', 'Add process');
% --- Executes on button press in deteleButton.
function deteleButton_Callback(hObject, eventdata, handles)
% hObject handle to deteleButton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global PROCESSES;
index = get(handles.processesList, 'Value');
if length(PROCESSES) < 1
return;
end
if index > 1
set(handles.processesList, 'Value', index-1);
end
PROCESSES(index) = [];
updateProcessesList(handles);
set(handles.addProcessButton, 'String', 'Add process');
% --- Executes on button press in clusteringOption1.
function clusteringOption1_Callback(hObject, eventdata, handles)
% hObject handle to clusteringOption1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hint: get(hObject,'Value') returns toggle state of clusteringOption1
set(handles.ClusteringParamX, 'Enable', 'off');
% --- Executes on button press in clusteringOption2.
function clusteringOption2_Callback(hObject, eventdata, handles)
% hObject handle to clusteringOption2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hint: get(hObject,'Value') returns toggle state of clusteringOption2
set(handles.ClusteringParamX, 'Enable', 'off');
% --- Executes on button press in clusteringOption3.
function clusteringOption3_Callback(hObject, eventdata, handles)
% hObject handle to clusteringOption3 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hint: get(hObject,'Value') returns toggle state of clusteringOption3
set(handles.ClusteringParamX, 'Enable', 'on');
% --- Executes on button press in clusteringOption4.
function clusteringOption4_Callback(hObject, eventdata, handles)
% hObject handle to clusteringOption4 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hint: get(hObject,'Value') returns toggle state of clusteringOption4
set(handles.ClusteringParamX, 'Enable', 'on');
% --- Executes on button press in RBSMMethod1.
function RBSMMethod1_Callback(hObject, eventdata, handles)
% hObject handle to RBSMMethod1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hint: get(hObject,'Value') returns toggle state of RBSMMethod1
set(handles.RBSMMatching, 'Enable', 'on');
set(handles.RBSMThreshold, 'Enable', 'off');
% --- Executes on button press in RBSMMethod2.
function RBSMMethod2_Callback(hObject, eventdata, handles)
% hObject handle to RBSMMethod2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hint: get(hObject,'Value') returns toggle state of RBSMMethod2
set(handles.RBSMMatching, 'Enable', 'off');
set(handles.RBSMThreshold, 'Enable', 'on');
% --- Executes on button press in loadGroundDatabutton.
function loadGroundDatabutton_Callback(hObject, eventdata, handles)
% hObject handle to loadGroundDatabutton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
path = get(handles.loadGroundDatabutton, 'UserData');
[FileName,PathName,FilterIndex] = uigetfile(strcat(path, '*.*'));
if FileName == 0
return;
end
global GROUND_TRUTH;
GROUND_TRUTH = imread(strcat(PathName, FileName));
%A = uint8(LEFT_IMAGE);
%images properties
[pathstr, name, ext] = fileparts(FileName);
set(handles.groundTruth, 'String', name);
set(handles.loadGroundDatabutton, 'UserData', PathName);
% --- Executes on button press in removeGroundDatabutton.
function removeGroundDatabutton_Callback(hObject, eventdata, handles)
% hObject handle to removeGroundDatabutton (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
%global GROUND_TRUTH;
clear global GROUND_TRUTH;
set(handles.groundTruth, 'String', '');
