vbpds.m

Vision based pedestrian detection system based on pso

                for i = 1:width
                    if v_s_h(i) > beta
                        f_h_e_v(:,i) = 0;
                    end
                    if v_s_v(i) > beta
                        f_h_e_v(:,i) = 0;
                    end
                end
                for i = 1:height
                    if h_s_h(i) > beta
                        f_h_e_h(i,:) = 0;
                    end
                    if h_s_v(i) > beta
                        f_v_e_h(i,:) = 0;
                    end
                end
                
                %figure, imshow(h_e)
                %figure, imshow(v_e)
                obj.error_code = '09-07';
                
                %define membership function'
                delta = 2;
                Left = 5;
                MiddleH = 9;
                Right = 13;
                mu_LE = zeros(width,1);
                mu_L = zeros(width,1);
                mu_MH = zeros(width,1);
                mu_R = zeros(width,1);
                mu_RE = zeros(width,1);
                
                mu_LE(1:delta) = 1;
                for i = delta+1:2*delta
                    mu_LE(i) = 2 - i/delta;
                end
                mu_LE((2*delta)+1:end) = 0;
                
                mu_L(1:Left-2) = 0;
                for i = Left-1:Left
                    mu_L(i) = 1 - .5*(Left-i);
                end
                for i = Left+1:Left+2
                    mu_L(i) = 1 - .5*(i-Left);
                end
                mu_L(Left+3:end) =0;
                
                mu_MH(1:MiddleH-2) = 0;
                for i = MiddleH-1:MiddleH
                    mu_MH(i) = 1 - .5*(MiddleH-i);
                end
                for i = MiddleH+1:MiddleH+2
                    mu_MH(i) = 1 - .5*(i-MiddleH);
                end
                mu_MH(MiddleH+3:end) =0;
                
                mu_R(1:Right-2) = 0;
                for i = Right-1:Right
                    mu_R(i) = 1 - .5*(Right-i);
                end
                for i = Right+1:Right+2
                    mu_R(i) = 1 - .5*(i-Right);
                end
                mu_R(Right+3:end) =0;
                
                gama = size(mu_RE,1)-delta;
                mu_RE(1:gama-delta) = 0;
                for i = gama-delta+1 : gama
                    mu_RE(i) = 1 + (i-gama)/delta;
                end
                mu_RE(gama+1:end) = 1;

                obj.error_code = '09-08';
                
                delta = 3;
                Top = 8;
                MiddleV = 18;
                Bottom = 28;
                mu_TE = zeros(height,1);
                mu_T = zeros(height,1);
                mu_MV = zeros(height,1);
                mu_B = zeros(height,1);
                mu_BE = zeros(height,1);
                
                mu_TE(1:delta) = 1;
                for i = delta+1:2*delta
                    mu_TE(i) = 2 - i/delta;
                end
                mu_TE((2*delta)+1:end) = 0;
                
                mu_T(1:Top-5) = 0;
                for i = Top-5:Top
                    mu_T(i) = 1 - (1/5)*(Top-i);
                end
                for i = Top+1:Top+5
                    mu_T(i) = 1 - (1/5)*(i-Top);
                end
                mu_T(Top+6:end) =0;
                
                mu_MV(1:MiddleV-5) = 0;
                for i = MiddleV-5:MiddleV
                    mu_MV(i) = 1 - (1/5)*(MiddleV-i);
                end
                for i = MiddleV+1:MiddleV+5
                    mu_MV(i) = 1 - (1/5)*(i-MiddleV);
                end
                mu_MV(MiddleV+6:end) =0;
                
                mu_B(1:Bottom-5) = 0;
                for i = Bottom-5:Bottom
                    mu_B(i) = 1 - (1/5)*(Bottom-i);
                end
                for i = Right+1:Right+5
                    mu_B(i) = 1 - (1/5)*(i-Bottom);
                end
                mu_B(Bottom+6:end) =0;
                
                gama = size(mu_BE,1)-delta;
                mu_BE(1:gama-delta) = 0;
                for i = gama-delta+1 : gama
                    mu_BE(i) = 1 + (i-gama)/delta;
                end
                mu_BE(gama+1:end) = 1;
                
                obj.error_code = '09-09';
                
                w_f_h_e_h = sum(f_h_e_h) / width;
                w_f_h_e_v = sum(f_h_e_v) / width;
                w_f_v_e_h = sum(f_v_e_h) / width;
                w_f_v_e_v = sum(f_v_e_v) / width;
                
                z_f_h_e_h = sum(f_h_e_h,2) / height;
                z_f_h_e_v = sum(f_h_e_v,2) / height;
                z_f_v_e_h = sum(f_v_e_h,2) / height;
                z_f_v_e_v = sum(f_v_e_v,2) / height;
                
                obj.pi(1)  = sum(w_f_h_e_h' .* mu_LE)/(sum(mu_LE));
                obj.pi(2)  = sum(w_f_h_e_h' .* mu_L) /(sum(mu_L));
                obj.pi(3)  = sum(w_f_h_e_h' .* mu_MH)/(sum(mu_MH));
                obj.pi(4)  = sum(w_f_h_e_h' .* mu_R) /(sum(mu_R));
                obj.pi(5)  = sum(w_f_h_e_h' .* mu_RE)/(sum(mu_RE));
                
                obj.pi(6)  = sum(w_f_h_e_v' .* mu_LE)/(sum(mu_LE));
                obj.pi(7)  = sum(w_f_h_e_v' .* mu_L) /(sum(mu_L));
                obj.pi(8)  = sum(w_f_h_e_v' .* mu_MH)/(sum(mu_MH));
                obj.pi(9)  = sum(w_f_h_e_v' .* mu_R) /(sum(mu_R));
                obj.pi(10) = sum(w_f_h_e_v' .* mu_RE)/(sum(mu_RE));
                
                obj.pi(11) = sum(w_f_v_e_h' .* mu_LE)/(sum(mu_LE));
                obj.pi(12) = sum(w_f_v_e_h' .* mu_L) /(sum(mu_L));
                obj.pi(13) = sum(w_f_v_e_h' .* mu_MH)/(sum(mu_MH));
                obj.pi(14) = sum(w_f_v_e_h' .* mu_R) /(sum(mu_R));
                obj.pi(15) = sum(w_f_v_e_h' .* mu_RE)/(sum(mu_RE));
                
                obj.pi(16) = sum(w_f_v_e_v' .* mu_LE)/(sum(mu_LE));
                obj.pi(17) = sum(w_f_v_e_v' .* mu_L) /(sum(mu_L));
                obj.pi(18) = sum(w_f_v_e_v' .* mu_MH)/(sum(mu_MH));
                obj.pi(19) = sum(w_f_v_e_v' .* mu_R) /(sum(mu_R));
                obj.pi(20) = sum(w_f_v_e_v' .* mu_RE)/(sum(mu_RE));
                
                obj.pi(21) = sum(z_f_h_e_h .* mu_TE)/(sum(mu_TE));
                obj.pi(22) = sum(z_f_h_e_h .* mu_T) /(sum(mu_T));
                obj.pi(23) = sum(z_f_h_e_h .* mu_MV)/(sum(mu_MV));
                obj.pi(24) = sum(z_f_h_e_h .* mu_B) /(sum(mu_B));
                obj.pi(25) = sum(z_f_h_e_h .* mu_BE)/(sum(mu_BE));
                
                obj.pi(26) = sum(z_f_h_e_v .* mu_TE)/(sum(mu_TE));
                obj.pi(27) = sum(z_f_h_e_v .* mu_T) /(sum(mu_T));
                obj.pi(28) = sum(z_f_h_e_v .* mu_MV)/(sum(mu_MV));
                obj.pi(29) = sum(z_f_h_e_v .* mu_B) /(sum(mu_B));
                obj.pi(30) = sum(z_f_h_e_v .* mu_BE)/(sum(mu_BE));
                
                obj.pi(31) = sum(z_f_v_e_h .* mu_TE)/(sum(mu_TE));
                obj.pi(32) = sum(z_f_v_e_h .* mu_T) /(sum(mu_T));
                obj.pi(33) = sum(z_f_v_e_h .* mu_MV)/(sum(mu_MV));
                obj.pi(34) = sum(z_f_v_e_h .* mu_B) /(sum(mu_B));
                obj.pi(35) = sum(z_f_v_e_h .* mu_BE)/(sum(mu_BE));
                
                obj.pi(36) = sum(z_f_v_e_v .* mu_TE)/(sum(mu_TE));
                obj.pi(37) = sum(z_f_v_e_v .* mu_T) /(sum(mu_T));
                obj.pi(38) = sum(z_f_v_e_v .* mu_MV)/(sum(mu_MV));
                obj.pi(39) = sum(z_f_v_e_v .* mu_B) /(sum(mu_B));
                obj.pi(40) = sum(z_f_v_e_v .* mu_BE)/(sum(mu_BE));
                %toc
                
            catch e
                if strcmp(obj.Show_Message,'true')
                    warning('VBPDS:extract_feature', 'Error in extracting features : "%s".\n',e.message);
                    disp(['VBPDS:extract_feature  ', 'error_code  : ' obj.error_code]);
                end
            end  
        end
        function obj = Load_Patterns_Feature(obj)
            reply = 'N';
            if strcmp(obj.reload,'true')
                disp('Loading Patterns Feature take a few minutes , \n')
                reply = input('Do you want realy load? Y/N [N]: ', 's');
                if isempty(reply)
                    reply = 'N';
                end
            end
            try
                All_Patterns_Feature = [];
                if strcmp(obj.reload,'true') &&( reply == 'Y')
                    for PatternNumber = 1:obj.Number_of_PedestrianPatterns
                        obj.error_code = '10-02';
                        obj.current_frame = uint8(obj.All_Patterns_Seprated(:,:,PatternNumber));
                        obj = obj.extract_feature;
                        All_Patterns_Feature_Separated(:,PatternNumber) = obj.pi(:);
                        All_Patterns_Feature = [All_Patterns_Feature All_Patterns_Feature_Separated(:,PatternNumber)];
                        Feature_Target(PatternNumber)=1;
                        disp(PatternNumber);
                    end
                    for PatternNumber = 1:obj.Number_of_NonPedestrianPatterns
                        obj.error_code = '10-03';
                        obj.current_frame = uint8(obj.All_Patterns_Seprated(:,:,obj.Number_of_PedestrianPatterns+PatternNumber));
                        obj = obj.extract_feature;
                        All_Patterns_Feature_Separated(:,obj.Number_of_PedestrianPatterns+PatternNumber) = obj.pi(:);
                        All_Patterns_Feature = [All_Patterns_Feature All_Patterns_Feature_Separated(:,obj.Number_of_PedestrianPatterns+PatternNumber)];
                        Feature_Target(obj.Number_of_PedestrianPatterns+PatternNumber)=0;
                        disp(obj.Number_of_PedestrianPatterns+PatternNumber);
                    end
                    obj.error_code = '10-04';

                    obj.Feature_Target = double(Feature_Target);
                    obj.All_Patterns_Feature = double(All_Patterns_Feature);
                    obj.All_Patterns_Feature_Separated = double(All_Patterns_Feature_Separated);

                    save 'Patterns_Feature' 'Feature_Target' -append
                    save 'Patterns_Feature' 'All_Patterns_Feature' -append
                    save 'Patterns_Feature' 'All_Patterns_Feature_Separated' -append

                else
                    obj.error_code = '10-05';
                    load 'Patterns_Feature' 'Feature_Target'
                    load 'Patterns_Feature' 'All_Patterns_Feature'
                    load 'Patterns_Feature' 'All_Patterns_Feature_Separated'

                    obj.Feature_Target = double(Feature_Target);
                    obj.All_Patterns_Feature = double(All_Patterns_Feature);
                    obj.All_Patterns_Feature_Separated = double(All_Patterns_Feature_Separated);
                end            
            catch e
                if strcmp(obj.Show_Message,'true')
                    warning('VBPDS:Load_Patterns_Feature', 'Error in Loading Patterns Feature : "%s".\n',e.message);
                    disp(['VBPDS:Load_Patterns_Feature  ', 'error_code  : ' obj.error_code]);
                end
            end
        end
        function obj = train_neural_network(obj)
            reply = 'N';
            if strcmp(obj.reload,'true')
                disp('Loading neural network take a few minutes , \n')
                reply = input('Do you want realy load? Y/N [N]: ', 's');
                if isempty(reply)
                    reply = 'N';
                end
            end
            obj.error_code = '11-01';
            if strcmp(obj.reload,'true') &&( reply == 'Y')
                try
                    Neural_Network = newff(obj.All_Patterns_Feature, obj.Feature_Target,[3 3]);
                    Neural_Network.trainParam.goal = 10^-30;
                    %Neural_Network.trainParam.transferfunction = 'satlins';
                    %Neural_Network.trainParam.transferfunction = 'hardlims';
                    Neural_Network.trainParam.epochs = 100;
                    obj.error_code = '11-02';
                    %,tr,Y,E,Pf,Af
                    [Neural_Network,tr,Y,E,Pf,Af] = train(Neural_Network,obj.All_Patterns_Feature,obj.Feature_Target);
                    obj.error_code = '11-03';
                catch e
                        if strcmp(obj.Show_Message, 'true')
                            warning('VBPDS:Train_Neural_Network', 'Error in Training Neural Network, "%s".', e.message);
                            disp(['VBPDS:Train_Neural_Network  ', 'error_code  : ' obj.error_code]);
                        end
                        load 'Neural_Network' 'Neural_Network'
                        obj.Neural_Network = Neural_Network;
                        return;
                end
                obj.Neural_Network = Neural_Network;
                save 'Neural_Network' 'Neural_Network' -append
            else
                load 'Neural_Network' 'Neural_Network'
                obj.Neural_Network = Neural_Network;
            end            
        end
    end
end