labeling_tool.m

% Copyright (c) 2025 Samsung Electronics Co., Ltd.
%
% Author(s):
% Mahmoud Afifi (m.afifi1@samsung.com, m.3afifi@gmail.com)
%
% Licensed under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) License, (the "License");
% you may not use this file except in compliance with the License.
% You may obtain a copy of the License at https://creativecommons.org/licenses/by-nc/4.0
% Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
% See the License for the specific language governing permissions and limitations under the License.
% For conditions of distribution and use, see the accompanying LICENSE.md file.
%
% This file contains callback functions of labeling GUI.



function varargout = labeling_tool(varargin)
gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
    'gui_Singleton',  gui_Singleton, ...
    'gui_OpeningFcn', @labeling_tool_OpeningFcn, ...
    'gui_OutputFcn',  @labeling_tool_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

function labeling_tool_OpeningFcn(hObject, eventdata, handles, varargin)
%Initialization function
handles.output = hObject;
handles.copied_pref_illum = 0;
handles.copied_gt_illum = 0;
axes(handles.img);
axis off;
global isdrawing_blur isdrawing_mask chromas ccts
isdrawing_blur = 0;
isdrawing_mask = 0;
ccts = [1325, 2000, 3000, 4000, 5000, 6000, 7000, 8000];
chromas = [1.5958, 0.2661;
    1.0020, 0.3150;
    0.7020, 0.4421;
    0.5697, 0.5487;
    0.5139, 0.6388;
    0.4759, 0.6976;
    0.4550, 0.7605;
    0.4448, 0.8431];
calibration();

guidata(hObject, handles);
control_all_options(handles, 'off');

function control_all_options(handles, option)
%Enables/disables all GUI functions
set(handles.export_dataset, 'Enable', option);
set(handles.discard, 'Enable', option);
set(handles.img, 'Visible', option);
set(handles.next, 'Enable', option);
set(handles.previous, 'Enable', option);
set(handles.first, 'Enable', option);
set(handles.last, 'Enable', option);
set(handles.select_wp, 'Enable', option);
set(handles.copy_wp, 'Enable', option);
set(handles.paste_wp, 'Enable', option);
set(handles.reset_wp, 'Enable', option);
set(handles.copy_pref_wp, 'Enable', option);
set(handles.paste_pref_wp, 'Enable', option);
set(handles.mask, 'Enable', option);
set(handles.reset_mask, 'Enable', option);
set(handles.blur, 'Enable', option);
set(handles.reset_blur, 'Enable', option);
set(handles.show_mask, 'Enable', option);
set(handles.show_raw, 'Enable', option);
set(handles.show_wb_raw_neutral, 'Enable', option);
set(handles.show_wb_raw_pref, 'Enable', option);
set(handles.show_wb_raw_cam, 'Enable', option);
set(handles.show_srgb, 'Enable', option);
set(handles.cct_slider, 'Enable', option);
set(handles.cam_neutral_wb, 'Enable', option);
set(handles.training, 'Enable', option);
set(handles.testing, 'Enable', option);
set(handles.daylight, 'Enable', option);
set(handles.sunset, 'Enable', option);
set(handles.night, 'Enable', option);
set(handles.relative, 'Enable', option);
set(handles.indoor, 'Enable', option);
set(handles.artificial_light, 'Enable', option);
set(handles.natural_light, 'Enable', option);
set(handles.validation, 'Enable', option);
set(handles.show_discarded, 'Enable', option);
if strcmpi(option, 'off')
    set(handles.set_status, 'String', '');
end
if strcmpi(option, 'on')
    if sum(handles.copied_pref_illum) == 0
        handles.paste_pref_wp.Enable = 'off';
    else
        handles.paste_pref_wp.Enable = 'on';
    end
    if sum(handles.copied_gt_illum) == 0
        handles.paste_wp.Enable = 'off';
    else
        handles.paste_wp.Enable = 'on';
    end
end


function varargout = labeling_tool_OutputFcn(hObject, eventdata, handles)
varargout{1} = handles.output;

function index = get_pre_index_wo_discarded(handles, index, pre_index)
%Gets previous index of non-discarded image.
while index >= 1
    if exist(fullfile(handles.dataset_path, 'labeling_tool_data', ...
            'labels', [handles.filenames{index}, '.json']), ...
            'file')
        data = load_file(fullfile(handles.dataset_path, ...
            'labeling_tool_data', 'labels', ...
            [handles.filenames{index}, '.json']));
        if data.discard
            index = index - 1;
        else
            break;
        end
    else
        break;
    end
end
if index < 1
    index = pre_index;
end

function index = get_next_index_wo_discarded(handles, index, pre_index)
%Gets next index of non-discarded image.
while index <= length(handles.filenames)
    if exist(fullfile(handles.dataset_path, 'labeling_tool_data', ...
            'labels', [handles.filenames{index}, '.json']), 'file')
        data = load_file(fullfile(handles.dataset_path, ...
            'labeling_tool_data', 'labels', ...
            [handles.filenames{index}, '.json']));
        if data.discard
            index = index + 1;
        else
            break;
        end
    else
        break;
    end
end
if index > length(handles.filenames)
    index = pre_index;
end

function next_Callback(hObject, eventdata, handles)
%Callback function of next btn
global mask blur_mask
index = handles.log.index;

imwrite(mask, fullfile(handles.dataset_path, ...
    'labeling_tool_data', 'labels', ...
    [handles.filenames{index}, '_mask.png']));

imwrite(blur_mask, fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', ...
        [handles.filenames{index}, '_blur_mask.png']));
mask = [];
blur_mask = [];
pre_index = index;
index = min(index + 1, length(handles.filenames));
if ~handles.show_discarded.Value
    index = get_next_index_wo_discarded(handles, index, pre_index);
end
log = handles.log;
log.index = index;
handles.log = log;
set_to_default(handles);
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'log.json'), log);
metadata = load_img(handles, 1);
handles.metadata = metadata;
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), metadata);
guidata(hObject, handles);


function previous_Callback(hObject, eventdata, handles)
%Callback function of previous btn
global mask blur_mask
index = handles.log.index;

imwrite(mask, fullfile(handles.dataset_path, ...
    'labeling_tool_data', 'labels', ...
    [handles.filenames{index}, '_mask.png']));

imwrite(blur_mask, fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', ...
        [handles.filenames{index}, '_blur_mask.png']));
mask = [];
blur_mask = [];
pre_index = index;
index = max(index - 1, 1);
if ~handles.show_discarded.Value
    index = get_pre_index_wo_discarded(handles, index, pre_index);
end
log = handles.log;
log.index = index;
handles.log = log;
set_to_default(handles);
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'log.json'), log);
metadata = load_img(handles, 1);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), metadata);
handles.metadata = metadata;
guidata(hObject, handles);


function last_Callback(hObject, eventdata, handles)
%Callback function of go-to-last-image btn
global mask blur_mask
index = handles.log.index;

imwrite(mask, fullfile(handles.dataset_path, ...
    'labeling_tool_data', 'labels', ...
    [handles.filenames{index}, '_mask.png']));

imwrite(blur_mask, fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', ...
        [handles.filenames{index}, '_blur_mask.png']));
mask = [];
blur_mask = [];
index = length(handles.filenames);
log = handles.log;
log.index = index;
handles.log = log;
set_to_default(handles);
guidata(hObject, handles);
metadata = load_img(handles, 1);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), metadata);
handles.metadata = metadata;
guidata(hObject, handles);

function first_Callback(hObject, eventdata, handles)
%Callback function of go-to-first-image btn
global mask blur_mask
index = handles.log.index;

imwrite(mask, fullfile(handles.dataset_path, ...
    'labeling_tool_data', 'labels', ...
    [handles.filenames{index}, '_mask.png']));

imwrite(blur_mask, fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', ...
        [handles.filenames{index}, '_blur_mask.png']));
mask = [];
blur_mask = [];
index = 1;
log = handles.log;
log.index = index;
handles.log = log;
set_to_default(handles);
guidata(hObject, handles);
metadata = load_img(handles, 1);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), metadata);
handles.metadata = metadata;
guidata(hObject, handles);

function [min_cct, max_cct, nearest_idx] = find_nearest_ccts(cct)
global ccts
[~, nearest_idx] = min(abs(cct - ccts));
min_cct = ccts(max(nearest_idx - 1, 1));
max_cct = ccts(min(nearest_idx + 1, length(ccts)));

function cct_slider_Callback(hObject, eventdata, handles)
%Callback function of CCT slider
global ccts
data = handles.metadata;
if handles.relative.Value
    curr_illum = reshape(data.pref_illum, 1, 3);
    curr_cct = predict_cct(curr_illum);
    [min_cct, max_cct, ~] = find_nearest_ccts(curr_cct);
else
    min_cct = min(ccts);
    max_cct = max(ccts);
end
new_cct = handles.cct_slider.Value * (max_cct - min_cct) + min_cct;
new_cct = max(min(new_cct, max(ccts)), min(ccts));
new_illum = predict_rgb(new_cct);
data.pref_illum = new_illum;
data = update_cct_values(data);
handles.metadata = data;
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.show_wb_raw_pref.Value = 1;
load_img(handles);


function cct_slider_CreateFcn(hObject, eventdata, handles)
if isequal(get(hObject,'BackgroundColor'), ...
        get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end


function mask_Callback(hObject, eventdata, handles)
%Callback function of create mask btn
global mask
handles.show_mask.Value = 1;
load_img(handles);
roi = drawfreehand;
bw = int8(createMask(roi));
mask = (int8(mask) + bw) >= 1;
handles.show_mask.Value = 1;
load_img(handles);

function blur_Callback(hObject, eventdata, handles)
%Callback function of blur btn
global blur_mask
handles.show_srgb.Value = 1;
load_img(handles);
roi = drawfreehand;
bw = int8(createMask(roi));

blur_mask = (int8(blur_mask) + bw) >= 1;
handles.show_srgb.Value = 1;
load_img(handles);




function discard_Callback(hObject, eventdata, handles)
%Callback function of discard chkbtn
metadata = handles.metadata;
metadata.discard = handles.discard.Value;
fname = handles.filenames{handles.log.index};
handles.metadata = metadata;
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [fname, '.json']), metadata);

function browse_Callback(hObject, eventdata, handles)
%Callback function of browse btn
dataset_path = uigetdir('~','Select dataset directory');
if dataset_path
    handles.dataset_path = dataset_path;
end
guidata(hObject, handles);
if exist(fullfile(dataset_path, 'raw_images'), 'dir') == 0 || ...
        exist(fullfile(dataset_path, 'srgb_images'), 'dir') == 0 || ...
        exist(fullfile(dataset_path, 'data'), 'dir') == 0 || ...
        exist(fullfile(dataset_path, 'dngs'), 'dir') == 0
    msgbox('Invalid directory. Choose another one','Invalid directory');
    return;
end

set_to_default(handles);
log = create_log(handles);
handles.log = log;
guidata(hObject, handles);
create_label_dir(handles);
filenames = load_data(handles);

handles.filenames = filenames;
metadata = load_img(handles, 1);
metadata = update_cct_values(metadata);
handles.metadata = metadata;
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
        'labels', [handles.filenames{handles.log.index}, '.json']), ...
        metadata);
guidata(hObject, handles);
control_all_options(handles, 'on');


function filenames = load_data(handles)
%Loads filenames
filenames = dir(fullfile(handles.dataset_path, 'raw_images', '*.png'));
filenames = strrep({filenames(:).name}, '.png', '');

function data = update_set(handles, data)
%Updates label data with the currently selected set.
if handles.training.Value == 1
    data.set = 'train';
elseif handles.validation.Value == 1
    data.set = 'valid';
elseif handles.testing.Value == 1
    data.set = 'test';
end


function update_set_gui(handles, data) 
%Updates GUI options based on current label data.
global ccts
if strcmpi(data.set, 'train')
    handles.training.Value = 1;
elseif strcmpi(data.set, 'valid')
    handles.validation.Value = 1;
elseif strcmpi(data.set, 'test')
    handles.testing.Value = 1;
end
handles.discard.Value = data.discard;
if strcmpi(data.scene_class, 'indoor')
    handles.indoor.Value = 1;
elseif strcmpi(data.scene_class, 'sunset/sunrise')
    handles.sunset.Value = 1;
elseif strcmpi(data.scene_class, 'night')
    handles.night.Value = 1;
elseif strcmpi(data.scene_class, 'daylight')
    handles.daylight.Value = 1;
end
if strcmpi(data.light_class, 'artificial')
    handles.artificial_light.Value = 1;
elseif strcmpi(data.light_class, 'natural')
    handles.natural_light.Value = 1;
end


function update_cct_slider(handles, data)
global ccts
if nargin == 1
    data = handles.metadata;
end
cct = predict_cct(data.pref_illum);
if handles.relative.Value
    curr_illum = reshape(data.pref_illum, 1, 3);
    curr_cct = predict_cct(curr_illum);
    [min_cct, max_cct, ~] = find_nearest_ccts(curr_cct);
    norm_cct = (curr_cct - min_cct) / (max_cct - min_cct);
else
    norm_cct = (cct - min(ccts)) / (max(ccts) - min(ccts));
end
handles.cct_slider.Value = norm_cct;


function data = update_metadata(data, handles)
%Updates label data with selected options in the GUI.
data.discard = handles.discard.Value;
if handles.indoor.Value
    data.scene_class = 'indoor';
elseif handles.daylight.Value
    data.scene_class = 'daylight';
elseif handles.night.Value
    data.scene_class = 'night';
elseif handles.sunset.Value
    data.scene_class = 'sunset/sunrise';
end
if handles.artificial_light.Value
    data.light_class = 'artificial';
elseif handles.natural_light.Value
    data.light_class = 'natural';
end
data = update_set(handles, data);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);



function data = load_img(handles, load_raw_mask)
%Loads image and label data.
global raw mask blur_mask
if nargin == 1
    load_raw_mask = 0;
end
handles.discard.Value = 0;
handles.training.Value = 1;
idx = handles.log.index;
dataset_path = handles.dataset_path;
filenames = handles.filenames;


if exist(fullfile(dataset_path, 'labeling_tool_data', 'labels', ...
        [filenames{idx}, '.json']), 'file') == 0
    data = load_file(fullfile(dataset_path, 'data', ...
        [filenames{idx}, '.json']));
    data.gt_illum = data.cam_illum;
    data.pref_illum = data.cam_illum;
    data = update_metadata(data, handles);
else
    data = load_file(fullfile(dataset_path, 'labeling_tool_data', ...
        'labels', [filenames{idx}, '.json']));
    update_set_gui(handles, data);
end

if handles.show_srgb.Value == 1
    img = im2double(imread(fullfile(dataset_path, 'srgb_images', ...
        [filenames{idx}, '.jpg'])));
elseif load_raw_mask == 1
    img = im2double(imread(fullfile(dataset_path, 'raw_images', ...
        [filenames{idx}, '.png'])));
else
    img = raw;
end
if exist(fullfile(dataset_path, 'labeling_tool_data', ...
        'labels', [filenames{idx}, '_mask.png']), 'file') == 0
    mask = zeros(size(img, 1), size(img, 2));
    blur_mask = zeros(size(img, 1), size(img, 2));
    imwrite(mask, fullfile(dataset_path, 'labeling_tool_data', ...
        'labels', [filenames{idx}, '_mask.png']));
    imwrite(blur_mask, fullfile(dataset_path, 'labeling_tool_data', ...
        'labels', [filenames{idx}, '_blur_mask.png']));
end

if load_raw_mask == 1
    raw = im2double(imread(fullfile(dataset_path, ...
        'raw_images', ...
        [filenames{idx}, '.png'])));
    mask = im2double(imread(fullfile(dataset_path, ...
            'labeling_tool_data', 'labels', ...
            [filenames{idx}, '_mask.png'])));
    blur_mask = imread(fullfile(dataset_path, 'labeling_tool_data', ...
        'labels', [filenames{idx}, '_blur_mask.png']));
end

if handles.show_mask.Value == 1 
    img = raw;
    img = reshape(reshape(img, [], 3) * diag(...
        data.gt_illum(2) ./ data.gt_illum) * data.ccm', ...
        size(img));
    img = img .^ (1/2.2);
    if sum(blur_mask(:)) > 0
        img = apply_blur(real(img), blur_mask);
    end
    img = img .* (1 - mask);
end


if handles.show_raw.Value == 0 && handles.show_srgb.Value == 0 && ...
        handles.show_mask.Value == 0
    if handles.show_wb_raw_neutral.Value == 1
        wp = data.gt_illum;
    elseif handles.show_wb_raw_cam.Value == 1
        wp = data.cam_illum;
    elseif handles.show_wb_raw_pref.Value == 1
        wp = data.pref_illum;
    end
    ccm = data.ccm;
    img = reshape((reshape(img, ...
            size(img, 1) * size(img, 2), 3) * diag(wp(2)./wp) * ccm'), ...
            size(img));
    img = img .^ (1/2.2);
elseif handles.show_raw.Value == 1
    img = img .^ (1/2.2);
end

if handles.show_mask.Value == 0
    img = apply_blur(real(img), blur_mask);
end

gt_cct = predict_cct(data.gt_illum);
pref_cct = predict_cct(data.pref_illum);
cam_cct =  predict_cct(data.cam_illum);
data.gt_cct = gt_cct;
data.pref_cct = pref_cct;
data.cam_cct = cam_cct;
update_cct_status(handles, data);
axes(handles.img);
axis off;
set(handles.img,'XTick',[])
imshow(img);
update_set_stats(handles);

function out_img = apply_blur(img, blur_mask)
%Applies image blur.
sigma = 41;
mask_sigma = 11;
mask = im2double(blur_mask);
mask = imgaussfilt(mask, mask_sigma);
if sum(mask(:)) > 0
    blurred = imgaussfilt(img, sigma);
    out_img = blurred .* mask + img .* (1 - mask);
else
    out_img = img;
end

function data = load_file(fname)
%Loads JSON file.
fid = fopen(fname);
raw = fread(fid,inf);
str = char(raw');
fclose(fid);
data = jsondecode(str);


function data = save_file(fname, data)
%Saves JSON file.
fid = fopen(fname, 'w');
encoded_data = jsonencode(data, 'PrettyPrint', true);
fprintf(fid,'%s',encoded_data);
fclose(fid);


function log = create_log(handles)
%Creates log JSON file.
if ~exist(fullfile(handles.dataset_path, 'labeling_tool_data', ...
        'log.json'), 'file')
    if ~exist(fullfile(handles.dataset_path, 'labeling_tool_data'), 'dir')
        mkdir(fullfile(handles.dataset_path, 'labeling_tool_data'));
    end
    log.index = 1;
    save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
        'log.json'), log);
else
    log = load_file(fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'log.json'));
end

function update_log(handles)
%Updates log JSON file.
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'log.json'), log);

function create_label_dir(handles)
%Creates labels folder.
if ~exist(fullfile(handles.dataset_path, 'labeling_tool_data', ...
        'labels'), 'dir')
    mkdir(fullfile(handles.dataset_path, 'labeling_tool_data', 'labels'));
end


function select_wp_Callback(hObject, eventdata, handles)
%Selects a reference white point from the image. 
bbx = round(getPosition(imrect));

img = im2double(imread(fullfile(handles.dataset_path, 'raw_images', ...
    [handles.filenames{handles.log.index}, '.png'])));
roi = img(bbx(2):bbx(2)+bbx(4), bbx(1):bbx(1)+bbx(3), :);

gt = mean(reshape(roi, [], 3));
gt = gt ./ norm(gt);

data = handles.metadata;
data.gt_illum = reshape(gt, 1, 3);
data = update_cct_values(data);
handles.metadata = data;
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.show_wb_raw_neutral.Value = 1;
load_img(handles);

function paste_wp_Callback(hObject, eventdata, handles)
%Pastes copied white point to the current image as ground-truth illuminant.
data = handles.metadata;
data.gt_illum = handles.copied_gt_illum;
data = update_cct_values(data);
handles.metadata = data;
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.show_wb_raw_neutral.Value = 1;
load_img(handles);

function export_dataset_Callback(hObject, eventdata, handles)
%Exports data into training, testing, validation according to label data.
handles.status.String = 'processing ...';
handles.cct_status.String = '';
pause(0.1);
control_all_options(handles, 'off');
dataset_path = fullfile(handles.dataset_path, 'final_dataset');
if exist(dataset_path, 'dir')
    rmdir(dataset_path, 's');
end
mkdir(dataset_path);
sets = {'train', 'val', 'test'};
subdirs = {'raw_images', ...
    'srgb_images', 'data', 'masks', 'blur_masks', ...
    'dngs'};
for s = 1 : length(sets)
    mkdir(fullfile(dataset_path, sets{s}));
    for sd = 1 : length(subdirs)
        mkdir(fullfile(dataset_path, sets{s}, subdirs{sd}));
    end
end


fnames = dir(fullfile(handles.dataset_path,  'labeling_tool_data', ...
    'labels', '*.json'));
fnames = {fnames(:).name};
fnames = fnames(randperm(length(fnames)));
val_count = 0;
tr_count = 0;
te_count = 0;
for f = 1 : length(fnames)
    handles.status.String = sprintf('Processing %d/%d', f, length(fnames));
    pause(0.1);
    data = load_file( ...
        fullfile(handles.dataset_path, 'labeling_tool_data', ...
        'labels', fnames{f}));
    if data.discard
        continue;
    end
    if strcmpi(data.set, 'train')
        target_dir = fullfile(dataset_path, 'train');
        count = tr_count;
        tr_count = tr_count + 1;
    elseif strcmpi(data.set, 'test')
        target_dir = fullfile(dataset_path, 'test');
        count = te_count;
        te_count = te_count + 1;
    elseif strcmpi(data.set, 'valid')
        target_dir = fullfile(dataset_path, 'val');
        count = val_count;
        val_count = val_count + 1;
    end
    
    blur_mask = imread(fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', strrep(fnames{f}, ...
        '.json', '_blur_mask.png')));

    mask = imread(fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', strrep(fnames{f}, ...
        '.json', '_mask.png')));

    srgb = im2double(imread(fullfile(...
        handles.dataset_path, 'srgb_images', strrep(fnames{f}, ...
        '.json', '.jpg'))));

    srgb = apply_blur(srgb, blur_mask);

    imwrite(im2uint8(srgb), ...
        fullfile(target_dir, 'srgb_images', ...
        sprintf('img_%05d.jpg', count)));

    raw = im2double(imread(fullfile(...
        handles.dataset_path, 'raw_images', strrep(fnames{f}, ...
        '.json', '.png'))));

    raw = apply_blur(raw, blur_mask);

    imwrite(im2uint16(raw), ...
        fullfile(target_dir, 'raw_images', ...
        sprintf('img_%05d.png', count)));

    imwrite(im2uint8(mask), ...
        fullfile(target_dir, 'masks', sprintf('img_%05d.png', count)));

    imwrite(im2uint8(blur_mask), ...
        fullfile(target_dir, 'blur_masks', ...
        sprintf('img_%05d.png', count)));

    movefile(fullfile(...
        handles.dataset_path, 'dngs', strrep(fnames{f}, ...
        '.json', '.dng')), ...
        fullfile(target_dir, 'dngs', ...
        sprintf('img_%05d.dng', count)));

    data = rmfield(data, 'discard');
    data = rmfield(data, 'set');
    data = rmfield(data, 'gw_illum');
    save_file(fullfile(target_dir, 'data', ...
        sprintf('img_%05d.json', count)), data);
end
handles.status.String = 'done!';
pause(0.5);
handles.status.String = '';
pause(0.1);
control_all_options(handles, 'on');

function copy_wp_Callback(hObject, eventdata, handles)
%Copies current white point. 
data = handles.metadata;
handles.copied_gt_illum = data.gt_illum;
handles.paste_wp.Enable = 'on';
guidata(hObject, handles);

function reset_mask_Callback(hObject, eventdata, handles)
%Resets mask of the current image.
global mask raw
mask = zeros(size(raw, 1), size(raw, 2));
imwrite(mask, fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '_mask.png']));
handles.show_srgb.Value = 1;
load_img(handles);


function reset_blur_Callback(hObject, eventdata, handles)
%Resets blur mask of the current image.
global blur_mask raw
blur_mask = zeros(size(raw, 1), size(raw, 2));
imwrite(blur_mask, fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '_blur_mask.png']));
handles.show_srgb.Value = 1;
load_img(handles);


function cam_neutral_wb_Callback(hObject, eventdata, handles)
%Callback function of cam-neutral white point slider.
data = handles.metadata;
neutral = reshape(data.gt_illum, [1, 3]);
cam = reshape(data.cam_illum, [1, 3]);
data.pref_illum = cam .* (1 - handles.cam_neutral_wb.Value) + ...
    neutral .* handles.cam_neutral_wb.Value;
data = update_cct_values(data);
handles.metadata = data;
guidata(hObject, handles);
handles.show_wb_raw_pref.Value = 1;
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
if handles.relative.Value
    handles.cct_slider.Value = 0.5;
else
    update_cct_slider(handles);
end
load_img(handles);

function cam_neutral_wb_CreateFcn(hObject, eventdata, handles)
if isequal(get(hObject,'BackgroundColor'), ...
        get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

function copy_pref_wp_Callback(hObject, eventdata, handles)
%Copies current user-preference white-point color.
data = handles.metadata;
handles.copied_pref_illum = data.pref_illum;
handles.paste_pref_wp.Enable = 'on';
guidata(hObject, handles);


function paste_pref_wp_Callback(hObject, eventdata, handles)
%Pastes copied user-preference (UP) white-point color and set as UP GT.
data = handles.metadata;
data.pref_illum = handles.copied_pref_illum;
data = update_cct_values(data);
handles.metadata = data;
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.show_wb_raw_pref.Value = 1;
load_img(handles);


function show_srgb_Callback(hObject, eventdata, handles)
%Callback function of radiobtn to show sRGB image 
load_img(handles);


function show_wb_raw_neutral_Callback(hObject, eventdata, handles)
%Callback function of radiobtn to show lsrgb image with neutral wb
load_img(handles);

function show_wb_raw_cam_Callback(hObject, eventdata, handles)
%Callback function of radiobtn to show lsrgb image with camera wb
load_img(handles);

function show_wb_raw_pref_Callback(hObject, eventdata, handles)
%Callback function of radiobtn to show lsrgb image with user-pref wb
load_img(handles);

function show_raw_Callback(hObject, eventdata, handles)
%Callback function of radiobtn to show raw image
load_img(handles);


function show_mask_Callback(hObject, eventdata, handles)
%Callback function of radiobtn to show srgb image with mask
load_img(handles);


function training_Callback(hObject, eventdata, handles)
%Callback function of training radiobtn.
data = handles.metadata;
data = update_set(handles, data);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.metadata = data;
guidata(hObject, handles);
update_set_stats(handles);

function validation_Callback(hObject, eventdata, handles)
%Callback function of validation radiobtn.
data = handles.metadata;
data = update_set(handles, data);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.metadata = data;
guidata(hObject, handles);
update_set_stats(handles);

function testing_Callback(hObject, eventdata, handles)
%Callback function of testing radiobtn.
data = handles.metadata;
data = update_set(handles, data);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.metadata = data;
guidata(hObject, handles);
update_set_stats(handles);

function update_set_stats(handles)
%Updates sets (train, test, val) statistics.
set(handles.set_status, 'String', '');
index = handles.log.index;
set(handles.status, 'String', sprintf('%d/%d', index, ...
    length(handles.filenames)));
fnames = dir(fullfile(handles.dataset_path,  'labeling_tool_data', ...
    'labels', '*.json'));
fnames = {fnames(:).name};
validation_count = 0;
validation_ae = 0;
testing_count = 0;
testing_ae = 0;
training_count = 0;
for f = 1 : length(fnames)
    fname = strrep(fnames{f}, '.json', '');
    data = load_file(fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', [fname, '.json']));
    if data.discard
        continue;
    end
    if strcmpi(data.set, 'train')
        training_count = training_count + 1;
    else
        gt = data.gt_illum;
        gw_est = data.gw_illum;
        ae = anguler_error(gw_est, gt);
        if strcmpi(data.set, 'valid')
            validation_count = validation_count + 1;
            validation_ae = validation_ae + ae;
        elseif strcmpi(data.set, 'test')
            testing_count = testing_count + 1;
            testing_ae = testing_ae + ae;
        end

    end
end
if validation_count > 0
    validation_ae = validation_ae / validation_count;
else
    validation_ae = 0;
end
if testing_count > 0
    testing_ae = testing_ae / testing_count;
else
    testing_ae = 0;
end

set_status = sprintf('Training set: %d\nValidation set: %d, GE AE: %0.2f\nTesting set: %d, GE AE: %0.2f',...
    training_count, validation_count, validation_ae, ...
    testing_count, testing_ae);

set(handles.set_status, 'String', set_status);

function f = anguler_error(a, b)
%Computes angular error between a and b.
a=reshape(double(a), 1, 3);
b=reshape(double(b), 1, 3);
a_norm = sqrt(sum(a.^2,2));
b_norm = sqrt(sum(b.^2,2));
angle=dot(a,b)./(a_norm.*b_norm);
angle(angle>1)=1;
f=acosd(angle);

function reset_wp_Callback(hObject, eventdata, handles)
%Callback function to reset white-point of neutral ground-truth.
data = handles.metadata;
data.gt_illum = data.cam_illum;
data = update_cct_values(data);
handles.metadata = data;
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.show_wb_raw_neutral.Value = 1;
load_img(handles);

function data = update_cct_values(data)
%Updates CCT values in labeling data.
data.gt_cct = predict_cct(data.gt_illum);
data.pref_cct = predict_cct(data.pref_illum);
data.cam_cct =  predict_cct(data.cam_illum);

function reset_pref_wp_Callback(hObject, eventdata, handles)
%Resets user-preference ground-truth illuminant color.
global ccts
data = handles.metadata;
data.pref_illum = data.cam_illum;
data = update_cct_values(data);
handles.metadata = data;
guidata(hObject, handles);
save_file(fullfile(handles.dataset_path, 'labeling_tool_data', ...
    'labels', [handles.filenames{handles.log.index}, '.json']), data);
handles.show_wb_raw_pref.Value = 1;
load_img(handles);
handles.cam_neutral_wb.Value = 0;
update_cct_slider(handles);

function daylight_Callback(hObject, eventdata, handles)
%Callback function of daylight scene classification. 
handles.metadata = update_metadata(handles.metadata, handles);
guidata(hObject, handles);

function sunset_Callback(hObject, eventdata, handles)
%Callback function of sunset scene classification.
handles.metadata = update_metadata(handles.metadata, handles);
guidata(hObject, handles);


function indoor_Callback(hObject, eventdata, handles)
%Callback function of indoor scene classification.
handles.metadata = update_metadata(handles.metadata, handles);
guidata(hObject, handles);

function night_Callback(hObject, eventdata, handles)
%Callback function of night scene classification.
handles.metadata = update_metadata(handles.metadata, handles);
guidata(hObject, handles);

function artificial_light_Callback(hObject, eventdata, handles)
%Callback function of artificial light classification.
handles.metadata = update_metadata(handles.metadata, handles);
guidata(hObject, handles);

function set_to_default(handles)
%Set GUI options to default.
handles.daylight.Value = 1;
handles.training.Value = 1;
handles.natural.Value = 1;
handles.cam_neutral_wb.Value = 0;
handles.cct_slider.Value = 0.5;

function natural_light_Callback(hObject, eventdata, handles)
%Callback function of natural light classification.
handles.metadata = update_metadata(handles.metadata, handles);
guidata(hObject, handles);

function calibration()
%Computes CCT-rgb coeffs.
global ccts chromas coeffs_rg_bg_to_cct
x_chromas = [chromas, ones(size(chromas, 1), 1)];
coeffs_rg_bg_to_cct = (x_chromas' * x_chromas) \ (x_chromas' * ccts(:));

function cct = predict_cct(rgb)
%Converts RGB illuminant color to CCT.
global coeffs_rg_bg_to_cct ccts
cct = min(max([rgb(1)/rgb(2), rgb(3)/rgb(2), 1] * ...
    coeffs_rg_bg_to_cct, min(ccts)), max(ccts));

function rgb = predict_rgb(cct)
%Converts CCT to  normalized RGB illuminant color.
global chromas
[min_cct, max_cct, nearest_idx] = find_nearest_ccts(cct);
ratio = (cct - min_cct) / (max_cct - min_cct);
chroma = chromas(max(nearest_idx - 1 , 1), :) * ratio + ...
    chromas(min(nearest_idx + 1 , size(chromas, 1)), :) * (1 - ratio);
rgb = [chroma(1), 1, chroma(2)];
rgb = rgb / norm(rgb);


function update_cct_status(handles, data)
%Updates CCT status in GUI with current CCT values.
prob_sunrise = data.capture_metadata.prob_sunrise;
prob_noon = data.capture_metadata.prob_noon;
prob_sunset = data.capture_metadata.prob_sunset;
prob_midnight = data.capture_metadata.prob_midnight;
[val, idx] = max([prob_sunrise, prob_noon, prob_sunset, prob_midnight]);
if idx == 1 || idx == 3
    max_prob = 'sunset/sunrise';
elseif idx == 2
    max_prob = 'noon';
else
    max_prob = 'midnight';
end
handles.cct_status.String = sprintf( ...
    'Neutral CCT = %d, Pref CCT = %d, Cam CCT = %d - max prob: %s (%0.2f)', ...
    round(data.gt_cct), round(data.pref_cct), round(data.cam_cct), ...
    max_prob, val);

function relative_Callback(hObject, eventdata, handles)
% Callback function of relative chkbnt
global ccts
if handles.relative.Value
    handles.cct_slider.Value = 0.5;
else
    cct = predict_cct(handles.metadata.pref_illum);
    norm_cct = (cct - min(ccts)) / (max(ccts) - min(ccts));
    handles.cct_slider.Value = norm_cct;
end


function show_discarded_Callback(hObject, eventdata, handles)
%Callback function of show_discarded chkbtn.
if ~handles.show_discarded.Value && handles.metadata.discard
    next_Callback(hObject, eventdata, handles);
end


function cct_value_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), ...
        get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function figure1_CloseRequestFcn(hObject, eventdata, handles)
global mask blur_mask
if isfield(handles, 'filenames') 
    imwrite(mask, fullfile(handles.dataset_path, ...
        'labeling_tool_data', 'labels', ...
        [handles.filenames{handles.log.index}, '_mask.png']));

    imwrite(blur_mask, fullfile(handles.dataset_path, ...
            'labeling_tool_data', 'labels', ...
            [handles.filenames{handles.log.index}, '_blur_mask.png']));
end
delete(hObject);