optical-flow-lk 0.2.0

Rust implementation of Lucas-Kanade optical flow and Shi-Tomasi feature detection
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

use image::{GrayImage, ImageBuffer, Luma};

/// Builds a pyramid of images where each successive layer is half as large in width and height
///
/// This method just takes the average of the 4 pixels, no interpolation or anything like that
///
/// # Arguments
/// * `image` - Source image (grayscale)
/// * `levels` - Level count
///
/// # Returns
/// Vector of layers in descending order of size. First element is source image
pub fn build_pyramid(image: &GrayImage, levels: usize) -> Vec<GrayImage> {
    let mut pyramid = Vec::new();
    pyramid.push(image.clone());

    for level in 1..levels {
        let previous_level = &pyramid[level - 1];
        let (width, height) = (previous_level.width(), previous_level.height());

        // Check that the image can be downscaled
        if width < 2 || height < 2 {
            break;
        }

        let new_width = width / 2;
        let new_height = height / 2;

        let mut new_image = ImageBuffer::new(new_width, new_height);

        for y in 0..new_height {
            for x in 0..new_width {
                let px = 2 * x;
                let py = 2 * y;

                // Average 4 pixels
                let pixel1 = previous_level.get_pixel(px, py)[0] as u32;
                let pixel2 = previous_level.get_pixel(px + 1, py)[0] as u32;
                let pixel3 = previous_level.get_pixel(px, py + 1)[0] as u32;
                let pixel4 = previous_level.get_pixel(px + 1, py + 1)[0] as u32;

                let average = ((pixel1 + pixel2 + pixel3 + pixel4) / 4) as u8;

                new_image.put_pixel(x, y, Luma([average]));
            }
        }

        pyramid.push(new_image);
    }

    pyramid
}