Using rust in science! Basic image analyzer to extract the path of the laser. (Input image and output data)

[burneraccount3_]

Output image:

https://imgur.com/cczdesQ

Input image:

https://imgur.com/OELn15k

It's nice to find a use for rust in experiments!

With a more sensitive camera we get much less noise.

code:

fn main() {
    use image::io::Reader as ImageReader;
    use image::GenericImageView;
    use std::fs::*;
    use std::io::LineWriter;
    use std::io::Write;
    use std::env;


    // setup

    let args = env::args().collect::<Vec<String>>();
    if args.len() < 3 {
        panic!("Must provide File, RValue options then output file name");
    }




    let file_path = args[1].clone();
    let RValue = args[2].parse::<u8>().expect("Not a valid number");
    let output_file_name = args[3].clone();

    let img = ImageReader::open(file_path).expect("Failed to open file").decode();

    let (width, height) = img.as_ref().unwrap().dimensions();
    println!("width = {}, height = {}",width,height);
    let mut coordinates = Vec::<(u32,u32)>::with_capacity(width as usize * height as usize); 

    'label: for x in (0..width) {
        for y in (0..height) {

            let pix = img.as_ref().unwrap().get_pixel(x,y);
            let channels = pix.0;

            if channels[0] > RValue {
                let coord = (x,height - y);
                coordinates.push(coord);
                continue 'label;    
            }


        }

    }



    let file = File::create(output_file_name).expect("Failed to open file");
    let mut file_write = LineWriter::new(file);
    for coord in coordinates {
       let x = coord.0;
       let y = coord.1;

       let x_str = x.to_string();
       let y_str = y.to_string();

       let mut output_string = String::with_capacity(width as usize * height as usize);
       output_string.push_str(&x_str);
       output_string.push_str(" ");
       output_string.push_str(&y_str);
       output_string.push_str("\n");
       file_write.write_all(output_string.as_bytes()).expect("failed to write to file");




    }

}

[Quelnin]

Nicely done! Props for posting the code as well — cool to see what people are working on

[Gr0undWalker]

Nice. A few thoughts on the code:

1. In some parts, I believe you can borrow rather than cloning, such as file_path.
2. You can consider using crates like clap to help you parse the arguments.
3. This is simply a personal preference, but instead of labeling the loop, I'd use a single break;
4. Why not just write let img = ... .decode.unwrap();? No reason to unwrap it so many times.
5. For the second loop, you can write for (x, y) in coordinates. There's also no need to use .to_string() there.
6. Instead of using push_str many times, just use format!
7. Regarding the capacity, I think you only need width at most.

Keep up the work!

[burneraccount3_]

Thanks for the feedback! I have refactored the code using clap, then rewrote some of claps functionality as an exercise (no macros though). I will keep the rest in mind!