evaluate.m

lambda1_list  = [1.6]; 
lambda2_list  = [5e-2];     
mu_list       = [5e-2];
% names = ["sofa", "pedestrians", "PETS2006"];
names = ["office", "highway"];
for t = 1:length(names)
origin_file = names(t);
disp(origin_file);
method = "nonlinear";
groundtruth_file = origin_file+"_gt";

load(groundtruth_file+".mat");
groundtruth = gray_images;
tensor2video(groundtruth, groundtruth_file+".avi");

load(origin_file+".mat");
origin = gray_images;
tensor2video(origin, origin_file+".avi");

for i = 1:length(lambda1_list)
    for j = 1:length(lambda2_list)
        for k = 1:length(mu_list)

            opts.lambda = lambda1_list(i);
            opts.lambda2 = lambda2_list(j);
            opts.mu = mu_list(k);

            configName = sprintf('%s_l1%.2e_l2%.2e_mu%.2e', names(t), lambda1_list(i), lambda2_list(j), mu_list(k));
            name = sprintf("%s_acceler_%s", method,names(t));
            disp(configName);

            load(sprintf("%s_acceler_%s_ABC.mat", method,configName));
            result_ADMM_reg = block_term_product(A1, B1, C1);
            disp(size(A1{1}));
            disp(size(B1{1}));
            disp(size(C1{1}));
            tensor2video(result_ADMM_reg,sprintf("%s_acceler_%s_ABC.avi", method,names(t)));


            load(sprintf("%s_acceler_%s_E.mat", method,configName));
            tensor2video(E1,sprintf("%s_acceler_%s_E.avi", method,names(t)));
            eval(origin, groundtruth, result_ADMM_reg, E1);
            mAP(origin, groundtruth, result_ADMM_reg, E1);
            tensor2video(result_ADMM_reg, origin_file+"_bg.avi");
            tensor2video(E1, origin_file+"_fg.avi");
            % load(sprintf("%s_acceler_%s_total.mat", method,configName));
            % tensor2video(total1,sprintf("%s_acceler_%s_total.avi", method,configName));
        end
    end
end
end
                                             
function [] = tensor2video(X, video_name)          
X_uint8 = im2uint8(mat2gray(X));

v = VideoWriter(video_name);  
open(v);

numFrames = size(X_uint8, 3);
for t = 1:numFrames
    frame = X_uint8(:, :, t); 
    writeVideo(v, frame);
end

close(v);
end
function Xhat = block_term_product(A, B, C)
    [R, ~] = size(A);
    [I, ~] = size(A{1});
    [J, ~] = size(B{1});
    [K, ~] = size(C{1});
    Xhat = zeros(I, J, K);

    for r = 1:R
        AB = A{r} * B{r}';
        for k = 1:K
            Xhat(:,:,k) = Xhat(:,:,k) + C{r}(k) * AB;
        end
    end
end


function [] = eval(origin, groundtruth, background, foreground)
if ~isequal(size(origin), size(background), size(groundtruth))
    error('Unmatched origin, background and groundtruth');
end

numFrames = size(origin, 3);


pred_mask = zeros(size(origin));

for i = 1:numFrames
    frame_origin = double(origin(:,:,i));
    frame_bg     = double(background(:,:,i));
    diff_img = abs(frame_origin-frame_bg); 
    % diff_img = abs(foreground(:, :, i));
    
    level = graythresh(diff_img);
    thresh_val = level * 255;
    
    pred_mask(:,:,i) = diff_img > 50;
end
% tensor2video(pred_mask, "highway_foreground.avi");
gt_mask = (groundtruth == 255) ;
ns_mask = (groundtruth == 170);
TP_total = 0; FP_total = 0; FN_total = 0; TN_total = 0;
total_pixels = numel(gt_mask);

for i = 1:numFrames
    p_mask = pred_mask(:,:,i);
    g_mask = gt_mask(:,:,i);
    m_mask = ns_mask(:, :, i);
    TP = sum(p_mask(:) & (g_mask(:)|m_mask(:)));
    FP = sum(p_mask(:) & (~g_mask(:)));
    FN = sum(~p_mask(:) & (g_mask(:)));
    TN = sum(~p_mask(:) & ((~g_mask(:))|m_mask(:)));
    
    TP_total = TP_total + TP;
    FP_total = FP_total + FP;
    FN_total = FN_total + FN;
    TN_total = TN_total + TN;
end

precision = TP_total / (TP_total + FP_total);
recall    = TP_total / (TP_total + FN_total);
F1        = 2 * precision * recall / (precision + recall);
PWC       = 100 * (FP_total + FN_total) / total_pixels;
fprintf("TP: %d FP: %d TN: %d FN: %d \n", TP_total, FP_total, TN_total, FN_total);
fprintf('Precision: %.4f\n', precision);
fprintf('Recall   : %.4f\n', recall);
fprintf('F1 Score : %.4f\n', F1);
fprintf('PWC      : %.4f%%\n', PWC);
end


function [] = mAP(origin, groundtruth, background, foreground)
numFrames = size(origin, 3);
APs = zeros(numFrames, 1);
alpha = 0.5; 
cnt = 0;
for i = 1:numFrames
    frame_origin = double(origin(:,:,i));
    frame_bg     = double(background(:,:,i));
    % diff_img     = abs(foreground(:, :, i));
    diff_img = abs(frame_origin-frame_bg);    
    level = graythresh(diff_img);
    T = level  * 255;
    pred_prob = 1 ./ (1 + exp(-alpha * (diff_img - T)));
    
    gt_mask = double(groundtruth(:,:,i) == 255);
    if numel(unique(gt_mask)) < 2
        APs(i) = NaN;
        continue;
    end
    [recall, precision, ~] = perfcurve(gt_mask(:), pred_prob(:), 1, 'xCrit', 'reca', 'yCrit', 'prec');
    if mod(i, 1000) == 0
        disp(recall);
        disp(precision);
    end
    validIdx = ~isnan(precision) & ~isnan(recall);
    if sum(validIdx) > 1
        APs(i) = trapz(recall(validIdx), precision(validIdx));
        cnt = cnt + 1;
    else

        APs(i) = 0; % hoặc một giá trị phù hợp nếu không đủ điểm để tính tích phân
    end
end
mAP = mean(APs(~isnan(APs)));
fprintf('Mean Average Precision (mAP): %.4f\n\n', mAP);
end