olgeee.m

Face recognition using webcam and this data.if the person exist means its gives the serial data out.

function [eigvector, eigvalue, bSuccess, elapse] = OLGEEE(W, D, options, data)

if ~exist('data','var')
    global data;
end

if (~exist('options','var'))
   options = [];
end

if isfield(options,'ReducedDim')
    Dim = options.ReducedDim;
else
    Dim = 30;
end
 bPCA = 1;
    if ~isfield(options,'PCARatio')
        options.PCARatio = 1;
    end
    if ~isfield(options,'bDisp')
    options.bDisp = 1;
end

bD = 1;
if ~exist('D','var') | isempty(D)
    bD = 0;
end


[nSmp,nFea] = size(data);
if size(W,1) ~= nSmp
    error('W and data mismatch!');
end
if bD & (size(D,1) ~= nSmp)
    error('D and data mismatch!');
end


%======================================
% SVD
%======================================
tmp_T = cputime;
size(data)
size(data')

    
    if nSmp > nFea
       ddata = data'*data;
        if issparse(ddata)
            ddata = full(ddata);
        end
        ddata = max(ddata,ddata');

        [eigvector_PCA, eigvalue_PCA] = eig(ddata);
        eigvalue_PCA = diag(eigvalue_PCA);
        clear ddata;

        maxEigValue = max(abs(eigvalue_PCA));
        eigIdx = find(eigvalue_PCA/maxEigValue < 1e-12);
        eigvalue_PCA(eigIdx) = [];
        eigvector_PCA(:,eigIdx) = [];

        [junk, index] = sort(-eigvalue_PCA);
        eigvalue_PCA = eigvalue_PCA(index);
        eigvector_PCA = eigvector_PCA(:, index);
        
         data = data*eigvector_PCA;
    else
        size(data);
size(data');
        ddata = double(data)*double(data');
        if issparse(ddata)
            ddata = full(ddata);
        end
        ddata = max(ddata,ddata');

        [eigvector, eigvalue_PCA] = eig(ddata);
        eigvalue_PCA = diag(eigvalue_PCA);
        clear ddata;

        maxEigValue = max(eigvalue_PCA);
        eigIdx = find(eigvalue_PCA/maxEigValue < 1e-12);
        eigvalue_PCA(eigIdx) = [];
        eigvector(:,eigIdx) = [];

        [junk, index] = sort(-eigvalue_PCA);
        eigvalue_PCA = eigvalue_PCA(index);
        eigvector = eigvector(:, index);
         eigvalue_PCA = eigvalue_PCA.^.5;
        eigvalue_PCAMinus = eigvalue_PCA.^-1;
        eigvector_PCA = (double(data')*eigvector).*repmat(eigvalue_PCAMinus',nFea,1);

        data = eigvector.*repmat(eigvalue_PCA',nSmp,1);
    end
    
    if bD
        DPrime = data'*D*data;
        DPrime = max(DPrime,DPrime');
    else
        DPrime = data'*data;
        DPrime = max(DPrime,DPrime');
    end
    WPrime = data'*W*data;
WPrime = max(WPrime,WPrime');

elapse.timePCA = cputime - tmp_T;
tmp_T = cputime;


% Generalized Eigen with Orthogonal Constraint 

dimM = size(WPrime,2);

if Dim > dimM
    Dim = dimM; 
end


rDPrime = chol(DPrime);
lDPrime = rDPrime';

Q0 = rDPrime\(lDPrime\WPrime);  % Q0 = inv(DPrime)*WPrime;

eigvector = [];
eigvalue = [];
tmpD = [];
Q = Q0;

bSuccess = 1;
for i = 1:Dim,
    try
        option = struct('disp',0);
        [eigVec, eigv] = eigs(Q,1,'lr',option);
    catch
        disp('eigs Error!');
        bSuccess = 0;
        elapse = 0;
        return;
    end

    if ~isreal(eigVec)
        disp('Virtual part!');
        bSuccess = 0;
        break;
    end

    if eigv < 1e-3
        break;
    end

    eigvector = [eigvector, eigVec];	% Each col of D is a eigenvector
    eigvalue = [eigvalue;eigv];


    tmpD = [tmpD, rDPrime\(lDPrime\eigVec)];  % tmpD = inv(DPrime)*D;
    DTran = eigvector';
    tmptmpD = DTran*tmpD;
    tmptmpD = max(tmptmpD,tmptmpD');
    rtmptmpD = chol(tmptmpD);
    tmptmpD = rtmptmpD\(rtmptmpD'\DTran); % tmptmpD = inv(D'*inv(DPrime)*D)*D'

    Q = -tmpD*tmptmpD;
    for j=1:dimM
        Q(j,j) = Q(j,j) + 1; 
    end
    Q = Q*Q0;

    if (mod(i,10) == 0) & options.bDisp
        %disp([num2str(i),' eigenvector calculated!']);
    end
end


if bPCA
    if bSuccess
        eigvector = eigvector_PCA*eigvector;
    elseif size(eigvector,1) == size(eigvector_PCA,2)
        eigvector = eigvector_PCA*eigvector;
    end
end