Lucas-Kanade光流算法、基于Kalman滤波的光流算法，基于Horn-Schunck光流算法matlab精确度代码

Lucas-Kanade光流算法的matlab实现：

function [u,v] = lucaskanade(frame1,frame2,window_size)

% convert frames to grayscale
if size(frame1, 3) == 3
    frame1 = rgb2gray(frame1);
end
if size(frame2, 3) == 3
    frame2 = rgb2gray(frame2);
end

% calculate gradients
fx = conv2(frame1,[-1 1; -1 1],'valid'); 
fy = conv2(frame1,[-1 -1; 1 1],'valid'); 
ft = conv2(frame2, ones(2), 'valid') + conv2(frame1, -ones(2), 'valid');

u = zeros(size(frame1));
v = zeros(size(frame2));

% iterate through each pixel in the frame
for i = window_size+1:size(fx,1)-window_size-1
    for j = window_size+1:size(fx,2)-window_size-1
        
        % extract the window around the pixel
        Ix = fx(i-window_size:i+window_size, j-window_size:j+window_size);
        Iy = fy(i-window_size:i+window_size, j-window_size:j+window_size);
        It = ft(i-window_size:i+window_size, j-window_size:j+window_size);
        
        % flatten the windows into vectors
        Ix = Ix(:);
        Iy = Iy(:);
        b = -It(:);
        
        A = [Ix Iy];
        
        % solve the equation Ax = b
        if rank(A'*A) >= 2
            nu = pinv(A)*b;
        else
            nu = [0;0];
        end
        
        u(i,j)=nu(1);
        v(i,j)=nu(2);
    end
end
end

基于Kalman滤波的光流算法matlab实现：

function [u,v] = kalmanflow(frame1,frame2,window_size)

% convert frames to grayscale
if size(frame1, 3) == 3
    frame1 = rgb2gray(frame1);
end
if size(frame2, 3) == 3
    frame2 = rgb2gray(frame2);
end

% calculate gradients
fx = conv2(frame1,[-1 1; -1 1],'valid'); 
fy = conv2(frame1,[-1 -1; 1 1],'valid'); 
ft = conv2(frame2, ones(2), 'valid') + conv2(frame1, -ones(2), 'valid');

u = zeros(size(frame1));
v = zeros(size(frame2));

% iterate through each pixel in the frame
for i = window_size+1:size(fx,1)-window_size-1
    for j = window_size+1:size(fx,2)-window_size-1
        
        % extract the window around the pixel
        Ix = fx(i-window_size:i+window_size, j-window_size:j+window_size);
        Iy = fy(i-window_size:i+window_size, j-window_size:j+window_size);
        It = ft(i-window_size:i+window_size, j-window_size:j+window_size);
        
        % flatten the windows into vectors
        Ix = Ix(:);
        Iy = Iy(:);
        b = -It(:);
        
        A = [Ix Iy];
        
        % initial guess for velocity
        nu = pinv(A)*b;
        
        % initialize Kalman filter
        x = nu;
        P = eye(2);
        Q = 0.1*eye(2);
        R = 0.1*eye(2);
        
        % iterate through each frame
        for k = 1:10
            % predict next state
            x = A*x;
            P = A*P*A' + Q;
            
            % update state based on measurement
            z = [fx(i+k,j+k); fy(i+k,j+k)];
            K = P*A'*inv(A*P*A' + R);
            x = x + K*(z - A*x);
            P = (eye(2) - K*A)*P;
        end
        
        u(i,j)=x(1);
        v(i,j)=x(2);
    end
end
end

基于Horn-Schunck光流算法matlab实现：

function [u, v] = hornschunck(frame1, frame2, alpha, iterations)

% convert frames to grayscale
if size(frame1, 3) == 3
    frame1 = rgb2gray(frame1);
end
if size(frame2, 3) == 3
    frame2 = rgb2gray(frame2);
end

% calculate gradients
fx = conv2(frame1, [-1 1; -1 1], 'valid');
fy = conv2(frame1, [-1 -1; 1 1], 'valid');
ft = conv2(frame2, ones(2), 'valid') + conv2(frame1, -ones(2), 'valid');

% initialize velocity vectors
u = zeros(size(frame1));
v = zeros(size(frame2));

% iterate through each pixel in the frame
for i = 1:iterations
    % calculate average velocity for each pixel
    u_avg = conv2(u, 0.25*[1 1; 1 1], 'same');
    v_avg = conv2(v, 0.25*[1 1; 1 1], 'same');
    
    % calculate intermediate variables
    rho = fx.*u_avg + fy.*v_avg + ft;
    delta = alpha^2 + fx.^2 + fy.^2;
    
    % update velocity vectors
    u = u_avg - fx.*rho./delta;
    v = v_avg - fy.*rho./delta;
end
end