Test result is bad

Author: ShownX

.gitignore

@@ -220,3 +220,5 @@ pip-log.txt
 #############
 *.mat
 *.asv
+*.png
+*.pts

ESR_Test.m

@@ -14,7 +14,7 @@ function ESR_Test()
         disp('lack of initial set of shapes');
     end
 
-    Data = loadsamples('/Volumes/LG_SDJet/Datasets/lfpw/annotations/trainset', 'png');
+    Data = loadsamples('lfpw/testset', 'png');
     params.N_img = size(Data, 1); 
     load('Data/InitialShape_68');
     dist_pupils_ms = getDistPupils(S0);
@@ -23,78 +23,113 @@ function ESR_Test()
 
     load('Data/Model.mat', 'Model'); 
     %%
-    for i = 1: 1
-        Prediction = ShapeRegression(Data{i}, initSet, Model, params);
-        figure
-        imshow(Data{i}.img_gray)
-        hold on
-        plot(Prediction(:, 1), Prediction(:, 2), 'g+');
-        hold off
+    prediction = zeros([size(params.meanshape), params.N_img]);
+    groundtruth = zeros([size(params.meanshape), params.N_img]);
+    for i = 1: params.N_img
+        Prediction = ShapeRegression(Data(i), initSet, Model, params);
+        prediction(:,:, i) = Prediction;
+        groundtruth(:,:, i) = Data{i}.shape_gt(params.ind_usedpts,:);
     end
-    
+    fprintf('MSRE is %f\n', mean(compute_error(prediction, groundtruth)));
 end
 
 function predict = ShapeRegression(data, initSet, Model, params)
     % Multiple initializations
-    
-    %predict = zeros(params.N_fp, 2);
-    ctshapes = initialTest(data, initSet, params);
+    Data = initialize(data, initSet, params);
 
     for t = 1: params.T
-        for i = 1: params.N_init
-            prediction_delta = fernCascadeTest(data, ctshapes(:, :, i), Model{t}.fernCascade, params);
-            ctshapes(:, :, i) = ctshapes(:, :, i) + prediction_delta;
+        for i = 1: params.N_aug
+            prediction_delta = fernCascadeTest(Data{i}, Model{t}.fernCascade, params, t);
+            % update the shape, convert to the current shape
+            bbx = Data{i}.intermediate_bboxes{t};
+            shape_stage = Data{i}.intermediate_shapes{t};
+            delta_shape = prediction_delta;
+            
+            [u, v] = transformPointsForward(Data{i}.meanshape2tf, delta_shape(:, 1), delta_shape(:, 2));
+            delta_shape_interm_coord = [u, v];
+            shape_residual = bsxfun(@times, delta_shape_interm_coord, [bbx(3),bbx(4)]);
+            shape_newstage = shape_stage + shape_residual;
+                        
+            % update the shape
+            Data{i}.intermediate_bboxes{t+1} = getbbox(shape_newstage);
+            Data{i}.intermediate_shapes{t+1} = shape_newstage;
+            meanshape_reproject = resetshape(Data{i}.intermediate_bboxes{t+1}, params.meanshape);
+            Data{i}.tf2meanshape = fitgeotrans( bsxfun(@minus, shape_newstage, mean(shape_newstage)), ...
+                bsxfun(@minus, meanshape_reproject, mean(meanshape_reproject)),...
+                'nonreflectivesimilarity');
+            Data{i}.meanshape2tf = fitgeotrans( bsxfun(@minus, meanshape_reproject, mean(meanshape_reproject)),...
+                bsxfun(@minus, shape_newstage, mean(shape_newstage)), ...
+                'nonreflectivesimilarity');
+            % shape_residual = bsxfun(@rdivide, Data{i}.shape_gt - shape_newstage, Data{i}.intermediate_bboxes{t+1}(3:4));
+            % [u, v] = transformPointsForward(Data{i}.tf2meanshape, shape_residual(:, 1), shape_residual(:, 2));   
+            % Data{i}.shapes_residual = [u, v];
         end
     end
-    predict = mean(ctshapes, 3);
+    
+    % Prediction
+%     gtshapes = zeros([size(params.meanshape), params.T+1]);
+%     ctshapes = zeros([size(params.meanshape), params.T+1]);
+%     for t = 1: params.T+1
+%         for i = 1: params.N_aug
+%             ctshapes(:,:, t) = ctshapes(:,:, t) + Data{i}.intermediate_shapes{t};
+%             gtshapes(: ,:, t) = gtshapes(: ,:, t) + Data{i}.shape_gt;
+%         end
+%     end
+%     ctshapes = ctshapes/params.N_aug;
+%     gtshapes = gtshapes/params.N_aug;
+%     Error = zeros(1, params.T+1);
+%     for t = 1:params.T
+%         Error(t) = compute_error(ctshapes(:,:, t), gtshapes(:,:, t));
+%     end
+%     bar(Error);
+    
+    predict = zeros([size(params.meanshape), params.N_aug]);
+    for i = 1:params.N_aug
+        predict(:, :, i) = Data{i}.intermediate_shapes{end};
+    end
+    predict = mean(predict, 3);
 end
 
-function prediction_delta = fernCascadeTest(image, current_shape, fernCascade, params)
-    image.intermediate_bbx = getbbox(current_shape);
-    meanshape = resetshape(image.intermediate_bbx, params.meanshape);
-    image.tf2meanshape = fitgeotrans(bsxfun(@minus, current_shape, mean(current_shape)), ...
-                bsxfun(@minus, meanshape, mean(meanshape)),...
-                'nonreflectivesimilarity');
-    image.meanshape2tf = fitgeotrans( bsxfun(@minus, meanshape, mean(meanshape)),...
-                bsxfun(@minus, current_shape, mean(current_shape)), ...
-                'nonreflectivesimilarity');
-    
+function delta_shape = fernCascadeTest(image, fernCascade, params, t)
     %extract shape indexed pixels
     candidate_pixel_location = fernCascade.candidate_pixel_location;
     nearest_landmark_index = fernCascade.nearest_landmark_index;
     intensities = zeros(1, params.P);
     for j = 1: params.P
-        x = candidate_pixel_location(j, 1)*image.intermediate_bbx(3);
-        y = candidate_pixel_location(j, 2)* image.intermediate_bbx(4);
+        x = candidate_pixel_location(j, 1)*image.intermediate_bboxes{t}(3);
+        y = candidate_pixel_location(j, 2)* image.intermediate_bboxes{t}(4);
         [project_x, project_y] = transformPointsForward(image.meanshape2tf, x, y);
         index = nearest_landmark_index(j);
 
-        real_x = round(project_x + current_shape(index, 1));
-        real_y = round(project_y + current_shape(index, 2));
+        real_x = round(project_x + image.intermediate_shapes{t}(index, 1));
+        real_y = round(project_y + image.intermediate_shapes{t}(index, 2));
         real_x = max(1, min(real_x, size(image.img_gray, 2)-1));
         real_y = max(1, min(real_y, size(image.img_gray, 1)-1));
         intensities(j)= image.img_gray(real_y, real_x);
     end
 
     delta_shape = zeros(size(params.meanshape));
-    for i = 1: params.K
-        fern = fernCascade.ferns{i}.fern;
+    for k = 1: params.K
+        fern = fernCascade.ferns{k}.fern;
         delta_shape = delta_shape + fernTest(intensities, fern, params);
     end
 
     %convert to the currentshape model
-    [u, v] = transformPointsForward(image.meanshape2tf, delta_shape(:, 1), delta_shape(:, 2));
-    prediction_delta = [u, v];
-    prediction_delta = bsxfun(@times, prediction_delta, [image.intermediate_bbx(3),image.intermediate_bbx(4)]);
+%     [u, v] = transformPointsForward(image.meanshape2tf, delta_shape(:, 1), delta_shape(:, 2));
+%     prediction_delta = [u, v];
+%     prediction_delta = bsxfun(@times, prediction_delta, [image.intermediate_bbx(3),image.intermediate_bbx(4)]);
 end
 
 function fern_pred = fernTest(intensities, fern, params)
     index = 0;
     for i = 1: params.F
-        intensity_1 = intensities(fern.selected_pixel_index(i, 1));
-        intensity_2 = intensities(fern.selected_pixel_index(i, 2));
+        m_f = fern.selected_pixel_index(i, 1);
+        n_f = fern.selected_pixel_index(i, 2);
+        
+        intensity_1 = intensities(m_f);
+        intensity_2 = intensities(n_f);
 
-        if (intensity_1 - intensity_2) >= fern.threshold(i)
+        if intensity_1 - intensity_2 >= fern.threshold(i)
             index = index + 2^(i-1);
         end
     end

ESR_Train.m

@@ -3,13 +3,13 @@ function ESR_Train()
     params = Train_params;
     % create paralllel local jobs note
     if isempty(gcp('nocreate'))
-        parpool(2);
+        parpool(8);
     end
     %% load data
     if exist('Data/train_init.mat', 'file')
         load('Data/train_init.mat', 'data');
     else
-        data = loadsamples('/Volumes/LG_SDJet/Datasets/lfpw/annotations/trainset', 'png');
+        data = loadsamples('/lfpw/annotations/trainset', 'png');
         %mkdir Data;
         save('Data/train_init.mat', 'data');
     end

Test_params.m

@@ -1,12 +1,12 @@
 function params = Test_params()
     params.T = 10; % the iteration stages
-    params.P = 40; % default = 400, the pixel number sampled on the images
-    params.K = 50; % default = 500, the number of fern on the internal-level boosted regression
+    params.P = 400; % default = 400, the pixel number sampled on the images
+    params.K = 500; % default = 500, the number of fern on the internal-level boosted regression
     params.k = [0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3]; 
     % the local scale of search, it set 0.3 times of the distance between two pupils on the mean shape
     params.F = 5; % the number of features in fern
 
-    params.N_init = 5; % initial number
+    params.N_aug = 5; % initial number
     %params.N_aug = 1;
 
     params.N_fp = 0;% size(params.mean_shape, 1);

Train.fig

@@ -0,0 +1,57 @@
+function Data = initialize(data, initSet, params)
+% initialize the data
+% data: image
+% initSet: the inital set of initialization
+% D: the number of initialization
+    Index = 0;
+    N_data = size(data, 1);
+    
+    Data = cell(N_data*params.N_aug, 1);
+    
+    for i = 1: N_data
+        % random select initial shapes without replacement
+        rand_index_ = randperm(params.N_img, params.N_aug);
+        while ismember(i, rand_index_)
+            rand_index_ = randperm(params.N_img, params.N_aug);
+        end
+        % expand the data
+        for j = 1: params.N_aug
+            r_index = rand_index_(j);
+            
+            Index = Index + 1;
+            % copy the original stuff
+            Data{Index}.img_gray = data{i}.img_gray;
+            Data{Index}.width_orig  = data{i}.width_orig;
+            Data{Index}.height_orig = data{i}.height_orig;    
+            Data{Index}.width       = data{i}.width;
+            Data{Index}.height      = data{i}.height;
+            Data{Index}.shape_gt    = data{i}.shape_gt(params.ind_usedpts, :);
+            Data{Index}.bbox_gt     = getbbox(Data{Index}.shape_gt);
+            % add the new element
+            Data{Index}.intermediate_shapes = cell(1, params.T);
+            Data{Index}.intermediate_bboxes = cell(1, params.T);
+            % scale and translate the sampled shape to ground-truth
+            % face rectangle region
+            select_shape = resetshape(data{i}.bbox_gt, initSet{r_index}.shape_gt(params.ind_usedpts, :));
+            
+            Data{Index}.intermediate_shapes{1} = select_shape;
+            Data{Index}.intermediate_bboxes{1} = getbbox(select_shape);
+
+            meanshape_resize = resetshape(Data{Index}.intermediate_bboxes{1}, params.meanshape);
+
+            Data{Index}.tf2meanshape = fitgeotrans(bsxfun(@minus, ...
+                Data{Index}.intermediate_shapes{1}, mean(Data{Index}.intermediate_shapes{1})), ...
+                bsxfun(@minus, meanshape_resize, mean(meanshape_resize)),...
+                'nonreflectivesimilarity');
+            Data{Index}.meanshape2tf = fitgeotrans(bsxfun(@minus, meanshape_resize, mean(meanshape_resize)), ...
+                bsxfun(@minus, Data{Index}.intermediate_shapes{1}, mean(Data{Index}.intermediate_shapes{1})),...
+                'nonreflectivesimilarity');                
+
+            shape_residual = bsxfun(@rdivide, Data{Index}.shape_gt - Data{Index}.intermediate_shapes{1},...
+                Data{Index}.intermediate_bboxes{1}(3: 4));  
+
+            [u, v] = transformPointsForward(Data{Index}.tf2meanshape, shape_residual(:, 1), shape_residual(:, 2));
+            Data{Index}.shapes_residual = [u, v];
+        end
+    end
+end